motiejus/zig
1
Fork 0
Code Releases Activity

Merge pull request #13251 from Vexu/c-abi

Browse Source 
implement ARM C ABI, separate C ABI tests from standalone tests
This commit is contained in:
Andrew Kelley
2022-10-23 12:16:58 -07:00
committed by GitHub
parent a3033c7bd9 f2a7aba586
commit 04472af328
13 changed files with 696 additions and 203 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
build.zig
View File

@@ -508,6 +508,7 @@ pub fn build(b: *Builder) !void {
b.enable_wasmtime,
b.enable_wine,
));
test_step.dependOn(tests.addCAbiTests(b, skip_non_native));
test_step.dependOn(tests.addLinkTests(b, test_filter, modes, enable_macos_sdk, skip_stage2_tests));
test_step.dependOn(tests.addStackTraceTests(b, test_filter, modes));
test_step.dependOn(tests.addCliTests(b, test_filter, modes));

62
src/arch/aarch64/abi.zig
View File

@@ -5,41 +5,54 @@ const Register = bits.Register;
const RegisterManagerFn = @import("../../register_manager.zig").RegisterManager;
const Type = @import("../../type.zig").Type;
pub const Class = enum(u8) { memory, integer, none, float_array, _ };
pub const Class = union(enum) {
memory,
byval,
integer,
double_integer,
float_array: u8,
};
/// For `float_array` the second element will be the amount of floats.
pub fn classifyType(ty: Type, target: std.Target) [2]Class {
var maybe_float_bits: ?u16 = null;
const float_count = countFloats(ty, target, &maybe_float_bits);
if (float_count <= sret_float_count) return .{ .float_array, @intToEnum(Class, float_count) };
return classifyTypeInner(ty, target);
}
pub fn classifyType(ty: Type, target: std.Target) Class {
std.debug.assert(ty.hasRuntimeBitsIgnoreComptime());
fn classifyTypeInner(ty: Type, target: std.Target) [2]Class {
if (!ty.hasRuntimeBitsIgnoreComptime()) return .{ .none, .none };
var maybe_float_bits: ?u16 = null;
switch (ty.zigTypeTag()) {
.Struct => {
if (ty.containerLayout() == .Packed) return .{ .integer, .none };
if (ty.containerLayout() == .Packed) return .byval;
const float_count = countFloats(ty, target, &maybe_float_bits);
if (float_count <= sret_float_count) return .{ .float_array = float_count };
const bit_size = ty.bitSize(target);
if (bit_size > 128) return .{ .memory, .none };
if (bit_size > 64) return .{ .integer, .integer };
return .{ .integer, .none };
if (bit_size > 128) return .memory;
if (bit_size > 64) return .double_integer;
return .integer;
},
.Union => {
if (ty.containerLayout() == .Packed) return .byval;
const float_count = countFloats(ty, target, &maybe_float_bits);
if (float_count <= sret_float_count) return .{ .float_array = float_count };
const bit_size = ty.bitSize(target);
if (bit_size > 128) return .{ .memory, .none };
if (bit_size > 64) return .{ .integer, .integer };
return .{ .integer, .none };
if (bit_size > 128) return .memory;
if (bit_size > 64) return .double_integer;
return .integer;
},
.Int, .Enum, .ErrorSet, .Float, .Bool => return .byval,
.Vector => {
const bit_size = ty.bitSize(target);
// TODO is this controlled by a cpu feature?
if (bit_size > 128) return .memory;
return .byval;
},
.Int, .Enum, .ErrorSet, .Vector, .Float, .Bool => return .{ .integer, .none },
.Array => return .{ .memory, .none },
.Optional => {
std.debug.assert(ty.isPtrLikeOptional());
return .{ .integer, .none };
return .byval;
},
.Pointer => {
std.debug.assert(!ty.isSlice());
return .{ .integer, .none };
return .byval;
},
.ErrorUnion,
.Frame,
@@ -55,17 +68,18 @@ fn classifyTypeInner(ty: Type, target: std.Target) [2]Class {
.Fn,
.Opaque,
.EnumLiteral,
.Array,
=> unreachable,
}
}
const sret_float_count = 4;
fn countFloats(ty: Type, target: std.Target, maybe_float_bits: *?u16) u32 {
const invalid = std.math.maxInt(u32);
fn countFloats(ty: Type, target: std.Target, maybe_float_bits: *?u16) u8 {
const invalid = std.math.maxInt(u8);
switch (ty.zigTypeTag()) {
.Union => {
const fields = ty.unionFields();
var max_count: u32 = 0;
var max_count: u8 = 0;
for (fields.values()) |field| {
const field_count = countFloats(field.ty, target, maybe_float_bits);
if (field_count == invalid) return invalid;
@@ -76,7 +90,7 @@ fn countFloats(ty: Type, target: std.Target, maybe_float_bits: *?u16) u32 {
},
.Struct => {
const fields_len = ty.structFieldCount();
var count: u32 = 0;
var count: u8 = 0;
var i: u32 = 0;
while (i < fields_len) : (i += 1) {
const field_ty = ty.structFieldType(i);

154
src/arch/arm/abi.zig
View File

@@ -2,6 +2,160 @@ const std = @import("std");
const bits = @import("bits.zig");
const Register = bits.Register;
const RegisterManagerFn = @import("../../register_manager.zig").RegisterManager;
const Type = @import("../../type.zig").Type;
pub const Class = union(enum) {
memory,
byval,
i32_array: u8,
i64_array: u8,
fn arrSize(total_size: u64, arr_size: u64) Class {
const count = @intCast(u8, std.mem.alignForward(total_size, arr_size) / arr_size);
if (arr_size == 32) {
return .{ .i32_array = count };
} else {
return .{ .i64_array = count };
}
}
};
pub const Context = enum { ret, arg };
pub fn classifyType(ty: Type, target: std.Target, ctx: Context) Class {
std.debug.assert(ty.hasRuntimeBitsIgnoreComptime());
var maybe_float_bits: ?u16 = null;
const max_byval_size = 512;
switch (ty.zigTypeTag()) {
.Struct => {
const bit_size = ty.bitSize(target);
if (ty.containerLayout() == .Packed) {
if (bit_size > 64) return .memory;
return .byval;
}
if (bit_size > max_byval_size) return .memory;
const float_count = countFloats(ty, target, &maybe_float_bits);
if (float_count <= byval_float_count) return .byval;
const fields = ty.structFieldCount();
var i: u32 = 0;
while (i < fields) : (i += 1) {
const field_ty = ty.structFieldType(i);
const field_alignment = ty.structFieldAlign(i, target);
const field_size = field_ty.bitSize(target);
if (field_size > 32 or field_alignment > 32) {
return Class.arrSize(bit_size, 64);
}
}
return Class.arrSize(bit_size, 32);
},
.Union => {
const bit_size = ty.bitSize(target);
if (ty.containerLayout() == .Packed) {
if (bit_size > 64) return .memory;
return .byval;
}
if (bit_size > max_byval_size) return .memory;
const float_count = countFloats(ty, target, &maybe_float_bits);
if (float_count <= byval_float_count) return .byval;
for (ty.unionFields().values()) |field| {
if (field.ty.bitSize(target) > 32 or field.normalAlignment(target) > 32) {
return Class.arrSize(bit_size, 64);
}
}
return Class.arrSize(bit_size, 32);
},
.Bool, .Float => return .byval,
.Int => {
// TODO this is incorrect for _BitInt(128) but implementing
// this correctly makes implementing compiler-rt impossible.
// const bit_size = ty.bitSize(target);
// if (bit_size > 64) return .memory;
return .byval;
},
.Enum, .ErrorSet => {
const bit_size = ty.bitSize(target);
if (bit_size > 64) return .memory;
return .byval;
},
.Vector => {
const bit_size = ty.bitSize(target);
// TODO is this controlled by a cpu feature?
if (ctx == .ret and bit_size > 128) return .memory;
if (bit_size > 512) return .memory;
return .byval;
},
.Optional => {
std.debug.assert(ty.isPtrLikeOptional());
return .byval;
},
.Pointer => {
std.debug.assert(!ty.isSlice());
return .byval;
},
.ErrorUnion,
.Frame,
.AnyFrame,
.NoReturn,
.Void,
.Type,
.ComptimeFloat,
.ComptimeInt,
.Undefined,
.Null,
.BoundFn,
.Fn,
.Opaque,
.EnumLiteral,
.Array,
=> unreachable,
}
}
const byval_float_count = 4;
fn countFloats(ty: Type, target: std.Target, maybe_float_bits: *?u16) u32 {
const invalid = std.math.maxInt(u32);
switch (ty.zigTypeTag()) {
.Union => {
const fields = ty.unionFields();
var max_count: u32 = 0;
for (fields.values()) |field| {
const field_count = countFloats(field.ty, target, maybe_float_bits);
if (field_count == invalid) return invalid;
if (field_count > max_count) max_count = field_count;
if (max_count > byval_float_count) return invalid;
}
return max_count;
},
.Struct => {
const fields_len = ty.structFieldCount();
var count: u32 = 0;
var i: u32 = 0;
while (i < fields_len) : (i += 1) {
const field_ty = ty.structFieldType(i);
const field_count = countFloats(field_ty, target, maybe_float_bits);
if (field_count == invalid) return invalid;
count += field_count;
if (count > byval_float_count) return invalid;
}
return count;
},
.Float => {
const float_bits = maybe_float_bits.* orelse {
const float_bits = ty.floatBits(target);
if (float_bits != 32 and float_bits != 64) return invalid;
maybe_float_bits.* = float_bits;
return 1;
};
if (ty.floatBits(target) == float_bits) return 1;
return invalid;
},
.Void => return 0,
else => return invalid,
}
}
pub const callee_preserved_regs = [_]Register{ .r4, .r5, .r6, .r7, .r8, .r10 };
pub const caller_preserved_regs = [_]Register{ .r0, .r1, .r2, .r3 };

69
src/arch/riscv64/abi.zig
View File

@@ -2,6 +2,75 @@ const std = @import("std");
const bits = @import("bits.zig");
const Register = bits.Register;
const RegisterManagerFn = @import("../../register_manager.zig").RegisterManager;
const Type = @import("../../type.zig").Type;
pub const Class = enum { memory, byval, integer, double_integer };
pub fn classifyType(ty: Type, target: std.Target) Class {
std.debug.assert(ty.hasRuntimeBitsIgnoreComptime());
const max_byval_size = target.cpu.arch.ptrBitWidth() * 2;
switch (ty.zigTypeTag()) {
.Struct => {
const bit_size = ty.bitSize(target);
if (ty.containerLayout() == .Packed) {
if (bit_size > max_byval_size) return .memory;
return .byval;
}
// TODO this doesn't exactly match what clang produces but its better than nothing
if (bit_size > max_byval_size) return .memory;
if (bit_size > max_byval_size / 2) return .double_integer;
return .integer;
},
.Union => {
const bit_size = ty.bitSize(target);
if (ty.containerLayout() == .Packed) {
if (bit_size > max_byval_size) return .memory;
return .byval;
}
// TODO this doesn't exactly match what clang produces but its better than nothing
if (bit_size > max_byval_size) return .memory;
if (bit_size > max_byval_size / 2) return .double_integer;
return .integer;
},
.Bool => return .integer,
.Float => return .byval,
.Int, .Enum, .ErrorSet => {
const bit_size = ty.bitSize(target);
if (bit_size > max_byval_size) return .memory;
return .byval;
},
.Vector => {
const bit_size = ty.bitSize(target);
if (bit_size > max_byval_size) return .memory;
return .integer;
},
.Optional => {
std.debug.assert(ty.isPtrLikeOptional());
return .byval;
},
.Pointer => {
std.debug.assert(!ty.isSlice());
return .byval;
},
.ErrorUnion,
.Frame,
.AnyFrame,
.NoReturn,
.Void,
.Type,
.ComptimeFloat,
.ComptimeInt,
.Undefined,
.Null,
.BoundFn,
.Fn,
.Opaque,
.EnumLiteral,
.Array,
=> unreachable,
}
}
pub const callee_preserved_regs = [_]Register{
.s0, .s1, .s2, .s3, .s4, .s5, .s6, .s7, .s8, .s9, .s10, .s11,

2
src/arch/x86_64/CodeGen.zig
View File

@@ -7149,7 +7149,7 @@ fn resolveCallingConventionValues(self: *Self, fn_ty: Type) !CallMCValues {
const classes: []const abi.Class = switch (self.target.os.tag) {
.windows => &[1]abi.Class{abi.classifyWindows(ty, self.target.*)},
else => mem.sliceTo(&abi.classifySystemV(ty, self.target.*), .none),
else => mem.sliceTo(&abi.classifySystemV(ty, self.target.*, .arg), .none),
};
if (classes.len > 1) {
return self.fail("TODO handle multiple classes per type", .{});

24
src/arch/x86_64/abi.zig
View File

@@ -60,9 +60,11 @@ pub fn classifyWindows(ty: Type, target: Target) Class {
}
}
pub const Context = enum { ret, arg };
/// There are a maximum of 8 possible return slots. Returned values are in
/// the beginning of the array; unused slots are filled with .none.
pub fn classifySystemV(ty: Type, target: Target) [8]Class {
pub fn classifySystemV(ty: Type, target: Target, ctx: Context) [8]Class {
const memory_class = [_]Class{
.memory, .none, .none, .none,
.none, .none, .none, .none,
@@ -134,6 +136,22 @@ pub fn classifySystemV(ty: Type, target: Target) [8]Class {
},
.Vector => {
const elem_ty = ty.childType();
if (ctx == .arg) {
const bit_size = ty.bitSize(target);
if (bit_size > 128) return memory_class;
if (bit_size > 80) return .{
.integer, .integer, .none, .none,
.none, .none, .none, .none,
};
if (bit_size > 64) return .{
.x87, .none, .none, .none,
.none, .none, .none, .none,
};
return .{
.integer, .none, .none, .none,
.none, .none, .none, .none,
};
}
const bits = elem_ty.bitSize(target) * ty.arrayLen();
if (bits <= 64) return .{
.sse, .none, .none, .none,
@@ -201,7 +219,7 @@ pub fn classifySystemV(ty: Type, target: Target) [8]Class {
}
}
const field_size = field.ty.abiSize(target);
const field_class_array = classifySystemV(field.ty, target);
const field_class_array = classifySystemV(field.ty, target, .arg);
const field_class = std.mem.sliceTo(&field_class_array, .none);
if (byte_i + field_size <= 8) {
// Combine this field with the previous one.
@@ -315,7 +333,7 @@ pub fn classifySystemV(ty: Type, target: Target) [8]Class {
}
}
// Combine this field with the previous one.
const field_class = classifySystemV(field.ty, target);
const field_class = classifySystemV(field.ty, target, .arg);
for (result) |*result_item, i| {
const field_item = field_class[i];
// "If both classes are equal, this is the resulting class."

194
src/codegen/llvm.zig
View File

@@ -24,6 +24,8 @@ const CType = @import("../type.zig").CType;
const x86_64_abi = @import("../arch/x86_64/abi.zig");
const wasm_c_abi = @import("../arch/wasm/abi.zig");
const aarch64_c_abi = @import("../arch/aarch64/abi.zig");
const arm_c_abi = @import("../arch/arm/abi.zig");
const riscv_c_abi = @import("../arch/riscv64/abi.zig");
const Error = error{ OutOfMemory, CodegenFail };
@@ -1130,6 +1132,25 @@ pub const Object = struct {
const casted_ptr = builder.buildBitCast(arg_ptr, param.typeOf().pointerType(0), "");
_ = builder.buildStore(param, casted_ptr);
if (isByRef(param_ty)) {
try args.append(arg_ptr);
} else {
const load_inst = builder.buildLoad(param_llvm_ty, arg_ptr, "");
load_inst.setAlignment(alignment);
try args.append(load_inst);
}
},
.i32_array, .i64_array => {
const param_ty = fn_info.param_types[it.zig_index - 1];
const param_llvm_ty = try dg.lowerType(param_ty);
const param = llvm_func.getParam(llvm_arg_i);
llvm_arg_i += 1;
const alignment = param_ty.abiAlignment(target);
const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty, alignment, target);
const casted_ptr = builder.buildBitCast(arg_ptr, param.typeOf().pointerType(0), "");
_ = builder.buildStore(param, casted_ptr);
if (isByRef(param_ty)) {
try args.append(arg_ptr);
} else {
@@ -2578,6 +2599,8 @@ pub const DeclGen = struct {
.multiple_llvm_float,
.as_u16,
.float_array,
.i32_array,
.i64_array,
=> continue,
.slice => unreachable, // extern functions do not support slice types.
@@ -3132,6 +3155,11 @@ pub const DeclGen = struct {
const arr_ty = float_ty.arrayType(field_count);
try llvm_params.append(arr_ty);
},
.i32_array, .i64_array => |arr_len| {
const elem_size: u8 = if (lowering == .i32_array) 32 else 64;
const arr_ty = dg.context.intType(elem_size).arrayType(arr_len);
try llvm_params.append(arr_ty);
},
};
return llvm.functionType(
@@ -4822,6 +4850,25 @@ pub const FuncGen = struct {
load_inst.setAlignment(alignment);
try llvm_args.append(load_inst);
},
.i32_array, .i64_array => |arr_len| {
const elem_size: u8 = if (lowering == .i32_array) 32 else 64;
const arg = args[it.zig_index - 1];
const arg_ty = self.air.typeOf(arg);
var llvm_arg = try self.resolveInst(arg);
if (!isByRef(arg_ty)) {
const p = self.buildAlloca(llvm_arg.typeOf(), null);
const store_inst = self.builder.buildStore(llvm_arg, p);
store_inst.setAlignment(arg_ty.abiAlignment(target));
llvm_arg = store_inst;
}
const array_llvm_ty = self.dg.context.intType(elem_size).arrayType(arr_len);
const casted = self.builder.buildBitCast(llvm_arg, array_llvm_ty.pointerType(0), "");
const alignment = arg_ty.abiAlignment(target);
const load_inst = self.builder.buildLoad(array_llvm_ty, casted, "");
load_inst.setAlignment(alignment);
try llvm_args.append(load_inst);
},
};
const call = self.builder.buildCall(
@@ -10083,10 +10130,16 @@ fn firstParamSRet(fn_info: Type.Payload.Function.Data, target: std.Target) bool
.mips, .mipsel => return false,
.x86_64 => switch (target.os.tag) {
.windows => return x86_64_abi.classifyWindows(fn_info.return_type, target) == .memory,
else => return x86_64_abi.classifySystemV(fn_info.return_type, target)[0] == .memory,
else => return x86_64_abi.classifySystemV(fn_info.return_type, target, .ret)[0] == .memory,
},
.wasm32 => return wasm_c_abi.classifyType(fn_info.return_type, target)[0] == .indirect,
.aarch64, .aarch64_be => return aarch64_c_abi.classifyType(fn_info.return_type, target)[0] == .memory,
.aarch64, .aarch64_be => return aarch64_c_abi.classifyType(fn_info.return_type, target) == .memory,
.arm, .armeb => switch (arm_c_abi.classifyType(fn_info.return_type, target, .ret)) {
.memory, .i64_array => return true,
.i32_array => |size| return size != 1,
.byval => return false,
},
.riscv32, .riscv64 => return riscv_c_abi.classifyType(fn_info.return_type, target) == .memory,
else => return false, // TODO investigate C ABI for other architectures
},
else => return false,
@@ -10139,7 +10192,7 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
if (is_scalar) {
return dg.lowerType(fn_info.return_type);
}
const classes = x86_64_abi.classifySystemV(fn_info.return_type, target);
const classes = x86_64_abi.classifySystemV(fn_info.return_type, target, .ret);
if (classes[0] == .memory) {
return dg.context.voidType();
}
@@ -10197,22 +10250,44 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*llvm.Type {
return dg.context.intType(@intCast(c_uint, abi_size * 8));
},
.aarch64, .aarch64_be => {
if (is_scalar) {
return dg.lowerType(fn_info.return_type);
switch (aarch64_c_abi.classifyType(fn_info.return_type, target)) {
.memory => return dg.context.voidType(),
.float_array => return dg.lowerType(fn_info.return_type),
.byval => return dg.lowerType(fn_info.return_type),
.integer => {
const bit_size = fn_info.return_type.bitSize(target);
return dg.context.intType(@intCast(c_uint, bit_size));
},
.double_integer => return dg.context.intType(64).arrayType(2),
}
const classes = aarch64_c_abi.classifyType(fn_info.return_type, target);
if (classes[0] == .memory or classes[0] == .none) {
return dg.context.voidType();
},
.arm, .armeb => {
switch (arm_c_abi.classifyType(fn_info.return_type, target, .ret)) {
.memory, .i64_array => return dg.context.voidType(),
.i32_array => |len| if (len == 1) {
return dg.context.intType(32);
} else {
return dg.context.voidType();
},
.byval => return dg.lowerType(fn_info.return_type),
}
if (classes[0] == .float_array) {
return dg.lowerType(fn_info.return_type);
},
.riscv32, .riscv64 => {
switch (riscv_c_abi.classifyType(fn_info.return_type, target)) {
.memory => return dg.context.voidType(),
.integer => {
const bit_size = fn_info.return_type.bitSize(target);
return dg.context.intType(@intCast(c_uint, bit_size));
},
.double_integer => {
var llvm_types_buffer: [2]*llvm.Type = .{
dg.context.intType(64),
dg.context.intType(64),
};
return dg.context.structType(&llvm_types_buffer, 2, .False);
},
.byval => return dg.lowerType(fn_info.return_type),
}
if (classes[1] == .none) {
const bit_size = fn_info.return_type.bitSize(target);
return dg.context.intType(@intCast(c_uint, bit_size));
}
return dg.context.intType(64).arrayType(2);
},
// TODO investigate C ABI for other architectures
else => return dg.lowerType(fn_info.return_type),
@@ -10242,6 +10317,8 @@ const ParamTypeIterator = struct {
slice,
as_u16,
float_array: u8,
i32_array: u8,
i64_array: u8,
};
pub fn next(it: *ParamTypeIterator) ?Lowering {
@@ -10288,15 +10365,6 @@ const ParamTypeIterator = struct {
.C => {
const is_scalar = isScalar(ty);
switch (it.target.cpu.arch) {
.riscv32, .riscv64 => {
it.zig_index += 1;
it.llvm_index += 1;
if (ty.tag() == .f16) {
return .as_u16;
} else {
return .byval;
}
},
.mips, .mipsel => {
it.zig_index += 1;
it.llvm_index += 1;
@@ -10334,18 +10402,18 @@ const ParamTypeIterator = struct {
else => unreachable,
},
else => {
if (is_scalar) {
it.zig_index += 1;
it.llvm_index += 1;
return .byval;
}
const classes = x86_64_abi.classifySystemV(ty, it.target);
const classes = x86_64_abi.classifySystemV(ty, it.target, .arg);
if (classes[0] == .memory) {
it.zig_index += 1;
it.llvm_index += 1;
it.byval_attr = true;
return .byref;
}
if (is_scalar) {
it.zig_index += 1;
it.llvm_index += 1;
return .byval;
}
var llvm_types_buffer: [8]u16 = undefined;
var llvm_types_index: u32 = 0;
for (classes) |class| {
@@ -10383,11 +10451,6 @@ const ParamTypeIterator = struct {
it.llvm_index += 1;
return .abi_sized_int;
}
if (classes[0] == .sse and classes[1] == .none) {
it.zig_index += 1;
it.llvm_index += 1;
return .byval;
}
it.llvm_types_buffer = llvm_types_buffer;
it.llvm_types_len = llvm_types_index;
it.llvm_index += llvm_types_index;
@@ -10410,24 +10473,45 @@ const ParamTypeIterator = struct {
.aarch64, .aarch64_be => {
it.zig_index += 1;
it.llvm_index += 1;
if (is_scalar) {
return .byval;
switch (aarch64_c_abi.classifyType(ty, it.target)) {
.memory => return .byref,
.float_array => |len| return Lowering{ .float_array = len },
.byval => return .byval,
.integer => {
it.llvm_types_len = 1;
it.llvm_types_buffer[0] = 64;
return .multiple_llvm_ints;
},
.double_integer => return Lowering{ .i64_array = 2 },
}
const classes = aarch64_c_abi.classifyType(ty, it.target);
if (classes[0] == .memory) {
return .byref;
},
.arm, .armeb => {
it.zig_index += 1;
it.llvm_index += 1;
switch (arm_c_abi.classifyType(ty, it.target, .arg)) {
.memory => {
it.byval_attr = true;
return .byref;
},
.byval => return .byval,
.i32_array => |size| return Lowering{ .i32_array = size },
.i64_array => |size| return Lowering{ .i64_array = size },
}
if (classes[0] == .float_array) {
return Lowering{ .float_array = @enumToInt(classes[1]) };
},
.riscv32, .riscv64 => {
it.zig_index += 1;
it.llvm_index += 1;
if (ty.tag() == .f16) {
return .as_u16;
}
if (classes[1] == .none) {
it.llvm_types_len = 1;
} else {
it.llvm_types_len = 2;
switch (riscv_c_abi.classifyType(ty, it.target)) {
.memory => {
return .byref;
},
.byval => return .byval,
.integer => return .abi_sized_int,
.double_integer => return Lowering{ .i64_array = 2 },
}
it.llvm_types_buffer[0] = 64;
it.llvm_types_buffer[1] = 64;
return .multiple_llvm_ints;
},
// TODO investigate C ABI for other architectures
else => {
@@ -10475,8 +10559,16 @@ fn ccAbiPromoteInt(
};
if (int_info.bits <= 16) return int_info.signedness;
switch (target.cpu.arch) {
.riscv64 => {
if (int_info.bits == 32) {
// LLVM always signextends 32 bit ints, unsure if bug.
return .signed;
}
if (int_info.bits < 64) {
return int_info.signedness;
}
},
.sparc64,
.riscv64,
.powerpc64,
.powerpc64le,
=> {

22
test/c_abi/build.zig
View File

@@ -1,22 +0,0 @@
const Builder = @import("std").build.Builder;
pub fn build(b: *Builder) void {
const rel_opts = b.standardReleaseOptions();
const target = b.standardTargetOptions(.{});
const c_obj = b.addObject("cfuncs", null);
c_obj.addCSourceFile("cfuncs.c", &[_][]const u8{"-std=c99"});
c_obj.setBuildMode(rel_opts);
c_obj.linkSystemLibrary("c");
c_obj.target = target;
const main = b.addTest("main.zig");
main.setBuildMode(rel_opts);
main.addObject(c_obj);
main.target = target;
const test_step = b.step("test", "Test the program");
test_step.dependOn(&main.step);
b.default_step.dependOn(test_step);
}

24
test/c_abi/build_wasm.zig
View File

@@ -1,24 +0,0 @@
const std = @import("std");
const Builder = std.build.Builder;
pub fn build(b: *Builder) void {
const rel_opts = b.standardReleaseOptions();
const target: std.zig.CrossTarget = .{ .cpu_arch = .wasm32, .os_tag = .wasi };
b.use_stage1 = false;
const c_obj = b.addObject("cfuncs", null);
c_obj.addCSourceFile("cfuncs.c", &[_][]const u8{"-std=c99"});
c_obj.setBuildMode(rel_opts);
c_obj.linkSystemLibrary("c");
c_obj.setTarget(target);
const main = b.addTest("main.zig");
main.setBuildMode(rel_opts);
main.addObject(c_obj);
main.setTarget(target);
const test_step = b.step("test", "Test the program");
test_step.dependOn(&main.step);
b.default_step.dependOn(test_step);
}

103
test/c_abi/cfuncs.c
View File

@@ -1,8 +1,8 @@
#include <inttypes.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <complex.h>
#include <inttypes.h>
#include <stdbool.h>
#include <stdlib.h>
#include <string.h>
void zig_panic();
@@ -12,6 +12,14 @@ static void assert_or_panic(bool ok) {
}
}
#if defined __powerpc__ && !defined _ARCH_PPC64
# define ZIG_PPC32
#endif
#if defined __riscv && defined _ILP32
# define ZIG_RISCV32
#endif
#ifdef __i386__
# define ZIG_NO_I128
#endif
@@ -24,6 +32,14 @@ static void assert_or_panic(bool ok) {
# define ZIG_NO_I128
#endif
#ifdef ZIG_PPC32
# define ZIG_NO_I128
#endif
#ifdef ZIG_RISCV32
# define ZIG_NO_I128
#endif
#ifdef __i386__
# define ZIG_NO_COMPLEX
#endif
@@ -32,6 +48,18 @@ static void assert_or_panic(bool ok) {
# define ZIG_NO_COMPLEX
#endif
#ifdef __arm__
# define ZIG_NO_COMPLEX
#endif
#ifdef __powerpc__
# define ZIG_NO_COMPLEX
#endif
#ifdef __riscv
# define ZIG_NO_COMPLEX
#endif
#ifndef ZIG_NO_I128
struct i128 {
__int128 value;
@@ -206,7 +234,7 @@ void run_c_tests(void) {
zig_longdouble(12.34l);
zig_five_floats(1.0f, 2.0f, 3.0f, 4.0f, 5.0f);
zig_ptr((void*)0xdeadbeefL);
zig_ptr((void *)0xdeadbeefL);
zig_bool(true);
@@ -249,14 +277,15 @@ void run_c_tests(void) {
}
#endif
#if !defined __mips__ && !defined __riscv
#if !defined __mips__ && !defined ZIG_PPC32
{
struct BigStruct s = {1, 2, 3, 4, 5};
zig_big_struct(s);
}
#endif
#if !defined __i386__ && !defined __arm__ && !defined __mips__ && !defined __riscv
#if !defined __i386__ && !defined __arm__ && !defined __mips__ && \
!defined ZIG_PPC32 && !defined _ARCH_PPC64
{
struct SmallStructInts s = {1, 2, 3, 4};
zig_small_struct_ints(s);
@@ -281,28 +310,30 @@ void run_c_tests(void) {
zig_small_packed_struct(s);
}
#if !defined __i386__ && !defined __arm__ && !defined __mips__ && !defined __riscv
#if !defined __i386__ && !defined __arm__ && !defined __mips__ && \
!defined ZIG_PPC32 && !defined _ARCH_PPC64
{
struct SplitStructInts s = {1234, 100, 1337};
zig_split_struct_ints(s);
}
#endif
#if !defined __arm__ && !defined __riscv
#if !defined __arm__ && !defined ZIG_PPC32 && !defined _ARCH_PPC64
{
struct MedStructMixed s = {1234, 100.0f, 1337.0f};
zig_med_struct_mixed(s);
}
#endif
#if !defined __i386__ && !defined __arm__ && !defined __mips__ && !defined __riscv
#if !defined __i386__ && !defined __arm__ && !defined __mips__ && \
!defined ZIG_PPC32 && !defined _ARCH_PPC64
{
struct SplitStructMixed s = {1234, 100, 1337.0f};
zig_split_struct_mixed(s);
}
#endif
#if !defined __mips__ && !defined __riscv
#if !defined __mips__ && !defined ZIG_PPC32
{
struct BigStruct s = {30, 31, 32, 33, 34};
struct BigStruct res = zig_big_struct_both(s);
@@ -314,7 +345,7 @@ void run_c_tests(void) {
}
#endif
#ifndef __riscv
#if !defined ZIG_PPC32 && !defined _ARCH_PPC64
{
struct Rect r1 = {1, 21, 16, 4};
struct Rect r2 = {178, 189, 21, 15};
@@ -322,7 +353,7 @@ void run_c_tests(void) {
}
#endif
#if !defined __mips__ && !defined __riscv
#if !defined __mips__ && !defined ZIG_PPC32
{
struct FloatRect r1 = {1, 21, 16, 4};
struct FloatRect r2 = {178, 189, 21, 15};
@@ -335,9 +366,7 @@ void run_c_tests(void) {
assert_or_panic(zig_ret_u8() == 0xff);
assert_or_panic(zig_ret_u16() == 0xffff);
#ifndef __riscv
assert_or_panic(zig_ret_u32() == 0xffffffff);
#endif
assert_or_panic(zig_ret_u64() == 0xffffffffffffffff);
assert_or_panic(zig_ret_i8() == -1);
@@ -404,7 +433,7 @@ void c_long_double(long double x) {
}
void c_ptr(void *x) {
assert_or_panic(x == (void*)0xdeadbeefL);
assert_or_panic(x == (void *)0xdeadbeefL);
}
void c_bool(bool x) {
@@ -672,7 +701,7 @@ void c_struct_with_array(StructWithArray x) {
}
StructWithArray c_ret_struct_with_array() {
return (StructWithArray) { 4, {}, 155 };
return (StructWithArray){4, {}, 155};
}
typedef struct {
@@ -701,3 +730,43 @@ FloatArrayStruct c_ret_float_array_struct() {
x.size.height = 4;
return x;
}
typedef uint32_t SmallVec __attribute__((vector_size(2 * sizeof(uint32_t))));
void c_small_vec(SmallVec vec) {
assert_or_panic(vec[0] == 1);
assert_or_panic(vec[1] == 2);
}
SmallVec c_ret_small_vec(void) {
return (SmallVec){3, 4};
}
typedef size_t BigVec __attribute__((vector_size(8 * sizeof(size_t))));
void c_big_vec(BigVec vec) {
assert_or_panic(vec[0] == 1);
assert_or_panic(vec[1] == 2);
assert_or_panic(vec[2] == 3);
assert_or_panic(vec[3] == 4);
assert_or_panic(vec[4] == 5);
assert_or_panic(vec[5] == 6);
assert_or_panic(vec[6] == 7);
assert_or_panic(vec[7] == 8);
}
BigVec c_ret_big_vec(void) {
return (BigVec){9, 10, 11, 12, 13, 14, 15, 16};
}
typedef struct {
float x, y;
} Vector2;
void c_ptr_size_float_struct(Vector2 vec) {
assert_or_panic(vec.x == 1);
assert_or_panic(vec.y == 2);
}
Vector2 c_ret_ptr_size_float_struct(void) {
return (Vector2){3, 4};
}

148
test/c_abi/main.zig
View File

@@ -3,7 +3,7 @@ const builtin = @import("builtin");
const print = std.debug.print;
const expect = std.testing.expect;
const has_i128 = builtin.cpu.arch != .i386 and !builtin.cpu.arch.isARM() and
!builtin.cpu.arch.isMIPS();
!builtin.cpu.arch.isMIPS() and !builtin.cpu.arch.isPPC();
extern fn run_c_tests() void;
@@ -112,6 +112,9 @@ test "C ABI floats" {
}
test "C ABI long double" {
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
c_long_double(12.34);
}
@@ -167,7 +170,8 @@ extern fn c_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble;
extern fn c_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat;
extern fn c_cmultd(a: ComplexDouble, b: ComplexDouble) ComplexDouble;
const complex_abi_compatible = builtin.cpu.arch != .i386 and !builtin.cpu.arch.isMIPS();
const complex_abi_compatible = builtin.cpu.arch != .i386 and !builtin.cpu.arch.isMIPS() and
!builtin.cpu.arch.isARM() and !builtin.cpu.arch.isPPC() and !builtin.cpu.arch.isRISCV();
test "C ABI complex float" {
if (!complex_abi_compatible) return error.SkipZigTest;
@@ -177,8 +181,8 @@ test "C ABI complex float" {
const b = ComplexFloat{ .real = 11.3, .imag = -1.5 };
const z = c_cmultf(a, b);
expect(z.real == 1.5) catch @panic("test failure: zig_complex_float 1");
expect(z.imag == 13.5) catch @panic("test failure: zig_complex_float 2");
try expect(z.real == 1.5);
try expect(z.imag == 13.5);
}
test "C ABI complex float by component" {
@@ -188,8 +192,8 @@ test "C ABI complex float by component" {
const b = ComplexFloat{ .real = 11.3, .imag = -1.5 };
const z2 = c_cmultf_comp(a.real, a.imag, b.real, b.imag);
expect(z2.real == 1.5) catch @panic("test failure: zig_complex_float 3");
expect(z2.imag == 13.5) catch @panic("test failure: zig_complex_float 4");
try expect(z2.real == 1.5);
try expect(z2.imag == 13.5);
}
test "C ABI complex double" {
@@ -199,8 +203,8 @@ test "C ABI complex double" {
const b = ComplexDouble{ .real = 11.3, .imag = -1.5 };
const z = c_cmultd(a, b);
expect(z.real == 1.5) catch @panic("test failure: zig_complex_double 1");
expect(z.imag == 13.5) catch @panic("test failure: zig_complex_double 2");
try expect(z.real == 1.5);
try expect(z.imag == 13.5);
}
test "C ABI complex double by component" {
@@ -210,8 +214,8 @@ test "C ABI complex double by component" {
const b = ComplexDouble{ .real = 11.3, .imag = -1.5 };
const z = c_cmultd_comp(a.real, a.imag, b.real, b.imag);
expect(z.real == 1.5) catch @panic("test failure: zig_complex_double 3");
expect(z.imag == 13.5) catch @panic("test failure: zig_complex_double 4");
try expect(z.real == 1.5);
try expect(z.imag == 13.5);
}
export fn zig_cmultf(a: ComplexFloat, b: ComplexFloat) ComplexFloat {
@@ -261,7 +265,7 @@ extern fn c_big_struct(BigStruct) void;
test "C ABI big struct" {
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
var s = BigStruct{
.a = 1,
@@ -287,7 +291,7 @@ const BigUnion = extern union {
extern fn c_big_union(BigUnion) void;
test "C ABI big union" {
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
var x = BigUnion{
.a = BigStruct{
@@ -320,9 +324,9 @@ extern fn c_ret_med_struct_mixed() MedStructMixed;
test "C ABI medium struct of ints and floats" {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isARM()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
var s = MedStructMixed{
.a = 1234,
@@ -331,9 +335,9 @@ test "C ABI medium struct of ints and floats" {
};
c_med_struct_mixed(s);
var s2 = c_ret_med_struct_mixed();
expect(s2.a == 1234) catch @panic("test failure");
expect(s2.b == 100.0) catch @panic("test failure");
expect(s2.c == 1337.0) catch @panic("test failure");
try expect(s2.a == 1234);
try expect(s2.b == 100.0);
try expect(s2.c == 1337.0);
}
export fn zig_med_struct_mixed(x: MedStructMixed) void {
@@ -353,9 +357,9 @@ extern fn c_ret_small_struct_ints() SmallStructInts;
test "C ABI small struct of ints" {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isARM()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
var s = SmallStructInts{
.a = 1,
@@ -365,10 +369,10 @@ test "C ABI small struct of ints" {
};
c_small_struct_ints(s);
var s2 = c_ret_small_struct_ints();
expect(s2.a == 1) catch @panic("test failure");
expect(s2.b == 2) catch @panic("test failure");
expect(s2.c == 3) catch @panic("test failure");
expect(s2.d == 4) catch @panic("test failure");
try expect(s2.a == 1);
try expect(s2.b == 2);
try expect(s2.c == 3);
try expect(s2.d == 4);
}
export fn zig_small_struct_ints(x: SmallStructInts) void {
@@ -435,9 +439,9 @@ extern fn c_split_struct_ints(SplitStructInt) void;
test "C ABI split struct of ints" {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isARM()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
var s = SplitStructInt{
.a = 1234,
@@ -463,9 +467,9 @@ extern fn c_ret_split_struct_mixed() SplitStructMixed;
test "C ABI split struct of ints and floats" {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isARM()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
var s = SplitStructMixed{
.a = 1234,
@@ -474,9 +478,9 @@ test "C ABI split struct of ints and floats" {
};
c_split_struct_mixed(s);
var s2 = c_ret_split_struct_mixed();
expect(s2.a == 1234) catch @panic("test failure");
expect(s2.b == 100) catch @panic("test failure");
expect(s2.c == 1337.0) catch @panic("test failure");
try expect(s2.a == 1234);
try expect(s2.b == 100);
try expect(s2.c == 1337.0);
}
export fn zig_split_struct_mixed(x: SplitStructMixed) void {
@@ -492,7 +496,7 @@ extern fn c_multiple_struct_floats(FloatRect, FloatRect) void;
test "C ABI sret and byval together" {
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
var s = BigStruct{
.a = 1,
@@ -543,9 +547,9 @@ const Vector5 = extern struct {
extern fn c_big_struct_floats(Vector5) void;
test "C ABI structs of floats as parameter" {
if (comptime builtin.cpu.arch.isARM()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
var v3 = Vector3{
.x = 3.0,
@@ -584,7 +588,8 @@ export fn zig_multiple_struct_ints(x: Rect, y: Rect) void {
}
test "C ABI structs of ints as multiple parameters" {
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
var r1 = Rect{
.left = 1,
@@ -621,7 +626,7 @@ export fn zig_multiple_struct_floats(x: FloatRect, y: FloatRect) void {
test "C ABI structs of floats as multiple parameters" {
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
var r1 = FloatRect{
.left = 1,
@@ -725,15 +730,15 @@ extern fn c_ret_struct_with_array() StructWithArray;
test "Struct with array as padding." {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isARM()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 });
var x = c_ret_struct_with_array();
try std.testing.expect(x.a == 4);
try std.testing.expect(x.b == 155);
try expect(x.a == 4);
try expect(x.b == 155);
}
const FloatArrayStruct = extern struct {
@@ -752,7 +757,7 @@ extern fn c_ret_float_array_struct() FloatArrayStruct;
test "Float array like struct" {
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
c_float_array_struct(.{
.origin = .{
@@ -766,8 +771,63 @@ test "Float array like struct" {
});
var x = c_ret_float_array_struct();
try std.testing.expect(x.origin.x == 1);
try std.testing.expect(x.origin.y == 2);
try std.testing.expect(x.size.width == 3);
try std.testing.expect(x.size.height == 4);
try expect(x.origin.x == 1);
try expect(x.origin.y == 2);
try expect(x.size.width == 3);
try expect(x.size.height == 4);
}
const SmallVec = @Vector(2, u32);
extern fn c_small_vec(SmallVec) void;
extern fn c_ret_small_vec() SmallVec;
test "small simd vector" {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
c_small_vec(.{ 1, 2 });
var x = c_ret_small_vec();
try expect(x[0] == 3);
try expect(x[1] == 4);
}
const BigVec = @Vector(8, usize);
extern fn c_big_vec(BigVec) void;
extern fn c_ret_big_vec() BigVec;
test "big simd vector" {
if (comptime builtin.cpu.arch.isPPC64()) return error.SkipZigTest;
c_big_vec(.{ 1, 2, 3, 4, 5, 6, 7, 8 });
var x = c_ret_big_vec();
try expect(x[0] == 9);
try expect(x[1] == 10);
try expect(x[2] == 11);
try expect(x[3] == 12);
try expect(x[4] == 13);
try expect(x[5] == 14);
try expect(x[6] == 15);
try expect(x[7] == 16);
}
const Vector2 = extern struct { x: f32, y: f32 };
extern fn c_ptr_size_float_struct(Vector2) void;
extern fn c_ret_ptr_size_float_struct() Vector2;
test "C ABI pointer sized float struct" {
if (builtin.cpu.arch == .i386) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
if (comptime builtin.cpu.arch.isPPC()) return error.SkipZigTest;
c_ptr_size_float_struct(.{ .x = 1, .y = 2 });
var x = c_ret_ptr_size_float_struct();
try expect(x.x == 3);
try expect(x.y == 4);
}

17
test/standalone.zig
View File

@@ -44,23 +44,6 @@ pub fn addCases(cases: *tests.StandaloneContext) void {
if (builtin.os.tag != .wasi) {
cases.addBuildFile("test/standalone/load_dynamic_library/build.zig", .{});
}
// C ABI compatibility issue: https://github.com/ziglang/zig/issues/1481
if (builtin.cpu.arch == .x86_64) {
if (builtin.zig_backend == .stage1 or builtin.zig_backend == .stage2_llvm) {
cases.addBuildFile("test/c_abi/build.zig", .{});
}
}
if (builtin.cpu.arch.isAARCH64() and builtin.zig_backend == .stage2_llvm) {
cases.addBuildFile("test/c_abi/build.zig", .{});
}
if (builtin.cpu.arch == .i386 and builtin.zig_backend == .stage2_llvm) {
cases.addBuildFile("test/c_abi/build.zig", .{});
}
// C ABI tests only pass for the Wasm target when using stage2
cases.addBuildFile("test/c_abi/build_wasm.zig", .{
.requires_stage2 = true,
.use_emulation = true,
});
cases.addBuildFile("test/standalone/c_compiler/build.zig", .{
.build_modes = true,

79
test/tests.zig
View File

@@ -1268,3 +1268,82 @@ fn printInvocation(args: []const []const u8) void {
}
std.debug.print("\n", .{});
}
const c_abi_targets = [_]CrossTarget{
.{},
.{
.cpu_arch = .x86_64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .i386,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .aarch64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .arm,
.os_tag = .linux,
.abi = .musleabihf,
},
.{
.cpu_arch = .mips,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .riscv64,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .wasm32,
.os_tag = .wasi,
.abi = .musl,
},
.{
.cpu_arch = .powerpc,
.os_tag = .linux,
.abi = .musl,
},
.{
.cpu_arch = .powerpc64le,
.os_tag = .linux,
.abi = .musl,
},
};
pub fn addCAbiTests(b: *build.Builder, skip_non_native: bool) *build.Step {
const step = b.step("test-c-abi", "Run the C ABI tests");
for (c_abi_targets) |c_abi_target| {
if (skip_non_native and !c_abi_target.isNative())
continue;
const test_step = b.addTest("test/c_abi/main.zig");
test_step.setTarget(c_abi_target);
if (c_abi_target.abi != null and c_abi_target.abi.?.isMusl()) {
// TODO NativeTargetInfo insists on dynamically linking musl
// for some reason?
test_step.target_info.dynamic_linker.max_byte = null;
}
test_step.linkLibC();
test_step.addCSourceFile("test/c_abi/cfuncs.c", &.{"-std=c99"});
const triple_prefix = c_abi_target.zigTriple(b.allocator) catch unreachable;
test_step.setNamePrefix(b.fmt("{s}-{s} ", .{
"test-c-abi",
triple_prefix,
}));
test_step.use_stage1 = false;
step.dependOn(&test_step.step);
}
return step;
}