Source code
pub const Function = struct {
global: Global.Index,
call_conv: CallConv = CallConv.default,
attributes: FunctionAttributes = .none,
section: String = .none,
alignment: Alignment = .default,
blocks: []const Block = &.{},
instructions: std.MultiArrayList(Instruction) = .{},
names: [*]const String = &[0]String{},
value_indices: [*]const u32 = &[0]u32{},
strip: bool,
debug_locations: std.AutoHashMapUnmanaged(Instruction.Index, DebugLocation) = .empty,
debug_values: []const Instruction.Index = &.{},
extra: []const u32 = &.{},
pub const Index = enum(u32) {
none = std.math.maxInt(u32),
_,
pub fn ptr(self: Index, builder: *Builder) *Function {
return &builder.functions.items[@intFromEnum(self)];
}
pub fn ptrConst(self: Index, builder: *const Builder) *const Function {
return &builder.functions.items[@intFromEnum(self)];
}
pub fn name(self: Index, builder: *const Builder) StrtabString {
return self.ptrConst(builder).global.name(builder);
}
pub fn rename(self: Index, new_name: StrtabString, builder: *Builder) Allocator.Error!void {
return self.ptrConst(builder).global.rename(new_name, builder);
}
pub fn typeOf(self: Index, builder: *const Builder) Type {
return self.ptrConst(builder).global.typeOf(builder);
}
pub fn toConst(self: Index, builder: *const Builder) Constant {
return self.ptrConst(builder).global.toConst();
}
pub fn toValue(self: Index, builder: *const Builder) Value {
return self.toConst(builder).toValue();
}
pub fn setLinkage(self: Index, linkage: Linkage, builder: *Builder) void {
return self.ptrConst(builder).global.setLinkage(linkage, builder);
}
pub fn setUnnamedAddr(self: Index, unnamed_addr: UnnamedAddr, builder: *Builder) void {
return self.ptrConst(builder).global.setUnnamedAddr(unnamed_addr, builder);
}
pub fn setCallConv(self: Index, call_conv: CallConv, builder: *Builder) void {
self.ptr(builder).call_conv = call_conv;
}
pub fn setAttributes(
self: Index,
new_function_attributes: FunctionAttributes,
builder: *Builder,
) void {
self.ptr(builder).attributes = new_function_attributes;
}
pub fn setSection(self: Index, section: String, builder: *Builder) void {
self.ptr(builder).section = section;
}
pub fn setAlignment(self: Index, alignment: Alignment, builder: *Builder) void {
self.ptr(builder).alignment = alignment;
}
pub fn setSubprogram(self: Index, subprogram: Metadata, builder: *Builder) void {
self.ptrConst(builder).global.setDebugMetadata(subprogram, builder);
}
};
pub const Block = struct {
instruction: Instruction.Index,
pub const Index = WipFunction.Block.Index;
};
pub const Instruction = struct {
tag: Tag,
data: u32,
pub const Tag = enum(u8) {
add,
@"add nsw",
@"add nuw",
@"add nuw nsw",
addrspacecast,
alloca,
@"alloca inalloca",
@"and",
arg,
ashr,
@"ashr exact",
atomicrmw,
bitcast,
block,
br,
br_cond,
call,
@"call fast",
cmpxchg,
@"cmpxchg weak",
extractelement,
extractvalue,
fadd,
@"fadd fast",
@"fcmp false",
@"fcmp fast false",
@"fcmp fast oeq",
@"fcmp fast oge",
@"fcmp fast ogt",
@"fcmp fast ole",
@"fcmp fast olt",
@"fcmp fast one",
@"fcmp fast ord",
@"fcmp fast true",
@"fcmp fast ueq",
@"fcmp fast uge",
@"fcmp fast ugt",
@"fcmp fast ule",
@"fcmp fast ult",
@"fcmp fast une",
@"fcmp fast uno",
@"fcmp oeq",
@"fcmp oge",
@"fcmp ogt",
@"fcmp ole",
@"fcmp olt",
@"fcmp one",
@"fcmp ord",
@"fcmp true",
@"fcmp ueq",
@"fcmp uge",
@"fcmp ugt",
@"fcmp ule",
@"fcmp ult",
@"fcmp une",
@"fcmp uno",
fdiv,
@"fdiv fast",
fence,
fmul,
@"fmul fast",
fneg,
@"fneg fast",
fpext,
fptosi,
fptoui,
fptrunc,
frem,
@"frem fast",
fsub,
@"fsub fast",
getelementptr,
@"getelementptr inbounds",
@"icmp eq",
@"icmp ne",
@"icmp sge",
@"icmp sgt",
@"icmp sle",
@"icmp slt",
@"icmp uge",
@"icmp ugt",
@"icmp ule",
@"icmp ult",
indirectbr,
insertelement,
insertvalue,
inttoptr,
load,
@"load atomic",
lshr,
@"lshr exact",
mul,
@"mul nsw",
@"mul nuw",
@"mul nuw nsw",
@"musttail call",
@"musttail call fast",
@"notail call",
@"notail call fast",
@"or",
phi,
@"phi fast",
ptrtoint,
ret,
@"ret void",
sdiv,
@"sdiv exact",
select,
@"select fast",
sext,
shl,
@"shl nsw",
@"shl nuw",
@"shl nuw nsw",
shufflevector,
sitofp,
srem,
store,
@"store atomic",
sub,
@"sub nsw",
@"sub nuw",
@"sub nuw nsw",
@"switch",
@"tail call",
@"tail call fast",
trunc,
udiv,
@"udiv exact",
urem,
uitofp,
@"unreachable",
va_arg,
xor,
zext,
pub fn toBinaryOpcode(self: Tag) BinaryOpcode {
return switch (self) {
.add,
.@"add nsw",
.@"add nuw",
.@"add nuw nsw",
.fadd,
.@"fadd fast",
=> .add,
.sub,
.@"sub nsw",
.@"sub nuw",
.@"sub nuw nsw",
.fsub,
.@"fsub fast",
=> .sub,
.sdiv,
.@"sdiv exact",
.fdiv,
.@"fdiv fast",
=> .sdiv,
.fmul,
.@"fmul fast",
.mul,
.@"mul nsw",
.@"mul nuw",
.@"mul nuw nsw",
=> .mul,
.srem,
.frem,
.@"frem fast",
=> .srem,
.udiv,
.@"udiv exact",
=> .udiv,
.shl,
.@"shl nsw",
.@"shl nuw",
.@"shl nuw nsw",
=> .shl,
.lshr,
.@"lshr exact",
=> .lshr,
.ashr,
.@"ashr exact",
=> .ashr,
.@"and" => .@"and",
.@"or" => .@"or",
.xor => .xor,
.urem => .urem,
else => unreachable,
};
}
pub fn toCastOpcode(self: Tag) CastOpcode {
return switch (self) {
.trunc => .trunc,
.zext => .zext,
.sext => .sext,
.fptoui => .fptoui,
.fptosi => .fptosi,
.uitofp => .uitofp,
.sitofp => .sitofp,
.fptrunc => .fptrunc,
.fpext => .fpext,
.ptrtoint => .ptrtoint,
.inttoptr => .inttoptr,
.bitcast => .bitcast,
.addrspacecast => .addrspacecast,
else => unreachable,
};
}
pub fn toCmpPredicate(self: Tag) CmpPredicate {
return switch (self) {
.@"fcmp false",
.@"fcmp fast false",
=> .fcmp_false,
.@"fcmp oeq",
.@"fcmp fast oeq",
=> .fcmp_oeq,
.@"fcmp oge",
.@"fcmp fast oge",
=> .fcmp_oge,
.@"fcmp ogt",
.@"fcmp fast ogt",
=> .fcmp_ogt,
.@"fcmp ole",
.@"fcmp fast ole",
=> .fcmp_ole,
.@"fcmp olt",
.@"fcmp fast olt",
=> .fcmp_olt,
.@"fcmp one",
.@"fcmp fast one",
=> .fcmp_one,
.@"fcmp ord",
.@"fcmp fast ord",
=> .fcmp_ord,
.@"fcmp true",
.@"fcmp fast true",
=> .fcmp_true,
.@"fcmp ueq",
.@"fcmp fast ueq",
=> .fcmp_ueq,
.@"fcmp uge",
.@"fcmp fast uge",
=> .fcmp_uge,
.@"fcmp ugt",
.@"fcmp fast ugt",
=> .fcmp_ugt,
.@"fcmp ule",
.@"fcmp fast ule",
=> .fcmp_ule,
.@"fcmp ult",
.@"fcmp fast ult",
=> .fcmp_ult,
.@"fcmp une",
.@"fcmp fast une",
=> .fcmp_une,
.@"fcmp uno",
.@"fcmp fast uno",
=> .fcmp_uno,
.@"icmp eq" => .icmp_eq,
.@"icmp ne" => .icmp_ne,
.@"icmp sge" => .icmp_sge,
.@"icmp sgt" => .icmp_sgt,
.@"icmp sle" => .icmp_sle,
.@"icmp slt" => .icmp_slt,
.@"icmp uge" => .icmp_uge,
.@"icmp ugt" => .icmp_ugt,
.@"icmp ule" => .icmp_ule,
.@"icmp ult" => .icmp_ult,
else => unreachable,
};
}
};
pub const Index = enum(u32) {
none = std.math.maxInt(u31),
_,
pub fn name(self: Instruction.Index, function: *const Function) String {
return function.names[@intFromEnum(self)];
}
pub fn valueIndex(self: Instruction.Index, function: *const Function) u32 {
return function.value_indices[@intFromEnum(self)];
}
pub fn toValue(self: Instruction.Index) Value {
return @enumFromInt(@intFromEnum(self));
}
pub fn isTerminatorWip(self: Instruction.Index, wip: *const WipFunction) bool {
return switch (wip.instructions.items(.tag)[@intFromEnum(self)]) {
.br,
.br_cond,
.indirectbr,
.ret,
.@"ret void",
.@"switch",
.@"unreachable",
=> true,
else => false,
};
}
pub fn hasResultWip(self: Instruction.Index, wip: *const WipFunction) bool {
return switch (wip.instructions.items(.tag)[@intFromEnum(self)]) {
.br,
.br_cond,
.fence,
.indirectbr,
.ret,
.@"ret void",
.store,
.@"store atomic",
.@"switch",
.@"unreachable",
.block,
=> false,
.call,
.@"call fast",
.@"musttail call",
.@"musttail call fast",
.@"notail call",
.@"notail call fast",
.@"tail call",
.@"tail call fast",
=> self.typeOfWip(wip) != .void,
else => true,
};
}
pub fn typeOfWip(self: Instruction.Index, wip: *const WipFunction) Type {
const instruction = wip.instructions.get(@intFromEnum(self));
return switch (instruction.tag) {
.add,
.@"add nsw",
.@"add nuw",
.@"add nuw nsw",
.@"and",
.ashr,
.@"ashr exact",
.fadd,
.@"fadd fast",
.fdiv,
.@"fdiv fast",
.fmul,
.@"fmul fast",
.frem,
.@"frem fast",
.fsub,
.@"fsub fast",
.lshr,
.@"lshr exact",
.mul,
.@"mul nsw",
.@"mul nuw",
.@"mul nuw nsw",
.@"or",
.sdiv,
.@"sdiv exact",
.shl,
.@"shl nsw",
.@"shl nuw",
.@"shl nuw nsw",
.srem,
.sub,
.@"sub nsw",
.@"sub nuw",
.@"sub nuw nsw",
.udiv,
.@"udiv exact",
.urem,
.xor,
=> wip.extraData(Binary, instruction.data).lhs.typeOfWip(wip),
.addrspacecast,
.bitcast,
.fpext,
.fptosi,
.fptoui,
.fptrunc,
.inttoptr,
.ptrtoint,
.sext,
.sitofp,
.trunc,
.uitofp,
.zext,
=> wip.extraData(Cast, instruction.data).type,
.alloca,
.@"alloca inalloca",
=> wip.builder.ptrTypeAssumeCapacity(
wip.extraData(Alloca, instruction.data).info.addr_space,
),
.arg => wip.function.typeOf(wip.builder)
.functionParameters(wip.builder)[instruction.data],
.atomicrmw => wip.extraData(AtomicRmw, instruction.data).val.typeOfWip(wip),
.block => .label,
.br,
.br_cond,
.fence,
.indirectbr,
.ret,
.@"ret void",
.store,
.@"store atomic",
.@"switch",
.@"unreachable",
=> .none,
.call,
.@"call fast",
.@"musttail call",
.@"musttail call fast",
.@"notail call",
.@"notail call fast",
.@"tail call",
.@"tail call fast",
=> wip.extraData(Call, instruction.data).ty.functionReturn(wip.builder),
.cmpxchg,
.@"cmpxchg weak",
=> wip.builder.structTypeAssumeCapacity(.normal, &.{
wip.extraData(CmpXchg, instruction.data).cmp.typeOfWip(wip),
.i1,
}),
.extractelement => wip.extraData(ExtractElement, instruction.data)
.val.typeOfWip(wip).childType(wip.builder),
.extractvalue => {
var extra = wip.extraDataTrail(ExtractValue, instruction.data);
const indices = extra.trail.next(extra.data.indices_len, u32, wip);
return extra.data.val.typeOfWip(wip).childTypeAt(indices, wip.builder);
},
.@"fcmp false",
.@"fcmp fast false",
.@"fcmp fast oeq",
.@"fcmp fast oge",
.@"fcmp fast ogt",
.@"fcmp fast ole",
.@"fcmp fast olt",
.@"fcmp fast one",
.@"fcmp fast ord",
.@"fcmp fast true",
.@"fcmp fast ueq",
.@"fcmp fast uge",
.@"fcmp fast ugt",
.@"fcmp fast ule",
.@"fcmp fast ult",
.@"fcmp fast une",
.@"fcmp fast uno",
.@"fcmp oeq",
.@"fcmp oge",
.@"fcmp ogt",
.@"fcmp ole",
.@"fcmp olt",
.@"fcmp one",
.@"fcmp ord",
.@"fcmp true",
.@"fcmp ueq",
.@"fcmp uge",
.@"fcmp ugt",
.@"fcmp ule",
.@"fcmp ult",
.@"fcmp une",
.@"fcmp uno",
.@"icmp eq",
.@"icmp ne",
.@"icmp sge",
.@"icmp sgt",
.@"icmp sle",
.@"icmp slt",
.@"icmp uge",
.@"icmp ugt",
.@"icmp ule",
.@"icmp ult",
=> wip.extraData(Binary, instruction.data).lhs.typeOfWip(wip)
.changeScalarAssumeCapacity(.i1, wip.builder),
.fneg,
.@"fneg fast",
=> @as(Value, @enumFromInt(instruction.data)).typeOfWip(wip),
.getelementptr,
.@"getelementptr inbounds",
=> {
var extra = wip.extraDataTrail(GetElementPtr, instruction.data);
const indices = extra.trail.next(extra.data.indices_len, Value, wip);
const base_ty = extra.data.base.typeOfWip(wip);
if (!base_ty.isVector(wip.builder)) for (indices) |index| {
const index_ty = index.typeOfWip(wip);
if (!index_ty.isVector(wip.builder)) continue;
return index_ty.changeScalarAssumeCapacity(base_ty, wip.builder);
};
return base_ty;
},
.insertelement => wip.extraData(InsertElement, instruction.data).val.typeOfWip(wip),
.insertvalue => wip.extraData(InsertValue, instruction.data).val.typeOfWip(wip),
.load,
.@"load atomic",
=> wip.extraData(Load, instruction.data).type,
.phi,
.@"phi fast",
=> wip.extraData(Phi, instruction.data).type,
.select,
.@"select fast",
=> wip.extraData(Select, instruction.data).lhs.typeOfWip(wip),
.shufflevector => {
const extra = wip.extraData(ShuffleVector, instruction.data);
return extra.lhs.typeOfWip(wip).changeLengthAssumeCapacity(
extra.mask.typeOfWip(wip).vectorLen(wip.builder),
wip.builder,
);
},
.va_arg => wip.extraData(VaArg, instruction.data).type,
};
}
pub fn typeOf(
self: Instruction.Index,
function_index: Function.Index,
builder: *Builder,
) Type {
const function = function_index.ptrConst(builder);
const instruction = function.instructions.get(@intFromEnum(self));
return switch (instruction.tag) {
.add,
.@"add nsw",
.@"add nuw",
.@"add nuw nsw",
.@"and",
.ashr,
.@"ashr exact",
.fadd,
.@"fadd fast",
.fdiv,
.@"fdiv fast",
.fmul,
.@"fmul fast",
.frem,
.@"frem fast",
.fsub,
.@"fsub fast",
.lshr,
.@"lshr exact",
.mul,
.@"mul nsw",
.@"mul nuw",
.@"mul nuw nsw",
.@"or",
.sdiv,
.@"sdiv exact",
.shl,
.@"shl nsw",
.@"shl nuw",
.@"shl nuw nsw",
.srem,
.sub,
.@"sub nsw",
.@"sub nuw",
.@"sub nuw nsw",
.udiv,
.@"udiv exact",
.urem,
.xor,
=> function.extraData(Binary, instruction.data).lhs.typeOf(function_index, builder),
.addrspacecast,
.bitcast,
.fpext,
.fptosi,
.fptoui,
.fptrunc,
.inttoptr,
.ptrtoint,
.sext,
.sitofp,
.trunc,
.uitofp,
.zext,
=> function.extraData(Cast, instruction.data).type,
.alloca,
.@"alloca inalloca",
=> builder.ptrTypeAssumeCapacity(
function.extraData(Alloca, instruction.data).info.addr_space,
),
.arg => function.global.typeOf(builder)
.functionParameters(builder)[instruction.data],
.atomicrmw => function.extraData(AtomicRmw, instruction.data)
.val.typeOf(function_index, builder),
.block => .label,
.br,
.br_cond,
.fence,
.indirectbr,
.ret,
.@"ret void",
.store,
.@"store atomic",
.@"switch",
.@"unreachable",
=> .none,
.call,
.@"call fast",
.@"musttail call",
.@"musttail call fast",
.@"notail call",
.@"notail call fast",
.@"tail call",
.@"tail call fast",
=> function.extraData(Call, instruction.data).ty.functionReturn(builder),
.cmpxchg,
.@"cmpxchg weak",
=> builder.structTypeAssumeCapacity(.normal, &.{
function.extraData(CmpXchg, instruction.data)
.cmp.typeOf(function_index, builder),
.i1,
}),
.extractelement => function.extraData(ExtractElement, instruction.data)
.val.typeOf(function_index, builder).childType(builder),
.extractvalue => {
var extra = function.extraDataTrail(ExtractValue, instruction.data);
const indices = extra.trail.next(extra.data.indices_len, u32, function);
return extra.data.val.typeOf(function_index, builder)
.childTypeAt(indices, builder);
},
.@"fcmp false",
.@"fcmp fast false",
.@"fcmp fast oeq",
.@"fcmp fast oge",
.@"fcmp fast ogt",
.@"fcmp fast ole",
.@"fcmp fast olt",
.@"fcmp fast one",
.@"fcmp fast ord",
.@"fcmp fast true",
.@"fcmp fast ueq",
.@"fcmp fast uge",
.@"fcmp fast ugt",
.@"fcmp fast ule",
.@"fcmp fast ult",
.@"fcmp fast une",
.@"fcmp fast uno",
.@"fcmp oeq",
.@"fcmp oge",
.@"fcmp ogt",
.@"fcmp ole",
.@"fcmp olt",
.@"fcmp one",
.@"fcmp ord",
.@"fcmp true",
.@"fcmp ueq",
.@"fcmp uge",
.@"fcmp ugt",
.@"fcmp ule",
.@"fcmp ult",
.@"fcmp une",
.@"fcmp uno",
.@"icmp eq",
.@"icmp ne",
.@"icmp sge",
.@"icmp sgt",
.@"icmp sle",
.@"icmp slt",
.@"icmp uge",
.@"icmp ugt",
.@"icmp ule",
.@"icmp ult",
=> function.extraData(Binary, instruction.data).lhs.typeOf(function_index, builder)
.changeScalarAssumeCapacity(.i1, builder),
.fneg,
.@"fneg fast",
=> @as(Value, @enumFromInt(instruction.data)).typeOf(function_index, builder),
.getelementptr,
.@"getelementptr inbounds",
=> {
var extra = function.extraDataTrail(GetElementPtr, instruction.data);
const indices = extra.trail.next(extra.data.indices_len, Value, function);
const base_ty = extra.data.base.typeOf(function_index, builder);
if (!base_ty.isVector(builder)) for (indices) |index| {
const index_ty = index.typeOf(function_index, builder);
if (!index_ty.isVector(builder)) continue;
return index_ty.changeScalarAssumeCapacity(base_ty, builder);
};
return base_ty;
},
.insertelement => function.extraData(InsertElement, instruction.data)
.val.typeOf(function_index, builder),
.insertvalue => function.extraData(InsertValue, instruction.data)
.val.typeOf(function_index, builder),
.load,
.@"load atomic",
=> function.extraData(Load, instruction.data).type,
.phi,
.@"phi fast",
=> function.extraData(Phi, instruction.data).type,
.select,
.@"select fast",
=> function.extraData(Select, instruction.data).lhs.typeOf(function_index, builder),
.shufflevector => {
const extra = function.extraData(ShuffleVector, instruction.data);
return extra.lhs.typeOf(function_index, builder).changeLengthAssumeCapacity(
extra.mask.typeOf(function_index, builder).vectorLen(builder),
builder,
);
},
.va_arg => function.extraData(VaArg, instruction.data).type,
};
}
const FormatData = struct {
instruction: Instruction.Index,
function: Function.Index,
builder: *Builder,
};
fn format(
data: FormatData,
comptime fmt_str: []const u8,
_: std.fmt.FormatOptions,
writer: anytype,
) @TypeOf(writer).Error!void {
if (comptime std.mem.indexOfNone(u8, fmt_str, ", %")) |_|
@compileError("invalid format string: '" ++ fmt_str ++ "'");
if (comptime std.mem.indexOfScalar(u8, fmt_str, ',') != null) {
if (data.instruction == .none) return;
try writer.writeByte(',');
}
if (comptime std.mem.indexOfScalar(u8, fmt_str, ' ') != null) {
if (data.instruction == .none) return;
try writer.writeByte(' ');
}
if (comptime std.mem.indexOfScalar(u8, fmt_str, '%') != null) try writer.print(
"{%} ",
.{data.instruction.typeOf(data.function, data.builder).fmt(data.builder)},
);
assert(data.instruction != .none);
try writer.print("%{}", .{
data.instruction.name(data.function.ptrConst(data.builder)).fmt(data.builder),
});
}
pub fn fmt(
self: Instruction.Index,
function: Function.Index,
builder: *Builder,
) std.fmt.Formatter(format) {
return .{ .data = .{ .instruction = self, .function = function, .builder = builder } };
}
};
pub const ExtraIndex = u32;
pub const BrCond = struct {
cond: Value,
then: Block.Index,
@"else": Block.Index,
weights: Weights,
pub const Weights = enum(u32) {none = 0,
unpredictable = 1,
_,
};
};
pub const Switch = struct {
val: Value,
default: Block.Index,
cases_len: u32,
weights: BrCond.Weights,};
pub const IndirectBr = struct {
addr: Value,
targets_len: u32,};
pub const Binary = struct {
lhs: Value,
rhs: Value,
};
pub const ExtractElement = struct {
val: Value,
index: Value,
};
pub const InsertElement = struct {
val: Value,
elem: Value,
index: Value,
};
pub const ShuffleVector = struct {
lhs: Value,
rhs: Value,
mask: Value,
};
pub const ExtractValue = struct {
val: Value,
indices_len: u32,};
pub const InsertValue = struct {
val: Value,
elem: Value,
indices_len: u32,};
pub const Alloca = struct {
type: Type,
len: Value,
info: Info,
pub const Kind = enum { normal, inalloca };
pub const Info = packed struct(u32) {
alignment: Alignment,
addr_space: AddrSpace,
_: u2 = undefined,
};
};
pub const Load = struct {
info: MemoryAccessInfo,
type: Type,
ptr: Value,
};
pub const Store = struct {
info: MemoryAccessInfo,
val: Value,
ptr: Value,
};
pub const CmpXchg = struct {
info: MemoryAccessInfo,
ptr: Value,
cmp: Value,
new: Value,
pub const Kind = enum { strong, weak };
};
pub const AtomicRmw = struct {
info: MemoryAccessInfo,
ptr: Value,
val: Value,
pub const Operation = enum(u5) {
xchg = 0,
add = 1,
sub = 2,
@"and" = 3,
nand = 4,
@"or" = 5,
xor = 6,
max = 7,
min = 8,
umax = 9,
umin = 10,
fadd = 11,
fsub = 12,
fmax = 13,
fmin = 14,
none = std.math.maxInt(u5),
};
};
pub const GetElementPtr = struct {
type: Type,
base: Value,
indices_len: u32,pub const Kind = Constant.GetElementPtr.Kind;
};
pub const Cast = struct {
val: Value,
type: Type,
pub const Signedness = Constant.Cast.Signedness;
};
pub const Phi = struct {
type: Type,};
pub const Select = struct {
cond: Value,
lhs: Value,
rhs: Value,
};
pub const Call = struct {
info: Info,
attributes: FunctionAttributes,
ty: Type,
callee: Value,
args_len: u32,pub const Kind = enum {
normal,
fast,
musttail,
musttail_fast,
notail,
notail_fast,
tail,
tail_fast,
};
pub const Info = packed struct(u32) {
call_conv: CallConv,
has_op_bundle_cold: bool,
_: u21 = undefined,
};
};
pub const VaArg = struct {
list: Value,
type: Type,
};
};
pub fn deinit(self: *Function, gpa: Allocator) void {
gpa.free(self.extra);
gpa.free(self.debug_values);
self.debug_locations.deinit(gpa);
gpa.free(self.value_indices[0..self.instructions.len]);
gpa.free(self.names[0..self.instructions.len]);
self.instructions.deinit(gpa);
gpa.free(self.blocks);
self.* = undefined;
}
pub fn arg(self: *const Function, index: u32) Value {
const argument = self.instructions.get(index);
assert(argument.tag == .arg);
assert(argument.data == index);
const argument_index: Instruction.Index = @enumFromInt(index);
return argument_index.toValue();
}
const ExtraDataTrail = struct {
index: Instruction.ExtraIndex,
fn nextMut(self: *ExtraDataTrail, len: u32, comptime Item: type, function: *Function) []Item {
const items: []Item = @ptrCast(function.extra[self.index..][0..len]);
self.index += @intCast(len);
return items;
}
fn next(
self: *ExtraDataTrail,
len: u32,
comptime Item: type,
function: *const Function,
) []const Item {
const items: []const Item = @ptrCast(function.extra[self.index..][0..len]);
self.index += @intCast(len);
return items;
}
};
fn extraDataTrail(
self: *const Function,
comptime T: type,
index: Instruction.ExtraIndex,
) struct { data: T, trail: ExtraDataTrail } {
var result: T = undefined;
const fields = @typeInfo(T).@"struct".fields;
inline for (fields, self.extra[index..][0..fields.len]) |field, value|
@field(result, field.name) = switch (field.type) {
u32 => value,
Alignment,
AtomicOrdering,
Block.Index,
FunctionAttributes,
Type,
Value,
Instruction.BrCond.Weights,
=> @enumFromInt(value),
MemoryAccessInfo,
Instruction.Alloca.Info,
Instruction.Call.Info,
=> @bitCast(value),
else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),
};
return .{
.data = result,
.trail = .{ .index = index + @as(Type.Item.ExtraIndex, @intCast(fields.len)) },
};
}
fn extraData(self: *const Function, comptime T: type, index: Instruction.ExtraIndex) T {
return self.extraDataTrail(T, index).data;
}
}