Commit ddd5b57045

joachimschmidt557 <joachim.schmidt557@outlook.com>
2022-05-26 16:03:49
stage2 AArch64: complete genTypedValue
master
1 parent 4994ac1
Changed files (30)
src
arch
aarch64
CodeGen.zig
test
behavior
bugs
11165.zig
11181.zig
11213.zig
1421.zig
394.zig
4560.zig
7187.zig
align.zig
array.zig
basic.zig
bitcast.zig
bitreverse.zig
byteswap.zig
cast.zig
comptime_memory.zig
error.zig
eval.zig
fn.zig
fn_delegation.zig
generics.zig
optional.zig
pointers.zig
sizeof_and_typeof.zig
slice.zig
struct.zig
type.zig
type_info.zig
union.zig
void.zig
src/arch/aarch64/CodeGen.zig
@@ -4572,6 +4572,7 @@ fn lowerUnnamedConst(self: *Self, tv: TypedValue) InnerError!MCValue {
 }
 
 fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
+    log.debug("genTypedValue: ty = {}, val = {}", .{ typed_value.ty.fmtDebug(), typed_value.val.fmtDebug() });
     if (typed_value.val.isUndef())
         return MCValue{ .undef = {} };
 
@@ -4585,20 +4586,13 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
 
     switch (typed_value.ty.zigTypeTag()) {
         .Pointer => switch (typed_value.ty.ptrSize()) {
-            .Slice => {
-                return self.lowerUnnamedConst(typed_value);
-            },
+            .Slice => {},
             else => {
                 switch (typed_value.val.tag()) {
                     .int_u64 => {
                         return MCValue{ .immediate = typed_value.val.toUnsignedInt(target) };
                     },
-                    .slice => {
-                        return self.lowerUnnamedConst(typed_value);
-                    },
-                    else => {
-                        return self.fail("TODO codegen more kinds of const pointers: {}", .{typed_value.val.tag()});
-                    },
+                    else => {},
                 }
             },
         },
@@ -4614,15 +4608,11 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
                 };
 
                 return MCValue{ .immediate = unsigned };
-            } else {
-                return self.lowerUnnamedConst(typed_value);
             }
         },
         .Bool => {
             return MCValue{ .immediate = @boolToInt(typed_value.val.toBool()) };
         },
-        .ComptimeInt => unreachable, // semantic analysis prevents this
-        .ComptimeFloat => unreachable, // semantic analysis prevents this
         .Optional => {
             if (typed_value.ty.isPtrLikeOptional()) {
                 if (typed_value.val.isNull())
@@ -4636,7 +4626,6 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
             } else if (typed_value.ty.abiSize(self.target.*) == 1) {
                 return MCValue{ .immediate = @boolToInt(typed_value.val.isNull()) };
             }
-            return self.fail("TODO non pointer optionals", .{});
         },
         .Enum => {
             if (typed_value.val.castTag(.enum_field_index)) |field_index| {
@@ -4695,11 +4684,22 @@ fn genTypedValue(self: *Self, typed_value: TypedValue) InnerError!MCValue {
 
             return self.lowerUnnamedConst(typed_value);
         },
-        .Struct => {
-            return self.lowerUnnamedConst(typed_value);
-        },
-        else => return self.fail("TODO implement const of type '{}'", .{typed_value.ty.fmtDebug()}),
+
+        .ComptimeInt => unreachable, // semantic analysis prevents this
+        .ComptimeFloat => unreachable, // semantic analysis prevents this
+        .Type => unreachable,
+        .EnumLiteral => unreachable,
+        .Void => unreachable,
+        .NoReturn => unreachable,
+        .Undefined => unreachable,
+        .Null => unreachable,
+        .BoundFn => unreachable,
+        .Opaque => unreachable,
+
+        else => {},
     }
+
+    return self.lowerUnnamedConst(typed_value);
 }
 
 const CallMCValues = struct {
test/behavior/bugs/11165.zig
@@ -2,7 +2,6 @@ const builtin = @import("builtin");
 
 test "bytes" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const S = struct {
         a: u32,
@@ -25,7 +24,6 @@ test "bytes" {
 
 test "aggregate" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const S = struct {
         a: u32,
test/behavior/bugs/11181.zig
@@ -2,7 +2,6 @@ const builtin = @import("builtin");
 
 test "const inferred array of slices" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const T = struct { v: bool };
 
@@ -16,7 +15,6 @@ test "const inferred array of slices" {
 
 test "var inferred array of slices" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const T = struct { v: bool };
test/behavior/bugs/11213.zig
@@ -4,7 +4,6 @@ const testing = std.testing;
 
 test {
     if (builtin.zig_backend == .stage2_c) 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 g: error{Test}!void = error.Test;
test/behavior/bugs/1421.zig
@@ -9,7 +9,6 @@ const S = struct {
 };
 
 test "functions with return type required to be comptime are generic" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     const ti = S.method();
test/behavior/bugs/394.zig
@@ -11,7 +11,6 @@ const expect = @import("std").testing.expect;
 const builtin = @import("builtin");
 
 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;
     const x = S{
test/behavior/bugs/4560.zig
@@ -2,8 +2,6 @@ const std = @import("std");
 const builtin = @import("builtin");
 
 test "fixed" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var s: S = .{
         .a = 1,
         .b = .{
test/behavior/bugs/7187.zig
@@ -3,7 +3,6 @@ const builtin = @import("builtin");
 const expect = std.testing.expect;
 
 test "miscompilation with bool return type" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     var x: usize = 1;
test/behavior/align.zig
@@ -7,7 +7,6 @@ var foo: u8 align(4) = 100;
 
 test "global variable alignment" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime try expect(@typeInfo(@TypeOf(&foo)).Pointer.alignment == 4);
test/behavior/array.zig
@@ -95,8 +95,6 @@ test "array literal with specified size" {
 }
 
 test "array len field" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var arr = [4]u8{ 0, 0, 0, 0 };
     var ptr = &arr;
     try expect(arr.len == 4);
@@ -217,8 +215,6 @@ fn doSomeMangling(array: *[4]u8) void {
 }
 
 test "implicit cast zero sized array ptr to slice" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     {
         var b = "".*;
         const c: []const u8 = &b;
test/behavior/basic.zig
@@ -362,7 +362,6 @@ fn testMemcpyMemset() !void {
 }
 
 test "variable is allowed to be a pointer to an opaque type" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
@@ -611,7 +610,6 @@ test "self reference through fn ptr field" {
 }
 
 test "global variable initialized to global variable array element" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     try expect(global_ptr == &gdt[0]);
@@ -677,7 +675,6 @@ test "explicit cast optional pointers" {
 }
 
 test "pointer comparison" {
-    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;
test/behavior/bitcast.zig
@@ -7,7 +7,6 @@ const minInt = std.math.minInt;
 const native_endian = builtin.target.cpu.arch.endian();
 
 test "@bitCast iX -> uX (32, 64)" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
 
     const bit_values = [_]usize{ 32, 64 };
test/behavior/bitreverse.zig
@@ -158,7 +158,6 @@ test "bitReverse vectors u0" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     comptime try vector0();
     try vector0();
test/behavior/byteswap.zig
@@ -118,7 +118,6 @@ test "@byteSwap vectors u0" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     comptime try vector0();
     try vector0();
test/behavior/cast.zig
@@ -843,7 +843,6 @@ test "peer cast *[0]T to []const T" {
 }
 
 test "peer cast *[N]T to [*]T" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
     var array = [4:99]i32{ 1, 2, 3, 4 };
@@ -1116,7 +1115,6 @@ fn incrementVoidPtrArray(array: ?*anyopaque, len: usize) void {
 test "compile time int to ptr of function" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
 
-    if (builtin.zig_backend == .stage2_aarch64) 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
test/behavior/comptime_memory.zig
@@ -5,7 +5,6 @@ const ptr_size = @sizeOf(usize);
 
 test "type pun signed and unsigned as single pointer" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime {
@@ -18,7 +17,6 @@ test "type pun signed and unsigned as single pointer" {
 
 test "type pun signed and unsigned as many pointer" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     comptime {
         var x: u32 = 0;
@@ -30,7 +28,6 @@ test "type pun signed and unsigned as many pointer" {
 
 test "type pun signed and unsigned as array pointer" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     comptime {
         var x: u32 = 0;
@@ -74,7 +71,6 @@ test "type pun signed and unsigned as array pointer" {
 
 test "type pun value and struct" {
     if (builtin.zig_backend == .stage1) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     comptime {
         const StructOfU32 = extern struct { x: u32 };
test/behavior/error.zig
@@ -119,7 +119,6 @@ test "widen cast integer payload of error union function call" {
 
 test "debug info for optional error set" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const SomeError = error{ Hello, Hello2 };
     var a_local_variable: ?SomeError = null;
test/behavior/eval.zig
@@ -406,8 +406,6 @@ var st_init_str_foo = StInitStrFoo{
 };
 
 test "inline for with same type but different values" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     var res: usize = 0;
     inline for ([_]type{ [2]u8, [1]u8, [2]u8 }) |T| {
         var a: T = undefined;
@@ -487,7 +485,6 @@ test "comptime bitwise operators" {
 
 test "comptime shlWithOverflow" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const ct_shifted: u64 = comptime amt: {
         var amt = @as(u64, 0);
@@ -559,8 +556,6 @@ pub fn vec3(x: f32, y: f32, z: f32) Vec3 {
 }
 
 test "inlined loop has array literal with elided runtime scope on first iteration but not second iteration" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     var runtime = [1]i32{3};
     comptime var i: usize = 0;
     inline while (i < 2) : (i += 1) {
@@ -611,7 +606,6 @@ const hi1 = "hi";
 const hi2 = hi1;
 test "const global shares pointer with other same one" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     try assertEqualPtrs(&hi1[0], &hi2[0]);
     comptime try expect(&hi1[0] == &hi2[0]);
@@ -982,7 +976,6 @@ test "closure capture type of runtime-known parameter" {
 
 test "comptime break passing through runtime condition converted to runtime break" {
     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 {
test/behavior/fn.zig
@@ -184,8 +184,6 @@ test "function with complex callconv and return type expressions" {
 }
 
 test "pass by non-copying value" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     try expect(addPointCoords(Point{ .x = 1, .y = 2 }) == 3);
 }
 
@@ -211,8 +209,6 @@ fn addPointCoordsVar(pt: anytype) !i32 {
 }
 
 test "pass by non-copying value as method" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var pt = Point2{ .x = 1, .y = 2 };
     try expect(pt.addPointCoords() == 3);
 }
@@ -227,8 +223,6 @@ const Point2 = struct {
 };
 
 test "pass by non-copying value as method, which is generic" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var pt = Point3{ .x = 1, .y = 2 };
     try expect(pt.addPointCoords(i32) == 3);
 }
@@ -244,8 +238,6 @@ const Point3 = struct {
 };
 
 test "pass by non-copying value as method, at comptime" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     comptime {
         var pt = Point2{ .x = 1, .y = 2 };
         try expect(pt.addPointCoords() == 3);
@@ -409,7 +401,6 @@ test "ability to give comptime types and non comptime types to same parameter" {
 
 test "function with inferred error set but returning no error" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
 
     const S = struct {
         fn foo() !void {}
test/behavior/fn_delegation.zig
@@ -32,7 +32,6 @@ fn custom(comptime T: type, comptime num: u64) fn (T) u64 {
 }
 
 test "fn delegation" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const foo = Foo{};
test/behavior/generics.zig
@@ -206,7 +206,6 @@ fn foo2(arg: anytype) bool {
 
 test "generic struct" {
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     var a1 = GenNode(i32){
         .value = 13,
         .next = null,
test/behavior/optional.zig
@@ -33,8 +33,6 @@ test "optional pointer to size zero struct" {
 }
 
 test "equality compare optional pointers" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     try testNullPtrsEql();
     comptime try testNullPtrsEql();
 }
test/behavior/pointers.zig
@@ -85,7 +85,6 @@ test "assigning integer to C pointer" {
 test "C pointer comparison and arithmetic" {
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
 
     const S = struct {
         fn doTheTest() !void {
@@ -477,7 +476,6 @@ test "element pointer arithmetic to slice" {
 }
 
 test "array slicing to slice" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     const S = struct {
test/behavior/sizeof_and_typeof.zig
@@ -19,7 +19,6 @@ test "@sizeOf on compile-time types" {
 
 test "@TypeOf() with multiple arguments" {
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest;
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
     {
test/behavior/slice.zig
@@ -207,7 +207,6 @@ test "slice string literal has correct type" {
 }
 
 test "result location zero sized array inside struct field implicit cast to slice" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest; // TODO
 
     const E = struct {
@@ -509,7 +508,6 @@ test "slice pointer-to-array null terminated" {
 test "slice pointer-to-array zero length" {
     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_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
 
     comptime {
test/behavior/struct.zig
@@ -168,14 +168,12 @@ const MemberFnTestFoo = struct {
 };
 
 test "call member function directly" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     const instance = MemberFnTestFoo{ .x = 1234 };
     const result = MemberFnTestFoo.member(instance);
     try expect(result == 1234);
 }
 
 test "store member function in variable" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     const instance = MemberFnTestFoo{ .x = 1234 };
     const memberFn = MemberFnTestFoo.member;
     const result = memberFn(instance);
@@ -1000,8 +998,6 @@ test "tuple element initialized with fn call" {
 }
 
 test "struct with union field" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
-
     const Value = struct {
         ref: u32 = 2,
         kind: union(enum) {
test/behavior/type.zig
@@ -473,7 +473,6 @@ test "Type.Union" {
 test "Type.Union from Type.Enum" {
     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_aarch64) return error.SkipZigTest; // TODO
 
     const Tag = @Type(.{
         .Enum = .{
@@ -503,7 +502,6 @@ test "Type.Union from Type.Enum" {
 test "Type.Union from regular enum" {
     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_aarch64) return error.SkipZigTest; // TODO
 
     const E = enum { working_as_expected };
     const T = @Type(.{
test/behavior/type_info.zig
@@ -381,7 +381,6 @@ extern fn foo(a: usize, b: bool, ...) callconv(.C) usize;
 extern fn fooAligned(a: usize, b: bool, ...) align(4) callconv(.C) usize;
 
 test "type info: generic function types" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
     if (builtin.zig_backend == .stage2_c) return error.SkipZigTest;
 
     if (builtin.zig_backend != .stage1) {
test/behavior/union.zig
@@ -1111,7 +1111,6 @@ test "union enum type gets a separate scope" {
 test "global variable struct contains union initialized to non-most-aligned field" {
     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 T = struct {
         const U = union(enum) {
test/behavior/void.zig
@@ -42,8 +42,6 @@ test "void optional" {
 }
 
 test "void array as a local variable initializer" {
-    if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest;
-
     var x = [_]void{{}} ** 1004;
     _ = x[0];
 }