srctree

pub fn fieldNames(comptime T: type) *const [fields(T).len][:0]const u8 {

var names: [fieldInfos.len][:0]const u8 = undefined;

// This concat can be removed with the next zig1 update.

for (&names, fieldInfos) |*name, field| name.* = field.name ++ "";

 

{

const temp_reg = try self.copyToTmpRegister(elem_ty, mat_elem_mcv);

const temp_alias = registerAlias(temp_reg, elem_abi_size);

const temp_lock = self.register_manager.lockRegAssumeUnused(temp_reg);

defer self.register_manager.unlockReg(temp_lock);

 

if (elem_bit_off < elem_extra_bits) {

try self.truncateRegister(elem_ty, temp_alias);

}

if (elem_bit_off > 0) try self.genShiftBinOpMir(

.{ ._l, .sh },

elem_ty,

.{ .register = temp_alias },

Type.u8,

.{ .immediate = elem_bit_off },

);

try self.genBinOpMir(

.{ ._, .@"or" },

elem_ty,

.{ .load_frame = .{ .index = frame_index, .off = elem_byte_off } },

.{ .register = temp_alias },

);

const temp_reg = try self.copyToTmpRegister(elem_ty, mat_elem_mcv);

const temp_alias = registerAlias(temp_reg, elem_abi_size);

const temp_lock = self.register_manager.lockRegAssumeUnused(temp_reg);

defer self.register_manager.unlockReg(temp_lock);

 

try self.truncateRegister(elem_ty, temp_alias);

.{ .register = temp_reg },

.{ .register = temp_alias },

debug_compile_unit: Builder.Metadata,

debug_enums_fwd_ref: Builder.Metadata,

debug_globals_fwd_ref: Builder.Metadata,

debug_enums: std.ArrayListUnmanaged(Builder.Metadata),

debug_globals: std.ArrayListUnmanaged(Builder.Metadata),

debug_file_map: std.AutoHashMapUnmanaged(*const Module.File, Builder.Metadata),

debug_type_map: std.AutoHashMapUnmanaged(Type, Builder.Metadata),

 

debug_unresolved_namespace_scopes: std.AutoArrayHashMapUnmanaged(InternPool.NamespaceIndex, Builder.Metadata),

.strip = strip,

builder.data_layout = try builder.fmt("{}", .{DataLayoutBuilder{ .target = target }});

const debug_compile_unit, const debug_enums_fwd_ref, const debug_globals_fwd_ref =

if (!builder.strip)

debug_info: {

// We fully resolve all paths at this point to avoid lack of

// source line info in stack traces or lack of debugging

// information which, if relative paths were used, would be

// very location dependent.

// TODO: the only concern I have with this is WASI as either host or target, should

// we leave the paths as relative then?

// TODO: This is totally wrong. In dwarf, paths are encoded as relative to

// a particular directory, and then the directory path is specified elsewhere.

// In the compiler frontend we have it stored correctly in this

// way already, but here we throw all that sweet information

// into the garbage can by converting into absolute paths. What

// a terrible tragedy.

const compile_unit_dir = blk: {

if (comp.module) |zcu| m: {

const d = try zcu.root_mod.root.joinString(arena, "");

if (d.len == 0) break :m;

if (std.fs.path.isAbsolute(d)) break :blk d;

break :blk std.fs.realpathAlloc(arena, d) catch break :blk d;

}

break :blk try std.process.getCwdAlloc(arena);

};

 

const debug_file = try builder.debugFile(

try builder.metadataString(comp.root_name),

try builder.metadataString(compile_unit_dir),

);

 

const debug_enums_fwd_ref = try builder.debugForwardReference();

const debug_globals_fwd_ref = try builder.debugForwardReference();

 

const debug_compile_unit = try builder.debugCompileUnit(

debug_file,

try builder.metadataStringFmt("zig {d}.{d}.{d}", .{

}),

debug_enums_fwd_ref,

debug_globals_fwd_ref,

.{ .optimized = comp.root_mod.optimize_mode != .Debug },

const i32_2 = try builder.intConst(.i32, 2);

const i32_3 = try builder.intConst(.i32, 3);

const debug_info_version = try builder.debugModuleFlag(

try builder.debugConstant(i32_2),

try builder.metadataString("Debug Info Version"),

try builder.debugConstant(i32_3),

);

switch (comp.config.debug_format) {

.strip => unreachable,

.dwarf => |f| {

const i32_4 = try builder.intConst(.i32, 4);

const dwarf_version = try builder.debugModuleFlag(

try builder.debugConstant(i32_2),

try builder.metadataString("Dwarf Version"),

try builder.debugConstant(i32_4),

);

switch (f) {

.@"32" => {

try builder.debugNamed(try builder.metadataString("llvm.module.flags"), &.{

debug_info_version,

dwarf_version,

});

},

.@"64" => {

const dwarf64 = try builder.debugModuleFlag(

try builder.debugConstant(i32_2),

try builder.metadataString("DWARF64"),

try builder.debugConstant(.@"1"),

);

try builder.debugNamed(try builder.metadataString("llvm.module.flags"), &.{

debug_info_version,

dwarf_version,

dwarf64,

});

},

}

},

.code_view => {

const code_view = try builder.debugModuleFlag(

try builder.debugConstant(i32_2),

try builder.metadataString("CodeView"),

try builder.debugConstant(.@"1"),

);

try builder.debugNamed(try builder.metadataString("llvm.module.flags"), &.{

debug_info_version,

code_view,

});

},

try builder.debugNamed(try builder.metadataString("llvm.dbg.cu"), &.{debug_compile_unit});

break :debug_info .{ debug_compile_unit, debug_enums_fwd_ref, debug_globals_fwd_ref };

} else .{.none} ** 3;

.debug_compile_unit = debug_compile_unit,

.debug_enums_fwd_ref = debug_enums_fwd_ref,

.debug_globals_fwd_ref = debug_globals_fwd_ref,

.debug_enums = .{},

.debug_globals = .{},

.debug_file_map = .{},

.debug_type_map = .{},

.debug_unresolved_namespace_scopes = .{},

self.debug_enums.deinit(gpa);

self.debug_globals.deinit(gpa);

self.debug_file_map.deinit(gpa);

self.debug_type_map.deinit(gpa);

self.debug_unresolved_namespace_scopes.deinit(gpa);

const name_string = try o.builder.stringNull(mod.intern_pool.stringToSlice(name));

const name_init = try o.builder.stringConst(name_string);

try o.builder.intConst(llvm_usize_ty, name_string.slice(&o.builder).?.len - 1),

if (!self.builder.strip) {

{

var i: usize = 0;

while (i < self.debug_unresolved_namespace_scopes.count()) : (i += 1) {

const namespace_index = self.debug_unresolved_namespace_scopes.keys()[i];

const fwd_ref = self.debug_unresolved_namespace_scopes.values()[i];

 

const namespace = self.module.namespacePtr(namespace_index);

const debug_type = try self.lowerDebugType(namespace.ty);

 

self.builder.debugForwardReferenceSetType(fwd_ref, debug_type);

}

self.builder.debugForwardReferenceSetType(

self.debug_enums_fwd_ref,

try self.builder.debugTuple(self.debug_enums.items),

);

 

self.builder.debugForwardReferenceSetType(

self.debug_globals_fwd_ref,

try self.builder.debugTuple(self.debug_globals.items),

);

var bitcode_arena_allocator = std.heap.ArenaAllocator.init(

std.heap.page_allocator,

);

errdefer bitcode_arena_allocator.deinit();

const bitcode = try self.builder.toBitcode(

bitcode_arena_allocator.allocator(),

);

 

if (options.pre_bc_path) |path| {

var file = try std.fs.cwd().createFile(path, .{});

defer file.close();

 

const ptr: [*]const u8 = @ptrCast(bitcode.ptr);

try file.writeAll(ptr[0..(bitcode.len * 4)]);

if (options.post_bc_path) |path| {

var file = try std.fs.cwd().createFileZ(path, .{});

defer file.close();

 

const ptr: [*]const u8 = @ptrCast(bitcode.ptr);

try file.writeAll(ptr[0..(bitcode.len * 4)]);

}

 

if (!build_options.have_llvm or !self.module.comp.config.use_lib_llvm) {

log.err("emitting without libllvm not implemented", .{});

return error.FailedToEmit;

}

 

initializeLLVMTarget(self.module.comp.root_mod.resolved_target.result.cpu.arch);

 

const context: *llvm.Context = llvm.Context.create();

defer context.dispose();

 

const module = blk: {

const bitcode_memory_buffer = llvm.MemoryBuffer.createMemoryBufferWithMemoryRange(

@ptrCast(bitcode.ptr),

bitcode.len * 4,

"BitcodeBuffer",

llvm.Bool.False,

);

defer bitcode_memory_buffer.dispose();

 

var module: *llvm.Module = undefined;

if (context.parseBitcodeInContext2(bitcode_memory_buffer, &module).toBool()) {

std.debug.print("Failed to parse bitcode\n", .{});

return error.FailedToEmit;

}

 

break :blk module;

};

bitcode_arena_allocator.deinit();

 

const target_triple_sentinel =

try self.gpa.dupeZ(u8, self.builder.target_triple.slice(&self.builder).?);

defer self.gpa.free(target_triple_sentinel);

var target: *llvm.Target = undefined;

var error_message: [*:0]const u8 = undefined;

if (llvm.Target.getFromTriple(target_triple_sentinel, &target, &error_message).toBool()) {

defer llvm.disposeMessage(error_message);

 

log.err("LLVM failed to parse '{s}': {s}", .{

self.builder.target_triple.slice(&self.builder).?,

error_message,

});

@panic("Invalid LLVM triple");

}

 

const optimize_mode = self.module.comp.root_mod.optimize_mode;

const pic = self.module.comp.root_mod.pic;

 

const opt_level: llvm.CodeGenOptLevel = if (optimize_mode == .Debug)

.None

else

.Aggressive;

 

const reloc_mode: llvm.RelocMode = if (pic)

.PIC

else if (self.module.comp.config.link_mode == .Dynamic)

llvm.RelocMode.DynamicNoPIC

else

.Static;

 

const code_model: llvm.CodeModel = switch (self.module.comp.root_mod.code_model) {

.default => .Default,

.tiny => .Tiny,

.small => .Small,

.kernel => .Kernel,

.medium => .Medium,

.large => .Large,

};

 

// TODO handle float ABI better- it should depend on the ABI portion of std.Target

const float_abi: llvm.ABIType = .Default;

 

var target_machine = llvm.TargetMachine.create(

target,

target_triple_sentinel,

if (self.module.comp.root_mod.resolved_target.result.cpu.model.llvm_name) |s| s.ptr else null,

self.module.comp.root_mod.resolved_target.llvm_cpu_features.?,

opt_level,

reloc_mode,

code_model,

self.module.comp.function_sections,

self.module.comp.data_sections,

float_abi,

if (target_util.llvmMachineAbi(self.module.comp.root_mod.resolved_target.result)) |s| s.ptr else null,

);

errdefer target_machine.dispose();

 

if (pic) module.setModulePICLevel();

if (self.module.comp.config.pie) module.setModulePIELevel();

if (code_model != .Default) module.setModuleCodeModel(code_model);

 

if (self.module.comp.llvm_opt_bisect_limit >= 0) {

context.setOptBisectLimit(self.module.comp.llvm_opt_bisect_limit);

}

// var error_message: [*:0]const u8 = undefined;

if (target_machine.emitToFile(

module,

if (target_machine.emitToFile(

module,

null,

const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);

const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);

const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, param_alignment, target);

const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);

const arg_ptr = try buildAllocaInner(&wip, param_llvm_ty, alignment, target);

const file, const subprogram = if (!o.builder.strip) debug_info: {

const file = try o.getDebugFile(namespace.file_scope);

const debug_decl_type = try o.lowerDebugType(decl.ty);

 

const subprogram = try o.builder.debugSubprogram(

file,

try o.builder.metadataString(ip.stringToSlice(decl.name)),

try o.builder.metadataStringFromString(function_index.name(&o.builder)),

line_number + func.lbrace_line,

debug_decl_type,

.{

.di_flags = .{

.StaticMember = true,

.NoReturn = fn_info.return_type == .noreturn_type,

},

.sp_flags = .{

.Optimized = owner_mod.optimize_mode != .Debug,

.Definition = true,

.LocalToUnit = is_internal_linkage,

},

},

o.debug_compile_unit,

function_index.setSubprogram(subprogram, &o.builder);

break :debug_info .{ file, subprogram };

} else .{.none} ** 2;

.file = file,

.scope = subprogram,

 

fn getDebugFile(o: *Object, file: *const Module.File) Allocator.Error!Builder.Metadata {

const gpa = o.gpa;

const gop = try o.debug_file_map.getOrPut(gpa, file);

errdefer assert(o.debug_file_map.remove(file));

if (gop.found_existing) return gop.value_ptr.*;

gop.value_ptr.* = try o.builder.debugFile(

try o.builder.metadataString(std.fs.path.basename(file.sub_file_path)),

dir_path: {

const sub_path = std.fs.path.dirname(file.sub_file_path) orelse "";

const dir_path = try file.mod.root.joinString(gpa, sub_path);

defer gpa.free(dir_path);

if (std.fs.path.isAbsolute(dir_path))

break :dir_path try o.builder.metadataString(dir_path);

var abs_buffer: [std.fs.MAX_PATH_BYTES]u8 = undefined;

const abs_path = std.fs.realpath(dir_path, &abs_buffer) catch

break :dir_path try o.builder.metadataString(dir_path);

break :dir_path try o.builder.metadataString(abs_path);

},

);

return gop.value_ptr.*;

pub fn lowerDebugType(

) Allocator.Error!Builder.Metadata {

assert(!o.builder.strip);

 

if (o.debug_type_map.get(ty)) |debug_type| return debug_type;

 

.Void,

.NoReturn,

=> {

const debug_void_type = try o.builder.debugSignedType(

try o.builder.metadataString("void"),

0,

);

try o.debug_type_map.put(gpa, ty, debug_void_type);

return debug_void_type;

const builder_name = try o.builder.metadataString(name);

const debug_bits = ty.abiSize(mod) * 8; // lldb cannot handle non-byte sized types

const debug_int_type = switch (info.signedness) {

.signed => try o.builder.debugSignedType(builder_name, debug_bits),

.unsigned => try o.builder.debugUnsignedType(builder_name, debug_bits),

try o.debug_type_map.put(gpa, ty, debug_int_type);

return debug_int_type;

const debug_enum_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);

try o.debug_type_map.put(gpa, ty, debug_enum_type);

return debug_enum_type;

const enumerators = try gpa.alloc(Builder.Metadata, enum_type.names.len);

enumerators[i] = try o.builder.debugEnumerator(

try o.builder.metadataString(ip.stringToSlice(field_name_ip)),

int_ty.isUnsignedInt(mod),

int_info.bits,

bigint,

);

const file = try o.getDebugFile(mod.namespacePtr(owner_decl.src_namespace).file_scope);

const scope = try o.namespaceToDebugScope(owner_decl.src_namespace);

const debug_enum_type = try o.builder.debugEnumerationType(

try o.builder.metadataString(name),

file,

scope,

owner_decl.src_node + 1, // Line

try o.lowerDebugType(int_ty),

try o.builder.debugTuple(enumerators),

 

try o.debug_type_map.put(gpa, ty, debug_enum_type);

try o.debug_enums.append(gpa, debug_enum_type);

return debug_enum_type;

const debug_float_type = try o.builder.debugFloatType(

try o.builder.metadataString(name),

bits,

);

try o.debug_type_map.put(gpa, ty, debug_float_type);

return debug_float_type;

const debug_bool_type = try o.builder.debugBoolType(

try o.builder.metadataString("bool"),

8, // lldb cannot handle non-byte sized types

);

try o.debug_type_map.put(gpa, ty, debug_bool_type);

return debug_bool_type;

const debug_ptr_type = try o.lowerDebugType(bland_ptr_ty);

try o.debug_type_map.put(gpa, ty, debug_ptr_type);

return debug_ptr_type;

const debug_fwd_ref = try o.builder.debugForwardReference();

 

// Set as forward reference while the type is lowered in case it references itself

try o.debug_type_map.put(gpa, ty, debug_fwd_ref);

 

const len_offset = len_align.forward(ptr_size);

const debug_ptr_type = try o.builder.debugMemberType(

try o.builder.metadataString("ptr"),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(ptr_ty),

ptr_size * 8,

ptr_align.toByteUnits(0) * 8,

0, // Offset

 

const debug_len_type = try o.builder.debugMemberType(

try o.builder.metadataString("len"),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(len_ty),

len_size * 8,

len_align.toByteUnits(0) * 8,

len_offset * 8,

);

 

const debug_slice_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Scope

line,

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(&.{

debug_ptr_type,

debug_len_type,

}),

);

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_slice_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_slice_type;

 

return debug_slice_type;

const debug_elem_ty = try o.lowerDebugType(Type.fromInterned(ptr_info.child));

 

 

const debug_ptr_type = try o.builder.debugPointerType(

try o.builder.metadataString(name),

.none, // File

.none, // Scope

0, // Line

debug_elem_ty,

0, // Offset

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_ptr_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_ptr_type;

 

return debug_ptr_type;

const debug_opaque_type = try o.builder.debugSignedType(

try o.builder.metadataString("anyopaque"),

0,

);

try o.debug_type_map.put(gpa, ty, debug_opaque_type);

return debug_opaque_type;

 

const debug_opaque_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

try o.getDebugFile(mod.namespacePtr(owner_decl.src_namespace).file_scope),

owner_decl.src_node + 1, // Line

.none, // Underlying type

0, // Size

0, // Align

.none, // Fields

try o.debug_type_map.put(gpa, ty, debug_opaque_type);

return debug_opaque_type;

const debug_array_type = try o.builder.debugArrayType(

.none, // Name

.none, // File

.none, // Scope

0, // Line

try o.lowerDebugType(ty.childType(mod)),

try o.builder.debugTuple(&.{

try o.builder.debugSubrange(

try o.builder.debugConstant(try o.builder.intConst(.i64, 0)),

try o.builder.debugConstant(try o.builder.intConst(.i64, ty.arrayLen(mod))),

),

}),

try o.debug_type_map.put(gpa, ty, debug_array_type);

return debug_array_type;

const debug_elem_type = switch (elem_ty.zigTypeTag(mod)) {

const builder_name = try o.builder.metadataString(name);

break :blk switch (info.signedness) {

.signed => try o.builder.debugSignedType(builder_name, info.bits),

.unsigned => try o.builder.debugUnsignedType(builder_name, info.bits),

.Bool => try o.builder.debugBoolType(

try o.builder.metadataString("bool"),

1,

),

else => try o.lowerDebugType(ty.childType(mod)),

const debug_vector_type = try o.builder.debugVectorType(

.none, // Name

.none, // File

.none, // Scope

0, // Line

debug_elem_type,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(&.{

try o.builder.debugSubrange(

try o.builder.debugConstant(try o.builder.intConst(.i64, 0)),

try o.builder.debugConstant(try o.builder.intConst(.i64, ty.vectorLen(mod))),

),

}),

 

try o.debug_type_map.put(gpa, ty, debug_vector_type);

return debug_vector_type;

const debug_bool_type = try o.builder.debugBoolType(

try o.builder.metadataString(name),

8,

);

try o.debug_type_map.put(gpa, ty, debug_bool_type);

return debug_bool_type;

const debug_fwd_ref = try o.builder.debugForwardReference();

 

// Set as forward reference while the type is lowered in case it references itself

try o.debug_type_map.put(gpa, ty, debug_fwd_ref);

 

if (ty.optionalReprIsPayload(mod)) {

const debug_optional_type = try o.lowerDebugType(child_ty);

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_optional_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_optional_type;

 

return debug_optional_type;

}

const non_null_offset = non_null_align.forward(payload_size);

const debug_data_type = try o.builder.debugMemberType(

try o.builder.metadataString("data"),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(child_ty),

payload_size * 8,

payload_align.toByteUnits(0) * 8,

0, // Offset

 

const debug_some_type = try o.builder.debugMemberType(

try o.builder.metadataString("some"),

.none,

debug_fwd_ref,

0,

try o.lowerDebugType(non_null_ty),

non_null_size * 8,

non_null_align.toByteUnits(0) * 8,

non_null_offset * 8,

);

 

const debug_optional_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Scope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(&.{

debug_data_type,

debug_some_type,

}),

);

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_optional_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_optional_type;

 

return debug_optional_type;

// TODO: Maybe remove?

const debug_error_union_type = try o.lowerDebugType(Type.anyerror);

try o.debug_type_map.put(gpa, ty, debug_error_union_type);

return debug_error_union_type;

 

const debug_fwd_ref = try o.builder.debugForwardReference();

 

var fields: [2]Builder.Metadata = undefined;

fields[error_index] = try o.builder.debugMemberType(

try o.builder.metadataString("tag"),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(Type.anyerror),

error_size * 8,

error_align.toByteUnits(0) * 8,

error_offset * 8,

fields[payload_index] = try o.builder.debugMemberType(

try o.builder.metadataString("value"),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(payload_ty),

payload_size * 8,

payload_align.toByteUnits(0) * 8,

payload_offset * 8,

const debug_error_union_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Sope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(&fields),

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_error_union_type);

 

try o.debug_type_map.put(gpa, ty, debug_error_union_type);

return debug_error_union_type;

const debug_error_set = try o.builder.debugUnsignedType(

try o.builder.metadataString("anyerror"),

16,

);

try o.debug_type_map.put(gpa, ty, debug_error_set);

return debug_error_set;

const builder_name = try o.builder.metadataString(name);

const debug_int_type = switch (info.signedness) {

.signed => try o.builder.debugSignedType(builder_name, ty.abiSize(mod) * 8),

.unsigned => try o.builder.debugUnsignedType(builder_name, ty.abiSize(mod) * 8),

try o.debug_type_map.put(gpa, ty, debug_int_type);

return debug_int_type;

var fields: std.ArrayListUnmanaged(Builder.Metadata) = .{};

defer fields.deinit(gpa);

try fields.ensureUnusedCapacity(gpa, tuple.types.len);

const debug_fwd_ref = try o.builder.debugForwardReference();

 

fields.appendAssumeCapacity(try o.builder.debugMemberType(

try o.builder.metadataString(field_name),

.none, // File

debug_fwd_ref,

0,

try o.lowerDebugType(Type.fromInterned(field_ty)),

field_size * 8,

field_align.toByteUnits(0) * 8,

field_offset * 8,

const debug_struct_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Scope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(fields.items),

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_struct_type);

 

try o.debug_type_map.put(gpa, ty, debug_struct_type);

return debug_struct_type;

const debug_struct_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);

try o.debug_type_map.put(gpa, ty, debug_struct_type);

return debug_struct_type;

const debug_struct_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);

try o.debug_type_map.put(gpa, ty, debug_struct_type);

return debug_struct_type;

var fields: std.ArrayListUnmanaged(Builder.Metadata) = .{};

defer fields.deinit(gpa);

try fields.ensureUnusedCapacity(gpa, struct_type.field_types.len);

 

const debug_fwd_ref = try o.builder.debugForwardReference();

 

// Set as forward reference while the type is lowered in case it references itself

try o.debug_type_map.put(gpa, ty, debug_fwd_ref);

fields.appendAssumeCapacity(try o.builder.debugMemberType(

try o.builder.metadataString(ip.stringToSlice(field_name)),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(field_ty),

field_size * 8,

field_align.toByteUnits(0) * 8,

field_offset * 8,

const debug_struct_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Scope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(fields.items),

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_struct_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_struct_type;

 

return debug_struct_type;

const debug_union_type = try o.makeEmptyNamespaceDebugType(owner_decl_index);

try o.debug_type_map.put(gpa, ty, debug_union_type);

return debug_union_type;

const debug_fwd_ref = try o.builder.debugForwardReference();

 

// Set as forward reference while the type is lowered in case it references itself

try o.debug_type_map.put(gpa, ty, debug_fwd_ref);

 

const debug_union_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Scope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(

&.{try o.lowerDebugType(Type.fromInterned(union_obj.enum_tag_ty))},

),

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_union_type;

 

return debug_union_type;

var fields: std.ArrayListUnmanaged(Builder.Metadata) = .{};

defer fields.deinit(gpa);

try fields.ensureUnusedCapacity(gpa, union_obj.field_names.len);

 

const debug_union_fwd_ref = if (layout.tag_size == 0)

debug_fwd_ref

else

try o.builder.debugForwardReference();

fields.appendAssumeCapacity(try o.builder.debugMemberType(

try o.builder.metadataString(ip.stringToSlice(field_name)),

.none, // File

debug_union_fwd_ref,

0, // Line

try o.lowerDebugType(Type.fromInterned(field_ty)),

field_size * 8,

field_align.toByteUnits(0) * 8,

0, // Offset

const debug_union_type = try o.builder.debugUnionType(

try o.builder.metadataString(union_name),

.none, // File

o.debug_compile_unit, // Scope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(fields.items),

o.builder.debugForwardReferenceSetType(debug_union_fwd_ref, debug_union_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_union_type;

 

return debug_union_type;

const debug_tag_type = try o.builder.debugMemberType(

try o.builder.metadataString("tag"),

.none, // File

debug_fwd_ref,

0, // Line

try o.lowerDebugType(Type.fromInterned(union_obj.enum_tag_ty)),

tag_offset * 8,

const debug_payload_type = try o.builder.debugMemberType(

try o.builder.metadataString("payload"),

.none, // File

debug_fwd_ref,

0, // Line

debug_union_type,

layout.payload_size * 8,

payload_offset * 8,

const full_fields: [2]Builder.Metadata =

.{ debug_tag_type, debug_payload_type }

.{ debug_payload_type, debug_tag_type };

const debug_tagged_union_type = try o.builder.debugStructType(

try o.builder.metadataString(name),

.none, // File

o.debug_compile_unit, // Scope

0, // Line

.none, // Underlying type

ty.abiSize(mod) * 8,

ty.abiAlignment(mod).toByteUnits(0) * 8,

try o.builder.debugTuple(&full_fields),

 

o.builder.debugForwardReferenceSetType(debug_fwd_ref, debug_tagged_union_type);

 

// Set to real type now that it has been lowered fully

const map_ptr = o.debug_type_map.getPtr(ty) orelse unreachable;

map_ptr.* = debug_tagged_union_type;

 

return debug_tagged_union_type;

var debug_param_types = std.ArrayList(Builder.Metadata).init(gpa);

defer debug_param_types.deinit();

 

try debug_param_types.ensureUnusedCapacity(3 + fn_info.param_types.len);

const ret_ty = if (sret) Type.void else Type.fromInterned(fn_info.return_type);

debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ret_ty));

debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));

debug_param_types.appendAssumeCapacity(try o.lowerDebugType(Type.void));

debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));

debug_param_types.appendAssumeCapacity(try o.lowerDebugType(ptr_ty));

debug_param_types.appendAssumeCapacity(try o.lowerDebugType(param_ty));

const debug_function_type = try o.builder.debugSubroutineType(

try o.builder.debugTuple(debug_param_types.items),

 

try o.debug_type_map.put(gpa, ty, debug_function_type);

return debug_function_type;

fn namespaceToDebugScope(o: *Object, namespace_index: InternPool.NamespaceIndex) !Builder.Metadata {

if (namespace.parent == .none) return try o.getDebugFile(namespace.file_scope);

 

const gop = try o.debug_unresolved_namespace_scopes.getOrPut(o.gpa, namespace_index);

 

if (!gop.found_existing) gop.value_ptr.* = try o.builder.debugForwardReference();

 

return gop.value_ptr.*;

fn makeEmptyNamespaceDebugType(o: *Object, decl_index: InternPool.DeclIndex) !Builder.Metadata {

return o.builder.debugStructType(

try o.builder.metadataString(mod.intern_pool.stringToSlice(decl.name)), // TODO use fully qualified name

try o.getDebugFile(mod.namespacePtr(decl.src_namespace).file_scope),

try o.namespaceToDebugScope(decl.src_namespace),

.none,

0,

0,

.none,

if (o.type_map.get(t.toIntern())) |value| return value;

try o.type_map.put(o.gpa, t.toIntern(), int_ty);

const ty = try o.builder.opaqueType(name);

try o.type_map.put(o.gpa, t.toIntern(), ty);

 

o.builder.namedTypeSetBody(

if (o.type_map.get(t.toIntern())) |value| return value;

try o.type_map.put(o.gpa, t.toIntern(), int_ty);

try o.type_map.put(o.gpa, t.toIntern(), enum_tag_ty);

const ty = try o.builder.opaqueType(name);

try o.type_map.put(o.gpa, t.toIntern(), ty);

 

o.builder.namedTypeSetBody(

const ty = try o.builder.opaqueType(name);

try o.type_map.put(o.gpa, t.toIntern(), ty);

 

o.builder.namedTypeSetBody(

.@"0", try o.builder.intConst(.i32, index),

return o.builder.gepConst(.inbounds, try o.lowerType(opt_ty), parent_ptr, null, &.{ .@"0", .@"0" });

.@"0",

.@"0",

.@"0", try o.builder.intConst(.i32, field_index),

const name = try o.builder.stringNull(ip.stringToSlice(enum_type.names.get(ip)[field_index]));

const name_init = try o.builder.stringConst(name);

try o.builder.intConst(usize_ty, name.slice(&o.builder).?.len - 1),

const line_number = decl.src_line + 1;

const is_internal_linkage = !o.module.decl_exports.contains(decl_index);

if (dg.object.builder.strip) return;

const debug_file = try o.getDebugFile(mod.namespacePtr(decl.src_namespace).file_scope);

 

const debug_global_var = try o.builder.debugGlobalVar(

try o.builder.metadataString(mod.intern_pool.stringToSlice(decl.name)), // Name

try o.builder.metadataStringFromString(variable_index.name(&o.builder)), // Linkage name

debug_file, // File

debug_file, // Scope

line_number,

try o.lowerDebugType(decl.ty),

variable_index,

.{ .local = is_internal_linkage },

);

 

const debug_expression = try o.builder.debugExpression(&.{});

 

const debug_global_var_expression = try o.builder.debugGlobalVarExpression(

debug_global_var,

debug_expression,

);

if (!is_internal_linkage or decl.isExtern(mod))

variable_index.setGlobalVariableExpression(debug_global_var_expression, &o.builder);

try o.debug_globals.append(o.gpa, debug_global_var_expression);

 

file: Builder.Metadata,

scope: Builder.Metadata,

 

inlined: std.ArrayListUnmanaged(struct {

base_line: u32,

location: Builder.Metadata,

scope: Builder.Metadata,

}) = .{},

 

scope_stack: std.ArrayListUnmanaged(Builder.Metadata) = .{},

 

self.scope_stack.deinit(self.gpa);

self.inlined.deinit(self.gpa);

phi.finish(

phi.finish(breaks.list.items(.val), breaks.list.items(.bb), &self.wip);

if (self.wip.builder.strip) return .none;

const inlined_at = if (self.inlined.items.len > 0)

self.inlined.items[self.inlined.items.len - 1].location

.none;

 

self.wip.current_debug_location = try self.wip.builder.debugLocation(

self.scope,

 

if (self.wip.builder.strip) return .none;

 

const ty_fn = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_fn;

self.file = try o.getDebugFile(namespace.file_scope);

 

const line_number = decl.src_line + 1;

try self.inlined.append(self.gpa, .{

.location = self.wip.current_debug_location,

.scope = self.scope,

 

const subprogram = try o.builder.debugSubprogram(

self.file,

try o.builder.metadataString(zcu.intern_pool.stringToSlice(decl.name)),

try o.builder.metadataString(zcu.intern_pool.stringToSlice(fqn)),

line_number + func.lbrace_line,

try o.lowerDebugType(fn_ty),

.{

.di_flags = .{ .StaticMember = true },

.sp_flags = .{

.Optimized = owner_mod.optimize_mode != .Debug,

.Definition = true,

.LocalToUnit = is_internal_linkage,

},

},

o.debug_compile_unit,

const lexical_block = try o.builder.debugLexicalBlock(

subprogram,

self.file,

line_number,

1,

);

self.scope = lexical_block;

const inlined_at = self.wip.current_debug_location;

self.wip.current_debug_location = try o.builder.debugLocation(

line_number,

0,

self.scope,

inlined_at,

);

fn airDbgInlineEnd(self: *FuncGen, inst: Air.Inst.Index) Allocator.Error!Builder.Value {

if (self.wip.builder.strip) return .none;

 

self.file = try o.getDebugFile(mod.namespacePtr(decl.src_namespace).file_scope);

 

const old = self.inlined.pop();

self.scope = old.scope;

self.wip.current_debug_location = old.location;

fn airDbgBlockBegin(self: *FuncGen) Allocator.Error!Builder.Value {

if (self.wip.builder.strip) return .none;

 

try self.scope_stack.append(self.gpa, self.scope);

 

const old = self.scope;

self.scope = try o.builder.debugLexicalBlock(

old,

self.file,

self.prev_dbg_line,

self.prev_dbg_column,

);

if (self.wip.builder.strip) return .none;

self.scope = self.scope_stack.pop();

if (self.wip.builder.strip) return .none;

const debug_local_var = try o.builder.debugLocalVar(

try o.builder.metadataString(name),

self.file,

self.scope,

try o.lowerDebugType(ptr_ty.childType(mod)),

 

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.declare",

&.{},

&.{

(try self.wip.debugValue(operand)).toValue(),

debug_local_var.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

);

 

if (self.wip.builder.strip) return .none;

const debug_local_var = try o.builder.debugLocalVar(

try o.builder.metadataString(name),

self.file,

self.scope,

try o.lowerDebugType(operand_ty),

 

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.declare",

&.{},

&.{

(try self.wip.debugValue(operand)).toValue(),

debug_local_var.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

);

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.declare",

&.{},

&.{

(try self.wip.debugValue(alloca)).toValue(),

debug_local_var.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

);

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.value",

&.{},

&.{

(try self.wip.debugValue(operand)).toValue(),

debug_local_var.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

);

&.{ lhs, rhs, .@"0" },

const zero_vector = try o.builder.splatValue(vector_result_ty, .@"0");

return self.wip.icmp(int_cond, result, .@"0", "");

if (self.wip.builder.strip) return arg_val;

 

if (needDbgVarWorkaround(o)) return arg_val;

const src_index = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.src_index;

const func_index = self.dg.decl.getOwnedFunctionIndex();

const func = mod.funcInfo(func_index);

const lbrace_line = mod.declPtr(func.owner_decl).src_line + func.lbrace_line + 1;

const lbrace_col = func.lbrace_column + 1;

 

const debug_parameter = try o.builder.debugParameter(

try o.builder.metadataString(mod.getParamName(func_index, src_index)),

self.file,

self.scope,

lbrace_line,

try o.lowerDebugType(inst_ty),

@intCast(self.arg_index),

);

 

const old_location = self.wip.current_debug_location;

self.wip.current_debug_location = try o.builder.debugLocation(

lbrace_line,

lbrace_col,

self.scope,

.none,

);

 

const owner_mod = self.dg.ownerModule();

if (isByRef(inst_ty, mod)) {

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.declare",

&.{},

&.{

(try self.wip.debugValue(arg_val)).toValue(),

debug_parameter.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

);

} else if (owner_mod.optimize_mode == .Debug) {

const alignment = inst_ty.abiAlignment(mod).toLlvm();

const alloca = try self.buildAlloca(arg_val.typeOfWip(&self.wip), alignment);

_ = try self.wip.store(.normal, arg_val, alloca, alignment);

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.declare",

&.{},

&.{

(try self.wip.debugValue(alloca)).toValue(),

debug_parameter.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

);

} else {

_ = try self.wip.callIntrinsic(

.normal,

.none,

.@"dbg.value",

&.{},

&.{

(try self.wip.debugValue(arg_val)).toValue(),

debug_parameter.toValue(),

(try o.builder.debugExpression(&.{})).toValue(),

},

"",

self.wip.current_debug_location = old_location;

return buildAllocaInner(&self.wip, llvm_ty, alignment, target);

const result = try self.wip.callIntrinsic(.normal, .none, .returnaddress, &.{}, &.{.@"0"}, "");

const result = try self.wip.callIntrinsic(.normal, .none, .frameaddress, &.{.ptr}, &.{.@"0"}, "");

it_ptr.finish(&.{ next_ptr, dest_ptr }, &.{ body_block, entry_block }, &self.wip);

phi.finish(&.{ .true, .false }, &.{ valid_block, invalid_block }, &self.wip);

const indices = [3]Builder.Value{ usize_zero, .@"0", .@"0" };

const indices: [3]Builder.Value = .{ usize_zero, try o.builder.intValue(.i32, payload_index), .@"0" };

const field_ptr = try self.wip.gep(.inbounds, llvm_union_ty, result_ptr, indices[0..len], "");

if (dimension >= 3) return .@"1";

const prev_debug_location = wip.current_debug_location;

wip.current_debug_location = prev_debug_location;

wip.current_debug_location = .none;

 

pub fn initializeLLVMTarget(arch: std.Target.Cpu.Arch) void {

switch (arch) {

.aarch64, .aarch64_be, .aarch64_32 => {

llvm.LLVMInitializeAArch64Target();

llvm.LLVMInitializeAArch64TargetInfo();

llvm.LLVMInitializeAArch64TargetMC();

llvm.LLVMInitializeAArch64AsmPrinter();

llvm.LLVMInitializeAArch64AsmParser();

},

.amdgcn => {

llvm.LLVMInitializeAMDGPUTarget();

llvm.LLVMInitializeAMDGPUTargetInfo();

llvm.LLVMInitializeAMDGPUTargetMC();

llvm.LLVMInitializeAMDGPUAsmPrinter();

llvm.LLVMInitializeAMDGPUAsmParser();

},

.thumb, .thumbeb, .arm, .armeb => {

llvm.LLVMInitializeARMTarget();

llvm.LLVMInitializeARMTargetInfo();

llvm.LLVMInitializeARMTargetMC();

llvm.LLVMInitializeARMAsmPrinter();

llvm.LLVMInitializeARMAsmParser();

},

.avr => {

llvm.LLVMInitializeAVRTarget();

llvm.LLVMInitializeAVRTargetInfo();

llvm.LLVMInitializeAVRTargetMC();

llvm.LLVMInitializeAVRAsmPrinter();

llvm.LLVMInitializeAVRAsmParser();

},

.bpfel, .bpfeb => {

llvm.LLVMInitializeBPFTarget();

llvm.LLVMInitializeBPFTargetInfo();

llvm.LLVMInitializeBPFTargetMC();

llvm.LLVMInitializeBPFAsmPrinter();

llvm.LLVMInitializeBPFAsmParser();

},

.hexagon => {

llvm.LLVMInitializeHexagonTarget();

llvm.LLVMInitializeHexagonTargetInfo();

llvm.LLVMInitializeHexagonTargetMC();

llvm.LLVMInitializeHexagonAsmPrinter();

llvm.LLVMInitializeHexagonAsmParser();

},

.lanai => {

llvm.LLVMInitializeLanaiTarget();

llvm.LLVMInitializeLanaiTargetInfo();

llvm.LLVMInitializeLanaiTargetMC();

llvm.LLVMInitializeLanaiAsmPrinter();

llvm.LLVMInitializeLanaiAsmParser();

},

.mips, .mipsel, .mips64, .mips64el => {

llvm.LLVMInitializeMipsTarget();

llvm.LLVMInitializeMipsTargetInfo();

llvm.LLVMInitializeMipsTargetMC();

llvm.LLVMInitializeMipsAsmPrinter();

llvm.LLVMInitializeMipsAsmParser();

},

.msp430 => {

llvm.LLVMInitializeMSP430Target();

llvm.LLVMInitializeMSP430TargetInfo();

llvm.LLVMInitializeMSP430TargetMC();

llvm.LLVMInitializeMSP430AsmPrinter();

llvm.LLVMInitializeMSP430AsmParser();

},

.nvptx, .nvptx64 => {

llvm.LLVMInitializeNVPTXTarget();

llvm.LLVMInitializeNVPTXTargetInfo();

llvm.LLVMInitializeNVPTXTargetMC();

llvm.LLVMInitializeNVPTXAsmPrinter();

// There is no LLVMInitializeNVPTXAsmParser function available.

},

.powerpc, .powerpcle, .powerpc64, .powerpc64le => {

llvm.LLVMInitializePowerPCTarget();

llvm.LLVMInitializePowerPCTargetInfo();

llvm.LLVMInitializePowerPCTargetMC();

llvm.LLVMInitializePowerPCAsmPrinter();

llvm.LLVMInitializePowerPCAsmParser();

},

.riscv32, .riscv64 => {

llvm.LLVMInitializeRISCVTarget();

llvm.LLVMInitializeRISCVTargetInfo();

llvm.LLVMInitializeRISCVTargetMC();

llvm.LLVMInitializeRISCVAsmPrinter();

llvm.LLVMInitializeRISCVAsmParser();

},

.sparc, .sparc64, .sparcel => {

llvm.LLVMInitializeSparcTarget();

llvm.LLVMInitializeSparcTargetInfo();

llvm.LLVMInitializeSparcTargetMC();

llvm.LLVMInitializeSparcAsmPrinter();

llvm.LLVMInitializeSparcAsmParser();

},

.s390x => {

llvm.LLVMInitializeSystemZTarget();

llvm.LLVMInitializeSystemZTargetInfo();

llvm.LLVMInitializeSystemZTargetMC();

llvm.LLVMInitializeSystemZAsmPrinter();

llvm.LLVMInitializeSystemZAsmParser();

},

.wasm32, .wasm64 => {

llvm.LLVMInitializeWebAssemblyTarget();

llvm.LLVMInitializeWebAssemblyTargetInfo();

llvm.LLVMInitializeWebAssemblyTargetMC();

llvm.LLVMInitializeWebAssemblyAsmPrinter();

llvm.LLVMInitializeWebAssemblyAsmParser();

},

.x86, .x86_64 => {

llvm.LLVMInitializeX86Target();

llvm.LLVMInitializeX86TargetInfo();

llvm.LLVMInitializeX86TargetMC();

llvm.LLVMInitializeX86AsmPrinter();

llvm.LLVMInitializeX86AsmParser();

},

.xtensa => {

if (build_options.llvm_has_xtensa) {

llvm.LLVMInitializeXtensaTarget();

llvm.LLVMInitializeXtensaTargetInfo();

llvm.LLVMInitializeXtensaTargetMC();

// There is no LLVMInitializeXtensaAsmPrinter function.

llvm.LLVMInitializeXtensaAsmParser();

}

},

.xcore => {

llvm.LLVMInitializeXCoreTarget();

llvm.LLVMInitializeXCoreTargetInfo();

llvm.LLVMInitializeXCoreTargetMC();

llvm.LLVMInitializeXCoreAsmPrinter();

// There is no LLVMInitializeXCoreAsmParser function.

},

.m68k => {

if (build_options.llvm_has_m68k) {

llvm.LLVMInitializeM68kTarget();

llvm.LLVMInitializeM68kTargetInfo();

llvm.LLVMInitializeM68kTargetMC();

llvm.LLVMInitializeM68kAsmPrinter();

llvm.LLVMInitializeM68kAsmParser();

}

},

.csky => {

if (build_options.llvm_has_csky) {

llvm.LLVMInitializeCSKYTarget();

llvm.LLVMInitializeCSKYTargetInfo();

llvm.LLVMInitializeCSKYTargetMC();

// There is no LLVMInitializeCSKYAsmPrinter function.

llvm.LLVMInitializeCSKYAsmParser();

}

},

.ve => {

llvm.LLVMInitializeVETarget();

llvm.LLVMInitializeVETargetInfo();

llvm.LLVMInitializeVETargetMC();

llvm.LLVMInitializeVEAsmPrinter();

llvm.LLVMInitializeVEAsmParser();

},

.arc => {

if (build_options.llvm_has_arc) {

llvm.LLVMInitializeARCTarget();

llvm.LLVMInitializeARCTargetInfo();

llvm.LLVMInitializeARCTargetMC();

llvm.LLVMInitializeARCAsmPrinter();

// There is no LLVMInitializeARCAsmParser function.

}

},

 

// LLVM backends that have no initialization functions.

.tce,

.tcele,

.r600,

.le32,

.le64,

.amdil,

.amdil64,

.hsail,

.hsail64,

.shave,

.spir,

.spir64,

.kalimba,

.renderscript32,

.renderscript64,

.dxil,

.loongarch32,

.loongarch64,

=> {},

 

.spu_2 => unreachable, // LLVM does not support this backend

.spirv32 => unreachable, // LLVM does not support this backend

.spirv64 => unreachable, // LLVM does not support this backend

}

}

function_attributes_set: std.AutoArrayHashMapUnmanaged(FunctionAttributes, void),

 

metadata_map: std.AutoArrayHashMapUnmanaged(void, void),

metadata_items: std.MultiArrayList(Metadata.Item),

metadata_extra: std.ArrayListUnmanaged(u32),

metadata_limbs: std.ArrayListUnmanaged(std.math.big.Limb),

metadata_forward_references: std.ArrayListUnmanaged(Metadata),

metadata_named: std.AutoArrayHashMapUnmanaged(MetadataString, struct {

len: u32,

index: Metadata.Item.ExtraIndex,

}),

 

metadata_string_map: std.AutoArrayHashMapUnmanaged(void, void),

metadata_string_indices: std.ArrayListUnmanaged(u32),

metadata_string_bytes: std.ArrayListUnmanaged(u8),

 

pub fn slice(self: String, builder: *const Builder) ?[]const u8 {

const start = builder.string_indices.items[index];

const end = builder.string_indices.items[index + 1];

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

if (comptime std.mem.indexOfNone(u8, fmt_str, "\"r")) |_|

const string_slice = data.string.slice(data.builder) orelse

if (comptime std.mem.indexOfScalar(u8, fmt_str, 'r')) |_|

return writer.writeAll(string_slice);

try printEscapedString(

string_slice,

if (comptime std.mem.indexOfScalar(u8, fmt_str, '"')) |_|

.always_quote

else

.quote_unless_valid_identifier,

writer,

);

pub const BinaryOpcode = enum(u4) {

add = 0,

sub = 1,

mul = 2,

udiv = 3,

sdiv = 4,

urem = 5,

srem = 6,

shl = 7,

lshr = 8,

ashr = 9,

@"and" = 10,

@"or" = 11,

xor = 12,

};

 

pub const CastOpcode = enum(u4) {

trunc = 0,

zext = 1,

sext = 2,

fptoui = 3,

fptosi = 4,

uitofp = 5,

sitofp = 6,

fptrunc = 7,

fpext = 8,

ptrtoint = 9,

inttoptr = 10,

bitcast = 11,

addrspacecast = 12,

};

 

pub const CmpPredicate = enum(u6) {

fcmp_false = 0,

fcmp_oeq = 1,

fcmp_ogt = 2,

fcmp_oge = 3,

fcmp_olt = 4,

fcmp_ole = 5,

fcmp_one = 6,

fcmp_ord = 7,

fcmp_uno = 8,

fcmp_ueq = 9,

fcmp_ugt = 10,

fcmp_uge = 11,

fcmp_ult = 12,

fcmp_ule = 13,

fcmp_une = 14,

fcmp_true = 15,

icmp_eq = 32,

icmp_ne = 33,

icmp_ugt = 34,

icmp_uge = 35,

icmp_ult = 36,

icmp_ule = 37,

icmp_sgt = 38,

icmp_sge = 39,

icmp_slt = 40,

icmp_sle = 41,

};

 

pub const StrtabString = struct {

offset: usize,

size: usize,

};

 

pub const Simple = enum(u5) {

void = 2,

half = 10,

bfloat = 23,

float = 3,

double = 4,

fp128 = 14,

x86_fp80 = 13,

ppc_fp128 = 15,

x86_amx = 24,

x86_mmx = 17,

label = 5,

token = 22,

metadata = 16,

const field = comptime blk: {

@setEvalBranchQuota(10_000);

for (@typeInfo(Attribute).Union.fields) |field| {

if (std.mem.eql(u8, field.name, @tagName(kind))) break :blk field;

}

unreachable;

};

else => @compileError("bad payload type: " ++ field.name ++ ": " ++

@typeName(field.type)),

zeroext = 34,

signext = 24,

inreg = 5,

byval = 3,

byref = 69,

preallocated = 65,

inalloca = 38,

sret = 29, // TODO: ?

elementtype = 77,

@"align" = 1,

@"noalias" = 9,

nocapture = 11,

nofree = 62,

nest = 8,

returned = 22,

nonnull = 39,

dereferenceable = 41,

dereferenceable_or_null = 42,

swiftself = 46,

swiftasync = 75,

swifterror = 47,

immarg = 60,

noundef = 68,

nofpclass = 87,

alignstack = 25,

allocalign = 80,

allocptr = 81,

readnone = 20,

readonly = 21,

writeonly = 52,

allockind = 82,

allocsize = 51,

alwaysinline = 2,

builtin = 35,

cold = 36,

convergent = 43,

disable_sanitizer_information = 78,

fn_ret_thunk_extern = 84,

hot = 72,

inlinehint = 4,

jumptable = 40,

memory = 86,

minsize = 6,

naked = 7,

nobuiltin = 10,

nocallback = 71,

noduplicate = 12,

noimplicitfloat = 13,

@"noinline" = 14,

nomerge = 66,

nonlazybind = 15,

noprofile = 73,

skipprofile = 85,

noredzone = 16,

noreturn = 17,

norecurse = 48,

willreturn = 61,

nosync = 63,

nounwind = 18,

nosanitize_bounds = 79,

nosanitize_coverage = 76,

null_pointer_is_valid = 67,

optforfuzzing = 57,

optnone = 37,

optsize = 19,

returns_twice = 23,

safestack = 44,

sanitize_address = 30,

sanitize_memory = 32,

sanitize_thread = 31,

sanitize_hwaddress = 55,

sanitize_memtag = 64,

speculative_load_hardening = 59,

speculatable = 53,

ssp = 26,

sspstrong = 28,

sspreq = 27,

strictfp = 54,

uwtable = 33,

nocf_check = 56,

shadowcallstack = 58,

mustprogress = 70,

vscale_range = 74,

no_sanitize_address = 100,

no_sanitize_hwaddress = 101,

sanitize_address_dyninit = 102,

inline else => |value, tag| .{ .kind = @as(Kind, self), .value = switch (@TypeOf(value)) {

else => @compileError("bad payload type: " ++ @tagName(tag) ++ @typeName(@TypeOf(value))),

pub const Linkage = enum(u4) {

private = 9,

internal = 3,

weak = 1,

weak_odr = 10,

linkonce = 4,

linkonce_odr = 11,

available_externally = 12,

appending = 2,

common = 8,

extern_weak = 7,

external = 0,

fn formatOptional(

data: ?Linkage,

comptime _: []const u8,

_: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

if (data) |linkage| try writer.print(" {s}", .{@tagName(linkage)});

}

pub fn fmtOptional(self: ?Linkage) std.fmt.Formatter(formatOptional) {

return .{ .data = self };

pub const Visibility = enum(u2) {

default = 0,

hidden = 1,

protected = 2,

pub const DllStorageClass = enum(u2) {

default = 0,

dllimport = 1,

dllexport = 2,

pub const ThreadLocal = enum(u3) {

default = 0,

generaldynamic = 1,

localdynamic = 2,

initialexec = 3,

localexec = 4,

pub const UnnamedAddr = enum(u2) {

default = 0,

unnamed_addr = 1,

local_unnamed_addr = 2,

pub fn toLlvm(self: Alignment) u6 {

return if (self == .default) 0 else (@intFromEnum(self) + 1);

}

 

dbg: Metadata = .none,

pub fn strtab(self: Index, builder: *const Builder) StrtabString {

const name_index = self.name(builder).toIndex() orelse return .{

.offset = 0,

.size = 0,

};

 

return .{

.offset = builder.string_indices.items[name_index],

.size = builder.string_indices.items[name_index + 1] - builder.string_indices.items[name_index],

};

}

 

pub fn setDebugMetadata(self: Index, dbg: Metadata, builder: *Builder) void {

self.ptr(builder).dbg = dbg;

pub fn setGlobalVariableExpression(self: Index, expression: Metadata, builder: *Builder) void {

self.ptrConst(builder).global.setDebugMetadata(expression, builder);

// Debug

@"dbg.declare",

@"dbg.value",

 

.@"dbg.declare" = .{

.ret_len = 0,

.params = &.{

.{ .kind = .{ .type = .metadata } },

.{ .kind = .{ .type = .metadata } },

.{ .kind = .{ .type = .metadata } },

},

.attrs = &.{ .nocallback, .nofree, .nosync, .nounwind, .speculatable, .willreturn, .{ .memory = Attribute.Memory.all(.none) } },

},

.@"dbg.value" = .{

.ret_len = 0,

.params = &.{

.{ .kind = .{ .type = .metadata } },

.{ .kind = .{ .type = .metadata } },

.{ .kind = .{ .type = .metadata } },

},

.attrs = &.{ .nocallback, .nofree, .nosync, .nounwind, .speculatable, .willreturn, .{ .memory = Attribute.Memory.all(.none) } },

},

 

value_indices: [*]const u32 = &[0]u32{},

debug_locations: std.AutoHashMapUnmanaged(Instruction.Index, Metadata) = .{},

debug_values: []const Instruction.Index = &.{},

pub fn setSubprogram(self: Index, subprogram: Metadata, builder: *Builder) void {

self.ptrConst(builder).global.setDebugMetadata(subprogram, builder);

 

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 fn valueIndex(self: Instruction.Index, function: *const Function) u32 {

return function.value_indices[@intFromEnum(self)];

}

 

.block,

}),

}),

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,

gpa.free(self.debug_values);

self.debug_locations.deinit(gpa);

gpa.free(self.value_indices[0..self.instructions.len]);

else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),

last_debug_location: Metadata,

current_debug_location: Metadata,

debug_locations: std.AutoArrayHashMapUnmanaged(Instruction.Index, Metadata),

debug_values: std.AutoArrayHashMapUnmanaged(Instruction.Index, void),

var self: WipFunction = .{

.last_debug_location = .none,

.current_debug_location = .none,

.debug_locations = .{},

.debug_values = .{},

if (!self.builder.strip) {

try self.names.ensureUnusedCapacity(self.builder.gpa, params_len);

}

if (!self.builder.strip) {

self.names.appendAssumeCapacity(.empty); // TODO: param names

}

return try self.addInst(null, .{ .tag = .ret, .data = @intFromEnum(val) });

return try self.addInst(null, .{ .tag = .@"ret void", .data = undefined });

const mask = try self.builder.splatValue(mask_ty, .@"0");

const scalar = try self.insertElement(poison, elem, .@"0", name);

.len = switch (len) {

.none => .@"1",

else => len,

},

return self.gep(.inbounds, ty, base, &.{ .@"0", try self.builder.intValue(.i32, index) }, name);

}, lhs, rhs, name);

}, lhs, rhs, name);

) void {

pub fn debugValue(self: *WipFunction, value: Value) Allocator.Error!Metadata {

if (self.builder.strip) return .none;

return switch (value.unwrap()) {

.instruction => |instr_index| blk: {

const gop = try self.debug_values.getOrPut(self.builder.gpa, instr_index);

 

const metadata: Metadata = @enumFromInt(Metadata.first_local_metadata + gop.index);

if (!gop.found_existing) gop.key_ptr.* = instr_index;

 

break :blk metadata;

},

.constant => |constant| try self.builder.debugConstant(constant),

.metadata => |metadata| metadata,

};

}

 

.metadata => |metadata| metadata.toValue(),

const value_indices = try gpa.alloc(u32, final_instructions_len);

errdefer gpa.free(value_indices);

 

var debug_locations: std.AutoHashMapUnmanaged(Instruction.Index, Metadata) = .{};

errdefer debug_locations.deinit(gpa);

try debug_locations.ensureUnusedCapacity(gpa, @intCast(self.debug_locations.count()));

 

const debug_values = try gpa.alloc(Instruction.Index, self.debug_values.count());

errdefer gpa.free(debug_values);

else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),

function.debug_locations.deinit(gpa);

function.debug_locations = .{};

gpa.free(function.debug_values);

function.debug_values = &.{};

next_unique_name: std.AutoHashMap(String, String),

builder: *Builder,

fn map(wip_name: *@This(), name: String, sep: []const u8) Allocator.Error!String {

switch (name) {

.none => return .none,

.empty => {

assert(wip_name.next_name != .none);

defer wip_name.next_name = @enumFromInt(@intFromEnum(wip_name.next_name) + 1);

return wip_name.next_name;

},

_ => {

assert(!name.isAnon());

const gop = try wip_name.next_unique_name.getOrPut(name);

if (!gop.found_existing) {

gop.value_ptr.* = @enumFromInt(0);

return name;

}

while (true) {

gop.value_ptr.* = @enumFromInt(@intFromEnum(gop.value_ptr.*) + 1);

const unique_name = try wip_name.builder.fmt("{r}{s}{r}", .{

name.fmt(wip_name.builder),

sep,

gop.value_ptr.fmt(wip_name.builder),

});

const unique_gop = try wip_name.next_unique_name.getOrPut(unique_name);

if (!unique_gop.found_existing) {

unique_gop.value_ptr.* = @enumFromInt(0);

return unique_name;

}

}

},

}

} = .{

.next_unique_name = std.AutoHashMap(String, String).init(gpa),

.builder = self.builder,

};

defer wip_name.next_unique_name.deinit();

 

var value_index: u32 = 0;

value_indices[function.instructions.len] = value_index;

value_index += 1;

names[@intFromEnum(new_argument_index)] = try wip_name.map(

".",

if (self.debug_locations.get(old_argument_index)) |location| {

debug_locations.putAssumeCapacity(new_argument_index, location);

}

if (self.debug_values.getIndex(old_argument_index)) |index| {

debug_values[index] = new_argument_index;

}

value_indices[function.instructions.len] = value_index;

names[@intFromEnum(new_block_index)] = try wip_name.map(current_block.name, "");

names[@intFromEnum(new_instruction_index)] = try wip_name.map(if (self.builder.strip)

self.names.items[@intFromEnum(old_instruction_index)], ".");

 

if (self.debug_locations.get(old_instruction_index)) |location| {

debug_locations.putAssumeCapacity(new_instruction_index, location);

}

 

if (self.debug_values.getIndex(old_instruction_index)) |index| {

debug_values[index] = new_instruction_index;

}

 

value_indices[@intFromEnum(new_instruction_index)] = value_index;

if (old_instruction_index.hasResultWip(self)) value_index += 1;

function.value_indices = value_indices.ptr;

function.debug_locations = debug_locations;

function.debug_values = debug_values;

self.debug_values.deinit(self.builder.gpa);

self.debug_locations.deinit(self.builder.gpa);

if (!self.builder.strip) {

try self.names.ensureUnusedCapacity(self.builder.gpa, 1);

try self.debug_locations.ensureUnusedCapacity(self.builder.gpa, 1);

}

if (!self.builder.strip) {

self.names.appendAssumeCapacity(final_name);

if (block_instructions.items.len == 0 or

self.current_debug_location != self.last_debug_location)

{

self.debug_locations.putAssumeCapacity(index, self.current_debug_location);

self.last_debug_location = self.current_debug_location;

}

}

else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),

else => @compileError("bad field type: " ++ field.name ++ ": " ++ @typeName(field.type)),

acquire = 3,

release = 4,

acq_rel = 5,

seq_cst = 6,

pub const FastMath = packed struct(u8) {

unsafe_algebra: bool = false, // Legacy

@"0",

@"1",

no_init = (1 << 30) - 1,

const first_global: Constant = @enumFromInt(1 << 29);

 

pub fn toBinaryOpcode(self: Tag) BinaryOpcode {

return switch (self) {

.add,

.@"add nsw",

.@"add nuw",

=> .add,

.sub,

.@"sub nsw",

.@"sub nuw",

=> .sub,

.mul,

.@"mul nsw",

.@"mul nuw",

=> .mul,

.shl => .shl,

.lshr => .lshr,

.ashr => .ashr,

.@"and" => .@"and",

.@"or" => .@"or",

.xor => .xor,

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,

};

}

.string => builder.arrayTypeAssumeCapacity(

@as(String, @enumFromInt(item.data)).slice(builder).?.len,

const bigint: std.math.big.int.Const = .{

const Mantissa64 = std.meta.FieldType(Float.Repr(f64), .mantissa);

 

const denormal_shift = switch (repr.exponent) {

std.math.minInt(Exponent32) => @as(

std.math.Log2Int(Mantissa64),

@clz(repr.mantissa),

) + 1,

else => 0,

};

Mantissa64,

std.math.floatMantissaBits(f64) - std.math.floatMantissaBits(f32) +

denormal_shift,

std.math.minInt(Exponent32) => if (repr.mantissa > 0)

@as(Exponent64, std.math.floatExponentMin(f32) +

std.math.floatExponentMax(f64)) - denormal_shift

else

std.math.minInt(Exponent64),

.string => try writer.print("c{\"}", .{

@as(String, @enumFromInt(item.data)).fmt(data.builder),

}),

@"0" = first_constant + @intFromEnum(Constant.@"0"),

@"1" = first_constant + @intFromEnum(Constant.@"1"),

const first_constant = 1 << 30;

const first_metadata = 1 << 31;

metadata: Metadata,

else if (@intFromEnum(self) < first_metadata)

.{ .constant = @enumFromInt(@intFromEnum(self) - first_constant) }

.{ .metadata = @enumFromInt(@intFromEnum(self) - first_metadata) };

.metadata => .metadata,

.metadata => .metadata,

.instruction, .metadata => null,

.metadata => unreachable,

};

pub const MetadataString = enum(u32) {

none = 0,

_,

 

pub fn slice(self: MetadataString, builder: *const Builder) []const u8 {

const index = @intFromEnum(self);

const start = builder.metadata_string_indices.items[index];

const end = builder.metadata_string_indices.items[index + 1];

return builder.metadata_string_bytes.items[start..end];

}

 

const Adapter = struct {

builder: *const Builder,

pub fn hash(_: Adapter, key: []const u8) u32 {

return @truncate(std.hash.Wyhash.hash(0, key));

}

pub fn eql(ctx: Adapter, lhs_key: []const u8, _: void, rhs_index: usize) bool {

const rhs_metadata_string: MetadataString = @enumFromInt(rhs_index);

return std.mem.eql(u8, lhs_key, rhs_metadata_string.slice(ctx.builder));

}

};

 

const FormatData = struct {

metadata_string: MetadataString,

builder: *const Builder,

};

fn format(

data: FormatData,

comptime _: []const u8,

_: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

try printEscapedString(data.metadata_string.slice(data.builder), .always_quote, writer);

}

fn fmt(self: MetadataString, builder: *const Builder) std.fmt.Formatter(format) {

return .{ .data = .{ .metadata_string = self, .builder = builder } };

pub const Metadata = enum(u32) {

none = 0,

_,

const first_forward_reference = 1 << 29;

const first_local_metadata = 1 << 30;

pub const Tag = enum(u6) {

none,

file,

compile_unit,

@"compile_unit optimized",

subprogram,

@"subprogram local",

@"subprogram definition",

@"subprogram local definition",

@"subprogram optimized",

@"subprogram optimized local",

@"subprogram optimized definition",

@"subprogram optimized local definition",

lexical_block,

location,

basic_bool_type,

basic_unsigned_type,

basic_signed_type,

basic_float_type,

composite_struct_type,

composite_union_type,

composite_enumeration_type,

composite_array_type,

composite_vector_type,

derived_pointer_type,

derived_member_type,

subroutine_type,

enumerator_unsigned,

enumerator_signed_positive,

enumerator_signed_negative,

subrange,

tuple,

module_flag,

expression,

local_var,

parameter,

global_var,

@"global_var local",

global_var_expression,

constant,

 

pub fn isInline(tag: Tag) bool {

return switch (tag) {

.none,

.expression,

.constant,

=> true,

.file,

.compile_unit,

.@"compile_unit optimized",

.subprogram,

.@"subprogram local",

.@"subprogram definition",

.@"subprogram local definition",

.@"subprogram optimized",

.@"subprogram optimized local",

.@"subprogram optimized definition",

.@"subprogram optimized local definition",

.lexical_block,

.location,

.basic_bool_type,

.basic_unsigned_type,

.basic_signed_type,

.basic_float_type,

.composite_struct_type,

.composite_union_type,

.composite_enumeration_type,

.composite_array_type,

.composite_vector_type,

.derived_pointer_type,

.derived_member_type,

.subroutine_type,

.enumerator_unsigned,

.enumerator_signed_positive,

.enumerator_signed_negative,

.subrange,

.tuple,

.module_flag,

.local_var,

.parameter,

.global_var,

.@"global_var local",

.global_var_expression,

=> false,

};

}

};

 

pub fn isInline(self: Metadata, builder: *const Builder) bool {

return builder.metadata_items.items(.tag)[@intFromEnum(self)].isInline();

}

 

pub fn unwrap(self: Metadata, builder: *const Builder) Metadata {

var metadata = self;

while (@intFromEnum(metadata) >= Metadata.first_forward_reference and

@intFromEnum(metadata) < Metadata.first_local_metadata)

{

const index = @intFromEnum(metadata) - Metadata.first_forward_reference;

metadata = builder.metadata_forward_references.items[index];

assert(metadata != .none);

}

return metadata;

}

 

pub const Item = struct {

tag: Tag,

data: ExtraIndex,

 

const ExtraIndex = u32;

};

 

pub const DIFlags = packed struct(u32) {

Visibility: enum(u2) { Zero, Private, Protected, Public } = .Zero,

FwdDecl: bool = false,

AppleBlock: bool = false,

ReservedBit4: u1 = 0,

Virtual: bool = false,

Artificial: bool = false,

Explicit: bool = false,

Prototyped: bool = false,

ObjcClassComplete: bool = false,

ObjectPointer: bool = false,

Vector: bool = false,

StaticMember: bool = false,

LValueReference: bool = false,

RValueReference: bool = false,

ExportSymbols: bool = false,

Inheritance: enum(u2) {

Zero,

SingleInheritance,

MultipleInheritance,

VirtualInheritance,

} = .Zero,

IntroducedVirtual: bool = false,

BitField: bool = false,

NoReturn: bool = false,

ReservedBit21: u1 = 0,

TypePassbyValue: bool = false,

TypePassbyReference: bool = false,

EnumClass: bool = false,

Thunk: bool = false,

NonTrivial: bool = false,

BigEndian: bool = false,

LittleEndian: bool = false,

AllCallsDescribed: bool = false,

Unused: u2 = 0,

 

pub fn format(

self: DIFlags,

comptime _: []const u8,

_: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

var need_pipe = false;

inline for (@typeInfo(DIFlags).Struct.fields) |field| {

switch (@typeInfo(field.type)) {

.Bool => if (@field(self, field.name)) {

if (need_pipe) try writer.writeAll(" | ") else need_pipe = true;

try writer.print("DIFlag{s}", .{field.name});

},

.Enum => if (@field(self, field.name) != .Zero) {

if (need_pipe) try writer.writeAll(" | ") else need_pipe = true;

try writer.print("DIFlag{s}", .{@tagName(@field(self, field.name))});

},

.Int => assert(@field(self, field.name) == 0),

else => @compileError("bad field type: " ++ field.name ++ ": " ++

@typeName(field.type)),

}

}

if (!need_pipe) try writer.writeByte('0');

}

};

 

pub const File = struct {

filename: MetadataString,

directory: MetadataString,

};

 

pub const CompileUnit = struct {

pub const Options = struct {

optimized: bool,

};

 

file: Metadata,

producer: MetadataString,

enums: Metadata,

globals: Metadata,

};

 

pub const Subprogram = struct {

pub const Options = struct {

di_flags: DIFlags,

sp_flags: DISPFlags,

};

 

pub const DISPFlags = packed struct(u32) {

Virtuality: enum(u2) { Zero, Virtual, PureVirtual } = .Zero,

LocalToUnit: bool = false,

Definition: bool = false,

Optimized: bool = false,

Pure: bool = false,

Elemental: bool = false,

Recursive: bool = false,

MainSubprogram: bool = false,

Deleted: bool = false,

ReservedBit10: u1 = 0,

ObjCDirect: bool = false,

Unused: u20 = 0,

 

pub fn format(

self: DISPFlags,

comptime _: []const u8,

_: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

var need_pipe = false;

inline for (@typeInfo(DISPFlags).Struct.fields) |field| {

switch (@typeInfo(field.type)) {

.Bool => if (@field(self, field.name)) {

if (need_pipe) try writer.writeAll(" | ") else need_pipe = true;

try writer.print("DISPFlag{s}", .{field.name});

},

.Enum => if (@field(self, field.name) != .Zero) {

if (need_pipe) try writer.writeAll(" | ") else need_pipe = true;

try writer.print("DISPFlag{s}", .{@tagName(@field(self, field.name))});

},

.Int => assert(@field(self, field.name) == 0),

else => @compileError("bad field type: " ++ field.name ++ ": " ++

@typeName(field.type)),

}

}

if (!need_pipe) try writer.writeByte('0');

}

};

 

file: Metadata,

name: MetadataString,

linkage_name: MetadataString,

line: u32,

scope_line: u32,

ty: Metadata,

di_flags: DIFlags,

compile_unit: Metadata,

};

 

pub const LexicalBlock = struct {

scope: Metadata,

file: Metadata,

line: u32,

column: u32,

};

 

pub const Location = struct {

line: u32,

column: u32,

scope: Metadata,

inlined_at: Metadata,

};

 

pub const BasicType = struct {

name: MetadataString,

size_in_bits_lo: u32,

size_in_bits_hi: u32,

 

pub fn bitSize(self: BasicType) u64 {

return @as(u64, self.size_in_bits_hi) << 32 | self.size_in_bits_lo;

}

};

 

pub const CompositeType = struct {

name: MetadataString,

file: Metadata,

scope: Metadata,

line: u32,

underlying_type: Metadata,

size_in_bits_lo: u32,

size_in_bits_hi: u32,

align_in_bits_lo: u32,

align_in_bits_hi: u32,

fields_tuple: Metadata,

 

pub fn bitSize(self: CompositeType) u64 {

return @as(u64, self.size_in_bits_hi) << 32 | self.size_in_bits_lo;

}

pub fn bitAlign(self: CompositeType) u64 {

return @as(u64, self.align_in_bits_hi) << 32 | self.align_in_bits_lo;

}

};

 

pub const DerivedType = struct {

name: MetadataString,

file: Metadata,

scope: Metadata,

line: u32,

underlying_type: Metadata,

size_in_bits_lo: u32,

size_in_bits_hi: u32,

align_in_bits_lo: u32,

align_in_bits_hi: u32,

offset_in_bits_lo: u32,

offset_in_bits_hi: u32,

 

pub fn bitSize(self: DerivedType) u64 {

return @as(u64, self.size_in_bits_hi) << 32 | self.size_in_bits_lo;

}

pub fn bitAlign(self: DerivedType) u64 {

return @as(u64, self.align_in_bits_hi) << 32 | self.align_in_bits_lo;

}

pub fn bitOffset(self: DerivedType) u64 {

return @as(u64, self.offset_in_bits_hi) << 32 | self.offset_in_bits_lo;

}

};

 

pub const SubroutineType = struct {

types_tuple: Metadata,

};

 

pub const Enumerator = struct {

name: MetadataString,

bit_width: u32,

limbs_index: u32,

limbs_len: u32,

};

 

pub const Subrange = struct {

lower_bound: Metadata,

count: Metadata,

};

 

pub const Expression = struct {

elements_len: u32,

 

// elements: [elements_len]u32

};

 

pub const Tuple = struct {

elements_len: u32,

 

// elements: [elements_len]Metadata

};

 

pub const ModuleFlag = struct {

behavior: Metadata,

name: MetadataString,

constant: Metadata,

};

 

pub const LocalVar = struct {

name: MetadataString,

file: Metadata,

scope: Metadata,

line: u32,

ty: Metadata,

};

 

pub const Parameter = struct {

name: MetadataString,

file: Metadata,

scope: Metadata,

line: u32,

ty: Metadata,

arg_no: u32,

};

 

pub const GlobalVar = struct {

pub const Options = struct {

local: bool,

};

 

name: MetadataString,

linkage_name: MetadataString,

file: Metadata,

scope: Metadata,

line: u32,

ty: Metadata,

variable: Variable.Index,

};

 

pub const GlobalVarExpression = struct {

variable: Metadata,

expression: Metadata,

};

 

pub fn toValue(self: Metadata) Value {

return @enumFromInt(Value.first_metadata + @intFromEnum(self));

}

 

const Formatter = struct {

builder: *Builder,

need_comma: bool,

map: std.AutoArrayHashMapUnmanaged(Metadata, void) = .{},

 

const FormatData = struct {

formatter: *Formatter,

prefix: []const u8 = "",

node: Node,

 

const Node = union(enum) {

none,

@"inline": Metadata,

index: u32,

 

local_value: ValueData,

local_metadata: ValueData,

local_inline: Metadata,

local_index: u32,

 

string: MetadataString,

bool: bool,

u32: u32,

u64: u64,

di_flags: DIFlags,

sp_flags: Subprogram.DISPFlags,

raw: []const u8,

 

const ValueData = struct {

value: Value,

function: Function.Index,

};

};

};

fn format(

data: FormatData,

comptime fmt_str: []const u8,

fmt_opts: std.fmt.FormatOptions,

writer: anytype,

) @TypeOf(writer).Error!void {

if (data.node == .none) return;

 

const is_specialized = fmt_str.len > 0 and fmt_str[0] == 'S';

const recurse_fmt_str = if (is_specialized) fmt_str[1..] else fmt_str;

 

if (data.formatter.need_comma) try writer.writeAll(", ");

defer data.formatter.need_comma = true;

try writer.writeAll(data.prefix);

 

const builder = data.formatter.builder;

switch (data.node) {

.none => unreachable,

.@"inline" => |node| {

const needed_comma = data.formatter.need_comma;

defer data.formatter.need_comma = needed_comma;

data.formatter.need_comma = false;

 

const item = builder.metadata_items.get(@intFromEnum(node));

switch (item.tag) {

.expression => {

var extra = builder.metadataExtraDataTrail(Expression, item.data);

const elements = extra.trail.next(extra.data.elements_len, u32, builder);

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

for (elements) |element| try format(.{

.formatter = data.formatter,

.node = .{ .u64 = element },

}, "%", fmt_opts, writer);

try writer.writeByte(')');

},

.constant => try Constant.format(.{

.constant = @enumFromInt(item.data),

.builder = builder,

}, recurse_fmt_str, fmt_opts, writer),

else => unreachable,

}

},

.index => |node| try writer.print("!{d}", .{node}),

inline .local_value, .local_metadata => |node, tag| try Value.format(.{

.value = node.value,

.function = node.function,

.builder = builder,

}, switch (tag) {

.local_value => recurse_fmt_str,

.local_metadata => "%",

else => unreachable,

}, fmt_opts, writer),

inline .local_inline, .local_index => |node, tag| {

if (comptime std.mem.eql(u8, recurse_fmt_str, "%"))

try writer.print("{%} ", .{Type.metadata.fmt(builder)});

try format(.{

.formatter = data.formatter,

.node = @unionInit(FormatData.Node, @tagName(tag)["local_".len..], node),

}, "%", fmt_opts, writer);

},

.string => |node| try writer.print((if (is_specialized) "" else "!") ++ "{}", .{

node.fmt(builder),

}),

inline .bool,

.u32,

.u64,

.di_flags,

.sp_flags,

=> |node| try writer.print("{}", .{node}),

.raw => |node| try writer.writeAll(node),

}

}

inline fn fmt(formatter: *Formatter, prefix: []const u8, node: anytype) switch (@TypeOf(node)) {

Metadata => Allocator.Error,

else => error{},

}!std.fmt.Formatter(format) {

const Node = @TypeOf(node);

const MaybeNode = switch (@typeInfo(Node)) {

.Optional => Node,

.Null => ?noreturn,

else => ?Node,

};

const Some = @typeInfo(MaybeNode).Optional.child;

return .{ .data = .{

.formatter = formatter,

.prefix = prefix,

.node = if (@as(MaybeNode, node)) |some| switch (@typeInfo(Some)) {

.Enum => |enum_info| switch (Some) {

Metadata => switch (some) {

.none => .none,

else => try formatter.refUnwrapped(some.unwrap(formatter.builder)),

},

MetadataString => .{ .string = some },

else => if (enum_info.is_exhaustive)

.{ .raw = @tagName(some) }

else

@compileError("unknown type to format: " ++ @typeName(Node)),

},

.EnumLiteral => .{ .raw = @tagName(some) },

.Bool => .{ .bool = some },

.Struct => switch (Some) {

DIFlags => .{ .di_flags = some },

Subprogram.DISPFlags => .{ .sp_flags = some },

else => @compileError("unknown type to format: " ++ @typeName(Node)),

},

.Int, .ComptimeInt => .{ .u64 = some },

.Pointer => .{ .raw = some },

else => @compileError("unknown type to format: " ++ @typeName(Node)),

} else switch (@typeInfo(Node)) {

.Optional, .Null => .none,

else => unreachable,

},

} };

}

inline fn fmtLocal(

formatter: *Formatter,

prefix: []const u8,

value: Value,

function: Function.Index,

) Allocator.Error!std.fmt.Formatter(format) {

return .{ .data = .{

.formatter = formatter,

.prefix = prefix,

.node = switch (value.unwrap()) {

.instruction, .constant => .{ .local_value = .{

.value = value,

.function = function,

} },

.metadata => |metadata| if (value == .none) .none else node: {

const unwrapped = metadata.unwrap(formatter.builder);

break :node if (@intFromEnum(unwrapped) >= first_local_metadata)

.{ .local_metadata = .{

.value = function.ptrConst(formatter.builder).debug_values[

@intFromEnum(unwrapped) - first_local_metadata

].toValue(),

.function = function,

} }

else switch (try formatter.refUnwrapped(unwrapped)) {

.@"inline" => |node| .{ .local_inline = node },

.index => |node| .{ .local_index = node },

else => unreachable,

};

},

},

} };

}

fn refUnwrapped(formatter: *Formatter, node: Metadata) Allocator.Error!FormatData.Node {

assert(node != .none);

assert(@intFromEnum(node) < first_forward_reference);

const builder = formatter.builder;

const unwrapped_metadata = node.unwrap(builder);

const tag = formatter.builder.metadata_items.items(.tag)[@intFromEnum(unwrapped_metadata)];

switch (tag) {

.none => unreachable,

.expression, .constant => return .{ .@"inline" = unwrapped_metadata },

else => {

assert(!tag.isInline());

const gop = try formatter.map.getOrPutValue(builder.gpa, unwrapped_metadata, {});

return .{ .index = @intCast(gop.index) };

},

}

}

 

inline fn specialized(

formatter: *Formatter,

distinct: enum { @"!", @"distinct !" },

node: enum {

DIFile,

DICompileUnit,

DISubprogram,

DILexicalBlock,

DILocation,

DIBasicType,

DICompositeType,

DIDerivedType,

DISubroutineType,

DIEnumerator,

DISubrange,

DILocalVariable,

DIGlobalVariable,

DIGlobalVariableExpression,

},

nodes: anytype,

writer: anytype,

) !void {

comptime var fmt_str: []const u8 = "";

const names = comptime std.meta.fieldNames(@TypeOf(nodes));

comptime var fields: [2 + names.len]std.builtin.Type.StructField = undefined;

inline for (fields[0..2], .{ "distinct", "node" }) |*field, name| {

fmt_str = fmt_str ++ "{[" ++ name ++ "]s}";

field.* = .{

.name = name,

.type = []const u8,

.default_value = null,

.is_comptime = false,

.alignment = 0,

};

}

fmt_str = fmt_str ++ "(";

inline for (fields[2..], names) |*field, name| {

fmt_str = fmt_str ++ "{[" ++ name ++ "]S}";

field.* = .{

.name = name,

.type = std.fmt.Formatter(format),

.default_value = null,

.is_comptime = false,

.alignment = 0,

};

}

fmt_str = fmt_str ++ ")\n";

 

var fmt_args: @Type(.{ .Struct = .{

.layout = .Auto,

.fields = &fields,

.decls = &.{},

.is_tuple = false,

} }) = undefined;

fmt_args.distinct = @tagName(distinct);

fmt_args.node = @tagName(node);

inline for (names) |name| @field(fmt_args, name) = try formatter.fmt(

name ++ ": ",

@field(nodes, name),

);

try writer.print(fmt_str, fmt_args);

}

};

};

 

pub fn init(options: Options) Allocator.Error!Builder {

.function_attributes_set = .{},

 

 

.metadata_map = .{},

.metadata_items = .{},

.metadata_extra = .{},

.metadata_limbs = .{},

.metadata_forward_references = .{},

.metadata_named = .{},

.metadata_string_map = .{},

.metadata_string_indices = .{},

.metadata_string_bytes = .{},

assert(try self.intConst(.i32, 0) == .@"0");

assert(try self.intConst(.i32, 1) == .@"1");

if (!self.strip) assert(try self.debugNone() == .none);

 

try self.metadata_string_indices.append(self.gpa, 0);

assert(try self.metadataString("") == .none);

self.function_attributes_set.deinit(self.gpa);

 

self.metadata_map.deinit(self.gpa);

self.metadata_items.deinit(self.gpa);

self.metadata_extra.deinit(self.gpa);

self.metadata_limbs.deinit(self.gpa);

self.metadata_forward_references.deinit(self.gpa);

self.metadata_named.deinit(self.gpa);

 

self.metadata_string_map.deinit(self.gpa);

self.metadata_string_indices.deinit(self.gpa);

self.metadata_string_bytes.deinit(self.gpa);

 

try self.string_bytes.ensureUnusedCapacity(self.gpa, bytes.len);

pub fn stringNull(self: *Builder, bytes: [:0]const u8) Allocator.Error!String {

return self.string(bytes[0 .. bytes.len + 1]);

}

 

try self.string_bytes.ensureUnusedCapacity(self.gpa, @intCast(std.fmt.count(fmt_str, fmt_args)));

self.string_bytes.writer(undefined).print(fmt_str, fmt_args) catch unreachable;

return self.trailingStringAssumeCapacity();

}

pub fn trailingString(self: *Builder) Allocator.Error!String {

try self.string_indices.ensureUnusedCapacity(self.gpa, 1);

try self.string_map.ensureUnusedCapacity(self.gpa, 1);

return self.trailingStringAssumeCapacity();

}

 

pub fn trailingStringAssumeCapacity(self: *Builder) String {

const start = self.string_indices.getLast();

const bytes: []const u8 = self.string_bytes.items[start..];

const count: usize = comptime std.fmt.count("{d}", .{std.math.maxInt(u32)});

) void {

if (!gop.found_existing) gop.value_ptr.* = {};

try self.function_attributes_set.ensureUnusedCapacity(self.gpa, 1);

const function_attributes: FunctionAttributes = @enumFromInt(try self.attrGeneric(@ptrCast(

 

_ = self.function_attributes_set.getOrPutAssumeCapacity(function_attributes);

return function_attributes;

const writer = self.string_bytes.writer(self.gpa);

try writer.print("llvm.{s}", .{@tagName(id)});

for (overload) |ty| try writer.print(".{m}", .{ty.fmt(self)});

break :name try self.trailingString();

self.print(std.io.getStdErr().writer()) catch {};

var file = std.fs.cwd().createFile(path, .{}) catch |err| {

log.err("failed printing LLVM module to \"{s}\": {s}", .{ path, @errorName(err) });

return false;

};

defer file.close();

self.print(file.writer()) catch |err| {

log.err("failed printing LLVM module to \"{s}\": {s}", .{ path, @errorName(err) });

return false;

};

var metadata_formatter: Metadata.Formatter = .{ .builder = self, .need_comma = undefined };

defer metadata_formatter.map.deinit(self.gpa);

if (need_newline) try writer.writeByte('\n') else need_newline = true;

if (need_newline) try writer.writeByte('\n') else need_newline = true;

if (need_newline) try writer.writeByte('\n') else need_newline = true;

if (need_newline) try writer.writeByte('\n') else need_newline = true;

metadata_formatter.need_comma = true;

defer metadata_formatter.need_comma = undefined;

\\{} ={}{}{}{}{ }{}{ }{} {s} {%}{ }{, }{}

Linkage.fmtOptional(if (global.linkage == .external and

variable.init != .no_init) null else global.linkage),

try metadata_formatter.fmt("!dbg ", global.dbg),

if (need_newline) try writer.writeByte('\n') else need_newline = true;

metadata_formatter.need_comma = true;

defer metadata_formatter.need_comma = undefined;

\\{} ={}{}{}{}{ }{} alias {%}, {%}{}

try metadata_formatter.fmt("!dbg ", global.dbg),

if (need_newline) try writer.writeByte('\n') else need_newline = true;

{

metadata_formatter.need_comma = false;

defer metadata_formatter.need_comma = undefined;

try writer.print("{ }{}", .{

function.alignment,

try metadata_formatter.fmt(" !dbg ", global.dbg),

});

}

var dbg: Metadata = .none;

if (function.debug_locations.get(instruction_index)) |debug_location|

dbg = debug_location;

try writer.print(" %{} = {s} {%}, {}", .{

try writer.print(" %{} = {s} {%} to {%}", .{

try writer.print(" %{} = {s} {%}{,%}{, }{, }", .{

Value.fmt(switch (extra.len) {

.@"1" => .none,

else => extra.len,

}, function_index, self),

try writer.print(" %{} = {s}{ } {s} {%}, {%}{ }{ }{, }", .{

continue;

try writer.print(" {s} {%}", .{

try writer.print(" br {%}, {%}, {%}", .{

metadata_formatter.need_comma = false;

defer metadata_formatter.need_comma = undefined;

try writer.print("{%}{}{}", .{

try metadata_formatter.fmtLocal(" ", arg, function_index),

try writer.print(" %{} = {s}{ } {%}, {%}, {%}{ }{ }{ }{, }", .{

try writer.print(" %{} = {s} {%}, {%}", .{

try writer.print(" %{} = {s} {%}", .{

try writer.print(" %{} = {s} {%}, {%}, {%}", .{

try writer.print(" %{} = {s}{ } {%}, {%}{ }{ }{, }", .{

try writer.print(" {s} {%}", .{

=> |tag| try writer.print(" {s}", .{@tagName(tag)}),

try writer.print(" %{} = {s} {%}, {%}, {%}", .{

try writer.print(" %{} = {s} {%}, {%}, {%}", .{

try writer.print(" {s}{ } {%}, {%}{ }{ }{, }", .{

try writer.writeAll(" ]");

try writer.print(" %{} = {s} {%}, {%}", .{

metadata_formatter.need_comma = true;

defer metadata_formatter.need_comma = undefined;

try writer.print("{}\n", .{try metadata_formatter.fmt("!dbg ", dbg)});

if (self.metadata_named.count() > 0) {