srctree

.field => |field| {

const base_ptr_ty = mod.intern_pool.typeOf(field.base).toType();

const base_ptr = try self.constantPtr(base_ptr_ty, field.base.toValue());

const field_index: u32 = @intCast(field.index);

return try self.structFieldPtr(ptr_ty, base_ptr_ty, base_ptr, field_index);

},

.field_parent_ptr => try self.airFieldParentPtr(inst),

fn intFromPtr(self: *DeclGen, operand_id: IdRef) !IdRef {

fn airIntFromPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {

if (self.liveness.isUnused(inst)) return null;

 

const un_op = self.air.instructions.items(.data)[inst].un_op;

const operand_id = try self.resolve(un_op);

return try self.intFromPtr(operand_id);

}

 

fn airFieldParentPtr(self: *DeclGen, inst: Air.Inst.Index) !?IdRef {

const mod = self.module;

const ty_pl = self.air.instructions.items(.data)[inst].ty_pl;

const extra = self.air.extraData(Air.FieldParentPtr, ty_pl.payload).data;

 

const parent_ty = self.air.getRefType(ty_pl.ty).childType(mod);

const res_ty = try self.resolveType(self.air.getRefType(ty_pl.ty), .indirect);

const usize_ty = Type.usize;

const usize_ty_ref = try self.resolveType(usize_ty, .direct);

 

const field_ptr = try self.resolve(extra.field_ptr);

const field_ptr_int = try self.intFromPtr(field_ptr);

const field_offset = parent_ty.structFieldOffset(extra.field_index, mod);

 

const base_ptr_int = base_ptr_int: {

if (field_offset == 0) break :base_ptr_int field_ptr_int;

 

const field_offset_id = try self.constInt(usize_ty_ref, field_offset);

break :base_ptr_int try self.binOpSimple(usize_ty, field_ptr_int, field_offset_id, .OpISub);

};

 

const base_ptr = self.spv.allocId();

try self.func.body.emit(self.spv.gpa, .OpConvertUToPtr, .{

.id_result_type = self.spv.resultId(res_ty),

.id_result = base_ptr,

.integer_value = base_ptr_int,

});

 

return base_ptr;

}

 

) !IdRef {