7f23e6e8d7
This commit builds on #65501 continue to simplify the build system and compiler now that we no longer have multiple LLVM backends to ship by default. Here this switches the compiler back to what it once was long long ago, which is linking LLVM directly to the compiler rather than dynamically loading it at runtime. The `codegen-backends` directory of the sysroot no longer exists and all relevant support in the build system is removed. Note that `rustc` still supports a dynamically loaded codegen backend as it did previously, it just no longer supports dynamically loaded codegen backends in its own sysroot. Additionally as part of this the `librustc_codegen_llvm` crate now once again explicitly depends on all of its crates instead of implicitly loading them through the sysroot. This involved filling out its `Cargo.toml` and deleting all the now-unnecessary `extern crate` annotations in the header of the crate. (this in turn required adding a number of imports for names of macros too). The end results of this change are: * Rustbuild's build process for the compiler as all the "oh don't forget the codegen backend" checks can be easily removed. * Building `rustc_codegen_llvm` is much simpler since it's simply another compiler crate. * Managing the dependencies of `rustc_codegen_llvm` is much simpler since it's "just another `Cargo.toml` to edit" * The build process should be a smidge faster because there's more parallelism in the main rustc build step rather than splitting `librustc_codegen_llvm` out to its own step. * The compiler is expected to be slightly faster by default because the codegen backend does not need to be dynamically loaded. * Disabling LLVM as part of rustbuild is still supported, supporting multiple codegen backends is still supported, and dynamic loading of a codegen backend is still supported.
94 lines
3.8 KiB
Rust
94 lines
3.8 KiB
Rust
use std::ffi::CString;
|
|
|
|
use crate::attributes;
|
|
use libc::c_uint;
|
|
use rustc::ty::TyCtxt;
|
|
use syntax::expand::allocator::{AllocatorKind, AllocatorTy, ALLOCATOR_METHODS};
|
|
use rustc::bug;
|
|
|
|
use crate::ModuleLlvm;
|
|
use crate::llvm::{self, False, True};
|
|
|
|
pub(crate) unsafe fn codegen(tcx: TyCtxt<'_>, mods: &mut ModuleLlvm, kind: AllocatorKind) {
|
|
let llcx = &*mods.llcx;
|
|
let llmod = mods.llmod();
|
|
let usize = match &tcx.sess.target.target.target_pointer_width[..] {
|
|
"16" => llvm::LLVMInt16TypeInContext(llcx),
|
|
"32" => llvm::LLVMInt32TypeInContext(llcx),
|
|
"64" => llvm::LLVMInt64TypeInContext(llcx),
|
|
tws => bug!("Unsupported target word size for int: {}", tws),
|
|
};
|
|
let i8 = llvm::LLVMInt8TypeInContext(llcx);
|
|
let i8p = llvm::LLVMPointerType(i8, 0);
|
|
let void = llvm::LLVMVoidTypeInContext(llcx);
|
|
|
|
for method in ALLOCATOR_METHODS {
|
|
let mut args = Vec::with_capacity(method.inputs.len());
|
|
for ty in method.inputs.iter() {
|
|
match *ty {
|
|
AllocatorTy::Layout => {
|
|
args.push(usize); // size
|
|
args.push(usize); // align
|
|
}
|
|
AllocatorTy::Ptr => args.push(i8p),
|
|
AllocatorTy::Usize => args.push(usize),
|
|
|
|
AllocatorTy::ResultPtr |
|
|
AllocatorTy::Unit => panic!("invalid allocator arg"),
|
|
}
|
|
}
|
|
let output = match method.output {
|
|
AllocatorTy::ResultPtr => Some(i8p),
|
|
AllocatorTy::Unit => None,
|
|
|
|
AllocatorTy::Layout |
|
|
AllocatorTy::Usize |
|
|
AllocatorTy::Ptr => panic!("invalid allocator output"),
|
|
};
|
|
let ty = llvm::LLVMFunctionType(output.unwrap_or(void),
|
|
args.as_ptr(),
|
|
args.len() as c_uint,
|
|
False);
|
|
let name = CString::new(format!("__rust_{}", method.name)).unwrap();
|
|
let llfn = llvm::LLVMRustGetOrInsertFunction(llmod,
|
|
name.as_ptr(),
|
|
ty);
|
|
|
|
if tcx.sess.target.target.options.default_hidden_visibility {
|
|
llvm::LLVMRustSetVisibility(llfn, llvm::Visibility::Hidden);
|
|
}
|
|
if tcx.sess.target.target.options.requires_uwtable {
|
|
attributes::emit_uwtable(llfn, true);
|
|
}
|
|
|
|
let callee = CString::new(kind.fn_name(method.name)).unwrap();
|
|
let callee = llvm::LLVMRustGetOrInsertFunction(llmod,
|
|
callee.as_ptr(),
|
|
ty);
|
|
llvm::LLVMRustSetVisibility(callee, llvm::Visibility::Hidden);
|
|
|
|
let llbb = llvm::LLVMAppendBasicBlockInContext(llcx,
|
|
llfn,
|
|
"entry\0".as_ptr().cast());
|
|
|
|
let llbuilder = llvm::LLVMCreateBuilderInContext(llcx);
|
|
llvm::LLVMPositionBuilderAtEnd(llbuilder, llbb);
|
|
let args = args.iter().enumerate().map(|(i, _)| {
|
|
llvm::LLVMGetParam(llfn, i as c_uint)
|
|
}).collect::<Vec<_>>();
|
|
let ret = llvm::LLVMRustBuildCall(llbuilder,
|
|
callee,
|
|
args.as_ptr(),
|
|
args.len() as c_uint,
|
|
None,
|
|
"\0".as_ptr().cast());
|
|
llvm::LLVMSetTailCall(ret, True);
|
|
if output.is_some() {
|
|
llvm::LLVMBuildRet(llbuilder, ret);
|
|
} else {
|
|
llvm::LLVMBuildRetVoid(llbuilder);
|
|
}
|
|
llvm::LLVMDisposeBuilder(llbuilder);
|
|
}
|
|
}
|