Struct rustc_codegen_llvm::LlvmCodegenBackend

pub struct LlvmCodegenBackend(());

Implementations

impl LlvmCodegenBackend

pub fn new() -> Box<dyn CodegenBackend>

Trait Implementations

impl Clone for LlvmCodegenBackend

pub fn clone(&self) -> LlvmCodegenBackend

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CodegenBackend for LlvmCodegenBackend

pub fn init(&self, sess: &Session)

pub fn print(&self, req: PrintRequest, sess: &Session)

pub fn print_passes(&self)

pub fn print_version(&self)

pub fn target_features(&self, sess: &Session) -> Vec<Symbol>

pub fn metadata_loader(&self) -> Box<MetadataLoaderDyn>

pub fn provide(&self, providers: &mut Providers)

pub fn provide_extern(&self, providers: &mut Providers)

pub fn codegen_crate<'tcx>(
    &self,
    tcx: TyCtxt<'tcx>,
    metadata: EncodedMetadata,
    need_metadata_module: bool
) -> Box<dyn Any>

pub fn join_codegen(
    &self,
    ongoing_codegen: Box<dyn Any>,
    sess: &Session
) -> Result<(CodegenResults, FxHashMap<WorkProductId, WorkProduct>), ErrorReported>

This is called on the returned Box<dyn Any> from codegen_backend

pub fn link(
    &self,
    sess: &Session,
    codegen_results: CodegenResults,
    outputs: &OutputFilenames
) -> Result<(), ErrorReported>

This is called on the returned Box<dyn Any> from join_codegen

pub fn target_override(&self, _opts: &Options) -> Option<Target>

If this plugin provides additional builtin targets, provide the one enabled by the options here. Be careful: this is called before init() is called.

impl ExtraBackendMethods for LlvmCodegenBackend

pub fn new_metadata(&self, tcx: TyCtxt<'_>, mod_name: &str) -> ModuleLlvm

pub fn write_compressed_metadata<'tcx>(
    &self,
    tcx: TyCtxt<'tcx>,
    metadata: &EncodedMetadata,
    llvm_module: &mut ModuleLlvm
)

pub fn codegen_allocator<'tcx>(
    &self,
    tcx: TyCtxt<'tcx>,
    mods: &mut ModuleLlvm,
    kind: AllocatorKind,
    has_alloc_error_handler: bool
)

pub fn compile_codegen_unit(
    &self,
    tcx: TyCtxt<'_>,
    cgu_name: Symbol
) -> (ModuleCodegen<ModuleLlvm>, u64)

This generates the codegen unit and returns it along with a u64 giving an estimate of the unit's processing cost.

pub fn target_machine_factory(
    &self,
    sess: &Session,
    optlvl: OptLevel
) -> Arc<dyn Fn() -> Result<&'static mut TargetMachine, String> + Send + Sync>

pub fn target_cpu<'b>(&self, sess: &'b Session) -> &'b str

pub fn tune_cpu<'b>(&self, sess: &'b Session) -> Option<&'b str>

impl Send for LlvmCodegenBackend

impl Sync for LlvmCodegenBackend

impl WriteBackendMethods for LlvmCodegenBackend

type Module = ModuleLlvm

type ModuleBuffer = ModuleBuffer

type Context = Context

type TargetMachine = &'static mut TargetMachine

type ThinData = ThinData

type ThinBuffer = ThinBuffer

pub fn print_pass_timings(&self)

pub fn run_link(
    cgcx: &CodegenContext<Self>,
    diag_handler: &Handler,
    modules: Vec<ModuleCodegen<Self::Module>>
) -> Result<ModuleCodegen<Self::Module>, FatalError>

Merge all modules into main_module and returning it

pub fn run_fat_lto(
    cgcx: &CodegenContext<Self>,
    modules: Vec<FatLTOInput<Self>>,
    cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>
) -> Result<LtoModuleCodegen<Self>, FatalError>

Performs fat LTO by merging all modules into a single one and returning it for further optimization.

pub fn run_thin_lto(
    cgcx: &CodegenContext<Self>,
    modules: Vec<(String, Self::ThinBuffer)>,
    cached_modules: Vec<(SerializedModule<Self::ModuleBuffer>, WorkProduct)>
) -> Result<(Vec<LtoModuleCodegen<Self>>, Vec<WorkProduct>), FatalError>

Performs thin LTO by performing necessary global analysis and returning two lists, one of the modules that need optimization and another for modules that can simply be copied over from the incr. comp. cache.

pub unsafe fn optimize(
    cgcx: &CodegenContext<Self>,
    diag_handler: &Handler,
    module: &ModuleCodegen<Self::Module>,
    config: &ModuleConfig
) -> Result<(), FatalError>

pub unsafe fn optimize_thin(
    cgcx: &CodegenContext<Self>,
    thin: &mut ThinModule<Self>
) -> Result<ModuleCodegen<Self::Module>, FatalError>

pub unsafe fn codegen(
    cgcx: &CodegenContext<Self>,
    diag_handler: &Handler,
    module: ModuleCodegen<Self::Module>,
    config: &ModuleConfig
) -> Result<CompiledModule, FatalError>

pub fn prepare_thin(
    module: ModuleCodegen<Self::Module>
) -> (String, Self::ThinBuffer)

pub fn serialize_module(
    module: ModuleCodegen<Self::Module>
) -> (String, Self::ModuleBuffer)

pub fn run_lto_pass_manager(
    cgcx: &CodegenContext<Self>,
    module: &ModuleCodegen<Self::Module>,
    config: &ModuleConfig,
    thin: bool
)