srctree

inst: Zir.Inst.Index,

air_tag: Air.Inst.Tag,

) CompileError!void {

const str_op = sema.code.instructions.items(.data)[@intFromEnum(inst)].str_op;

const operand = try sema.resolveInst(str_op.operand);

const name = str_op.getStr(sema.code);

air_tag: Air.Inst.Tag,

name: []const u8,

) CompileError!void {

const mod = sema.mod;

const operand_ty = sema.typeOf(operand);

const val_ty = switch (air_tag) {

 

const gpa = comp.gpa;

const target = comp.root_mod.resolved_target.result;

const llvm_target_triple = try targetTriple(arena, target);

 

var builder = try Builder.init(.{

.allocator = gpa,

.name = comp.root_name,

.target = target,

.triple = llvm_target_triple,

const mod = o.module;

const errors_len = mod.global_error_set.count();

 

defer wip.deinit();

wip.cursor = .{ .block = try wip.block(0, "Entry") };

 

}

}

 

const emit_asm_msg = options.asm_path orelse "(none)";

const emit_bin_msg = options.bin_path orelse "(none)";

const post_llvm_ir_msg = options.post_ir_path orelse "(none)";

 

const bitcode = try self.builder.toBitcode(self.gpa);

defer self.gpa.free(bitcode);

 

if (options.pre_bc_path) |path| {

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

};

defer context.dispose();

 

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}", .{

error_message,

});

@panic("Invalid LLVM triple");

air: Air,

liveness: Liveness,

) !void {

const func = zcu.funcInfo(func_index);

const decl_index = func.owner_decl;

const decl = zcu.declPtr(decl_index);

function_index.setSection(try o.builder.string(section), &o.builder);

 

var deinit_wip = true;

defer if (deinit_wip) wip.deinit();

wip.cursor = .{ .block = try wip.block(0, "Entry") };

 

.unsigned => try attributes.addRetAttr(.zeroext, &o.builder),

};

 

const err_return_tracing = Type.fromInterned(fn_info.return_type).isError(zcu) and

comp.config.any_error_tracing;

 

 

function_index.setAttributes(try attributes.finish(&o.builder), &o.builder);

 

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

 

const line_number = decl.src_line + 1;

function_index.setAttributes(try attributes.finish(&o.builder), &o.builder);

gop.value_ptr.* = function_index.ptrConst(&o.builder).global;

 

defer wip.deinit();

wip.cursor = .{ .block = try wip.block(0, "Entry") };

 

 

fn genDecl(dg: *DeclGen) !void {

const o = dg.object;

const decl = dg.decl;

const decl_index = dg.decl_index;

assert(decl.has_tv);

 

_ = try o.resolveLlvmFunction(extern_func.decl);

} else {

const variable_index = try o.resolveGlobalDecl(decl_index);

variable_index.setAlignment(

&o.builder,

);

variable_index.setSection(try o.builder.string(section), &o.builder);

assert(decl.has_tv);

variable_index.setMutability(.constant, &o.builder);

break :init_val decl.val.toIntern();

};

const line_number = decl.src_line + 1;

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

 

 

 

const debug_global_var = try o.builder.debugGlobalVar(

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

debug_file, // File

debug_file, // Scope

debug_global_var,

debug_expression,

);

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

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

}

}

 

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

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

self.prev_dbg_line = @intCast(self.base_line + dbg_stmt.line + 1);

self.prev_dbg_column = @intCast(dbg_stmt.column + 1);

}

 

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

const o = self.dg.object;

const zcu = o.module;

 

}

 

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

const o = self.dg.object;

 

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

}

 

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

const o = self.dg.object;

 

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

}

 

fn airDbgBlockEnd(self: *FuncGen) !Builder.Value {

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

return .none;

}

 

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

const o = self.dg.object;

const mod = o.module;

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

}

 

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

const o = self.dg.object;

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

const operand = try self.resolveInst(pl_op.operand);

const arg_val = self.args[self.arg_index];

self.arg_index += 1;

 

 

const inst_ty = self.typeOfIndex(inst);

if (needDbgVarWorkaround(o)) return arg_val;

function_index.setAttributes(try attributes.finish(&o.builder), &o.builder);

gop.value_ptr.* = function_index;

 

defer wip.deinit();

wip.cursor = .{ .block = try wip.block(0, "Entry") };

 

 

instructions: std.MultiArrayList(Instruction) = .{},

names: [*]const String = &[0]String{},

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

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

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

extra: []const u32 = &.{},

blocks: std.ArrayListUnmanaged(Block),

instructions: std.MultiArrayList(Instruction),

names: std.ArrayListUnmanaged(String),

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

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

extra: std.ArrayListUnmanaged(u32),

 

pub const Instruction = Function.Instruction;

 

var self: WipFunction = .{

.builder = builder,

.prev_debug_location = .no_location,

.debug_location = .no_location,

.cursor = undefined,

.blocks = .{},

.instructions = .{},

.names = .{},

.debug_locations = .{},

.debug_values = .{},

.extra = .{},

};

errdefer self.deinit();

 

try self.ensureUnusedExtraCapacity(params_len, NoExtra, 0);

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

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

}

for (0..params_len) |param_index| {

self.instructions.appendAssumeCapacity(.{ .tag = .arg, .data = @intCast(param_index) });

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

}

}

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

 

const index: Block.Index = @enumFromInt(self.blocks.items.len);

self.blocks.appendAssumeCapacity(.{

.name = final_name,

.incoming = incoming,

}

 

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

return switch (value.unwrap()) {

.instruction => |instr_index| blk: {

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

value_index += 1;

function.instructions.appendAssumeCapacity(argument);

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

".",

);

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

},

}

function.instructions.appendAssumeCapacity(instruction);

if (old_instruction_index.hasResultWip(self)) .empty else .none

else

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

function.blocks = blocks;

function.names = names.ptr;

function.value_indices = value_indices.ptr;

function.debug_locations = debug_locations;

function.debug_values = debug_values;

}

) Allocator.Error!Instruction.Index {

const block_instructions = &self.cursor.block.ptr(self).instructions;

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

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

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

}

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

const final_name = if (name) |n|

else

.none;

 

const index: Instruction.Index = @enumFromInt(self.instructions.len);

self.instructions.appendAssumeCapacity(instruction);

self.names.appendAssumeCapacity(final_name);

if (block_instructions.items.len == 0 or

!std.meta.eql(self.debug_location, self.prev_debug_location))

return self;

}

 

pub fn deinit(self: *Builder) void {

self.module_asm.deinit(self.gpa);

 

) Function.Index {

assert(ty.isFunction(self));

const function_index: Function.Index = @enumFromInt(self.functions.items.len);

return function_index;

}

 

return @intCast(switch (value.unwrap()) {

.instruction => |instruction| instruction.valueIndex(adapter.func) + adapter.firstInstr(),

.constant => |constant| adapter.constant_adapter.getConstantIndex(constant),

const real_metadata = metadata.unwrap(adapter.metadata_adapter.builder);

if (@intFromEnum(real_metadata) < Metadata.first_local_metadata)

 

return @intCast(@intFromEnum(metadata) -

Metadata.first_local_metadata +

adapter.metadata_adapter.builder.metadata_string_map.count() - 1 +

adapter.metadata_adapter.builder.metadata_map.count() - 1);

});

}

 

var adapter = FunctionAdapter.init(constant_adapter, metadata_adapter, &func);

 

// Emit function level metadata block

const MetadataBlock = ir.FunctionMetadataBlock;

var metadata_block = try function_block.enterSubBlock(MetadataBlock);

 

},

}

 

if (func.debug_locations.get(@enumFromInt(instr_index))) |debug_location| {

switch (debug_location) {

.no_location => has_location = false,

}

 

// VALUE_SYMTAB

const ValueSymbolTable = ir.FunctionValueSymbolTable;

 

var value_symtab_block = try function_block.enterSubBlock(ValueSymbolTable);

}

 

// METADATA_ATTACHMENT_BLOCK

const dbg = func.global.ptrConst(self).dbg;

 

if (dbg == .none) break :blk;