Module debug_info

Source
Expand description

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 Aliases§

DIFlags
LLVMDWARFTypeEncoding