Struct inkwell::targets::TargetMachine

pub struct TargetMachine { /* private fields */ }

Implementations

impl TargetMachine

pub unsafe fn new(target_machine: LLVMTargetMachineRef) -> Self

pub fn as_mut_ptr(&self) -> LLVMTargetMachineRef

Acquires the underlying raw pointer belonging to this TargetMachine type.

pub fn get_target(&self) -> Target

pub fn get_triple(&self) -> TargetTriple

pub fn get_default_triple() -> TargetTriple

Gets the default triple for the current system.

Example

use inkwell::targets::TargetMachine;

let default_triple = TargetMachine::get_default_triple();

assert_eq!(default_triple.as_str().to_str(), Ok("x86_64-pc-linux-gnu"));

pub fn normalize_triple(triple: &TargetTriple) -> TargetTriple

pub fn get_host_cpu_name() -> LLVMString

Gets a string containing the host CPU’s name (triple).

Example Output

x86_64-pc-linux-gnu

pub fn get_host_cpu_features() -> LLVMString

Gets a comma separated list of supported features by the host CPU.

Example Output

+sse2,+cx16,+sahf,-tbm

pub fn get_cpu(&self) -> LLVMString

pub fn get_feature_string(&self) -> &CStr

pub fn get_target_data(&self) -> TargetData

Create TargetData from this target machine

pub fn set_asm_verbosity(&self, verbosity: bool)

pub fn add_analysis_passes<T>(&self, pass_manager: &PassManager<T>)

pub fn write_to_memory_buffer( &self, module: &Module<'_>, file_type: FileType, ) -> Result<MemoryBuffer, LLVMString>

Writes a TargetMachine to a MemoryBuffer.

Example

use inkwell::OptimizationLevel;
use inkwell::context::Context;
use inkwell::targets::{CodeModel, RelocMode, FileType, Target, TargetMachine, TargetTriple, InitializationConfig};

Target::initialize_x86(&InitializationConfig::default());

let opt = OptimizationLevel::Default;
let reloc = RelocMode::Default;
let model = CodeModel::Default;
let target = Target::from_name("x86-64").unwrap();
let target_machine = target.create_target_machine(
    &TargetTriple::create("x86_64-pc-linux-gnu"),
    "x86-64",
    "+avx2",
    opt,
    reloc,
    model
)
.unwrap();

let context = Context::create();
let module = context.create_module("my_module");
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);

module.add_function("my_fn", fn_type, None);

let buffer = target_machine.write_to_memory_buffer(&module, FileType::Assembly).unwrap();

pub fn write_to_file( &self, module: &Module<'_>, file_type: FileType, path: &Path, ) -> Result<(), LLVMString>

Saves a TargetMachine to a file.

Example

use inkwell::OptimizationLevel;
use inkwell::context::Context;
use inkwell::targets::{CodeModel, RelocMode, FileType, Target, TargetMachine, TargetTriple, InitializationConfig};

use std::path::Path;

Target::initialize_x86(&InitializationConfig::default());

let opt = OptimizationLevel::Default;
let reloc = RelocMode::Default;
let model = CodeModel::Default;
let path = Path::new("/tmp/some/path/main.asm");
let target = Target::from_name("x86-64").unwrap();
let target_machine = target.create_target_machine(
    &TargetTriple::create("x86_64-pc-linux-gnu"),
    "x86-64",
    "+avx2",
    opt,
    reloc,
    model
)
.unwrap();

let context = Context::create();
let module = context.create_module("my_module");
let void_type = context.void_type();
let fn_type = void_type.fn_type(&[], false);

module.add_function("my_fn", fn_type, None);

assert!(target_machine.write_to_file(&module, FileType::Object, &path).is_ok());

Trait Implementations

impl Debug for TargetMachine

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Drop for TargetMachine

fn drop(&mut self)

Executes the destructor for this type.