Module llvm_plugin_inkwell::debug_info

Debug symbols - DebugInfoBuilder interface

Example usage

Setting up the module for holding debug info:

let context = Context::create();
let module = context.create_module("bin");

let debug_metadata_version = context.i32_type().const_int(3, false);
module.add_basic_value_flag(
    "Debug Info Version",
    inkwell::module::FlagBehavior::Warning,
    debug_metadata_version,
);
let builder = context.create_builder();
let (dibuilder, compile_unit) = module.create_debug_info_builder(
    true,
    /* language */ inkwell::debug_info::DWARFSourceLanguage::C,
    /* filename */ "source_file",
    /* directory */ ".",
    /* producer */ "my llvm compiler frontend",
    /* is_optimized */ false,
    /* compiler command line flags */ "",
    /* runtime_ver */ 0,
    /* split_name */ "",
    /* kind */ inkwell::debug_info::DWARFEmissionKind::Full,
    /* dwo_id */ 0,
    /* split_debug_inling */ false,
    /* debug_info_for_profiling */ false,
);

Creating function debug info

 let ditype = dibuilder.create_basic_type(
     "type_name",
     0_u64,
     0x00,
     inkwell::debug_info::DIFlags::Public,
 ).unwrap();
 let subroutine_type = dibuilder.create_subroutine_type(
     compile_unit.get_file(),
     /* return type */ Some(ditype.as_type()),
     /* parameter types */ &[],
     inkwell::debug_info::DIFlags::Public,
 );
 let func_scope: DISubprogram<'_> = dibuilder.create_function(
     /* scope */ compile_unit.as_debug_info_scope(),
     /* func name */ "main",
     /* linkage_name */ None,
     /* file */ compile_unit.get_file(),
     /* line_no */ 0,
     /* DIType */ subroutine_type,
     /* is_local_to_unit */ true,
     /* is_definition */ true,
     /* scope_line */ 0,
     /* flags */ inkwell::debug_info::DIFlags::Public,
     /* is_optimized */ false,
 );

The DISubprogram value must be attached to the generated FunctionValue:

/* after creating function: */
    let fn_val = module.add_function(fn_name_str, fn_type, None);
    fn_val.set_subprogram(func_scope);

Setting debug locations

let lexical_block = dibuilder.create_lexical_block(
        /* scope */ func_scope.as_debug_info_scope(),
        /* file */ compile_unit.get_file(),
        /* line_no */ 0,
        /* column_no */ 0);

let loc = dibuilder
    .create_debug_location(&context, /* line */ 0, /* column */ 0,
    /* current_scope */ lexical_block.as_debug_info_scope(),
    /* inlined_at */ None);
builder.set_current_debug_location(&context, loc);

// Create global variable
let gv = module.add_global(context.i64_type(), Some(inkwell::AddressSpace::Global), "gv");


let const_v = di.create_constant_expression(10);

let gv_debug = di.create_global_variable_expression(cu.get_file().as_debug_info_scope(), "gv", "", cu.get_file(), 1, ditype.as_type(), true, Some(const_v), None, 8);

let meta_value: inkwell::values::BasicMetadataValueEnum = gv_debug.as_metadata_value(&context).into();
let metadata = context.metadata_node(&[meta_value]);
gv.set_metadata(metadata, 0);//dbg

Finalize debug info

Before any kind of code generation (including verification passes; they generate code and validate debug info), do:

dibuilder.finalize();

Structs

DIBasicType

A primitive debug info type created by create_basic_type method of DebugInfoBuilder

DICompileUnit

Compilation unit scope for debug info

DICompositeType

A wrapper around an array of types, such as a union or struct.

DIDerivedType

A wrapper around a single type, such as a typedef or member type.

DIExpression

https://llvm.org/docs/LangRef.html#diexpression

DIFile

Source file scope for debug info

DIGlobalVariableExpression

DILexicalBlock

Lexical block scope for debug info

DILocalVariable

Metadata representing a variable inside a scope

DILocation

A debug location within the source code. Contains the following information:

DINamespace

Namespace scope for debug info

DIScope

Any kind of debug information scope (i.e. visibility of a source code symbol). Scopes are created by special DebugInfoBuilder methods (eg create_lexical_block) and can be turned into a DIScope with the AsDIScope::as_debug_info_scope trait method.

DISubprogram

Function body scope for debug info

DISubroutineType

Metadata representing the type of a function

DIType

Any kind of debug info type

DebugInfoBuilder

A builder object to create debug info metadata. Used along with Builder while producing IR. Created by Module::create_debug_info_builder. See debug_info module level documentation for more.

Enums

DWARFEmissionKind

The amount of debug information to emit. Corresponds to LLVMDWARFEmissionKind enum from LLVM.

DWARFSourceLanguage

Source languages known by DWARF. Corresponds to LLVMDWARFSourceLanguage enum from LLVM.

Traits

AsDIScope

Specific scopes (i.e. DILexicalBlock) can be turned into a DIScope with the AsDIScope::as_debug_info_scope trait method.

DIFlagsConstants

Functions

debug_metadata_version

Gets the version of debug metadata produced by the current LLVM version.

Type Definitions

DIFlags

LLVMDWARFTypeEncoding