mirror of
https://github.com/ziglang/zig.git
synced 2026-01-25 16:55:22 +00:00
6f303c01f3
* Sema: resolve type fully when emitting an alloc AIR instruction to avoid tripping assertion for checking struct field alignment. * LLVM backend: keep a reference to the LLVM target data alive during lowering so that we can ask LLVM what it thinks the ABI alignment and size of LLVM types are. We need this in order to lower tuples and structs so that we can put in extra padding bytes when Zig disagrees with LLVM about the size or alignment of something. * LLVM backend: make the LLVM struct type packed that contains the most aligned union field and the padding. This prevents the struct from being too big according to LLVM. In the future, we may want to consider instead emitting unions in a "flat" manner; putting the tag, most aligned union field, and padding all in the same struct field space. * LLVM backend: make structs with 2 or fewer fields return isByRef=false. This results in more efficient codegen. This required lowering of bitcast to sometimes store the struct into an alloca, ptrcast, and then load because LLVM does not allow bitcasting structs. * enable more passing behavior tests.
88 lines
2.6 KiB
Zig
88 lines
2.6 KiB
Zig
const std = @import("std");
|
|
const builtin = @import("builtin");
|
|
const expect = std.testing.expect;
|
|
const native_endian = builtin.target.cpu.arch.endian();
|
|
|
|
test "reinterpret bytes as integer with nonzero offset" {
|
|
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
|
|
|
|
try testReinterpretBytesAsInteger();
|
|
comptime try testReinterpretBytesAsInteger();
|
|
}
|
|
|
|
fn testReinterpretBytesAsInteger() !void {
|
|
const bytes = "\x12\x34\x56\x78\xab";
|
|
const expected = switch (native_endian) {
|
|
.Little => 0xab785634,
|
|
.Big => 0x345678ab,
|
|
};
|
|
try expect(@ptrCast(*align(1) const u32, bytes[1..5]).* == expected);
|
|
}
|
|
|
|
test "reinterpret bytes of an array into an extern struct" {
|
|
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
|
|
|
|
try testReinterpretBytesAsExternStruct();
|
|
comptime try testReinterpretBytesAsExternStruct();
|
|
}
|
|
|
|
fn testReinterpretBytesAsExternStruct() !void {
|
|
var bytes align(2) = [_]u8{ 1, 2, 3, 4, 5, 6 };
|
|
|
|
const S = extern struct {
|
|
a: u8,
|
|
b: u16,
|
|
c: u8,
|
|
};
|
|
|
|
var ptr = @ptrCast(*const S, &bytes);
|
|
var val = ptr.c;
|
|
try expect(val == 5);
|
|
}
|
|
|
|
test "reinterpret struct field at comptime" {
|
|
if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
|
|
if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
|
|
|
|
const numNative = comptime Bytes.init(0x12345678);
|
|
if (native_endian != .Little) {
|
|
try expect(std.mem.eql(u8, &[_]u8{ 0x12, 0x34, 0x56, 0x78 }, &numNative.bytes));
|
|
} else {
|
|
try expect(std.mem.eql(u8, &[_]u8{ 0x78, 0x56, 0x34, 0x12 }, &numNative.bytes));
|
|
}
|
|
}
|
|
|
|
const Bytes = struct {
|
|
bytes: [4]u8,
|
|
|
|
pub fn init(v: u32) Bytes {
|
|
var res: Bytes = undefined;
|
|
@ptrCast(*align(1) u32, &res.bytes).* = v;
|
|
|
|
return res;
|
|
}
|
|
};
|
|
|
|
test "comptime ptrcast keeps larger alignment" {
|
|
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
|
|
|
|
comptime {
|
|
const a: u32 = 1234;
|
|
const p = @ptrCast([*]const u8, &a);
|
|
try expect(@TypeOf(p) == [*]align(@alignOf(u32)) const u8);
|
|
}
|
|
}
|
|
|
|
test "implicit optional pointer to optional anyopaque pointer" {
|
|
if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
|
|
|
|
var buf: [4]u8 = "aoeu".*;
|
|
var x: ?[*]u8 = &buf;
|
|
var y: ?*anyopaque = x;
|
|
var z = @ptrCast(*[4]u8, y);
|
|
try expect(std.mem.eql(u8, z, "aoeu"));
|
|
}
|