mirror/zig
1
0
Fork 0
mirror of https://github.com/ziglang/zig.git synced 2026-02-13 04:48:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

stage2 AArch64: complete genTypedValue

Browse Source
This commit is contained in:
joachimschmidt557 2022-05-26 16:03:49 +02:00 committed by Andrew Kelley
parent 4994ac18e4
commit ddd5b57045
30 changed files with 18 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
src/arch/aarch64/CodeGen.zig
View File

@ -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 {

1
test/behavior/align.zig
View File

@ -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);

4
test/behavior/array.zig
View File

@ -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;

3
test/behavior/basic.zig
View File

@ -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;

1
test/behavior/bitcast.zig
View File

@ -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 };

1
test/behavior/bitreverse.zig
View File

@ -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();

2
test/behavior/bugs/11165.zig
View File

@ -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,

2
test/behavior/bugs/11181.zig
View File

@ -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 };

1
test/behavior/bugs/11213.zig
View File

@ -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;

1
test/behavior/bugs/1421.zig
View File

@ -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();

1
test/behavior/bugs/394.zig
View File

@ -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{

2
test/behavior/bugs/4560.zig
View File

@ -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 = .{

1
test/behavior/bugs/7187.zig
View File

@ -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;

1
test/behavior/byteswap.zig
View File

@ -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();

2
test/behavior/cast.zig
View File

@ -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

4
test/behavior/comptime_memory.zig
View File

@ -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 };

1
test/behavior/error.zig
View File

@ -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;

7
test/behavior/eval.zig
View File

@ -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 {

9
test/behavior/fn.zig
View File

@ -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 {}

1
test/behavior/fn_delegation.zig
View File

@ -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{};

1
test/behavior/generics.zig
View File

@ -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,

2
test/behavior/optional.zig
View File

@ -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();
}

2
test/behavior/pointers.zig
View File

@ -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 {

1
test/behavior/sizeof_and_typeof.zig
View File

@ -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;
{

2
test/behavior/slice.zig
View File

@ -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 {

4
test/behavior/struct.zig
View File

@ -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) {

2
test/behavior/type.zig
View File

@ -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(.{

1
test/behavior/type_info.zig
View File

@ -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) {

1
test/behavior/union.zig
View File

@ -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) {

2
test/behavior/void.zig
View File

@ -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];
}