LLVM: add extra padding to structs and tuples sometimes

 * 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.

11 files changed, 40 insertions, 31 deletions

diff --git a/test/behavior/basic.zig b/test/behavior/basic.zig
index 7b2fa0948c..b122314720 100644
--- a/test/behavior/basic.zig
+++ b/test/behavior/basic.zig
@@ -778,8 +778,6 @@ extern var opaque_extern_var: opaque {};
 var var_to_export: u32 = 42;
 
 test "lazy typeInfo value as generic parameter" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     const S = struct {
         fn foo(args: anytype) void {
             _ = args;
diff --git a/test/behavior/bugs/394.zig b/test/behavior/bugs/394.zig
index 28934c8dd0..e7d6e80936 100644
--- a/test/behavior/bugs/394.zig
+++ b/test/behavior/bugs/394.zig
@@ -10,7 +10,7 @@ const S = struct {
 const expect = @import("std").testing.expect;
 const builtin = @import("builtin");
 
-test "bug 394 fixed" {
+test "fixed" {
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
diff --git a/test/behavior/for.zig b/test/behavior/for.zig
index 8f465eb3de..023a2d3c30 100644
--- a/test/behavior/for.zig
+++ b/test/behavior/for.zig
@@ -157,7 +157,9 @@ test "2 break statements and an else" {
 }
 
 test "for loop with pointer elem var" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const source = "abcdefg";
     var target: [source.len]u8 = undefined;
@@ -199,7 +201,10 @@ test "for copies its payload" {
 }
 
 test "for on slice with allowzero ptr" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn doTheTest(slice: []const u8) !void {
diff --git a/test/behavior/if.zig b/test/behavior/if.zig
index d8beba0222..349d7d233d 100644
--- a/test/behavior/if.zig
+++ b/test/behavior/if.zig
@@ -106,8 +106,6 @@ test "if copies its payload" {
 }
 
 test "if prongs cast to expected type instead of peer type resolution" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     const S = struct {
         fn doTheTest(f: bool) !void {
             var x: i32 = 0;
diff --git a/test/behavior/optional.zig b/test/behavior/optional.zig
index cc8174dc13..d6963a6143 100644
--- a/test/behavior/optional.zig
+++ b/test/behavior/optional.zig
@@ -251,7 +251,9 @@ test "coerce an anon struct literal to optional struct" {
 }
 
 test "0-bit child type coerced to optional return ptr result location" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn doTheTest() !void {
@@ -300,7 +302,9 @@ test "0-bit child type coerced to optional" {
 }
 
 test "array of optional unaligned types" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const Enum = enum { one, two, three };
 
@@ -320,15 +324,15 @@ test "array of optional unaligned types" {
 
     // The index must be a runtime value
     var i: usize = 0;
-    try expectEqual(Enum.one, values[i].?.Num);
+    try expect(Enum.one == values[i].?.Num);
     i += 1;
-    try expectEqual(Enum.two, values[i].?.Num);
+    try expect(Enum.two == values[i].?.Num);
     i += 1;
-    try expectEqual(Enum.three, values[i].?.Num);
+    try expect(Enum.three == values[i].?.Num);
     i += 1;
-    try expectEqual(Enum.one, values[i].?.Num);
+    try expect(Enum.one == values[i].?.Num);
     i += 1;
-    try expectEqual(Enum.two, values[i].?.Num);
+    try expect(Enum.two == values[i].?.Num);
     i += 1;
-    try expectEqual(Enum.three, values[i].?.Num);
+    try expect(Enum.three == values[i].?.Num);
 }
diff --git a/test/behavior/ptrcast.zig b/test/behavior/ptrcast.zig
index 2bc35e4286..025335e909 100644
--- a/test/behavior/ptrcast.zig
+++ b/test/behavior/ptrcast.zig
@@ -41,7 +41,11 @@ fn testReinterpretBytesAsExternStruct() !void {
 }
 
 test "reinterpret struct field at comptime" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    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) {
diff --git a/test/behavior/reflection.zig b/test/behavior/reflection.zig
index a181e95b86..865813a663 100644
--- a/test/behavior/reflection.zig
+++ b/test/behavior/reflection.zig
@@ -5,8 +5,6 @@ const mem = std.mem;
 const reflection = @This();
 
 test "reflection: function return type, var args, and param types" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     comptime {
         const info = @typeInfo(@TypeOf(dummy)).Fn;
         try expect(info.return_type.? == i32);
diff --git a/test/behavior/sizeof_and_typeof.zig b/test/behavior/sizeof_and_typeof.zig
index a405309244..852e1e74e4 100644
--- a/test/behavior/sizeof_and_typeof.zig
+++ b/test/behavior/sizeof_and_typeof.zig
@@ -180,8 +180,6 @@ test "@sizeOf(T) == 0 doesn't force resolving struct size" {
 }
 
 test "@TypeOf() has no runtime side effects" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     const S = struct {
         fn foo(comptime T: type, ptr: *T) T {
             ptr.* += 1;
@@ -195,8 +193,6 @@ test "@TypeOf() has no runtime side effects" {
 }
 
 test "branching logic inside @TypeOf" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     const S = struct {
         var data: i32 = 0;
         fn foo() anyerror!i32 {
diff --git a/test/behavior/struct.zig b/test/behavior/struct.zig
index 13fe0820ce..20123e8014 100644
--- a/test/behavior/struct.zig
+++ b/test/behavior/struct.zig
@@ -857,7 +857,9 @@ test "fn with C calling convention returns struct by value" {
 }
 
 test "non-packed struct with u128 entry in union" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const U = union(enum) {
         Num: u128,
@@ -952,7 +954,9 @@ test "fully anonymous struct" {
 }
 
 test "fully anonymous list literal" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) 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 S = struct {
         fn doTheTest() !void {
diff --git a/test/behavior/type.zig b/test/behavior/type.zig
index b1ecccbb1a..eea4d7d203 100644
--- a/test/behavior/type.zig
+++ b/test/behavior/type.zig
@@ -138,8 +138,6 @@ test "Type.Array" {
 }
 
 test "@Type create slice with null sentinel" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     const Slice = @Type(TypeInfo{
         .Pointer = .{
             .size = .Slice,
@@ -156,8 +154,6 @@ test "@Type create slice with null sentinel" {
 }
 
 test "@Type picks up the sentinel value from TypeInfo" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
-
     try testTypes(&[_]type{
         [11:0]u8,                            [4:10]u8,
         [*:0]u8,                             [*:0]const u8,
diff --git a/test/behavior/var_args.zig b/test/behavior/var_args.zig
index 0e37c845b6..6639d8664e 100644
--- a/test/behavior/var_args.zig
+++ b/test/behavior/var_args.zig
@@ -13,7 +13,9 @@ fn add(args: anytype) i32 {
 }
 
 test "add arbitrary args" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try expect(add(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
     try expect(add(.{@as(i32, 1234)}) == 1234);
@@ -34,7 +36,9 @@ test "send void arg to var args" {
 }
 
 test "pass args directly" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try expect(addSomeStuff(.{ @as(i32, 1), @as(i32, 2), @as(i32, 3), @as(i32, 4) }) == 10);
     try expect(addSomeStuff(.{@as(i32, 1234)}) == 1234);
@@ -46,7 +50,9 @@ fn addSomeStuff(args: anytype) i32 {
 }
 
 test "runtime parameter before var args" {
-    if (builtin.zig_backend != .stage1) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
+    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try expect((try extraFn(10, .{})) == 0);
     try expect((try extraFn(10, .{false})) == 1);