Commit cd59b8277d
Changed files (1)
src
codegen
src/codegen/llvm.zig
@@ -745,7 +745,7 @@ pub const Object = struct {
const param = llvm_func.getParam(llvm_arg_i);
llvm_arg_i += 1;
- const param_llvm_ty = try dg.llvmType(param_ty);
+ const param_llvm_ty = try dg.lowerType(param_ty);
const abi_size = @intCast(c_uint, param_ty.abiSize(target));
const int_llvm_ty = dg.context.intType(abi_size * 8);
const int_ptr_llvm_ty = int_llvm_ty.pointerType(0);
@@ -775,7 +775,7 @@ pub const Object = struct {
.Struct => {
const fields = param_ty.structFields().values();
if (is_by_ref) {
- const param_llvm_ty = try dg.llvmType(param_ty);
+ const param_llvm_ty = try dg.lowerType(param_ty);
const arg_ptr = buildAllocaInner(builder, llvm_func, false, param_llvm_ty);
arg_ptr.setAlignment(param_ty.abiAlignment(target));
@@ -2100,7 +2100,7 @@ pub const DeclGen = struct {
break :init_val decl.val;
};
if (init_val.tag() != .unreachable_value) {
- const llvm_init = try dg.genTypedValue(.{ .ty = decl.ty, .val = init_val });
+ const llvm_init = try dg.lowerValue(.{ .ty = decl.ty, .val = init_val });
if (global.globalGetValueType() == llvm_init.typeOf()) {
global.setInitializer(llvm_init);
} else {
@@ -2171,7 +2171,7 @@ pub const DeclGen = struct {
const target = dg.module.getTarget();
const sret = firstParamSRet(fn_info, target);
- const fn_type = try dg.llvmType(zig_fn_type);
+ const fn_type = try dg.lowerType(zig_fn_type);
const fqn = try decl.getFullyQualifiedName(dg.module);
defer dg.gpa.free(fqn);
@@ -2198,7 +2198,7 @@ pub const DeclGen = struct {
dg.addArgAttr(llvm_fn, 0, "nonnull"); // Sret pointers must not be address 0
dg.addArgAttr(llvm_fn, 0, "noalias");
- const raw_llvm_ret_ty = try dg.llvmType(fn_info.return_type);
+ const raw_llvm_ret_ty = try dg.lowerType(fn_info.return_type);
llvm_fn.addSretAttr(0, raw_llvm_ret_ty);
}
@@ -2291,7 +2291,7 @@ pub const DeclGen = struct {
const fqn = try decl.getFullyQualifiedName(dg.module);
defer dg.gpa.free(fqn);
- const llvm_type = try dg.llvmType(decl.ty);
+ const llvm_type = try dg.lowerType(decl.ty);
const llvm_addrspace = dg.llvmAddressSpace(decl.@"addrspace");
const llvm_global = dg.object.llvm_module.addGlobalInAddressSpace(llvm_type, fqn, llvm_addrspace);
gop.value_ptr.* = llvm_global;
@@ -2345,15 +2345,15 @@ pub const DeclGen = struct {
}
fn isUnnamedType(dg: *DeclGen, ty: Type, val: *const llvm.Value) bool {
- // Once `llvmType` succeeds, successive calls to it with the same Zig type
- // are guaranteed to succeed. So if a call to `llvmType` fails here it means
+ // Once `lowerType` succeeds, successive calls to it with the same Zig type
+ // are guaranteed to succeed. So if a call to `lowerType` fails here it means
// it is the first time lowering the type, which means the value can't possible
// have that type.
- const llvm_ty = dg.llvmType(ty) catch return true;
+ const llvm_ty = dg.lowerType(ty) catch return true;
return val.typeOf() != llvm_ty;
}
- fn llvmType(dg: *DeclGen, t: Type) Allocator.Error!*const llvm.Type {
+ fn lowerType(dg: *DeclGen, t: Type) Allocator.Error!*const llvm.Type {
const gpa = dg.gpa;
const target = dg.module.getTarget();
switch (t.zigTypeTag()) {
@@ -2385,8 +2385,8 @@ pub const DeclGen = struct {
const ptr_type = t.slicePtrFieldType(&buf);
const fields: [2]*const llvm.Type = .{
- try dg.llvmType(ptr_type),
- try dg.llvmType(Type.usize),
+ try dg.lowerType(ptr_type),
+ try dg.lowerType(Type.usize),
};
return dg.context.structType(&fields, fields.len, .False);
}
@@ -2402,7 +2402,7 @@ pub const DeclGen = struct {
else => elem_ty.hasRuntimeBitsIgnoreComptime(),
};
const llvm_elem_ty = if (lower_elem_ty)
- try dg.llvmType(elem_ty)
+ try dg.lowerType(elem_ty)
else
dg.context.intType(8);
return llvm_elem_ty.pointerType(llvm_addrspace);
@@ -2430,12 +2430,12 @@ pub const DeclGen = struct {
.Array => {
const elem_ty = t.childType();
assert(elem_ty.onePossibleValue() == null);
- const elem_llvm_ty = try dg.llvmType(elem_ty);
+ const elem_llvm_ty = try dg.lowerType(elem_ty);
const total_len = t.arrayLen() + @boolToInt(t.sentinel() != null);
return elem_llvm_ty.arrayType(@intCast(c_uint, total_len));
},
.Vector => {
- const elem_type = try dg.llvmType(t.childType());
+ const elem_type = try dg.lowerType(t.childType());
return elem_type.vectorType(t.vectorLen());
},
.Optional => {
@@ -2444,7 +2444,7 @@ pub const DeclGen = struct {
if (!child_ty.hasRuntimeBitsIgnoreComptime()) {
return dg.context.intType(1);
}
- const payload_llvm_ty = try dg.llvmType(child_ty);
+ const payload_llvm_ty = try dg.lowerType(child_ty);
if (t.optionalReprIsPayload()) {
return payload_llvm_ty;
}
@@ -2458,13 +2458,13 @@ pub const DeclGen = struct {
const error_type = t.errorUnionSet();
const payload_type = t.errorUnionPayload();
if (error_type.errorSetCardinality() == .zero) {
- return dg.llvmType(payload_type);
+ return dg.lowerType(payload_type);
}
if (!payload_type.hasRuntimeBitsIgnoreComptime()) {
- return try dg.llvmType(Type.anyerror);
+ return try dg.lowerType(Type.anyerror);
}
- const llvm_error_type = try dg.llvmType(error_type);
- const llvm_payload_type = try dg.llvmType(payload_type);
+ const llvm_error_type = try dg.lowerType(error_type);
+ const llvm_payload_type = try dg.lowerType(payload_type);
const payload_align = payload_type.abiAlignment(target);
const error_align = Type.anyerror.abiAlignment(target);
@@ -2515,7 +2515,7 @@ pub const DeclGen = struct {
const llvm_array_ty = dg.context.intType(8).arrayType(@intCast(c_uint, padding_len));
try llvm_field_types.append(gpa, llvm_array_ty);
}
- const field_llvm_ty = try dg.llvmType(field_ty);
+ const field_llvm_ty = try dg.lowerType(field_ty);
try llvm_field_types.append(gpa, field_llvm_ty);
offset += field_ty.abiSize(target);
@@ -2544,7 +2544,7 @@ pub const DeclGen = struct {
if (struct_obj.layout == .Packed) {
var buf: Type.Payload.Bits = undefined;
const int_ty = struct_obj.packedIntegerType(target, &buf);
- const int_llvm_ty = try dg.llvmType(int_ty);
+ const int_llvm_ty = try dg.lowerType(int_ty);
gop.value_ptr.* = int_llvm_ty;
return int_llvm_ty;
}
@@ -2579,7 +2579,7 @@ pub const DeclGen = struct {
const llvm_array_ty = dg.context.intType(8).arrayType(@intCast(c_uint, padding_len));
try llvm_field_types.append(gpa, llvm_array_ty);
}
- const field_llvm_ty = try dg.llvmType(field.ty);
+ const field_llvm_ty = try dg.lowerType(field.ty);
try llvm_field_types.append(gpa, field_llvm_ty);
offset += field.ty.abiSize(target);
@@ -2614,7 +2614,7 @@ pub const DeclGen = struct {
const union_obj = t.cast(Type.Payload.Union).?.data;
if (layout.payload_size == 0) {
- const enum_tag_llvm_ty = try dg.llvmType(union_obj.tag_ty);
+ const enum_tag_llvm_ty = try dg.lowerType(union_obj.tag_ty);
gop.value_ptr.* = enum_tag_llvm_ty;
return enum_tag_llvm_ty;
}
@@ -2626,7 +2626,7 @@ pub const DeclGen = struct {
gop.value_ptr.* = llvm_union_ty; // must be done before any recursive calls
const aligned_field = union_obj.fields.values()[layout.most_aligned_field];
- const llvm_aligned_field_ty = try dg.llvmType(aligned_field.ty);
+ const llvm_aligned_field_ty = try dg.lowerType(aligned_field.ty);
const llvm_payload_ty = t: {
if (layout.most_aligned_field_size == layout.payload_size) {
@@ -2645,7 +2645,7 @@ pub const DeclGen = struct {
llvm_union_ty.structSetBody(&llvm_fields, llvm_fields.len, .False);
return llvm_union_ty;
}
- const enum_tag_llvm_ty = try dg.llvmType(union_obj.tag_ty);
+ const enum_tag_llvm_ty = try dg.lowerType(union_obj.tag_ty);
// Put the tag before or after the payload depending on which one's
// alignment is greater.
@@ -2667,7 +2667,7 @@ pub const DeclGen = struct {
llvm_union_ty.structSetBody(&llvm_fields, llvm_fields_len, .False);
return llvm_union_ty;
},
- .Fn => return llvmTypeFn(dg, t),
+ .Fn => return lowerTypeFn(dg, t),
.ComptimeInt => unreachable,
.ComptimeFloat => unreachable,
.Type => unreachable,
@@ -2682,7 +2682,7 @@ pub const DeclGen = struct {
}
}
- fn llvmTypeFn(dg: *DeclGen, fn_ty: Type) Allocator.Error!*const llvm.Type {
+ fn lowerTypeFn(dg: *DeclGen, fn_ty: Type) Allocator.Error!*const llvm.Type {
const target = dg.module.getTarget();
const fn_info = fn_ty.fnInfo();
const llvm_ret_ty = try lowerFnRetTy(dg, fn_info);
@@ -2691,7 +2691,7 @@ pub const DeclGen = struct {
defer llvm_params.deinit();
if (firstParamSRet(fn_info, target)) {
- const llvm_sret_ty = try dg.llvmType(fn_info.return_type);
+ const llvm_sret_ty = try dg.lowerType(fn_info.return_type);
try llvm_params.append(llvm_sret_ty.pointerType(0));
}
@@ -2703,7 +2703,7 @@ pub const DeclGen = struct {
.data = dg.object.getStackTraceType(),
};
const ptr_ty = Type.initPayload(&ptr_ty_payload.base);
- try llvm_params.append(try dg.llvmType(ptr_ty));
+ try llvm_params.append(try dg.lowerType(ptr_ty));
}
var it = iterateParamTypes(dg, fn_info);
@@ -2711,11 +2711,11 @@ pub const DeclGen = struct {
.no_bits => continue,
.byval => {
const param_ty = fn_info.param_types[it.zig_index - 1];
- try llvm_params.append(try dg.llvmType(param_ty));
+ try llvm_params.append(try dg.lowerType(param_ty));
},
.byref => {
const param_ty = fn_info.param_types[it.zig_index - 1];
- const raw_llvm_ty = try dg.llvmType(param_ty);
+ const raw_llvm_ty = try dg.lowerType(param_ty);
try llvm_params.append(raw_llvm_ty.pointerType(0));
},
.abi_sized_int => {
@@ -2757,7 +2757,7 @@ pub const DeclGen = struct {
// one field; in this case keep the type information
// to avoid the potentially costly ptrtoint/bitcast.
if (bits_used == 0 and field_abi_bits == int_bits) {
- const llvm_field_ty = try dg.llvmType(field.ty);
+ const llvm_field_ty = try dg.lowerType(field.ty);
llvm_params.appendAssumeCapacity(llvm_field_ty);
field_i += 1;
if (field_i >= fields.len) {
@@ -2795,16 +2795,16 @@ pub const DeclGen = struct {
);
}
- fn genTypedValue(dg: *DeclGen, tv: TypedValue) Error!*const llvm.Value {
+ fn lowerValue(dg: *DeclGen, tv: TypedValue) Error!*const llvm.Value {
if (tv.val.isUndef()) {
- const llvm_type = try dg.llvmType(tv.ty);
+ const llvm_type = try dg.lowerType(tv.ty);
return llvm_type.getUndef();
}
const target = dg.module.getTarget();
switch (tv.ty.zigTypeTag()) {
.Bool => {
- const llvm_type = try dg.llvmType(tv.ty);
+ const llvm_type = try dg.lowerType(tv.ty);
return if (tv.val.toBool()) llvm_type.constAllOnes() else llvm_type.constNull();
},
// TODO this duplicates code with Pointer but they should share the handling
@@ -2865,7 +2865,7 @@ pub const DeclGen = struct {
return unsigned_val;
},
.Float => {
- const llvm_ty = try dg.llvmType(tv.ty);
+ const llvm_ty = try dg.lowerType(tv.ty);
switch (tv.ty.floatBits(target)) {
16, 32, 64 => return llvm_ty.constReal(tv.val.toFloat(f64)),
80 => {
@@ -2902,7 +2902,7 @@ pub const DeclGen = struct {
const decl = dg.module.declPtr(decl_index);
dg.module.markDeclAlive(decl);
const val = try dg.resolveGlobalDecl(decl_index);
- const llvm_var_type = try dg.llvmType(tv.ty);
+ const llvm_var_type = try dg.lowerType(tv.ty);
const llvm_addrspace = dg.llvmAddressSpace(decl.@"addrspace");
const llvm_type = llvm_var_type.pointerType(llvm_addrspace);
return val.constBitCast(llvm_type);
@@ -2911,11 +2911,11 @@ pub const DeclGen = struct {
const slice = tv.val.castTag(.slice).?.data;
var buf: Type.SlicePtrFieldTypeBuffer = undefined;
const fields: [2]*const llvm.Value = .{
- try dg.genTypedValue(.{
+ try dg.lowerValue(.{
.ty = tv.ty.slicePtrFieldType(&buf),
.val = slice.ptr,
}),
- try dg.genTypedValue(.{
+ try dg.lowerValue(.{
.ty = Type.usize,
.val = slice.len,
}),
@@ -2923,15 +2923,15 @@ pub const DeclGen = struct {
return dg.context.constStruct(&fields, fields.len, .False);
},
.int_u64, .one, .int_big_positive => {
- const llvm_usize = try dg.llvmType(Type.usize);
+ const llvm_usize = try dg.lowerType(Type.usize);
const llvm_int = llvm_usize.constInt(tv.val.toUnsignedInt(target), .False);
- return llvm_int.constIntToPtr(try dg.llvmType(tv.ty));
+ return llvm_int.constIntToPtr(try dg.lowerType(tv.ty));
},
.field_ptr, .opt_payload_ptr, .eu_payload_ptr, .elem_ptr => {
return dg.lowerParentPtr(tv.val, tv.ty.childType());
},
.null_value, .zero => {
- const llvm_type = try dg.llvmType(tv.ty);
+ const llvm_type = try dg.lowerType(tv.ty);
return llvm_type.constNull();
},
else => |tag| return dg.todo("implement const of pointer type '{}' ({})", .{
@@ -2986,7 +2986,7 @@ pub const DeclGen = struct {
defer gpa.free(llvm_elems);
var need_unnamed = false;
for (elem_vals[0..len]) |elem_val, i| {
- llvm_elems[i] = try dg.genTypedValue(.{ .ty = elem_ty, .val = elem_val });
+ llvm_elems[i] = try dg.lowerValue(.{ .ty = elem_ty, .val = elem_val });
need_unnamed = need_unnamed or dg.isUnnamedType(elem_ty, llvm_elems[i]);
}
if (need_unnamed) {
@@ -2996,7 +2996,7 @@ pub const DeclGen = struct {
.True,
);
} else {
- const llvm_elem_ty = try dg.llvmType(elem_ty);
+ const llvm_elem_ty = try dg.lowerType(elem_ty);
return llvm_elem_ty.constArray(
llvm_elems.ptr,
@intCast(c_uint, llvm_elems.len),
@@ -3016,13 +3016,13 @@ pub const DeclGen = struct {
var need_unnamed = false;
if (len != 0) {
for (llvm_elems[0..len]) |*elem| {
- elem.* = try dg.genTypedValue(.{ .ty = elem_ty, .val = val });
+ elem.* = try dg.lowerValue(.{ .ty = elem_ty, .val = val });
}
need_unnamed = need_unnamed or dg.isUnnamedType(elem_ty, llvm_elems[0]);
}
if (sentinel) |sent| {
- llvm_elems[len] = try dg.genTypedValue(.{ .ty = elem_ty, .val = sent });
+ llvm_elems[len] = try dg.lowerValue(.{ .ty = elem_ty, .val = sent });
need_unnamed = need_unnamed or dg.isUnnamedType(elem_ty, llvm_elems[len]);
}
@@ -3033,7 +3033,7 @@ pub const DeclGen = struct {
.True,
);
} else {
- const llvm_elem_ty = try dg.llvmType(elem_ty);
+ const llvm_elem_ty = try dg.lowerType(elem_ty);
return llvm_elem_ty.constArray(
llvm_elems.ptr,
@intCast(c_uint, llvm_elems.len),
@@ -3043,13 +3043,13 @@ pub const DeclGen = struct {
.empty_array_sentinel => {
const elem_ty = tv.ty.elemType();
const sent_val = tv.ty.sentinel().?;
- const sentinel = try dg.genTypedValue(.{ .ty = elem_ty, .val = sent_val });
+ const sentinel = try dg.lowerValue(.{ .ty = elem_ty, .val = sent_val });
const llvm_elems: [1]*const llvm.Value = .{sentinel};
const need_unnamed = dg.isUnnamedType(elem_ty, llvm_elems[0]);
if (need_unnamed) {
return dg.context.constStruct(&llvm_elems, llvm_elems.len, .True);
} else {
- const llvm_elem_ty = try dg.llvmType(elem_ty);
+ const llvm_elem_ty = try dg.lowerType(elem_ty);
return llvm_elem_ty.constArray(&llvm_elems, llvm_elems.len);
}
},
@@ -3066,17 +3066,17 @@ pub const DeclGen = struct {
}
if (tv.ty.optionalReprIsPayload()) {
if (tv.val.castTag(.opt_payload)) |payload| {
- return dg.genTypedValue(.{ .ty = payload_ty, .val = payload.data });
+ return dg.lowerValue(.{ .ty = payload_ty, .val = payload.data });
} else if (is_pl) {
- return dg.genTypedValue(.{ .ty = payload_ty, .val = tv.val });
+ return dg.lowerValue(.{ .ty = payload_ty, .val = tv.val });
} else {
- const llvm_ty = try dg.llvmType(tv.ty);
+ const llvm_ty = try dg.lowerType(tv.ty);
return llvm_ty.constNull();
}
}
assert(payload_ty.zigTypeTag() != .Fn);
const fields: [2]*const llvm.Value = .{
- try dg.genTypedValue(.{
+ try dg.lowerValue(.{
.ty = payload_ty,
.val = if (tv.val.castTag(.opt_payload)) |pl| pl.data else Value.initTag(.undef),
}),
@@ -3095,7 +3095,7 @@ pub const DeclGen = struct {
return dg.resolveLlvmFunction(fn_decl_index);
},
.ErrorSet => {
- const llvm_ty = try dg.llvmType(tv.ty);
+ const llvm_ty = try dg.lowerType(tv.ty);
switch (tv.val.tag()) {
.@"error" => {
const err_name = tv.val.castTag(.@"error").?.data.name;
@@ -3113,23 +3113,23 @@ pub const DeclGen = struct {
const payload_type = tv.ty.errorUnionPayload();
if (error_type.errorSetCardinality() == .zero) {
const payload_val = tv.val.castTag(.eu_payload).?.data;
- return dg.genTypedValue(.{ .ty = payload_type, .val = payload_val });
+ return dg.lowerValue(.{ .ty = payload_type, .val = payload_val });
}
const is_pl = tv.val.errorUnionIsPayload();
if (!payload_type.hasRuntimeBitsIgnoreComptime()) {
// We use the error type directly as the type.
const err_val = if (!is_pl) tv.val else Value.initTag(.zero);
- return dg.genTypedValue(.{ .ty = error_type, .val = err_val });
+ return dg.lowerValue(.{ .ty = error_type, .val = err_val });
}
const payload_align = payload_type.abiAlignment(target);
const error_align = Type.anyerror.abiAlignment(target);
- const llvm_error_value = try dg.genTypedValue(.{
+ const llvm_error_value = try dg.lowerValue(.{
.ty = error_type,
.val = if (is_pl) Value.initTag(.zero) else tv.val,
});
- const llvm_payload_value = try dg.genTypedValue(.{
+ const llvm_payload_value = try dg.lowerValue(.{
.ty = payload_type,
.val = if (tv.val.castTag(.eu_payload)) |pl| pl.data else Value.initTag(.undef),
});
@@ -3142,7 +3142,7 @@ pub const DeclGen = struct {
}
},
.Struct => {
- const llvm_struct_ty = try dg.llvmType(tv.ty);
+ const llvm_struct_ty = try dg.lowerType(tv.ty);
const field_vals = tv.val.castTag(.aggregate).?.data;
const gpa = dg.gpa;
@@ -3175,7 +3175,7 @@ pub const DeclGen = struct {
llvm_fields.appendAssumeCapacity(llvm_array_ty.getUndef());
}
- const field_llvm_val = try dg.genTypedValue(.{
+ const field_llvm_val = try dg.lowerValue(.{
.ty = field_ty,
.val = field_vals[i],
});
@@ -3223,7 +3223,7 @@ pub const DeclGen = struct {
const field = fields[i];
if (!field.ty.hasRuntimeBitsIgnoreComptime()) continue;
- const non_int_val = try dg.genTypedValue(.{
+ const non_int_val = try dg.lowerValue(.{
.ty = field.ty,
.val = field_val,
});
@@ -3267,7 +3267,7 @@ pub const DeclGen = struct {
llvm_fields.appendAssumeCapacity(llvm_array_ty.getUndef());
}
- const field_llvm_val = try dg.genTypedValue(.{
+ const field_llvm_val = try dg.lowerValue(.{
.ty = field.ty,
.val = field_vals[i],
});
@@ -3302,13 +3302,13 @@ pub const DeclGen = struct {
}
},
.Union => {
- const llvm_union_ty = try dg.llvmType(tv.ty);
+ const llvm_union_ty = try dg.lowerType(tv.ty);
const tag_and_val = tv.val.castTag(.@"union").?.data;
const layout = tv.ty.unionGetLayout(target);
if (layout.payload_size == 0) {
- return genTypedValue(dg, .{
+ return lowerValue(dg, .{
.ty = tv.ty.unionTagType().?,
.val = tag_and_val.tag,
});
@@ -3322,7 +3322,7 @@ pub const DeclGen = struct {
const padding_len = @intCast(c_uint, layout.payload_size);
break :p dg.context.intType(8).arrayType(padding_len).getUndef();
}
- const field = try genTypedValue(dg, .{ .ty = field_ty, .val = tag_and_val.val });
+ const field = try lowerValue(dg, .{ .ty = field_ty, .val = tag_and_val.val });
const field_size = field_ty.abiSize(target);
if (field_size == layout.payload_size) {
break :p field;
@@ -3348,7 +3348,7 @@ pub const DeclGen = struct {
return llvm_union_ty.constNamedStruct(&fields, fields.len);
}
}
- const llvm_tag_value = try genTypedValue(dg, .{
+ const llvm_tag_value = try lowerValue(dg, .{
.ty = tv.ty.unionTagType().?,
.val = tag_and_val.tag,
});
@@ -3385,7 +3385,7 @@ pub const DeclGen = struct {
.data = bytes[i],
};
- elem.* = try dg.genTypedValue(.{
+ elem.* = try dg.lowerValue(.{
.ty = elem_ty,
.val = Value.initPayload(&byte_payload.base),
});
@@ -3405,7 +3405,7 @@ pub const DeclGen = struct {
const llvm_elems = try dg.gpa.alloc(*const llvm.Value, vector_len);
defer dg.gpa.free(llvm_elems);
for (llvm_elems) |*elem, i| {
- elem.* = try dg.genTypedValue(.{ .ty = elem_ty, .val = elem_vals[i] });
+ elem.* = try dg.lowerValue(.{ .ty = elem_ty, .val = elem_vals[i] });
}
return llvm.constVector(
llvm_elems.ptr,
@@ -3420,7 +3420,7 @@ pub const DeclGen = struct {
const llvm_elems = try dg.gpa.alloc(*const llvm.Value, len);
defer dg.gpa.free(llvm_elems);
for (llvm_elems) |*elem| {
- elem.* = try dg.genTypedValue(.{ .ty = elem_ty, .val = val });
+ elem.* = try dg.lowerValue(.{ .ty = elem_ty, .val = val });
}
return llvm.constVector(
llvm_elems.ptr,
@@ -3470,7 +3470,7 @@ pub const DeclGen = struct {
if (ptr_child_ty.eql(decl.ty, dg.module)) {
return llvm_ptr;
} else {
- return llvm_ptr.constBitCast((try dg.llvmType(ptr_child_ty)).pointerType(0));
+ return llvm_ptr.constBitCast((try dg.lowerType(ptr_child_ty)).pointerType(0));
}
}
@@ -3492,15 +3492,15 @@ pub const DeclGen = struct {
},
.int_i64 => {
const int = ptr_val.castTag(.int_i64).?.data;
- const llvm_usize = try dg.llvmType(Type.usize);
+ const llvm_usize = try dg.lowerType(Type.usize);
const llvm_int = llvm_usize.constInt(@bitCast(u64, int), .False);
- return llvm_int.constIntToPtr((try dg.llvmType(ptr_child_ty)).pointerType(0));
+ return llvm_int.constIntToPtr((try dg.lowerType(ptr_child_ty)).pointerType(0));
},
.int_u64 => {
const int = ptr_val.castTag(.int_u64).?.data;
- const llvm_usize = try dg.llvmType(Type.usize);
+ const llvm_usize = try dg.lowerType(Type.usize);
const llvm_int = llvm_usize.constInt(int, .False);
- return llvm_int.constIntToPtr((try dg.llvmType(ptr_child_ty)).pointerType(0));
+ return llvm_int.constIntToPtr((try dg.lowerType(ptr_child_ty)).pointerType(0));
},
.field_ptr => blk: {
const field_ptr = ptr_val.castTag(.field_ptr).?.data;
@@ -3549,7 +3549,7 @@ pub const DeclGen = struct {
const parent_llvm_ptr = try dg.lowerParentPtr(elem_ptr.array_ptr, elem_ptr.elem_ty);
bitcast_needed = !elem_ptr.elem_ty.eql(ptr_child_ty, dg.module);
- const llvm_usize = try dg.llvmType(Type.usize);
+ const llvm_usize = try dg.lowerType(Type.usize);
const indices: [1]*const llvm.Value = .{
llvm_usize.constInt(elem_ptr.index, .False),
};
@@ -3602,7 +3602,7 @@ pub const DeclGen = struct {
else => unreachable,
};
if (bitcast_needed) {
- return llvm_ptr.constBitCast((try dg.llvmType(ptr_child_ty)).pointerType(0));
+ return llvm_ptr.constBitCast((try dg.lowerType(ptr_child_ty)).pointerType(0));
} else {
return llvm_ptr;
}
@@ -3621,11 +3621,11 @@ pub const DeclGen = struct {
.data = tv.val.sliceLen(self.module),
};
const fields: [2]*const llvm.Value = .{
- try self.genTypedValue(.{
+ try self.lowerValue(.{
.ty = ptr_ty,
.val = tv.val,
}),
- try self.genTypedValue(.{
+ try self.lowerValue(.{
.ty = Type.usize,
.val = Value.initPayload(&slice_len.base),
}),
@@ -3657,7 +3657,7 @@ pub const DeclGen = struct {
else
try self.resolveGlobalDecl(decl_index);
- const llvm_type = try self.llvmType(tv.ty);
+ const llvm_type = try self.lowerType(tv.ty);
if (tv.ty.zigTypeTag() == .Int) {
return llvm_val.constPtrToInt(llvm_type);
} else {
@@ -3672,8 +3672,8 @@ pub const DeclGen = struct {
// The value cannot be undefined, because we use the `nonnull` annotation
// for non-optional pointers. We also need to respect the alignment, even though
// the address will never be dereferenced.
- const llvm_usize = try dg.llvmType(Type.usize);
- const llvm_ptr_ty = try dg.llvmType(ptr_ty);
+ const llvm_usize = try dg.lowerType(Type.usize);
+ const llvm_ptr_ty = try dg.lowerType(ptr_ty);
if (alignment != 0) {
return llvm_usize.constInt(alignment, .False).constIntToPtr(llvm_ptr_ty);
}
@@ -3852,7 +3852,7 @@ pub const FuncGen = struct {
const val = self.air.value(inst).?;
const ty = self.air.typeOf(inst);
- const llvm_val = try self.dg.genTypedValue(.{ .ty = ty, .val = val });
+ const llvm_val = try self.dg.lowerValue(.{ .ty = ty, .val = val });
if (!isByRef(ty)) {
gop.value_ptr.* = llvm_val;
return llvm_val;
@@ -3870,7 +3870,7 @@ pub const FuncGen = struct {
// Because of LLVM limitations for lowering certain types such as unions,
// the type of global constants might not match the type it is supposed to
// be, and so we must bitcast the pointer at the usage sites.
- const wanted_llvm_ty = try self.dg.llvmType(ty);
+ const wanted_llvm_ty = try self.dg.lowerType(ty);
const wanted_llvm_ptr_ty = wanted_llvm_ty.pointerType(0);
const casted_ptr = global.constBitCast(wanted_llvm_ptr_ty);
gop.value_ptr.* = casted_ptr;
@@ -4094,7 +4094,7 @@ pub const FuncGen = struct {
defer llvm_args.deinit();
const ret_ptr = if (!sret) null else blk: {
- const llvm_ret_ty = try self.dg.llvmType(return_type);
+ const llvm_ret_ty = try self.dg.lowerType(return_type);
const ret_ptr = self.buildAlloca(llvm_ret_ty);
ret_ptr.setAlignment(return_type.abiAlignment(target));
try llvm_args.append(ret_ptr);
@@ -4126,7 +4126,7 @@ pub const FuncGen = struct {
// which is always lowered to an LLVM type of `*i8`.
// 2. The argument is a global which does act as a pointer, however
// a bitcast is needed in order for the LLVM types to match.
- const llvm_param_ty = try self.dg.llvmType(param_ty);
+ const llvm_param_ty = try self.dg.lowerType(param_ty);
const casted_ptr = self.builder.buildBitCast(llvm_arg, llvm_param_ty, "");
try llvm_args.append(casted_ptr);
} else {
@@ -4173,7 +4173,7 @@ pub const FuncGen = struct {
);
const int_ptr = self.buildAlloca(int_llvm_ty);
int_ptr.setAlignment(alignment);
- const param_llvm_ty = try self.dg.llvmType(param_ty);
+ const param_llvm_ty = try self.dg.lowerType(param_ty);
const casted_ptr = self.builder.buildBitCast(int_ptr, param_llvm_ty.pointerType(0), "");
const store_inst = self.builder.buildStore(llvm_arg, casted_ptr);
store_inst.setAlignment(alignment);
@@ -4284,7 +4284,7 @@ pub const FuncGen = struct {
return null;
}
- const llvm_ret_ty = try self.dg.llvmType(return_type);
+ const llvm_ret_ty = try self.dg.lowerType(return_type);
if (ret_ptr) |rp| {
call.setCallSret(llvm_ret_ty);
@@ -4354,7 +4354,7 @@ pub const FuncGen = struct {
// Functions with an empty error set are emitted with an error code
// return type and return zero so they can be function pointers coerced
// to functions that return anyerror.
- const err_int = try self.dg.llvmType(Type.anyerror);
+ const err_int = try self.dg.lowerType(Type.anyerror);
_ = self.builder.buildRet(err_int.constInt(0, .False));
} else {
_ = self.builder.buildRetVoid();
@@ -4393,7 +4393,7 @@ pub const FuncGen = struct {
// Functions with an empty error set are emitted with an error code
// return type and return zero so they can be function pointers coerced
// to functions that return anyerror.
- const err_int = try self.dg.llvmType(Type.anyerror);
+ const err_int = try self.dg.lowerType(Type.anyerror);
_ = self.builder.buildRet(err_int.constInt(0, .False));
} else {
_ = self.builder.buildRetVoid();
@@ -4407,7 +4407,7 @@ pub const FuncGen = struct {
const ptr = try self.resolveInst(un_op);
const target = self.dg.module.getTarget();
const abi_ret_ty = try lowerFnRetTy(self.dg, fn_info);
- const llvm_ret_ty = try self.dg.llvmType(ret_ty);
+ const llvm_ret_ty = try self.dg.lowerType(ret_ty);
const casted_ptr = if (abi_ret_ty == llvm_ret_ty) ptr else p: {
const ptr_abi_ty = abi_ret_ty.pointerType(0);
break :p self.builder.buildBitCast(ptr, ptr_abi_ty, "");
@@ -4588,7 +4588,7 @@ pub const FuncGen = struct {
const is_body = inst_ty.zigTypeTag() == .Fn;
if (!is_body and !inst_ty.hasRuntimeBitsIgnoreComptime()) return null;
- const raw_llvm_ty = try self.dg.llvmType(inst_ty);
+ const raw_llvm_ty = try self.dg.lowerType(inst_ty);
const llvm_ty = ty: {
// If the zig tag type is a function, this represents an actual function body; not
@@ -4728,9 +4728,9 @@ pub const FuncGen = struct {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const operand_ty = self.air.typeOf(ty_op.operand);
const array_ty = operand_ty.childType();
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
const len = llvm_usize.constInt(array_ty.arrayLen(), .False);
- const slice_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+ const slice_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
if (!array_ty.hasRuntimeBitsIgnoreComptime()) {
return self.builder.buildInsertValue(slice_llvm_ty.getUndef(), len, 1, "");
}
@@ -4755,7 +4755,7 @@ pub const FuncGen = struct {
const dest_ty = self.air.typeOfIndex(inst);
const dest_scalar_ty = dest_ty.scalarType();
- const dest_llvm_ty = try self.dg.llvmType(dest_ty);
+ const dest_llvm_ty = try self.dg.lowerType(dest_ty);
const target = self.dg.module.getTarget();
if (intrinsicsAllowed(dest_scalar_ty, target)) {
@@ -4806,7 +4806,7 @@ pub const FuncGen = struct {
const dest_ty = self.air.typeOfIndex(inst);
const dest_scalar_ty = dest_ty.scalarType();
- const dest_llvm_ty = try self.dg.llvmType(dest_ty);
+ const dest_llvm_ty = try self.dg.lowerType(dest_ty);
if (intrinsicsAllowed(operand_scalar_ty, target)) {
// TODO set fast math flag
@@ -4833,7 +4833,7 @@ pub const FuncGen = struct {
compiler_rt_dest_abbrev,
}) catch unreachable;
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const param_types = [1]*const llvm.Type{operand_llvm_ty};
const libc_fn = self.getLibcFunction(fn_name, ¶m_types, libc_ret_ty);
const params = [1]*const llvm.Value{operand};
@@ -4994,7 +4994,7 @@ pub const FuncGen = struct {
const containing_int = struct_llvm_val;
const shift_amt = containing_int.typeOf().constInt(bit_offset, .False);
const shifted_value = self.builder.buildLShr(containing_int, shift_amt, "");
- const elem_llvm_ty = try self.dg.llvmType(field_ty);
+ const elem_llvm_ty = try self.dg.lowerType(field_ty);
if (field_ty.zigTypeTag() == .Float) {
const elem_bits = @intCast(c_uint, field_ty.bitSize(target));
const same_size_int = self.context.intType(elem_bits);
@@ -5026,7 +5026,7 @@ pub const FuncGen = struct {
return self.load(field_ptr, field_ptr_ty);
},
.Union => {
- const llvm_field_ty = try self.dg.llvmType(field_ty);
+ const llvm_field_ty = try self.dg.lowerType(field_ty);
const layout = struct_ty.unionGetLayout(target);
const payload_index = @boolToInt(layout.tag_align >= layout.payload_align);
const union_field_ptr = self.builder.buildStructGEP(struct_llvm_val, payload_index, "");
@@ -5053,7 +5053,7 @@ pub const FuncGen = struct {
const struct_ty = self.air.getRefType(ty_pl.ty).childType();
const field_offset = struct_ty.structFieldOffset(extra.field_index, target);
- const res_ty = try self.dg.llvmType(self.air.getRefType(ty_pl.ty));
+ const res_ty = try self.dg.lowerType(self.air.getRefType(ty_pl.ty));
if (field_offset == 0) {
return self.builder.buildBitCast(field_ptr, res_ty, "");
}
@@ -5383,7 +5383,7 @@ pub const FuncGen = struct {
}
const ret_ty = self.air.typeOfIndex(inst);
- const ret_llvm_ty = try self.dg.llvmType(ret_ty);
+ const ret_llvm_ty = try self.dg.lowerType(ret_ty);
const llvm_fn_ty = llvm.functionType(
ret_llvm_ty,
llvm_param_types.ptr,
@@ -5425,7 +5425,7 @@ pub const FuncGen = struct {
const operand_ty = self.air.typeOf(un_op);
const optional_ty = if (operand_is_ptr) operand_ty.childType() else operand_ty;
if (optional_ty.optionalReprIsPayload()) {
- const optional_llvm_ty = try self.dg.llvmType(optional_ty);
+ const optional_llvm_ty = try self.dg.lowerType(optional_ty);
const loaded = if (operand_is_ptr) self.builder.buildLoad(operand, "") else operand;
return self.builder.buildICmp(pred, loaded, optional_llvm_ty.constNull(), "");
}
@@ -5462,7 +5462,7 @@ pub const FuncGen = struct {
const operand = try self.resolveInst(un_op);
const err_union_ty = self.air.typeOf(un_op);
const payload_ty = err_union_ty.errorUnionPayload();
- const err_set_ty = try self.dg.llvmType(Type.initTag(.anyerror));
+ const err_set_ty = try self.dg.lowerType(Type.initTag(.anyerror));
const zero = err_set_ty.constNull();
if (err_union_ty.errorUnionSet().errorSetCardinality() == .zero) {
@@ -5506,7 +5506,7 @@ pub const FuncGen = struct {
// a pointer to a zero-bit value.
// TODO once we update to LLVM 14 this bitcast won't be necessary.
- const res_ptr_ty = try self.dg.llvmType(result_ty);
+ const res_ptr_ty = try self.dg.lowerType(result_ty);
return self.builder.buildBitCast(operand, res_ptr_ty, "");
}
if (optional_ty.optionalReprIsPayload()) {
@@ -5534,7 +5534,7 @@ pub const FuncGen = struct {
_ = self.builder.buildStore(non_null_bit, operand);
// TODO once we update to LLVM 14 this bitcast won't be necessary.
- const res_ptr_ty = try self.dg.llvmType(result_ty);
+ const res_ptr_ty = try self.dg.lowerType(result_ty);
return self.builder.buildBitCast(operand, res_ptr_ty, "");
}
if (optional_ty.optionalReprIsPayload()) {
@@ -5604,7 +5604,7 @@ pub const FuncGen = struct {
if (!operand_is_ptr) return null;
// TODO once we update to LLVM 14 this bitcast won't be necessary.
- const res_ptr_ty = try self.dg.llvmType(result_ty);
+ const res_ptr_ty = try self.dg.lowerType(result_ty);
return self.builder.buildBitCast(operand, res_ptr_ty, "");
}
if (operand_is_ptr or isByRef(payload_ty)) {
@@ -5626,7 +5626,7 @@ pub const FuncGen = struct {
const operand_ty = self.air.typeOf(ty_op.operand);
const err_union_ty = if (operand_is_ptr) operand_ty.childType() else operand_ty;
if (err_union_ty.errorUnionSet().errorSetCardinality() == .zero) {
- const err_llvm_ty = try self.dg.llvmType(Type.anyerror);
+ const err_llvm_ty = try self.dg.lowerType(Type.anyerror);
if (operand_is_ptr) {
return self.builder.buildBitCast(operand, err_llvm_ty.pointerType(0), "");
} else {
@@ -5662,7 +5662,7 @@ pub const FuncGen = struct {
return operand;
}
const payload_ty = error_union_ty.errorUnionPayload();
- const non_error_val = try self.dg.genTypedValue(.{ .ty = error_ty, .val = Value.zero });
+ const non_error_val = try self.dg.lowerValue(.{ .ty = error_ty, .val = Value.zero });
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
_ = self.builder.buildStore(non_error_val, operand);
return operand;
@@ -5715,7 +5715,7 @@ pub const FuncGen = struct {
if (optional_ty.optionalReprIsPayload()) {
return operand;
}
- const llvm_optional_ty = try self.dg.llvmType(optional_ty);
+ const llvm_optional_ty = try self.dg.lowerType(optional_ty);
if (isByRef(optional_ty)) {
const optional_ptr = self.buildAlloca(llvm_optional_ty);
const payload_ptr = self.builder.buildStructGEP(optional_ptr, 0, "");
@@ -5746,8 +5746,8 @@ pub const FuncGen = struct {
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
return operand;
}
- const ok_err_code = (try self.dg.llvmType(Type.anyerror)).constNull();
- const err_un_llvm_ty = try self.dg.llvmType(inst_ty);
+ const ok_err_code = (try self.dg.lowerType(Type.anyerror)).constNull();
+ const err_un_llvm_ty = try self.dg.lowerType(inst_ty);
const target = self.dg.module.getTarget();
const payload_offset = errUnionPayloadOffset(payload_ty, target);
@@ -5781,7 +5781,7 @@ pub const FuncGen = struct {
if (!payload_ty.hasRuntimeBitsIgnoreComptime()) {
return operand;
}
- const err_un_llvm_ty = try self.dg.llvmType(err_un_ty);
+ const err_un_llvm_ty = try self.dg.lowerType(err_un_ty);
const target = self.dg.module.getTarget();
const payload_offset = errUnionPayloadOffset(payload_ty, target);
@@ -5866,7 +5866,7 @@ pub const FuncGen = struct {
const ptr = try self.resolveInst(bin_op.lhs);
const len = try self.resolveInst(bin_op.rhs);
const inst_ty = self.air.typeOfIndex(inst);
- const llvm_slice_ty = try self.dg.llvmType(inst_ty);
+ const llvm_slice_ty = try self.dg.lowerType(inst_ty);
// In case of slicing a global, the result type looks something like `{ i8*, i64 }`
// but `ptr` is pointing to the global directly. If it's an array, we would want to
@@ -5874,7 +5874,7 @@ pub const FuncGen = struct {
// This prevents an assertion failure.
var buf: Type.SlicePtrFieldTypeBuffer = undefined;
const ptr_ty = inst_ty.slicePtrFieldType(&buf);
- const ptr_llvm_ty = try self.dg.llvmType(ptr_ty);
+ const ptr_llvm_ty = try self.dg.lowerType(ptr_ty);
const casted_ptr = self.builder.buildBitCast(ptr, ptr_llvm_ty, "");
const partial = self.builder.buildInsertValue(llvm_slice_ty.getUndef(), casted_ptr, 0, "");
return self.builder.buildInsertValue(partial, len, 1, "");
@@ -6040,7 +6040,7 @@ pub const FuncGen = struct {
// const d = @divTrunc(a, b);
// const r = @rem(a, b);
// return if (r == 0) d else d - ((a < 0) ^ (b < 0));
- const result_llvm_ty = try self.dg.llvmType(inst_ty);
+ const result_llvm_ty = try self.dg.lowerType(inst_ty);
const zero = result_llvm_ty.constNull();
const div_trunc = self.builder.buildSDiv(lhs, rhs, "");
const rem = self.builder.buildSRem(lhs, rhs, "");
@@ -6090,7 +6090,7 @@ pub const FuncGen = struct {
const lhs = try self.resolveInst(bin_op.lhs);
const rhs = try self.resolveInst(bin_op.rhs);
const inst_ty = self.air.typeOfIndex(inst);
- const inst_llvm_ty = try self.dg.llvmType(inst_ty);
+ const inst_llvm_ty = try self.dg.lowerType(inst_ty);
const scalar_ty = inst_ty.scalarType();
if (scalar_ty.isRuntimeFloat()) {
@@ -6174,8 +6174,8 @@ pub const FuncGen = struct {
const intrinsic_name = if (scalar_ty.isSignedInt()) signed_intrinsic else unsigned_intrinsic;
- const llvm_lhs_ty = try self.dg.llvmType(lhs_ty);
- const llvm_dest_ty = try self.dg.llvmType(dest_ty);
+ const llvm_lhs_ty = try self.dg.lowerType(lhs_ty);
+ const llvm_dest_ty = try self.dg.lowerType(dest_ty);
const tg = self.dg.module.getTarget();
@@ -6283,7 +6283,7 @@ pub const FuncGen = struct {
) !*const llvm.Value {
const target = self.dg.module.getTarget();
const scalar_ty = ty.scalarType();
- const scalar_llvm_ty = try self.dg.llvmType(scalar_ty);
+ const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
if (intrinsicsAllowed(scalar_ty, target)) {
const llvm_predicate: llvm.RealPredicate = switch (pred) {
@@ -6383,8 +6383,8 @@ pub const FuncGen = struct {
) !*const llvm.Value {
const target = self.dg.module.getTarget();
const scalar_ty = ty.scalarType();
- const llvm_ty = try self.dg.llvmType(ty);
- const scalar_llvm_ty = try self.dg.llvmType(scalar_ty);
+ const llvm_ty = try self.dg.lowerType(ty);
+ const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
const intrinsics_allowed = op != .tan and intrinsicsAllowed(scalar_ty, target);
var fn_name_buf: [64]u8 = undefined;
@@ -6478,12 +6478,12 @@ pub const FuncGen = struct {
const rhs_scalar_ty = rhs_ty.scalarType();
const dest_ty = self.air.typeOfIndex(inst);
- const llvm_dest_ty = try self.dg.llvmType(dest_ty);
+ const llvm_dest_ty = try self.dg.lowerType(dest_ty);
const tg = self.dg.module.getTarget();
const casted_rhs = if (rhs_scalar_ty.bitSize(tg) < lhs_scalar_ty.bitSize(tg))
- self.builder.buildZExt(rhs, try self.dg.llvmType(lhs_ty), "")
+ self.builder.buildZExt(rhs, try self.dg.lowerType(lhs_ty), "")
else
rhs;
@@ -6543,7 +6543,7 @@ pub const FuncGen = struct {
const tg = self.dg.module.getTarget();
const casted_rhs = if (rhs_scalar_ty.bitSize(tg) < lhs_scalar_ty.bitSize(tg))
- self.builder.buildZExt(rhs, try self.dg.llvmType(lhs_ty), "")
+ self.builder.buildZExt(rhs, try self.dg.lowerType(lhs_ty), "")
else
rhs;
if (lhs_scalar_ty.isSignedInt()) return self.builder.buildNSWShl(lhs, casted_rhs, "");
@@ -6566,7 +6566,7 @@ pub const FuncGen = struct {
const tg = self.dg.module.getTarget();
const casted_rhs = if (rhs_scalar_ty.bitSize(tg) < lhs_scalar_ty.bitSize(tg))
- self.builder.buildZExt(rhs, try self.dg.llvmType(lhs_type), "")
+ self.builder.buildZExt(rhs, try self.dg.lowerType(lhs_type), "")
else
rhs;
return self.builder.buildShl(lhs, casted_rhs, "");
@@ -6588,7 +6588,7 @@ pub const FuncGen = struct {
const tg = self.dg.module.getTarget();
const casted_rhs = if (rhs_scalar_ty.bitSize(tg) < lhs_scalar_ty.bitSize(tg))
- self.builder.buildZExt(rhs, try self.dg.llvmType(lhs_ty), "")
+ self.builder.buildZExt(rhs, try self.dg.lowerType(lhs_ty), "")
else
rhs;
if (lhs_scalar_ty.isSignedInt()) return self.builder.buildSShlSat(lhs, casted_rhs, "");
@@ -6611,7 +6611,7 @@ pub const FuncGen = struct {
const tg = self.dg.module.getTarget();
const casted_rhs = if (rhs_scalar_ty.bitSize(tg) < lhs_scalar_ty.bitSize(tg))
- self.builder.buildZExt(rhs, try self.dg.llvmType(lhs_ty), "")
+ self.builder.buildZExt(rhs, try self.dg.lowerType(lhs_ty), "")
else
rhs;
const is_signed_int = lhs_scalar_ty.isSignedInt();
@@ -6639,7 +6639,7 @@ pub const FuncGen = struct {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const dest_ty = self.air.typeOfIndex(inst);
const dest_info = dest_ty.intInfo(target);
- const dest_llvm_ty = try self.dg.llvmType(dest_ty);
+ const dest_llvm_ty = try self.dg.lowerType(dest_ty);
const operand = try self.resolveInst(ty_op.operand);
const operand_ty = self.air.typeOf(ty_op.operand);
const operand_info = operand_ty.intInfo(target);
@@ -6661,7 +6661,7 @@ pub const FuncGen = struct {
const ty_op = self.air.instructions.items(.data)[inst].ty_op;
const operand = try self.resolveInst(ty_op.operand);
- const dest_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+ const dest_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
return self.builder.buildTrunc(operand, dest_llvm_ty, "");
}
@@ -6679,7 +6679,7 @@ pub const FuncGen = struct {
if (!backendSupportsF80(target) and (src_bits == 80 or dest_bits == 80)) {
return softF80TruncOrExt(self, operand, src_bits, dest_bits);
}
- const dest_llvm_ty = try self.dg.llvmType(dest_ty);
+ const dest_llvm_ty = try self.dg.lowerType(dest_ty);
return self.builder.buildFPTrunc(operand, dest_llvm_ty, "");
}
@@ -6697,7 +6697,7 @@ pub const FuncGen = struct {
if (!backendSupportsF80(target) and (src_bits == 80 or dest_bits == 80)) {
return softF80TruncOrExt(self, operand, src_bits, dest_bits);
}
- const dest_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+ const dest_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
return self.builder.buildFPExt(operand, dest_llvm_ty, "");
}
@@ -6707,7 +6707,7 @@ pub const FuncGen = struct {
const un_op = self.air.instructions.items(.data)[inst].un_op;
const operand = try self.resolveInst(un_op);
- const dest_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+ const dest_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
return self.builder.buildPtrToInt(operand, dest_llvm_ty, "");
}
@@ -6720,7 +6720,7 @@ pub const FuncGen = struct {
const inst_ty = self.air.typeOfIndex(inst);
const operand_is_ref = isByRef(operand_ty);
const result_is_ref = isByRef(inst_ty);
- const llvm_dest_ty = try self.dg.llvmType(inst_ty);
+ const llvm_dest_ty = try self.dg.lowerType(inst_ty);
const target = self.dg.module.getTarget();
if (operand_is_ref and result_is_ref) {
@@ -6740,14 +6740,14 @@ pub const FuncGen = struct {
const array_ptr = self.buildAlloca(llvm_dest_ty);
const bitcast_ok = elem_ty.bitSize(target) == elem_ty.abiSize(target) * 8;
if (bitcast_ok) {
- const llvm_vector_ty = try self.dg.llvmType(operand_ty);
+ const llvm_vector_ty = try self.dg.lowerType(operand_ty);
const casted_ptr = self.builder.buildBitCast(array_ptr, llvm_vector_ty.pointerType(0), "");
const llvm_store = self.builder.buildStore(operand, casted_ptr);
llvm_store.setAlignment(inst_ty.abiAlignment(target));
} else {
// If the ABI size of the element type is not evenly divisible by size in bits;
// a simple bitcast will not work, and we fall back to extractelement.
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
const llvm_u32 = self.context.intType(32);
const zero = llvm_usize.constNull();
const vector_len = operand_ty.arrayLen();
@@ -6764,7 +6764,7 @@ pub const FuncGen = struct {
return array_ptr;
} else if (operand_ty.zigTypeTag() == .Array and inst_ty.zigTypeTag() == .Vector) {
const elem_ty = operand_ty.childType();
- const llvm_vector_ty = try self.dg.llvmType(inst_ty);
+ const llvm_vector_ty = try self.dg.lowerType(inst_ty);
if (!operand_is_ref) {
return self.dg.todo("implement bitcast non-ref array to vector", .{});
}
@@ -6781,7 +6781,7 @@ pub const FuncGen = struct {
} else {
// If the ABI size of the element type is not evenly divisible by size in bits;
// a simple bitcast will not work, and we fall back to extractelement.
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
const llvm_u32 = self.context.intType(32);
const zero = llvm_usize.constNull();
const vector_len = operand_ty.arrayLen();
@@ -6813,7 +6813,7 @@ pub const FuncGen = struct {
const alignment = @maximum(operand_ty.abiAlignment(target), inst_ty.abiAlignment(target));
const result_ptr = self.buildAlloca(llvm_dest_ty);
result_ptr.setAlignment(alignment);
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const casted_ptr = self.builder.buildBitCast(result_ptr, operand_llvm_ty.pointerType(0), "");
const store_inst = self.builder.buildStore(operand, casted_ptr);
store_inst.setAlignment(alignment);
@@ -6827,7 +6827,7 @@ pub const FuncGen = struct {
const alignment = @maximum(operand_ty.abiAlignment(target), inst_ty.abiAlignment(target));
const result_ptr = self.buildAlloca(llvm_dest_ty);
result_ptr.setAlignment(alignment);
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const casted_ptr = self.builder.buildBitCast(result_ptr, operand_llvm_ty.pointerType(0), "");
const store_inst = self.builder.buildStore(operand, casted_ptr);
store_inst.setAlignment(alignment);
@@ -6901,7 +6901,7 @@ pub const FuncGen = struct {
const pointee_type = ptr_ty.childType();
if (!pointee_type.isFnOrHasRuntimeBitsIgnoreComptime()) return self.dg.lowerPtrToVoid(ptr_ty);
- const pointee_llvm_ty = try self.dg.llvmType(pointee_type);
+ const pointee_llvm_ty = try self.dg.lowerType(pointee_type);
const alloca_inst = self.buildAlloca(pointee_llvm_ty);
const target = self.dg.module.getTarget();
const alignment = ptr_ty.ptrAlignment(target);
@@ -6915,7 +6915,7 @@ pub const FuncGen = struct {
const ret_ty = ptr_ty.childType();
if (!ret_ty.isFnOrHasRuntimeBitsIgnoreComptime()) return self.dg.lowerPtrToVoid(ptr_ty);
if (self.ret_ptr) |ret_ptr| return ret_ptr;
- const ret_llvm_ty = try self.dg.llvmType(ret_ty);
+ const ret_llvm_ty = try self.dg.lowerType(ret_ty);
const target = self.dg.module.getTarget();
const alloca_inst = self.buildAlloca(ret_llvm_ty);
alloca_inst.setAlignment(ptr_ty.ptrAlignment(target));
@@ -6946,7 +6946,7 @@ pub const FuncGen = struct {
const dest_ptr_u8 = self.builder.buildBitCast(dest_ptr, ptr_u8_llvm_ty, "");
const fill_char = u8_llvm_ty.constInt(0xaa, .False);
const dest_ptr_align = ptr_ty.ptrAlignment(target);
- const usize_llvm_ty = try self.dg.llvmType(Type.usize);
+ const usize_llvm_ty = try self.dg.lowerType(Type.usize);
const len = usize_llvm_ty.constInt(operand_size, .False);
_ = self.builder.buildMemSet(dest_ptr_u8, fill_char, len, dest_ptr_align, ptr_ty.isVolatilePtr());
if (self.dg.module.comp.bin_file.options.valgrind) {
@@ -6983,7 +6983,7 @@ pub const FuncGen = struct {
const llvm_fn = self.getIntrinsic("llvm.returnaddress", &.{});
const params = [_]*const llvm.Value{llvm_i32.constNull()};
const ptr_val = self.builder.buildCall(llvm_fn, ¶ms, params.len, .Fast, .Auto, "");
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
return self.builder.buildPtrToInt(ptr_val, llvm_usize, "");
}
@@ -7001,7 +7001,7 @@ pub const FuncGen = struct {
const params = [_]*const llvm.Value{llvm_i32.constNull()};
const ptr_val = self.builder.buildCall(llvm_fn, ¶ms, params.len, .Fast, .Auto, "");
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
return self.builder.buildPtrToInt(ptr_val, llvm_usize, "");
}
@@ -7046,7 +7046,7 @@ pub const FuncGen = struct {
var payload = self.builder.buildExtractValue(result, 0, "");
if (opt_abi_ty != null) {
- payload = self.builder.buildTrunc(payload, try self.dg.llvmType(operand_ty), "");
+ payload = self.builder.buildTrunc(payload, try self.dg.lowerType(operand_ty), "");
}
const success_bit = self.builder.buildExtractValue(result, 1, "");
@@ -7054,7 +7054,7 @@ pub const FuncGen = struct {
return self.builder.buildSelect(success_bit, payload.typeOf().constNull(), payload, "");
}
- const optional_llvm_ty = try self.dg.llvmType(optional_ty);
+ const optional_llvm_ty = try self.dg.lowerType(optional_ty);
const non_null_bit = self.builder.buildNot(success_bit, "");
const partial = self.builder.buildInsertValue(optional_llvm_ty.getUndef(), payload, 0, "");
return self.builder.buildInsertValue(partial, non_null_bit, 1, "");
@@ -7090,7 +7090,7 @@ pub const FuncGen = struct {
ordering,
single_threaded,
);
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
if (is_float) {
return self.builder.buildBitCast(uncasted_result, operand_llvm_ty, "");
} else {
@@ -7103,7 +7103,7 @@ pub const FuncGen = struct {
}
// It's a pointer but we need to treat it as an int.
- const usize_llvm_ty = try self.dg.llvmType(Type.usize);
+ const usize_llvm_ty = try self.dg.lowerType(Type.usize);
const casted_ptr = self.builder.buildBitCast(ptr, usize_llvm_ty.pointerType(0), "");
const casted_operand = self.builder.buildPtrToInt(operand, usize_llvm_ty, "");
const uncasted_result = self.builder.buildAtomicRmw(
@@ -7113,7 +7113,7 @@ pub const FuncGen = struct {
ordering,
single_threaded,
);
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
return self.builder.buildIntToPtr(uncasted_result, operand_llvm_ty, "");
}
@@ -7132,7 +7132,7 @@ pub const FuncGen = struct {
const casted_ptr = self.builder.buildBitCast(ptr, abi_ty.pointerType(0), "");
const load_inst = (try self.load(casted_ptr, ptr_ty)).?;
load_inst.setOrdering(ordering);
- return self.builder.buildTrunc(load_inst, try self.dg.llvmType(operand_ty), "");
+ return self.builder.buildTrunc(load_inst, try self.dg.lowerType(operand_ty), "");
}
const load_inst = (try self.load(ptr, ptr_ty)).?;
load_inst.setOrdering(ordering);
@@ -7273,13 +7273,13 @@ pub const FuncGen = struct {
const operand = try self.resolveInst(ty_op.operand);
const llvm_i1 = self.context.intType(1);
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const fn_val = self.getIntrinsic(llvm_fn_name, &.{operand_llvm_ty});
const params = [_]*const llvm.Value{ operand, llvm_i1.constNull() };
const wrong_size_result = self.builder.buildCall(fn_val, ¶ms, params.len, .C, .Auto, "");
const result_ty = self.air.typeOfIndex(inst);
- const result_llvm_ty = try self.dg.llvmType(result_ty);
+ const result_llvm_ty = try self.dg.lowerType(result_ty);
const target = self.dg.module.getTarget();
const bits = operand_ty.intInfo(target).bits;
@@ -7301,12 +7301,12 @@ pub const FuncGen = struct {
const operand = try self.resolveInst(ty_op.operand);
const params = [_]*const llvm.Value{operand};
- const operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ const operand_llvm_ty = try self.dg.lowerType(operand_ty);
const fn_val = self.getIntrinsic(llvm_fn_name, &.{operand_llvm_ty});
const wrong_size_result = self.builder.buildCall(fn_val, ¶ms, params.len, .C, .Auto, "");
const result_ty = self.air.typeOfIndex(inst);
- const result_llvm_ty = try self.dg.llvmType(result_ty);
+ const result_llvm_ty = try self.dg.lowerType(result_ty);
const target = self.dg.module.getTarget();
const bits = operand_ty.intInfo(target).bits;
@@ -7330,7 +7330,7 @@ pub const FuncGen = struct {
assert(bits % 8 == 0);
var operand = try self.resolveInst(ty_op.operand);
- var operand_llvm_ty = try self.dg.llvmType(operand_ty);
+ var operand_llvm_ty = try self.dg.lowerType(operand_ty);
if (bits % 16 == 8) {
// If not an even byte-multiple, we need zero-extend + shift-left 1 byte
@@ -7364,7 +7364,7 @@ pub const FuncGen = struct {
const wrong_size_result = self.builder.buildCall(fn_val, ¶ms, params.len, .C, .Auto, "");
const result_ty = self.air.typeOfIndex(inst);
- const result_llvm_ty = try self.dg.llvmType(result_ty);
+ const result_llvm_ty = try self.dg.lowerType(result_ty);
const result_bits = result_ty.intInfo(target).bits;
if (bits > result_bits) {
return self.builder.buildTrunc(wrong_size_result, result_llvm_ty, "");
@@ -7407,14 +7407,14 @@ pub const FuncGen = struct {
}
const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
- const llvm_ret_ty = try self.dg.llvmType(slice_ty);
- const usize_llvm_ty = try self.dg.llvmType(Type.usize);
+ const llvm_ret_ty = try self.dg.lowerType(slice_ty);
+ const usize_llvm_ty = try self.dg.lowerType(Type.usize);
const target = self.dg.module.getTarget();
const slice_alignment = slice_ty.abiAlignment(target);
var int_tag_type_buffer: Type.Payload.Bits = undefined;
const int_tag_ty = enum_ty.intTagType(&int_tag_type_buffer);
- const param_types = [_]*const llvm.Type{try self.dg.llvmType(int_tag_ty)};
+ const param_types = [_]*const llvm.Type{try self.dg.lowerType(int_tag_ty)};
const fn_type = llvm.functionType(llvm_ret_ty, ¶m_types, param_types.len, .False);
const fn_val = self.dg.object.llvm_module.addFunction(llvm_fn_name, fn_type);
@@ -7471,7 +7471,7 @@ pub const FuncGen = struct {
.base = .{ .tag = .enum_field_index },
.data = @intCast(u32, field_index),
};
- break :int try self.dg.genTypedValue(.{
+ break :int try self.dg.lowerValue(.{
.ty = enum_ty,
.val = Value.initPayload(&tag_val_payload.base),
});
@@ -7496,8 +7496,8 @@ pub const FuncGen = struct {
// Function signature: fn (anyerror) bool
- const ret_llvm_ty = try self.dg.llvmType(Type.bool);
- const anyerror_llvm_ty = try self.dg.llvmType(Type.anyerror);
+ const ret_llvm_ty = try self.dg.lowerType(Type.bool);
+ const anyerror_llvm_ty = try self.dg.lowerType(Type.anyerror);
const param_types = [_]*const llvm.Type{anyerror_llvm_ty};
const fn_type = llvm.functionType(ret_llvm_ty, ¶m_types, param_types.len, .False);
@@ -7606,7 +7606,7 @@ pub const FuncGen = struct {
.Add => switch (scalar_ty.zigTypeTag()) {
.Int => return self.builder.buildAddReduce(operand),
.Float => {
- const scalar_llvm_ty = try self.dg.llvmType(scalar_ty);
+ const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
const neutral_value = scalar_llvm_ty.constReal(-0.0);
return self.builder.buildFPAddReduce(neutral_value, operand);
},
@@ -7615,7 +7615,7 @@ pub const FuncGen = struct {
.Mul => switch (scalar_ty.zigTypeTag()) {
.Int => return self.builder.buildMulReduce(operand),
.Float => {
- const scalar_llvm_ty = try self.dg.llvmType(scalar_ty);
+ const scalar_llvm_ty = try self.dg.lowerType(scalar_ty);
const neutral_value = scalar_llvm_ty.constReal(1.0);
return self.builder.buildFPMulReduce(neutral_value, operand);
},
@@ -7631,7 +7631,7 @@ pub const FuncGen = struct {
const result_ty = self.air.typeOfIndex(inst);
const len = @intCast(usize, result_ty.arrayLen());
const elements = @ptrCast([]const Air.Inst.Ref, self.air.extra[ty_pl.payload..][0..len]);
- const llvm_result_ty = try self.dg.llvmType(result_ty);
+ const llvm_result_ty = try self.dg.lowerType(result_ty);
const target = self.dg.module.getTarget();
switch (result_ty.zigTypeTag()) {
@@ -7719,7 +7719,7 @@ pub const FuncGen = struct {
.Array => {
assert(isByRef(result_ty));
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
const alloca_inst = self.buildAlloca(llvm_result_ty);
alloca_inst.setAlignment(result_ty.abiAlignment(target));
@@ -7754,7 +7754,7 @@ pub const FuncGen = struct {
const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;
const extra = self.air.extraData(Air.UnionInit, ty_pl.payload).data;
const union_ty = self.air.typeOfIndex(inst);
- const union_llvm_ty = try self.dg.llvmType(union_ty);
+ const union_llvm_ty = try self.dg.lowerType(union_ty);
const target = self.dg.module.getTarget();
const layout = union_ty.unionGetLayout(target);
if (layout.payload_size == 0) {
@@ -7774,8 +7774,8 @@ pub const FuncGen = struct {
const union_obj = union_ty.cast(Type.Payload.Union).?.data;
assert(union_obj.haveFieldTypes());
const field = union_obj.fields.values()[extra.field_index];
- const field_llvm_ty = try self.dg.llvmType(field.ty);
- const tag_llvm_ty = try self.dg.llvmType(union_obj.tag_ty);
+ const field_llvm_ty = try self.dg.lowerType(field.ty);
+ const tag_llvm_ty = try self.dg.lowerType(union_obj.tag_ty);
const field_size = field.ty.abiSize(target);
const field_align = field.normalAlignment(target);
@@ -8011,7 +8011,7 @@ pub const FuncGen = struct {
const slice_ty = Type.initTag(.const_slice_u8_sentinel_0);
const slice_alignment = slice_ty.abiAlignment(self.dg.module.getTarget());
- const llvm_slice_ty = try self.dg.llvmType(slice_ty);
+ const llvm_slice_ty = try self.dg.lowerType(slice_ty);
const llvm_slice_ptr_ty = llvm_slice_ty.pointerType(0); // TODO: Address space
const error_name_table_global = self.dg.object.llvm_module.addGlobal(llvm_slice_ptr_ty, "__zig_err_name_table");
@@ -8075,7 +8075,7 @@ pub const FuncGen = struct {
// out the relevant bits when accessing the pointee.
// Here we perform a bitcast because we want to use the host_size
// as the llvm pointer element type.
- const result_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+ const result_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
// TODO this can be removed if we change host_size to be bits instead
// of bytes.
return self.builder.buildBitCast(struct_ptr, result_llvm_ty, "");
@@ -8090,7 +8090,7 @@ pub const FuncGen = struct {
// end of the struct. Treat our struct pointer as an array of two and get
// the index to the element at index `1` to get a pointer to the end of
// the struct.
- const llvm_usize = try self.dg.llvmType(Type.usize);
+ const llvm_usize = try self.dg.lowerType(Type.usize);
const llvm_index = llvm_usize.constInt(1, .False);
const indices: [1]*const llvm.Value = .{llvm_index};
return self.builder.buildInBoundsGEP(struct_ptr, &indices, indices.len, "");
@@ -8111,7 +8111,7 @@ pub const FuncGen = struct {
) !?*const llvm.Value {
const union_obj = union_ty.cast(Type.Payload.Union).?.data;
const field = &union_obj.fields.values()[field_index];
- const result_llvm_ty = try self.dg.llvmType(self.air.typeOfIndex(inst));
+ const result_llvm_ty = try self.dg.lowerType(self.air.typeOfIndex(inst));
if (!field.ty.hasRuntimeBitsIgnoreComptime()) {
return null;
}
@@ -8150,7 +8150,7 @@ pub const FuncGen = struct {
const ptr_volatile = llvm.Bool.fromBool(ptr_ty.isVolatilePtr());
if (info.host_size == 0) {
if (isByRef(info.pointee_type)) {
- const elem_llvm_ty = try self.dg.llvmType(info.pointee_type);
+ const elem_llvm_ty = try self.dg.lowerType(info.pointee_type);
const result_align = info.pointee_type.abiAlignment(target);
const max_align = @maximum(result_align, ptr_alignment);
const result_ptr = self.buildAlloca(elem_llvm_ty);
@@ -8183,7 +8183,7 @@ pub const FuncGen = struct {
const elem_bits = @intCast(c_uint, ptr_ty.elemType().bitSize(target));
const shift_amt = containing_int.typeOf().constInt(info.bit_offset, .False);
const shifted_value = self.builder.buildLShr(containing_int, shift_amt, "");
- const elem_llvm_ty = try self.dg.llvmType(info.pointee_type);
+ const elem_llvm_ty = try self.dg.lowerType(info.pointee_type);
if (isByRef(info.pointee_type)) {
const result_align = info.pointee_type.abiAlignment(target);
@@ -8625,7 +8625,7 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.
// anyerror return type instead, so that it can be coerced into a function
// pointer type which has anyerror as the return type.
if (fn_info.return_type.isError()) {
- return dg.llvmType(Type.anyerror);
+ return dg.lowerType(Type.anyerror);
} else {
return dg.context.voidType();
}
@@ -8636,7 +8636,7 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.
if (isByRef(fn_info.return_type)) {
return dg.context.voidType();
} else {
- return dg.llvmType(fn_info.return_type);
+ return dg.lowerType(fn_info.return_type);
}
},
.C => {
@@ -8657,24 +8657,24 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.
else => false,
};
switch (target.cpu.arch) {
- .mips, .mipsel => return dg.llvmType(fn_info.return_type),
+ .mips, .mipsel => return dg.lowerType(fn_info.return_type),
.x86_64 => switch (target.os.tag) {
.windows => switch (x86_64_abi.classifyWindows(fn_info.return_type, target)) {
.integer => {
if (is_scalar) {
- return dg.llvmType(fn_info.return_type);
+ return dg.lowerType(fn_info.return_type);
} else {
const abi_size = fn_info.return_type.abiSize(target);
return dg.context.intType(@intCast(c_uint, abi_size * 8));
}
},
.memory => return dg.context.voidType(),
- .sse => return dg.llvmType(fn_info.return_type),
+ .sse => return dg.lowerType(fn_info.return_type),
else => unreachable,
},
else => {
if (is_scalar) {
- return dg.llvmType(fn_info.return_type);
+ return dg.lowerType(fn_info.return_type);
}
const classes = x86_64_abi.classifySystemV(fn_info.return_type, target);
if (classes[0] == .memory) {
@@ -8715,10 +8715,10 @@ fn lowerFnRetTy(dg: *DeclGen, fn_info: Type.Payload.Function.Data) !*const llvm.
},
},
// TODO investigate C ABI for other architectures
- else => return dg.llvmType(fn_info.return_type),
+ else => return dg.lowerType(fn_info.return_type),
}
},
- else => return dg.llvmType(fn_info.return_type),
+ else => return dg.lowerType(fn_info.return_type),
}
}