srctree

fn handler(sig: i32, info: *const posix.siginfo_t, ctx_ptr: ?*anyopaque) callconv(.C) void {

/// Rendered as an identifier (using fmtIdent)

/// Rendered as "payload." followed by as identifier (using fmtIdent)

/// Rendered with fmtCTypePoolString

ctype_pool_string: CType.Pool.String,

fn_name: CType.Pool.String,

const Data = union {

fn getType(local: Local) LocalType {

fn isInitializer(loc: ValueRenderLocation) bool {

return switch (loc) {

 

fn toCTypeKind(loc: ValueRenderLocation) CType.Kind {

return switch (loc) {

.FunctionArgument => .parameter,

.Initializer, .Other => .complete,

.StaticInitializer => .global,

};

}

comptime fmt_str: []const u8,

_: std.fmt.FormatOptions,

) @TypeOf(writer).Error!void {

const solo = fmt_str.len != 0 and fmt_str[0] == ' '; // space means solo; not part of a bigger ident.

const CTypePoolStringFormatData = struct {

ctype_pool_string: CType.Pool.String,

ctype_pool: *const CType.Pool,

};

fn formatCTypePoolString(

data: CTypePoolStringFormatData,

comptime fmt_str: []const u8,

fmt_opts: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

if (data.ctype_pool_string.toSlice(data.ctype_pool)) |slice|

try formatIdent(slice, fmt_str, fmt_opts, writer)

else

try writer.print("{}", .{data.ctype_pool_string.fmt(data.ctype_pool)});

}

pub fn fmtCTypePoolString(

ctype_pool_string: CType.Pool.String,

ctype_pool: *const CType.Pool,

) std.fmt.Formatter(formatCTypePoolString) {

return .{ .data = .{ .ctype_pool_string = ctype_pool_string, .ctype_pool = ctype_pool } };

}

 

break :result .{ .local = decl_c_value.new_local };

.local_ref => |i| try w.print("&t{d}", .{i}),

return gop.value_ptr.fn_name.toSlice(ctype_pool).?;

 

fn copyCValue(f: *Function, ctype: CType, dst: CValue, src: CValue) !void {

switch (dst) {

.new_local, .local => |dst_local_index| switch (src) {

.new_local, .local => |src_local_index| if (dst_local_index == src_local_index) return,

else => {},

},

else => {},

}

const writer = f.object.writer();

const a = try Assignment.start(f, writer, ctype);

try f.writeCValue(writer, dst, .Other);

try a.assign(f, writer);

try f.writeCValue(writer, src, .Initializer);

try a.end(f, writer);

}

 

fn moveCValue(f: *Function, inst: Air.Inst.Index, ty: Type, src: CValue) !CValue {

switch (src) {

// Move the freshly allocated local to be owned by this instruction,

// by returning it here instead of freeing it.

.new_local => return src,

else => {

try freeCValue(f, inst, src);

const dst = try f.allocLocal(inst, ty);

try f.copyCValue(try f.ctypeFromType(ty, .complete), dst, src);

return dst;

},

}

}

 

fn freeCValue(f: *Function, inst: ?Air.Inst.Index, val: CValue) !void {

switch (val) {

.new_local => |local_index| try freeLocal(f, inst, local_index, null),

else => {},

}

}

const ptr_ctype = try dg.ctypeFromType(ptr_ty, .complete);

const elem_ctype = ptr_ctype.info(ctype_pool).pointer.elem_ctype;

try dg.renderCType(writer, ptr_ctype);

const ctype = try dg.ctypeFromType(ty, .complete);

const elem_ctype = ctype.info(ctype_pool).pointer.elem_ctype;

try dg.renderCType(writer, ctype);

fn renderErrorName(dg: *DeclGen, writer: anytype, err_name: InternPool.NullTerminatedString) !void {

const zcu = dg.zcu;

const ip = &zcu.intern_pool;

try writer.print("zig_error_{}", .{fmtIdent(err_name.toSlice(ip))});

}

 

const ctype_pool = &dg.ctype_pool;

const ctype = try dg.ctypeFromType(ty, location.toCTypeKind());

try dg.renderCType(writer, ctype);

.err => |err| try dg.renderErrorName(writer, err.name),

.error_union => |error_union| switch (ctype.info(ctype_pool)) {

.basic => switch (error_union.val) {

.err_name => |err_name| try dg.renderErrorName(writer, err_name),

.payload => try writer.writeAll("0"),

},

.pointer, .aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| {

if (!location.isInitializer()) {

try writer.writeByte('(');

try dg.renderCType(writer, ctype);

try writer.writeByte(')');

try writer.writeByte('{');

for (0..aggregate.fields.len) |field_index| {

if (field_index > 0) try writer.writeByte(',');

switch (aggregate.fields.at(field_index, ctype_pool).name.index) {

.@"error" => switch (error_union.val) {

.err_name => |err_name| try dg.renderErrorName(writer, err_name),

.payload => try writer.writeByte('0'),

},

.payload => switch (error_union.val) {

.err_name => try dg.renderUndefValue(

writer,

ty.errorUnionPayload(zcu),

initializer_type,

),

.payload => |payload| try dg.renderValue(

writer,

Value.fromInterned(payload),

initializer_type,

),

},

else => unreachable,

}

}

try writer.writeByte('}');

},

.enum_tag => |enum_tag| try dg.renderValue(writer, Value.fromInterned(enum_tag.int), location),

const aggregate = ctype.info(ctype_pool).aggregate;

try dg.renderCType(writer, ctype);

for (0..aggregate.fields.len) |field_index| {

if (field_index > 0) try writer.writeByte(',');

try dg.renderValue(writer, Value.fromInterned(

switch (aggregate.fields.at(field_index, ctype_pool).name.index) {

.ptr => slice.ptr,

.len => slice.len,

else => unreachable,

},

), initializer_type);

}

try dg.renderCType(writer, ctype);

.opt => |opt| switch (ctype.info(ctype_pool)) {

.basic => if (ctype.isBool()) try writer.writeAll(switch (opt.val) {

.none => "true",

else => "false",

}) else switch (opt.val) {

.none => try writer.writeAll("0"),

else => |payload| switch (ip.indexToKey(payload)) {

.undef => |err_ty| try dg.renderUndefValue(

writer,

Type.fromInterned(err_ty),

location,

),

.err => |err| try dg.renderErrorName(writer, err.name),

else => unreachable,

},

},

.pointer => switch (opt.val) {

.none => try writer.writeAll("NULL"),

else => |payload| try dg.renderValue(writer, Value.fromInterned(payload), location),

},

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| {

.none => {},

else => |payload| switch (aggregate.fields.at(0, ctype_pool).name.index) {

.is_null, .payload => {},

.ptr, .len => return dg.renderValue(

writer,

Value.fromInterned(payload),

location,

),

}

if (!location.isInitializer()) {

try writer.writeByte('(');

try dg.renderCType(writer, ctype);

try writer.writeByte(')');

}

try writer.writeByte('{');

for (0..aggregate.fields.len) |field_index| {

if (field_index > 0) try writer.writeByte(',');

switch (aggregate.fields.at(field_index, ctype_pool).name.index) {

.is_null => try writer.writeAll(switch (opt.val) {

.none => "true",

else => "false",

}),

.payload => switch (opt.val) {

.none => try dg.renderUndefValue(

writer,

ty.optionalChild(zcu),

initializer_type,

),

else => |payload| try dg.renderValue(

writer,

Value.fromInterned(payload),

initializer_type,

),

},

.ptr => try writer.writeAll("NULL"),

.len => try dg.renderUndefValue(writer, Type.usize, initializer_type),

else => unreachable,

}

}

try writer.writeByte('}');

},

try dg.renderCType(writer, ctype);

try dg.renderCType(writer, ctype);

try dg.renderCType(writer, ctype);

try dg.renderUndefValue(writer, ty, location);

try dg.renderCType(writer, ctype);

try dg.renderValue(writer, Value.fromInterned(un.val), location);

try dg.renderValue(writer, Value.fromInterned(un.val), location);

try dg.renderCType(writer, ctype);

try dg.renderCType(writer, ctype);

try dg.renderCType(writer, ctype);

try dg.renderValue(writer, Value.fromInterned(un.val), location);

} else try writer.writeAll("0");

const has_tag = loaded_union.hasTag(ip);

if (has_tag) try writer.writeByte('{');

const aggregate = ctype.info(ctype_pool).aggregate;

for (0..if (has_tag) aggregate.fields.len else 1) |outer_field_index| {

if (outer_field_index > 0) try writer.writeByte(',');

switch (if (has_tag)

aggregate.fields.at(outer_field_index, ctype_pool).name.index

else

.payload) {

.tag => try dg.renderValue(

writer,

Value.fromInterned(un.tag),

initializer_type,

),

.payload => {

try writer.writeByte('{');

if (field_ty.hasRuntimeBits(zcu)) {

try writer.print(" .{ } = ", .{fmtIdent(field_name.toSlice(ip))});

try dg.renderValue(

writer,

Value.fromInterned(un.val),

initializer_type,

);

try writer.writeByte(' ');

} else for (0..loaded_union.field_types.len) |inner_field_index| {

const inner_field_ty = Type.fromInterned(

loaded_union.field_types.get(ip)[inner_field_index],

);

if (!inner_field_ty.hasRuntimeBits(zcu)) continue;

try dg.renderUndefValue(writer, inner_field_ty, initializer_type);

break;

}

try writer.writeByte('}');

},

else => unreachable,

if (has_tag) try writer.writeByte('}');

const ctype_pool = &dg.ctype_pool;

const ctype = try dg.ctypeFromType(ty, location.toCTypeKind());

.ptr_type => |ptr_type| switch (ptr_type.flags.size) {

.One, .Many, .C => {

try writer.writeAll("((");

try dg.renderCType(writer, ctype);

return writer.print("){x})", .{

try dg.fmtIntLiteral(try zcu.undefValue(Type.usize), .Other),

});

},

.Slice => {

if (!location.isInitializer()) {

try writer.writeByte('(');

try dg.renderCType(writer, ctype);

try writer.writeByte(')');

}

try writer.writeAll("{(");

const ptr_ty = ty.slicePtrFieldType(zcu);

try dg.renderType(writer, ptr_ty);

return writer.print("){x}, {0x}}}", .{

try dg.fmtIntLiteral(try zcu.undefValue(Type.usize), .Other),

});

},

.opt_type => |child_type| switch (ctype.info(ctype_pool)) {

.basic, .pointer => try dg.renderUndefValue(

writer,

Type.fromInterned(if (ctype.isBool()) .bool_type else child_type),

location,

),

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| {

switch (aggregate.fields.at(0, ctype_pool).name.index) {

.is_null, .payload => {},

.ptr, .len => return dg.renderUndefValue(

writer,

Type.fromInterned(child_type),

location,

),

else => unreachable,

}

if (!location.isInitializer()) {

try writer.writeByte('(');

try dg.renderCType(writer, ctype);

try writer.writeByte(')');

}

try writer.writeByte('{');

for (0..aggregate.fields.len) |field_index| {

if (field_index > 0) try writer.writeByte(',');

try dg.renderUndefValue(writer, Type.fromInterned(

switch (aggregate.fields.at(field_index, ctype_pool).name.index) {

.is_null => .bool_type,

.payload => child_type,

else => unreachable,

},

), initializer_type);

}

try writer.writeByte('}');

},

try dg.renderCType(writer, ctype);

try dg.renderCType(writer, ctype);

try dg.renderCType(writer, ctype);

const has_tag = loaded_union.hasTag(ip);

if (has_tag) try writer.writeByte('{');

const aggregate = ctype.info(ctype_pool).aggregate;

for (0..if (has_tag) aggregate.fields.len else 1) |outer_field_index| {

if (outer_field_index > 0) try writer.writeByte(',');

switch (if (has_tag)

aggregate.fields.at(outer_field_index, ctype_pool).name.index

else

.payload) {

.tag => try dg.renderUndefValue(

writer,

Type.fromInterned(loaded_union.enum_tag_ty),

initializer_type,

),

.payload => {

try writer.writeByte('{');

for (0..loaded_union.field_types.len) |inner_field_index| {

const inner_field_ty = Type.fromInterned(

loaded_union.field_types.get(ip)[inner_field_index],

);

if (!inner_field_ty.hasRuntimeBits(zcu)) continue;

try dg.renderUndefValue(

writer,

inner_field_ty,

initializer_type,

);

break;

}

try writer.writeByte('}');

},

else => unreachable,

if (has_tag) try writer.writeByte('}');

.error_union_type => |error_union_type| switch (ctype.info(ctype_pool)) {

.basic => try dg.renderUndefValue(

writer,

Type.fromInterned(error_union_type.error_set_type),

location,

),

.pointer, .aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| {

if (!location.isInitializer()) {

try writer.writeByte('(');

try dg.renderCType(writer, ctype);

try writer.writeByte(')');

}

try writer.writeByte('{');

for (0..aggregate.fields.len) |field_index| {

if (field_index > 0) try writer.writeByte(',');

try dg.renderUndefValue(

writer,

Type.fromInterned(

switch (aggregate.fields.at(field_index, ctype_pool).name.index) {

.@"error" => error_union_type.error_set_type,

.payload => error_union_type.payload_type,

else => unreachable,

},

),

initializer_type,

);

}

try writer.writeByte('}');

},

try dg.renderCType(writer, ctype);

fmt_ctype_pool_string: std.fmt.Formatter(formatCTypePoolString),

.fmt_ctype_pool_string => |fmt| try w.print("{}{ }", .{ trailing, fmt }),

.ident, .fmt_ctype_pool_string => {},

fn renderType(dg: *DeclGen, w: anytype, t: Type) error{OutOfMemory}!void {

fn renderCType(dg: *DeclGen, w: anytype, ctype: CType) error{OutOfMemory}!void {

fn intCastIsNoop(dg: *DeclGen, dest_ty: Type, src_ty: Type) bool {

const zcu = dg.zcu;

const dest_bits = dest_ty.bitSize(zcu);

const dest_int_info = dest_ty.intInfo(zcu);

const src_is_ptr = src_ty.isPtrAtRuntime(zcu);

const src_eff_ty: Type = if (src_is_ptr) switch (dest_int_info.signedness) {

.unsigned => Type.usize,

.signed => Type.isize,

} else src_ty;

 

const src_bits = src_eff_ty.bitSize(zcu);

const src_int_info = if (src_eff_ty.isAbiInt(zcu)) src_eff_ty.intInfo(zcu) else null;

if (dest_bits <= 64 and src_bits <= 64) {

const needs_cast = src_int_info == null or

(toCIntBits(dest_int_info.bits) != toCIntBits(src_int_info.?.bits) or

dest_int_info.signedness != src_int_info.?.signedness);

return !needs_cast and !src_is_ptr;

} else return false;

}

fn renderIntCast(

dg: *DeclGen,

w: anytype,

dest_ty: Type,

context: IntCastContext,

src_ty: Type,

location: ValueRenderLocation,

) !void {

.ctype_pool_string => |string| try w.print("{ }", .{

fmtCTypePoolString(string, &dg.ctype_pool),

}),

.none,

.new_local,

.local,

.local_ref,

.constant,

.arg,

.arg_array,

.ctype_pool_string,

=> unreachable,

.none,

.new_local,

.local,

.local_ref,

.constant,

.field,

.undef,

.arg,

.arg_array,

.ctype_pool_string,

=> unreachable,

const kind = loc.toCTypeKind();

try writer.print("{}{ }", .{ trailing, fmtCTypePoolString(field_info.name, ctype_pool) });

try w.print(" {}(", .{val.fn_name.fmt(lazy_ctype_pool)});

const fn_name = fmtCTypePoolString(val.fn_name, lazy_ctype_pool);

try o.dg.renderFunctionSignature(fwd_decl_writer, fn_decl_index, .forward, .{

.fmt_ctype_pool_string = fn_name,

});

.fmt_ctype_pool_string = fn_name,

.optional_payload => try airOptionalPayload(f, inst, false),

.optional_payload_ptr => try airOptionalPayload(f, inst, true),

.is_null => try airIsNull(f, inst, .eq, false),

.is_non_null => try airIsNull(f, inst, .neq, false),

.is_null_ptr => try airIsNull(f, inst, .eq, true),

.is_non_null_ptr => try airIsNull(f, inst, .neq, true),

.ptr_slice_len_ptr => try airSliceField(f, inst, true, "len"),

.new_local => |local_index| .{ .local = local_index },

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

if (f.object.dg.intCastIsNoop(inst_scalar_ty, scalar_ty)) return f.moveCValue(inst, inst_ty, operand);

 

const a = try Assignment.start(f, writer, try f.ctypeFromType(scalar_ty, .complete));

 

const dest_c_bits = toCIntBits(dest_bits) orelse

const need_cast = dest_c_bits < 64;

const need_lo = scalar_int_info.bits > 64 and dest_bits <= 64;

const need_mask = dest_bits < 8 or !std.math.isPowerOfTwo(dest_bits);

if (!need_cast and !need_lo and !need_mask) return f.moveCValue(inst, inst_ty, operand);

 

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_scalar_ty, .complete));

try a.assign(f, writer);

if (need_cast) {

if (need_lo) {

if (!need_mask) {

if (need_lo) try writer.writeByte(')');

try a.end(f, writer);

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const src_scalar_ctype = try f.ctypeFromType(src_ty.scalarType(zcu), .complete);

const v = try Vectorize.start(f, inst, writer, ptr_ty);

try f.freeCValue(inst, array_src);

try writer.writeAll(";\n");

try v.end(f, inst, writer);

const v = try Vectorize.start(f, inst, writer, ptr_ty);

const a = try Assignment.start(f, writer, src_scalar_ctype);

try a.assign(f, writer);

try writer.writeAll("zig_or_");

try a.end(f, writer);

try v.end(f, inst, writer);

switch (ptr_val) {

.local_ref => |ptr_local_index| switch (src_val) {

.new_local, .local => |src_local_index| if (ptr_local_index == src_local_index)

return .none,

else => {},

},

else => {},

}

const v = try Vectorize.start(f, inst, writer, ptr_ty);

const a = try Assignment.start(f, writer, src_scalar_ctype);

try a.assign(f, writer);

try a.end(f, writer);

try v.end(f, inst, writer);

const ctype_pool = &f.object.dg.ctype_pool;

const local = try f.allocLocal(inst, Type.bool);

const a = try Assignment.start(f, writer, CType.bool);

const operand_ctype = try f.ctypeFromType(operand_ty, .complete);

switch (operand_ctype.info(ctype_pool)) {

.basic, .pointer => {

try f.writeCValue(writer, lhs, .Other);

try writer.writeAll(compareOperatorC(operator));

try f.writeCValue(writer, rhs, .Other);

},

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| if (aggregate.fields.len == 2 and

(aggregate.fields.at(0, ctype_pool).name.index == .is_null or

aggregate.fields.at(1, ctype_pool).name.index == .is_null))

{

try f.writeCValueMember(writer, lhs, .{ .identifier = "is_null" });

try writer.writeAll(" || ");

try f.writeCValueMember(writer, rhs, .{ .identifier = "is_null" });

try writer.writeAll(" ? ");

try f.writeCValueMember(writer, lhs, .{ .identifier = "is_null" });

try writer.writeAll(compareOperatorC(operator));

try f.writeCValueMember(writer, rhs, .{ .identifier = "is_null" });

try writer.writeAll(" : ");

try f.writeCValueMember(writer, lhs, .{ .identifier = "payload" });

try writer.writeAll(compareOperatorC(operator));

try f.writeCValueMember(writer, rhs, .{ .identifier = "payload" });

} else for (0..aggregate.fields.len) |field_index| {

if (field_index > 0) try writer.writeAll(switch (operator) {

.lt, .lte, .gte, .gt => unreachable,

.eq => " && ",

.neq => " || ",

});

const field_name: CValue = .{

.ctype_pool_string = aggregate.fields.at(field_index, ctype_pool).name,

};

try f.writeCValueMember(writer, lhs, field_name);

try writer.writeAll(compareOperatorC(operator));

try f.writeCValueMember(writer, rhs, field_name);

},

const local = try f.allocLocal(inst, Type.bool);

if (!elem_ty.hasRuntimeBitsIgnoreComptime(zcu)) return f.moveCValue(inst, inst_ty, lhs);

const inst_scalar_ctype = try f.ctypeFromType(inst_scalar_ty, .complete);

const a = try Assignment.start(f, writer, inst_scalar_ctype);

try a.assign(f, writer);

// We must convert to and from integer types to prevent UB if the operation

// results in a NULL pointer, or if LHS is NULL. The operation is only UB

// if the result is NULL and then dereferenced.

try writer.writeByte('(');

try f.renderCType(writer, inst_scalar_ctype);

try writer.writeAll(")(((uintptr_t)");

try f.writeCValue(writer, lhs, .Other);

try v.elem(f, writer);

try writer.writeAll(") ");

try writer.writeByte(operator);

try writer.writeAll(" (");

try f.writeCValue(writer, rhs, .Other);

try v.elem(f, writer);

try writer.writeAll("*sizeof(");

try f.renderType(writer, elem_ty);

try writer.writeAll(")))");

try a.end(f, writer);

const a = try Assignment.start(f, writer, try f.ctypeFromType(ptr_ty, .complete));

const a = try Assignment.start(f, writer, CType.usize);

CType.void

try f.renderCType(writer, CType.void);

try f.freeCValue(inst, resolved_arg);

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(operand_ty, .complete));

const inst_ty = f.typeOfIndex(inst);

const bitcasted = try bitcast(f, inst_ty, operand, operand_ty);

return f.moveCValue(inst, inst_ty, bitcasted);

fn bitcast(f: *Function, dest_ty: Type, operand: CValue, operand_ty: Type) !CValue {

src_info.bits == dest_info.bits) return operand;

return local;

try f.freeCValue(null, operand_lval);

return local;

 

const lowered_condition_ty = if (condition_ty.toIntern() == .bool_type)

Type.u1

else if (condition_ty.isPtrAtRuntime(zcu))

Type.usize

else

condition_ty;

if (condition_ty.toIntern() != lowered_condition_ty.toIntern()) {

try f.renderType(writer, lowered_condition_ty);

const case_body: []const Air.Inst.Index =

@ptrCast(f.air.extra[case.end + items.len ..][0..case.data.body_len]);

const item_value = try f.air.value(item, zcu);

if (item_value.?.getUnsignedInt(zcu)) |item_int| try writer.print("{}\n", .{

try f.fmtIntLiteral(try zcu.intValue(lowered_condition_ty, item_int)),

}) else {

if (condition_ty.isPtrAtRuntime(zcu)) {

try writer.writeByte('(');

try f.renderType(writer, Type.usize);

try writer.writeByte(')');

}

try f.object.dg.renderValue(writer, (try f.air.value(item, zcu)).?, .Other);

operator: std.math.CompareOperator,

const ctype_pool = &f.object.dg.ctype_pool;

const a = try Assignment.start(f, writer, CType.bool);

try a.assign(f, writer);

const opt_ctype = try f.ctypeFromType(optional_ty, .complete);

const rhs = switch (opt_ctype.info(ctype_pool)) {

.basic, .pointer => rhs: {

if (is_ptr)

try f.writeCValueDeref(writer, operand)

else

try f.writeCValue(writer, operand, .Other);

break :rhs if (opt_ctype.isBool())

"true"

else if (opt_ctype.isInteger())

"0"

else

"NULL";

},

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| switch (aggregate.fields.at(0, ctype_pool).name.index) {

.is_null, .payload => rhs: {

if (is_ptr)

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "is_null" })

else

try f.writeCValueMember(writer, operand, .{ .identifier = "is_null" });

break :rhs "true";

},

.ptr, .len => rhs: {

if (is_ptr)

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "ptr" })

else

try f.writeCValueMember(writer, operand, .{ .identifier = "ptr" });

break :rhs "NULL";

},

else => unreachable,

},

try writer.writeAll(compareOperatorC(operator));

try writer.writeAll(rhs);

fn airOptionalPayload(f: *Function, inst: Air.Inst.Index, is_ptr: bool) !CValue {

const ctype_pool = &f.object.dg.ctype_pool;

const operand_ty = f.typeOf(ty_op.operand);

const opt_ty = if (is_ptr) operand_ty.childType(zcu) else operand_ty;

const opt_ctype = try f.ctypeFromType(opt_ty, .complete);

if (opt_ctype.isBool()) return if (is_ptr) .{ .undef = inst_ty } else .none;

const operand = try f.resolveInst(ty_op.operand);

switch (opt_ctype.info(ctype_pool)) {

.basic, .pointer => return f.moveCValue(inst, inst_ty, operand),

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| switch (aggregate.fields.at(0, ctype_pool).name.index) {

.is_null, .payload => {

const writer = f.object.writer();

const local = try f.allocLocal(inst, inst_ty);

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

try f.writeCValue(writer, local, .Other);

try a.assign(f, writer);

if (is_ptr) {

try writer.writeByte('&');

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "payload" });

} else try f.writeCValueMember(writer, operand, .{ .identifier = "payload" });

try a.end(f, writer);

return local;

},

.ptr, .len => return f.moveCValue(inst, inst_ty, operand),

else => unreachable,

},

const opt_ctype = try f.ctypeFromType(operand_ty.childType(zcu), .complete);

switch (opt_ctype.info(&f.object.dg.ctype_pool)) {

.basic => {

const a = try Assignment.start(f, writer, opt_ctype);

try f.writeCValueDeref(writer, operand);

try a.assign(f, writer);

try f.object.dg.renderValue(writer, Value.false, .Initializer);

try a.end(f, writer);

},

.pointer => {

if (f.liveness.isUnused(inst)) return .none;

const local = try f.allocLocal(inst, inst_ty);

const a = try Assignment.start(f, writer, opt_ctype);

try f.writeCValue(writer, local, .Other);

try a.assign(f, writer);

try f.writeCValue(writer, operand, .Other);

try a.end(f, writer);

return local;

},

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => {

{

const a = try Assignment.start(f, writer, opt_ctype);

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "is_null" });

try a.assign(f, writer);

try f.object.dg.renderValue(writer, Value.false, .Initializer);

try a.end(f, writer);

}

if (f.liveness.isUnused(inst)) return .none;

const local = try f.allocLocal(inst, inst_ty);

const a = try Assignment.start(f, writer, opt_ctype);

try f.writeCValue(writer, local, .Other);

try a.assign(f, writer);

try writer.writeByte('&');

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "payload" });

try a.end(f, writer);

return local;

},

if (local.new_local != temp_local.new_local) {

try writer.writeAll("memcpy(");

try f.writeCValue(writer, .{ .local_ref = local.new_local }, .FunctionArgument);

try writer.writeAll(", ");

try f.writeCValue(writer, .{ .local_ref = temp_local.new_local }, .FunctionArgument);

try writer.writeAll(", sizeof(");

try f.renderType(writer, inst_ty);

try writer.writeAll("));\n");

}

if (switch (local) {

.new_local, .local => |local_index| switch (operand_lval) {

.new_local, .local => |operand_local_index| local_index != operand_local_index,

else => true,

},

else => true,

}) {

try writer.writeAll("memcpy(&");

try f.writeCValue(writer, local, .Other);

try writer.writeAll(", &");

try f.writeCValue(writer, operand_lval, .Other);

try writer.writeAll(", sizeof(");

try f.renderType(writer, inst_ty);

try writer.writeAll("));\n");

try f.freeCValue(inst, operand_lval);

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const ctype_pool = &f.object.dg.ctype_pool;

const inst_ctype = try f.ctypeFromType(inst_ty, .complete);

if (inst_ctype.isBool()) return .{ .constant = Value.true };

const operand = try f.resolveInst(ty_op.operand);

switch (inst_ctype.info(ctype_pool)) {

.basic, .pointer => return f.moveCValue(inst, inst_ty, operand),

.aligned, .array, .vector, .fwd_decl, .function => unreachable,

.aggregate => |aggregate| switch (aggregate.fields.at(0, ctype_pool).name.index) {

.is_null, .payload => {

const operand_ctype = try f.ctypeFromType(f.typeOf(ty_op.operand), .complete);

const writer = f.object.writer();

const local = try f.allocLocal(inst, inst_ty);

{

const a = try Assignment.start(f, writer, CType.bool);

try f.writeCValueMember(writer, local, .{ .identifier = "is_null" });

try a.assign(f, writer);

try writer.writeAll("false");

try a.end(f, writer);

}

{

const a = try Assignment.start(f, writer, operand_ctype);

try f.writeCValueMember(writer, local, .{ .identifier = "payload" });

try a.assign(f, writer);

try f.writeCValue(writer, operand, .Initializer);

try a.end(f, writer);

}

return local;

},

.ptr, .len => return f.moveCValue(inst, inst_ty, operand),

else => unreachable,

},

const a = try Assignment.start(f, writer, try f.ctypeFromType(payload_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(err_ty, .complete));

const inst_ty = f.typeOfIndex(inst);

const operand_ty = f.typeOf(ty_op.operand);

const error_union_ty = operand_ty.childType(zcu);

try reap(f, inst, &.{ty_op.operand});

const a = try Assignment.start(f, writer, try f.ctypeFromType(operand_ty, .complete));

try a.assign(f, writer);

try writer.print("{}", .{try f.fmtIntLiteral(no_err)});

try a.end(f, writer);

return .none;

}

{

const a = try Assignment.start(f, writer, try f.ctypeFromType(err_int_ty, .complete));

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "error" });

try a.assign(f, writer);

try writer.print("{}", .{try f.fmtIntLiteral(no_err)});

try a.end(f, writer);

const local = try f.allocLocal(inst, inst_ty);

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

try a.assign(f, writer);

try writer.writeByte('&');

try f.writeCValueDerefMember(writer, operand, .{ .identifier = "payload" });

try a.end(f, writer);

const a = try Assignment.start(f, writer, try f.ctypeFromType(payload_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(err_ty, .complete));

const a = try Assignment.start(f, writer, CType.bool);

const a = try Assignment.start(f, writer, try f.ctypeFromType(ptr_ty, .complete));

const a = try Assignment.start(f, writer, CType.usize);

const a = try Assignment.start(f, writer, try f.ctypeFromType(scalar_ty, .complete));

if (operand_ty.isSlice(zcu))

try f.writeCValueMember(writer, operand, .{ .identifier = "ptr" })

else

const ctype = try f.ctypeFromType(ty, .complete);

const new_value_mat = try Materialize.start(f, inst, ty, new_value);

const a = try Assignment.start(f, writer, ctype);

const a = try Assignment.start(f, writer, ctype);

const a = try Assignment.start(f, writer, ctype);

const a = try Assignment.start(f, writer, CType.bool);

const operand_mat = try Materialize.start(f, inst, ty, operand);

const element_mat = try Materialize.start(f, inst, ty, element);

const a = try Assignment.start(f, writer, try f.ctypeFromType(elem_ty, .complete));

try f.writeCValue(writer, bitcasted, .FunctionArgument);

try f.writeCValue(writer, bitcasted, .FunctionArgument);

try f.freeCValue(inst, bitcasted);

const a = try Assignment.start(f, writer, try f.ctypeFromType(tag_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(inst_scalar_ty, .complete));

const a: Assignment = .{

.ctype = try f.ctypeFromType(Type.fromInterned(info.child), .complete),

};

const a = try Assignment.start(f, writer, try f.ctypeFromType(field_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(field_ty, .complete));

if (loaded_union.getLayout(ip) == .@"packed") return f.moveCValue(inst, union_ty, payload);

const a = try Assignment.start(f, writer, try f.ctypeFromType(tag_ty, .complete));

const a = try Assignment.start(f, writer, try f.ctypeFromType(payload_ty, .complete));

// C99 only requires 4095.

const max_string_initializer_len = @min(65535, 4095);

// C99 only requires 4095.

const max_literal_len = @min(16380 - max_char_len, 4095);

.ctype = CType.void,

.ctype = CType.u64,

pub fn start(f: *Function, inst: Air.Inst.Index, ty: Type, value: CValue) !Materialize {

return .{ .local = switch (value) {

.local_ref, .constant, .decl_ref, .undef => try f.moveCValue(inst, ty, value),

.new_local => |local| .{ .local = local },

else => value,

} };

try f.freeCValue(inst, self.local);

pub fn start(f: *Function, writer: anytype, ctype: CType) !Assignment {

const self: Assignment = .{ .ctype = ctype };

pub const @"void": CType = .{ .index = .void };

pub const @"bool": CType = .{ .index = .bool };

pub const @"i8": CType = .{ .index = .int8_t };

pub const @"u8": CType = .{ .index = .uint8_t };

pub const @"i16": CType = .{ .index = .int16_t };

pub const @"u16": CType = .{ .index = .uint16_t };

pub const @"i32": CType = .{ .index = .int32_t };

pub const @"u32": CType = .{ .index = .uint32_t };

pub const @"i64": CType = .{ .index = .int64_t };

pub const @"u64": CType = .{ .index = .uint64_t };

pub const @"i128": CType = .{ .index = .zig_i128 };

pub const @"u128": CType = .{ .index = .zig_u128 };

pub const @"isize": CType = .{ .index = .intptr_t };

pub const @"usize": CType = .{ .index = .uintptr_t };

pub const @"f16": CType = .{ .index = .zig_f16 };

pub const @"f32": CType = .{ .index = .zig_f32 };

pub const @"f64": CType = .{ .index = .zig_f64 };

pub const @"f80": CType = .{ .index = .zig_f80 };

pub const @"f128": CType = .{ .index = .zig_f128 };

 

const pool_index, const is_null =

return switch (is_null) {

name: Pool.String,

if (!std.meta.eql(lhs_field.alignas, rhs_field.alignas)) return false;

if (!pool_adapter.eql(lhs_field.ctype, rhs_field.ctype)) return false;

return if (lhs_field.name.toPoolSlice(lhs_pool)) |lhs_name|

if (rhs_field.name.toPoolSlice(rhs_pool)) |rhs_name|

std.mem.eql(u8, lhs_name, rhs_name)

else

false

else

lhs_field.name.index == rhs_field.name.index;

pub const String = struct {

index: String.Index,

 

const FormatData = struct { string: String, pool: *const Pool };

fn format(

data: FormatData,

comptime fmt_str: []const u8,

_: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

if (fmt_str.len > 0) @compileError("invalid format string '" ++ fmt_str ++ "'");

if (data.string.toSlice(data.pool)) |slice|

try writer.writeAll(slice)

else

try writer.print("f{d}", .{@intFromEnum(data.string.index)});

}

pub fn fmt(str: String, pool: *const Pool) std.fmt.Formatter(format) {

return .{ .data = .{ .string = str, .pool = pool } };

}

 

fn fromUnnamed(index: u31) String {

return .{ .index = @enumFromInt(index) };

}

 

fn isNamed(str: String) bool {

return @intFromEnum(str.index) >= String.Index.first_named_index;

}

 

pub fn toSlice(str: String, pool: *const Pool) ?[]const u8 {

return str.toPoolSlice(pool) orelse if (str.isNamed()) @tagName(str.index) else null;

}

 

fn toPoolSlice(str: String, pool: *const Pool) ?[]const u8 {

if (str.toPoolIndex()) |pool_index| {

const start = pool.string_indices.items[pool_index + 0];

const end = pool.string_indices.items[pool_index + 1];

return pool.string_bytes.items[start..end];

} else return null;

}

 

fn fromPoolIndex(pool_index: usize) String {

return .{ .index = @enumFromInt(String.Index.first_pool_index + pool_index) };

}

 

fn toPoolIndex(str: String) ?u32 {

const pool_index, const is_null =

@subWithOverflow(@intFromEnum(str.index), String.Index.first_pool_index);

return switch (is_null) {

0 => pool_index,

1 => null,

};

}

 

const Index = enum(u32) {

array = first_named_index,

@"error",

is_null,

len,

payload,

ptr,

tag,

_,

 

const first_named_index: u32 = 1 << 31;

const first_pool_index: u32 = first_named_index + @typeInfo(String.Index).Enum.fields.len;

};

 

const Adapter = struct {

pool: *const Pool,

pub fn hash(_: @This(), slice: []const u8) Map.Hash {

return @truncate(Hasher.Impl.hash(1, slice));

}

pub fn eql(string_adapter: @This(), lhs_slice: []const u8, _: void, rhs_index: usize) bool {

const rhs_string = String.fromPoolIndex(rhs_index);

const rhs_slice = rhs_string.toPoolSlice(string_adapter.pool).?;

return std.mem.eql(u8, lhs_slice, rhs_slice);

}

};

};

 

0 => return CType.void,

.signed => return CType.i8,

.unsigned => return CType.u8,

.signed => return CType.i16,

.unsigned => return CType.u16,

.signed => return CType.i32,

.unsigned => return CType.u32,

.signed => return CType.i64,

.unsigned => return CType.u64,

.signed => return CType.i128,

.unsigned => return CType.u128,

.name = .{ .index = .array },

=> return CType.void,

.u1_type, .u8_type => return CType.u8,

.i8_type => return CType.i8,

.u16_type => return CType.u16,

.i16_type => return CType.i16,

.u29_type, .u32_type => return CType.u32,

.i32_type => return CType.i32,

.u64_type => return CType.u64,

.i64_type => return CType.i64,

.u80_type, .u128_type => return CType.u128,

.i128_type => return CType.i128,

.usize_type => return CType.usize,

.isize_type => return CType.isize,

.f16_type => return CType.f16,

.f32_type => return CType.f32,

.f64_type => return CType.f64,

.f80_type => return CType.f80,

.f128_type => return CType.f128,

.bool_type, .optional_noreturn_type => return CType.bool,

.elem_ctype = CType.u8,

.elem_ctype = CType.u8,

.elem_ctype = CType.void,

.name = .{ .index = .ptr },

.elem_ctype = CType.u8,

.name = .{ .index = .len },

.ctype = CType.usize,

.name = .{ .index = .ptr },

.name = .{ .index = .len },

.ctype = CType.usize,

if (len == 0) return CType.void;

if (elem_ctype.index == .void) return CType.void;

.name = .{ .index = .array },

if (vector_info.len == 0) return CType.void;

if (elem_ctype.index == .void) return CType.void;

.name = .{ .index = .array },

if (ip.isNoReturn(payload_type)) return CType.void;

if (payload_ctype.index == .void) return CType.bool;

.name = .{ .index = .is_null },

.ctype = CType.bool,

.name = .{ .index = .payload },

.name = .{ .index = .@"error" },

.name = .{ .index = .payload },

CType.void;

String.fromUnnamed(@intCast(field_index));

if (fields_len == 0) return CType.void;

if (fields_len == 0) return CType.void;

CType.void;

if (fields_len == 0) return CType.void;

.name = .{ .index = .tag },

.name = .{ .index = .payload },

if (struct_fields_len == 0) return CType.void;

.opaque_type => return CType.void,

.func_type => |func_info| if (func_info.is_generic) return CType.void else {

) else CType.void;

const field_name = if (field.name.toPoolSlice(source_pool)) |slice|

try pool.string(allocator, slice)

else

field.name;

const field_name = if (field.name.toPoolSlice(source_pool)) |slice|

try pool.string(allocator, slice)

else

field.name;

pub fn string(pool: *Pool, allocator: std.mem.Allocator, slice: []const u8) !String {

try pool.string_bytes.appendSlice(allocator, slice);

switch (field.type) {

CType.Index => hasher.update((CType{ .index = value }).hash(pool)),

String.Index => if ((String{ .index = value }).toPoolSlice(pool)) |slice|

hasher.update(slice)

else

hasher.update(@intFromEnum(value)),

else => hasher.update(value),

}

const start = pool.string_indices.getLast();

const slice: []const u8 = pool.string_bytes.items[start..];

if (slice.len >= 2 and slice[0] == 'f' and switch (slice[1]) {

'0' => slice.len == 2,

'1'...'9' => true,

else => false,

}) if (std.fmt.parseInt(u31, slice[1..], 10)) |unnamed| {

pool.string_bytes.shrinkRetainingCapacity(start);

return String.fromUnnamed(unnamed);

} else |_| {};

if (std.meta.stringToEnum(String.Index, slice)) |index| {

pool.string_bytes.shrinkRetainingCapacity(start);

return .{ .index = index };

}

 

const gop = pool.string_map.getOrPutAssumeCapacityAdapted(slice, String.Adapter{ .pool = pool });

return String.fromPoolIndex(gop.index);

if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support always tail calls

 

if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support always tail calls

 

if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // MSVC doesn't support always tail calls

 

if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows and !builtin.link_libc) return error.SkipZigTest;

test "optional with zero-bit type" {

if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest;

if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;

const S = struct {

fn doTheTest(comptime ZeroBit: type, comptime zero_bit: ZeroBit) !void {

const WithRuntime = struct {

zero_bit: ZeroBit,

runtime: u1,

};

var with_runtime: WithRuntime = undefined;

with_runtime = .{ .zero_bit = zero_bit, .runtime = 0 };

 

const Opt = struct { opt: ?ZeroBit };

var opt: Opt = .{ .opt = null };

try expect(opt.opt == null);

try expect(opt.opt != zero_bit);

try expect(opt.opt != with_runtime.zero_bit);

opt.opt = zero_bit;

try expect(opt.opt != null);

try expect(opt.opt == zero_bit);

try expect(opt.opt == with_runtime.zero_bit);

opt = .{ .opt = zero_bit };

try expect(opt.opt != null);

try expect(opt.opt == zero_bit);

try expect(opt.opt == with_runtime.zero_bit);

opt.opt = with_runtime.zero_bit;

try expect(opt.opt != null);

try expect(opt.opt == zero_bit);

try expect(opt.opt == with_runtime.zero_bit);

opt = .{ .opt = with_runtime.zero_bit };

try expect(opt.opt != null);

try expect(opt.opt == zero_bit);

try expect(opt.opt == with_runtime.zero_bit);

 

var two: ?struct { ZeroBit, ZeroBit } = undefined;

two = .{ with_runtime.zero_bit, with_runtime.zero_bit };

if (!@inComptime()) {

try expect(two != null);

try expect(two.?[0] == zero_bit);

try expect(two.?[0] == with_runtime.zero_bit);

try expect(two.?[1] == zero_bit);

try expect(two.?[1] == with_runtime.zero_bit);

}

}

 

try S.doTheTest(void, {});

try comptime S.doTheTest(void, {});

try S.doTheTest(enum { only }, .only);

try comptime S.doTheTest(enum { only }, .only);

if (builtin.zig_backend == .stage2_c and builtin.os.tag == .windows) return error.SkipZigTest; // crashes MSVC

 

"-Wall",

"-Wembedded-directive",

"-Wempty-translation-unit",

"-Wextra",

"-Wgnu",

"-Winvalid-utf8",

"-Wkeyword-macro",

"-Woverlength-strings",

 

"-Wno-braced-scalar-init",

"-Wno-excess-initializers",

"-Wno-incompatible-pointer-types-discards-qualifiers",

"-Wno-unused",

"-Wno-unused-parameter",

"-Wno-incompatible-pointer-types",