srctree

fn lowerValueToInt(o: *Object, llvm_int_ty: Builder.Type, arg_val: InternPool.Index) Error!Builder.Constant {

const mod = o.module;

const ip = &mod.intern_pool;

const target = mod.getTarget();

 

const val = Value.fromInterned(arg_val);

const val_key = ip.indexToKey(val.toIntern());

 

if (val.isUndefDeep(mod)) return o.builder.undefConst(llvm_int_ty);

 

const ty = Type.fromInterned(val_key.typeOf());

switch (val_key) {

.extern_func => |extern_func| {

const fn_decl_index = extern_func.decl;

const function_index = try o.resolveLlvmFunction(fn_decl_index);

const ptr = function_index.ptrConst(&o.builder).global.toConst();

return o.builder.convConst(ptr, llvm_int_ty);

},

.func => |func| {

const fn_decl_index = func.owner_decl;

const function_index = try o.resolveLlvmFunction(fn_decl_index);

const ptr = function_index.ptrConst(&o.builder).global.toConst();

return o.builder.convConst(ptr, llvm_int_ty);

},

.ptr => return o.builder.convConst(try o.lowerPtr(arg_val, 0), llvm_int_ty),

.aggregate => switch (ip.indexToKey(ty.toIntern())) {

.struct_type => {

const struct_type = ip.loadStructType(ty.toIntern());

assert(struct_type.haveLayout(ip));

assert(struct_type.layout == .@"packed");

comptime assert(Type.packed_struct_layout_version == 2);

var running_int = try o.builder.intConst(llvm_int_ty, 0);

var running_bits: u16 = 0;

for (struct_type.field_types.get(ip), 0..) |field_ty, field_index| {

if (!Type.fromInterned(field_ty).hasRuntimeBitsIgnoreComptime(mod)) continue;

 

const shift_rhs = try o.builder.intConst(llvm_int_ty, running_bits);

const field_val = try o.lowerValueToInt(llvm_int_ty, (try val.fieldValue(mod, field_index)).toIntern());

const shifted = try o.builder.binConst(.shl, field_val, shift_rhs);

 

running_int = try o.builder.binConst(.xor, running_int, shifted);

 

const ty_bit_size: u16 = @intCast(Type.fromInterned(field_ty).bitSize(mod));

running_bits += ty_bit_size;

}

return running_int;

},

.vector_type => {},

else => unreachable,

},

.un => |un| {

const layout = ty.unionGetLayout(mod);

if (layout.payload_size == 0) return o.lowerValue(un.tag);

 

const union_obj = mod.typeToUnion(ty).?;

const container_layout = union_obj.getLayout(ip);

 

assert(container_layout == .@"packed");

 

var need_unnamed = false;

if (un.tag == .none) {

assert(layout.tag_size == 0);

const union_val = try o.lowerValueToInt(llvm_int_ty, un.val);

 

need_unnamed = true;

return union_val;

}

const field_index = mod.unionTagFieldIndex(union_obj, Value.fromInterned(un.tag)).?;

const field_ty = Type.fromInterned(union_obj.field_types.get(ip)[field_index]);

if (!field_ty.hasRuntimeBits(mod)) return o.builder.intConst(llvm_int_ty, 0);

return o.lowerValueToInt(llvm_int_ty, un.val);

},

.simple_value => |simple_value| switch (simple_value) {

.false, .true => {},

else => unreachable,

},

.int,

.float,

.enum_tag,

=> {},

else => unreachable,

}

const bits = ty.bitSize(mod);

const bytes: usize = @intCast(std.mem.alignForward(u64, bits, 8) / 8);

 

var stack = std.heap.stackFallback(32, o.gpa);

const allocator = stack.get();

 

const limbs = try allocator.alloc(

std.math.big.Limb,

std.mem.alignForward(usize, bytes, @sizeOf(std.math.big.Limb)) /

@sizeOf(std.math.big.Limb),

);

defer allocator.free(limbs);

@memset(limbs, 0);

 

val.writeToPackedMemory(

ty,

mod,

std.mem.sliceAsBytes(limbs)[0..bytes],

0,

) catch unreachable;

 

if (builtin.target.cpu.arch.endian() == .little) {

if (target.cpu.arch.endian() == .big)

std.mem.reverse(u8, std.mem.sliceAsBytes(limbs)[0..bytes]);

} else if (target.cpu.arch.endian() == .little) {

for (limbs) |*limb| {

limb.* = std.mem.nativeToLittle(usize, limb.*);

}

}

 

return o.builder.bigIntConst(llvm_int_ty, .{

.limbs = limbs,

.positive = true,

});

}

 

const bits = ty.bitSize(mod);

const llvm_int_ty = try o.builder.intType(@intCast(bits));

 

return o.lowerValueToInt(llvm_int_ty, arg_val);

const bits = ty.bitSize(mod);

const llvm_int_ty = try o.builder.intType(@intCast(bits));

 

return o.lowerValueToInt(llvm_int_ty, arg_val);

const bits = ty.bitSize(mod);

const llvm_int_ty = try o.builder.intType(@intCast(bits));

 

return o.lowerValueToInt(llvm_int_ty, arg_val);

const union_val = try o.lowerValue(un.val);

return o.builder.convConst(llvm_val, try o.lowerType(ptr_ty));

return o.builder.convConst(llvm_val, try o.lowerType(ptr_ty));

const mask_val = try o.builder.intValue(payload_llvm_ty, -1);

const zext_mask_val = try fg.wip.cast(.zext, mask_val, load_llvm_ty, "");

break :blk try fg.wip.bin(.@"and", shifted, zext_mask_val, "");

const mask_val = blk: {

const zext = try self.wip.cast(

.zext,

try o.builder.intValue(value_bits_type, -1),

containing_int_ty,

"",

);

const shl = try self.wip.bin(.shl, zext, shift_amt.toValue(), "");

break :blk try self.wip.bin(

.xor,

shl,

try o.builder.intValue(containing_int_ty, -1),

"",

);

};

const anded_containing_int = try self.wip.bin(.@"and", containing_int, mask_val, "");

return self.cast(self.builder.convTag(signedness, val_ty, ty), val, ty, name);

return self.convConstAssumeCapacity(val, ty);

return (try self.convConst(val, ty)).toValue();

) Function.Instruction.Tag {

fn convConstTag(

self: *Builder,

val_ty: Type,

ty: Type,

) Constant.Tag {

assert(val_ty != ty);

return switch (val_ty.scalarTag(self)) {

.integer => switch (ty.scalarTag(self)) {

.integer => switch (std.math.order(val_ty.scalarBits(self), ty.scalarBits(self))) {

.gt => .trunc,

else => unreachable,

},

.pointer => .inttoptr,

else => unreachable,

},

.pointer => switch (ty.scalarTag(self)) {

.integer => .ptrtoint,

.pointer => .addrspacecast,

else => unreachable,

},

else => unreachable,

};

}

 

return self.castConstAssumeCapacity(self.convConstTag(val_ty, ty), val, ty);