Generalized mir::codegen_mir (and all subsequent functions)

src/librustc_codegen_llvm/abi.rs

@@ -17,11 +17,12 @@ use mir::operand::OperandValue;
 use type_::Type;
 use type_of::{LayoutLlvmExt, PointerKind};
 use value::Value;
+use rustc_target::abi::call::ArgType;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods};
+use interfaces::*;
 
 use rustc_target::abi::{LayoutOf, Size, TyLayout};
-use rustc::ty::{self, Ty};
+use rustc::ty::{self, Ty, Instance};
 use rustc::ty::layout;
 
 use libc::c_uint;
@@ -279,6 +280,27 @@ impl ArgTypeExt<'ll, 'tcx> for ArgType<'tcx, Ty<'tcx>> {
  }
 }
 
+impl<'a, 'll: 'a, 'tcx: 'll> ArgTypeMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
+ fn store_fn_arg(
+ &self,
+ ty: &ArgType<'tcx, Ty<'tcx>>,
+ idx: &mut usize, dst: PlaceRef<'tcx, <Self::CodegenCx as Backend>::Value>
+ ) {
+ ty.store_fn_arg(&self, idx, dst)
+ }
+ fn store_arg_ty(
+ &self,
+ ty: &ArgType<'tcx, Ty<'tcx>>,
+ val: &'ll Value,
+ dst: PlaceRef<'tcx, &'ll Value>
+ ) {
+ ty.store(&self, val, dst)
+ }
+ fn memory_ty(&self, ty: &ArgType<'tcx, Ty<'tcx>>) -> &'ll Type {
+ ty.memory_ty(self.cx())
+ }
+}
+
 pub trait FnTypeExt<'tcx> {
  fn of_instance(cx: &CodegenCx<'ll, 'tcx, &'ll Value>, instance: &ty::Instance<'tcx>) -> Self;
  fn new(cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
@@ -754,3 +776,29 @@ impl<'tcx> FnTypeExt<'tcx> for FnType<'tcx, Ty<'tcx>> {
  }
  }
 }
+
+impl AbiMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+ fn new_fn_type(&self, sig: ty::FnSig<'tcx>, extra_args: &[Ty<'tcx>]) -> FnType<'tcx, Ty<'tcx>> {
+ FnType::new(&self, sig, extra_args)
+ }
+ fn new_vtable(
+ &self,
+ sig: ty::FnSig<'tcx>,
+ extra_args: &[Ty<'tcx>]
+ ) -> FnType<'tcx, Ty<'tcx>> {
+ FnType::new_vtable(&self, sig, extra_args)
+ }
+ fn fn_type_of_instance(&self, instance: &Instance<'tcx>) -> FnType<'tcx, Ty<'tcx>> {
+ FnType::of_instance(&self, instance)
+ }
+}
+
+impl AbiBuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
+ fn apply_attrs_callsite(
+ &self,
+ ty: &FnType<'tcx, Ty<'tcx>>,
+ callsite: <Self::CodegenCx as Backend>::Value
+ ) {
+ ty.apply_attrs_callsite(&self, callsite)
+ }
+}

src/librustc_codegen_llvm/asm.rs

@@ -15,41 +15,43 @@ use builder::Builder;
 use value::Value;
 
 use rustc::hir;
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods};
+use interfaces::*;
 
 use mir::place::PlaceRef;
 use mir::operand::OperandValue;
 
 use std::ffi::CString;
 use libc::{c_uint, c_char};
 
-// Take an inline assembly expression and splat it out via LLVM
-pub fn codegen_inline_asm(
- bx: &Builder<'a, 'll, 'tcx, &'ll Value>,
- ia: &hir::InlineAsm,
- outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
- mut inputs: Vec<&'ll Value>
-) -> bool {
- let mut ext_constraints = vec![];
- let mut output_types = vec![];
-
- // Prepare the output operands
- let mut indirect_outputs = vec![];
- for (i, (out, place)) in ia.outputs.iter().zip(&outputs).enumerate() {
- if out.is_rw {
- inputs.push(bx.load_ref(place).immediate());
- ext_constraints.push(i.to_string());
+
+impl AsmBuilderMethods<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
+ // Take an inline assembly expression and splat it out via LLVM
+ fn codegen_inline_asm(
+ &self,
+ ia: &hir::InlineAsm,
+ outputs: Vec<PlaceRef<'tcx, &'ll Value>>,
+ mut inputs: Vec<&'ll Value>
+ ) -> bool {
+ let mut ext_constraints = vec![];
+ let mut output_types = vec![];
+
+ // Prepare the output operands
+ let mut indirect_outputs = vec![];
+ for (i, (out, place)) in ia.outputs.iter().zip(&outputs).enumerate() {
+ if out.is_rw {
+ inputs.push(self.load_ref(place).immediate());
+ ext_constraints.push(i.to_string());
+ }
+ if out.is_indirect {
+ indirect_outputs.push(self.load_ref(place).immediate());
+ } else {
+ output_types.push(place.layout.llvm_type(self.cx()));
+ }
  }
- if out.is_indirect {
- indirect_outputs.push(bx.load_ref(place).immediate());
- } else {
- output_types.push(place.layout.llvm_type(bx.cx()));
+ if !indirect_outputs.is_empty() {
+ indirect_outputs.extend_from_slice(&inputs);
+ inputs = indirect_outputs;
  }
- }
- if !indirect_outputs.is_empty() {
- indirect_outputs.extend_from_slice(&inputs);
- inputs = indirect_outputs;
- }
 
  let clobbers = ia.clobbers.iter()
  .map(|s| format!("~{{{}}}", &s));
@@ -103,26 +105,28 @@ pub fn codegen_inline_asm(
  OperandValue::Immediate(v).store(bx, place);
  }
 
- // Store mark in a metadata node so we can map LLVM errors
- // back to source locations. See #17552.
- unsafe {
- let key = "srcloc";
- let kind = llvm::LLVMGetMDKindIDInContext(bx.cx().llcx,
- key.as_ptr() as *const c_char, key.len() as c_uint);
+  // Store mark in a metadata node so we can map LLVM errors
+  // back to source locations. See #17552.
+  unsafe {
+  let key = "srcloc";
+  let kind = llvm::LLVMGetMDKindIDInContext(self.cx().llcx,
+  key.as_ptr() as *const c_char, key.len() as c_uint);
 
- let val: &'ll Value = bx.cx().const_i32(ia.ctxt.outer().as_u32() as i32);
+  let val: &'ll Value = self.cx().const_i32(ia.ctxt.outer().as_u32() as i32);
 
- llvm::LLVMSetMetadata(r, kind,
- llvm::LLVMMDNodeInContext(bx.cx().llcx, &val, 1));
+ llvm::LLVMSetMetadata(r, kind,
+ llvm::LLVMMDNodeInContext(self.cx().llcx, &val, 1));
+ }
  }
 
  return true;
 }
 
-pub fn codegen_global_asm<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>,
- ga: &hir::GlobalAsm) {
- let asm = CString::new(ga.asm.as_str().as_bytes()).unwrap();
- unsafe {
- llvm::LLVMRustAppendModuleInlineAsm(cx.llmod, asm.as_ptr());
+impl AsmMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
+ fn codegen_global_asm(&self, ga: &hir::GlobalAsm) {
+ let asm = CString::new(ga.asm.as_str().as_bytes()).unwrap();
+ unsafe {
+ llvm::LLVMRustAppendModuleInlineAsm(self.llmod, asm.as_ptr());
+ }
  }
 }

src/librustc_codegen_llvm/attributes.rs

@@ -16,11 +16,11 @@ use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::session::Session;
 use rustc::session::config::Sanitizer;
 use rustc::ty::TyCtxt;
-use rustc::ty::layout::HasTyCtxt;
 use rustc::ty::query::Providers;
 use rustc_data_structures::sync::Lrc;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_target::spec::PanicStrategy;
+use interfaces::*;
 
 use attributes;
 use llvm::{self, Attribute};

src/librustc_codegen_llvm/base.rs

@@ -58,7 +58,6 @@ use rustc_mir::monomorphize::item::DefPathBasedNames;
 use common::{self, IntPredicate, RealPredicate, TypeKind};
 use context::CodegenCx;
 use debuginfo;
-use declare;
 use meth;
 use mir;
 use monomorphize::Instance;
@@ -395,15 +394,18 @@ pub fn wants_msvc_seh(sess: &Session) -> bool {
  sess.target.target.options.is_like_msvc
 }
 
-pub fn call_assume(bx: &Builder<'_, 'll, '_, &'ll Value>, val: &'ll Value) {
+pub fn call_assume<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
+ bx: &Bx,
+ val: <Bx::CodegenCx as Backend>::Value
+) {
  let assume_intrinsic = bx.cx().get_intrinsic("llvm.assume");
  bx.call(assume_intrinsic, &[val], None);
 }
 
-pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll ,'tcx>>(
- bx: &Builder,
- val: <Builder::CodegenCx as Backend>::Value
-) -> <Builder::CodegenCx as Backend>::Value {
+pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll, Bx : BuilderMethods<'a, 'll ,'tcx>>(
+ bx: &Bx,
+ val: <Bx::CodegenCx as Backend>::Value
+) -> <Bx::CodegenCx as Backend>::Value {
  if bx.cx().val_ty(val) == bx.cx().type_i1() {
  bx.zext(val, bx.cx().type_i8())
  } else {
@@ -449,7 +451,7 @@ pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>
  bx.call_memcpy(dst, src, bx.cx().const_usize(size), align, flags);
 }
 
-pub fn codegen_instance<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>, instance: Instance<'tcx>) {
+pub fn codegen_instance<'a, 'll: 'a, 'tcx: 'll>(cx: &'a CodegenCx<'ll, 'tcx, &'ll Value>, instance: Instance<'tcx>) {
  let _s = if cx.sess().codegen_stats() {
  let mut instance_name = String::new();
  DefPathBasedNames::new(cx.tcx, true, true)
@@ -474,7 +476,7 @@ pub fn codegen_instance<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx, &'a Value>, instance:
  cx.stats.borrow_mut().n_closures += 1;
 
  let mir = cx.tcx.instance_mir(instance.def);
- mir::codegen_mir(cx, lldecl, &mir, instance, sig);
+ mir::codegen_mir::<'a, 'll, 'tcx, Builder<'a, 'll, 'tcx, &'ll Value>>(cx, lldecl, &mir, instance, sig);
 }
 
 pub fn set_link_section(llval: &Value, attrs: &CodegenFnAttrs) {
@@ -535,15 +537,15 @@ fn maybe_create_entry_wrapper(cx: &CodegenCx<'ll, '_, &'ll Value>) {
  &main_ret_ty.no_late_bound_regions().unwrap(),
  );
 
- if declare::get_defined_value(cx, "main").is_some() {
+ if cx.get_defined_value("main").is_some() {
  // FIXME: We should be smart and show a better diagnostic here.
  cx.sess().struct_span_err(sp, "entry symbol `main` defined multiple times")
  .help("did you use #[no_mangle] on `fn main`? Use #[start] instead")
  .emit();
  cx.sess().abort_if_errors();
  bug!();
  }
- let llfn = declare::declare_cfn(cx, "main", llfty);
+ let llfn = cx.declare_cfn("main", llfty);
 
  // `main` should respect same config for frame pointer elimination as rest of code
  attributes::set_frame_pointer_elimination(cx, llfn);

src/librustc_codegen_llvm/builder.rs

@@ -18,7 +18,7 @@ use value::Value;
 use libc::{c_uint, c_char};
 use rustc::ty::TyCtxt;
 use rustc::ty::layout::{self, Align, Size};
-use rustc::session::{config, Session};
+use rustc::session::config;
 use rustc_data_structures::small_c_str::SmallCStr;
 use interfaces::*;
 use syntax;
@@ -99,10 +99,6 @@ impl BuilderMethods<'a, 'll, 'tcx>
  Builder::new_block(self.cx, self.llfn(), name)
  }
 
- fn sess(&self) -> &Session {
- self.cx.sess()
- }
-
  fn tcx(&self) -> TyCtxt<'a, 'tcx, 'tcx> {
  self.cx.tcx
  }
@@ -605,7 +601,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
 
 
  fn range_metadata(&self, load: &'ll Value, range: Range<u128>) {
- if self.sess().target.target.arch == "amdgpu" {
+ if self.cx().sess().target.target.arch == "amdgpu" {
  // amdgpu/LLVM does something weird and thinks a i64 value is
  // split into a v2i32, halving the bitwidth LLVM expects,
  // tripping an assertion. So, for now, just disable this
@@ -1381,7 +1377,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
  return;
  }
  let cx = &self.cx();
- let ptr_width = &self.sess().target.target.target_pointer_width;
+ let ptr_width = &self.cx().sess().target.target.target_pointer_width;
  let key = format!("llvm.memcpy.p0i8.p0i8.i{}", ptr_width);
  let memcpy = cx.get_intrinsic(&key);
  let src_ptr = &self.pointercast(src, cx.type_i8p());
@@ -1400,7 +1396,7 @@ impl BuilderMethods<'a, 'll, 'tcx>
  align: &'ll Value,
  volatile: bool,
  ) -> &'ll Value {
- let ptr_width = &self.sess().target.target.target_pointer_width;
+ let ptr_width = &self.cx().sess().target.target.target_pointer_width;
  let intrinsic_key = format!("llvm.memset.p0i8.i{}", ptr_width);
  let llintrinsicfn = &self.cx().get_intrinsic(&intrinsic_key);
  let volatile = &self.cx().const_bool(volatile);
@@ -1425,4 +1421,14 @@ impl BuilderMethods<'a, 'll, 'tcx>
  fn cx(&self) -> &'a CodegenCx<'ll, 'tcx, &'ll Value> {
  &self.cx
  }
+
+ fn delete_basic_block(&self, bb: &'ll BasicBlock) {
+ unsafe {
+ llvm::LLVMDeleteBasicBlock(bb);
+ }
+ }
+
+ fn do_not_inline(&self, llret: &'ll Value) {
+ llvm::Attribute::NoInline.apply_callsite(llvm::AttributePlace::Function, llret);
+ }
 }

src/librustc_codegen_llvm/callee.rs

@@ -15,12 +15,10 @@
 //! closure.
 
 use attributes;
-use common::{self, CodegenCx};
-use consts;
-use declare;
+use common;
 use llvm;
 use monomorphize::Instance;
-use type_of::LayoutLlvmExt;
+use context::CodegenCx;
 use value::Value;
 use interfaces::*;
 
@@ -40,16 +38,16 @@ pub fn get_fn(
  cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
  instance: Instance<'tcx>,
 ) -> &'ll Value {
- let tcx = cx.tcx;
+ let tcx = cx.tcx();
 
  debug!("get_fn(instance={:?})", instance);
 
  assert!(!instance.substs.needs_infer());
  assert!(!instance.substs.has_escaping_regions());
  assert!(!instance.substs.has_param_types());
 
- let fn_ty = instance.ty(cx.tcx);
- if let Some(&llfn) = cx.instances.borrow().get(&instance) {
+ let fn_ty = instance.ty(*cx.tcx());
+ if let Some(&llfn) = cx.instances().borrow().get(&instance) {
  return llfn;
  }
 
@@ -58,9 +56,9 @@ pub fn get_fn(
 
  // Create a fn pointer with the substituted signature.
  let fn_ptr_ty = tcx.mk_fn_ptr(common::ty_fn_sig(cx, fn_ty));
- let llptrty = cx.layout_of(fn_ptr_ty).llvm_type(cx);
+ let llptrty = cx.backend_type(&cx.layout_of(fn_ptr_ty));
 
- let llfn = if let Some(llfn) = declare::get_declared_value(cx, &sym) {
+ let llfn = if let Some(llfn) = cx.get_declared_value(&sym) {
  // This is subtle and surprising, but sometimes we have to bitcast
  // the resulting fn pointer. The reason has to do with external
  // functions. If you have two crates that both bind the same C
@@ -86,17 +84,17 @@ pub fn get_fn(
  // other weird situations. Annoying.
  if cx.val_ty(llfn) != llptrty {
  debug!("get_fn: casting {:?} to {:?}", llfn, llptrty);
- consts::ptrcast(llfn, llptrty)
+ cx.static_ptrcast(llfn, llptrty)
  } else {
  debug!("get_fn: not casting pointer!");
  llfn
  }
  } else {
- let llfn = declare::declare_fn(cx, &sym, fn_ty);
+ let llfn = cx.declare_fn(&sym, fn_ty);
  assert_eq!(cx.val_ty(llfn), llptrty);
  debug!("get_fn: not casting pointer!");
 
- if instance.def.is_inline(tcx) {
+ if instance.def.is_inline(*tcx) {
  attributes::inline(cx, llfn, attributes::InlineAttr::Hint);
  }
  attributes::from_fn_attrs(cx, llfn, Some(instance.def.def_id()));