}
}
-pub fn create_target_machine(sess: &Session, find_features: bool) -> &'static mut llvm::TargetMachine {
+pub fn create_target_machine(
+ sess: &Session,
+ find_features: bool,
+) -> &'static mut llvm::TargetMachine {
target_machine_factory(sess, find_features)().unwrap_or_else(|err| {
llvm_err(sess.diagnostic(), err).raise()
})
}
}
-pub fn to_immediate(bx: &Builder<'_, 'll, '_>, val: &'ll Value, layout: layout::TyLayout) -> &'ll Value {
+pub fn to_immediate(
+ bx: &Builder<'_, 'll, '_>,
+ val: &'ll Value,
+ layout: layout::TyLayout,
+) -> &'ll Value {
if let layout::Abi::Scalar(ref scalar) = layout.abi {
return to_immediate_scalar(bx, val, scalar);
}
val
}
-pub fn to_immediate_scalar(bx: &Builder<'_, 'll, '_>, val: &'ll Value, scalar: &layout::Scalar) -> &'ll Value {
+pub fn to_immediate_scalar(
+ bx: &Builder<'_, 'll, '_>,
+ val: &'ll Value,
+ scalar: &layout::Scalar,
+) -> &'ll Value {
if scalar.is_bool() {
return bx.trunc(val, Type::i1(bx.cx));
}
}
}
- pub fn cond_br(&self, cond: &'ll Value, then_llbb: &'ll BasicBlock, else_llbb: &'ll BasicBlock) {
+ pub fn cond_br(
+ &self,
+ cond: &'ll Value,
+ then_llbb: &'ll BasicBlock,
+ else_llbb: &'ll BasicBlock,
+ ) {
self.count_insn("condbr");
unsafe {
llvm::LLVMBuildCondBr(self.llbuilder, cond, then_llbb, else_llbb);
}
}
- pub fn switch(&self, v: &'ll Value, else_llbb: &'ll BasicBlock, num_cases: usize) -> &'ll Value {
+ pub fn switch(
+ &self,
+ v: &'ll Value,
+ else_llbb: &'ll BasicBlock,
+ num_cases: usize,
+ ) -> &'ll Value {
unsafe {
llvm::LLVMBuildSwitch(self.llbuilder, v, else_llbb, num_cases as c_uint)
}
// FIXME: add a non-fast math version once
// https://bugs.llvm.org/show_bug.cgi?id=36732
// is fixed.
- let instr = llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src);
- let instr = instr.expect("LLVMRustBuildVectorReduceFAdd is not available in LLVM version < 5.0");
+ let instr = llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src)
+ .expect("LLVMRustBuildVectorReduceFAdd is not available in LLVM version < 5.0");
llvm::LLVMRustSetHasUnsafeAlgebra(instr);
instr
}
// FIXME: add a non-fast math version once
// https://bugs.llvm.org/show_bug.cgi?id=36732
// is fixed.
- let instr = llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src);
- let instr = instr.expect("LLVMRustBuildVectorReduceFMul is not available in LLVM version < 5.0");
+ let instr = llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src)
+ .expect("LLVMRustBuildVectorReduceFMul is not available in LLVM version < 5.0");
llvm::LLVMRustSetHasUnsafeAlgebra(instr);
instr
}
pub fn vector_reduce_fmin_fast(&self, src: &'ll Value) -> &'ll Value {
self.count_insn("vector.reduce.fmin_fast");
unsafe {
- let instr = llvm::LLVMRustBuildVectorReduceFMin(self.llbuilder, src, /*NoNaNs:*/ true);
- let instr = instr.expect("LLVMRustBuildVectorReduceFMin is not available in LLVM version < 5.0");
+ let instr = llvm::LLVMRustBuildVectorReduceFMin(self.llbuilder, src, /*NoNaNs:*/ true)
+ .expect("LLVMRustBuildVectorReduceFMin is not available in LLVM version < 5.0");
llvm::LLVMRustSetHasUnsafeAlgebra(instr);
instr
}
pub fn vector_reduce_fmax_fast(&self, src: &'ll Value) -> &'ll Value {
self.count_insn("vector.reduce.fmax_fast");
unsafe {
- let instr = llvm::LLVMRustBuildVectorReduceFMax(self.llbuilder, src, /*NoNaNs:*/ true);
- let instr = instr.expect("LLVMRustBuildVectorReduceFMax is not available in LLVM version < 5.0");
+ let instr = llvm::LLVMRustBuildVectorReduceFMax(self.llbuilder, src, /*NoNaNs:*/ true)
+ .expect("LLVMRustBuildVectorReduceFMax is not available in LLVM version < 5.0");
llvm::LLVMRustSetHasUnsafeAlgebra(instr);
instr
}
// This is a 'c-like' raw string, which differs from
// our boxed-and-length-annotated strings.
-pub fn C_cstr(cx: &CodegenCx<'ll, '_>, s: LocalInternedString, null_terminated: bool) -> &'ll Value {
+pub fn C_cstr(
+ cx: &CodegenCx<'ll, '_>,
+ s: LocalInternedString,
+ null_terminated: bool,
+) -> &'ll Value {
unsafe {
if let Some(&llval) = cx.const_cstr_cache.borrow().get(&s) {
return llval;
C_struct_in_context(cx.llcx, elts, packed)
}
-pub fn C_struct_in_context(llcx: &'ll llvm::Context, elts: &[&'ll Value], packed: bool) -> &'ll Value {
+pub fn C_struct_in_context(
+ llcx: &'ll llvm::Context,
+ elts: &[&'ll Value],
+ packed: bool,
+) -> &'ll Value {
unsafe {
llvm::LLVMConstStructInContext(llcx,
elts.as_ptr(), elts.len() as c_uint,
!is_any_library(sess) && get_reloc_model(sess) == llvm::RelocMode::PIC
}
-pub unsafe fn create_module(sess: &Session, llcx: &'ll llvm::Context, mod_name: &str) -> &'ll llvm::Module {
+pub unsafe fn create_module(
+ sess: &Session,
+ llcx: &'ll llvm::Context,
+ mod_name: &str,
+) -> &'ll llvm::Module {
let mod_name = CString::new(mod_name).unwrap();
let llmod = llvm::LLVMModuleCreateWithNameInContext(mod_name.as_ptr(), llcx);
/// Produce DIScope DIEs for each MIR Scope which has variables defined in it.
/// If debuginfo is disabled, the returned vector is empty.
-pub fn create_mir_scopes(cx: &CodegenCx<'ll, '_>, mir: &Mir, debug_context: &FunctionDebugContext<'ll>)
- -> IndexVec<SourceScope, MirDebugScope<'ll>> {
+pub fn create_mir_scopes(
+ cx: &CodegenCx<'ll, '_>,
+ mir: &Mir,
+ debug_context: &FunctionDebugContext<'ll>,
+) -> IndexVec<SourceScope, MirDebugScope<'ll>> {
let null_scope = MirDebugScope {
scope_metadata: None,
file_start_pos: BytePos(0),
///
/// If there’s a value with the same name already declared, the function will
/// update the declaration and return existing Value instead.
-fn declare_raw_fn(cx: &CodegenCx<'ll, '_>, name: &str, callconv: llvm::CallConv, ty: &'ll Type) -> &'ll Value {
+fn declare_raw_fn(
+ cx: &CodegenCx<'ll, '_>,
+ name: &str,
+ callconv: llvm::CallConv,
+ ty: &'ll Type,
+) -> &'ll Value {
debug!("declare_raw_fn(name={:?}, ty={:?})", name, ty);
let namebuf = CString::new(name).unwrap_or_else(|_|{
bug!("name {:?} contains an interior null byte", name)
pub fn open(dst: &Path) -> Result<ArchiveRO, String> {
return unsafe {
let s = path2cstr(dst);
- let ar = super::LLVMRustOpenArchive(s.as_ptr())
- .ok_or_else(|| super::last_error().unwrap_or("failed to open archive".to_string()))?;
+ let ar = super::LLVMRustOpenArchive(s.as_ptr()).ok_or_else(|| {
+ super::last_error().unwrap_or("failed to open archive".to_string())
+ })?;
Ok(ArchiveRO { raw: ar })
};
Args: *const &'a Value,
Name: *const c_char)
-> Option<&'a Value>;
- pub fn LLVMRustBuildCatchRet(B: &'a Builder, Pad: &'a Value, BB: &'a BasicBlock) -> Option<&'a Value>;
+ pub fn LLVMRustBuildCatchRet(
+ B: &'a Builder,
+ Pad: &'a Value,
+ BB: &'a BasicBlock,
+ ) -> Option<&'a Value>;
pub fn LLVMRustBuildCatchSwitch(Builder: &'a Builder,
ParentPad: Option<&'a Value>,
BB: Option<&'a BasicBlock>,
pub fn LLVMRustOpenArchive(path: *const c_char) -> Option<&'static mut Archive>;
pub fn LLVMRustArchiveIteratorNew(AR: &'a Archive) -> &'a mut ArchiveIterator<'a>;
- pub fn LLVMRustArchiveIteratorNext(AIR: &ArchiveIterator<'a>) -> Option<&'a mut ArchiveChild<'a>>;
+ pub fn LLVMRustArchiveIteratorNext(
+ AIR: &ArchiveIterator<'a>,
+ ) -> Option<&'a mut ArchiveChild<'a>>;
pub fn LLVMRustArchiveChildName(ACR: &ArchiveChild, size: &mut size_t) -> *const c_char;
pub fn LLVMRustArchiveChildData(ACR: &ArchiveChild, size: &mut size_t) -> *const c_char;
pub fn LLVMRustArchiveChildFree(ACR: &'a mut ArchiveChild<'a>);
self.store_with_flags(bx, dest, MemFlags::NONTEMPORAL);
}
- fn store_with_flags(self, bx: &Builder<'a, 'll, 'tcx>, dest: PlaceRef<'ll, 'tcx>, flags: MemFlags) {
+ fn store_with_flags(
+ self,
+ bx: &Builder<'a, 'll, 'tcx>,
+ dest: PlaceRef<'ll, 'tcx>,
+ flags: MemFlags,
+ ) {
debug!("OperandRef::store: operand={:?}, dest={:?}", self, dest);
// Avoid generating stores of zero-sized values, because the only way to have a zero-sized
// value is through `undef`, and store itself is useless.