Generalized base::unsized_info

Author: denismerigoux

src/librustc_codegen_llvm/base.rs

@@ -39,7 +39,7 @@ use rustc::middle::weak_lang_items;
 use rustc::mir::mono::{Linkage, Visibility, Stats, CodegenUnitNameBuilder};
 use rustc::middle::cstore::{EncodedMetadata};
 use rustc::ty::{self, Ty, TyCtxt};
-use rustc::ty::layout::{self, Align, TyLayout, LayoutOf};
+use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, HasTyCtxt};
 use rustc::ty::query::Providers;
 use rustc::middle::cstore::{self, LinkagePreference};
 use rustc::middle::exported_symbols;
@@ -56,7 +56,6 @@ use callee;
 use rustc_mir::monomorphize::collector::{self, MonoItemCollectionMode};
 use rustc_mir::monomorphize::item::DefPathBasedNames;
 use common::{self, IntPredicate, RealPredicate, TypeKind};
-use consts;
 use context::CodegenCx;
 use debuginfo;
 use declare;
@@ -188,16 +187,16 @@ pub fn compare_simd_types<'a, 'll:'a, 'tcx:'ll, Builder : BuilderMethods<'a, 'll
 /// The `old_info` argument is a bit funny. It is intended for use
 /// in an upcast, where the new vtable for an object will be derived
 /// from the old one.
-pub fn unsized_info(
- cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
+pub fn unsized_info<'a, 'll: 'a, 'tcx: 'll, Cx: 'a + CodegenMethods<'ll, 'tcx>>(
+ cx: &'a Cx,
  source: Ty<'tcx>,
  target: Ty<'tcx>,
- old_info: Option<&'ll Value>,
-) -> &'ll Value {
- let (source, target) = cx.tcx.struct_lockstep_tails(source, target);
+ old_info: Option<Cx::Value>,
+) -> Cx::Value where &'a Cx: LayoutOf<Ty = Ty<'tcx>, TyLayout = TyLayout<'tcx>> + HasTyCtxt<'tcx> {
+ let (source, target) = cx.tcx().struct_lockstep_tails(source, target);
  match (&source.sty, &target.sty) {
  (&ty::Array(_, len), &ty::Slice(_)) => {
- cx.const_usize(len.unwrap_usize(cx.tcx))
+ cx.const_usize(len.unwrap_usize(*cx.tcx()))
  }
  (&ty::Dynamic(..), &ty::Dynamic(..)) => {
  // For now, upcasts are limited to changes in marker
@@ -206,10 +205,10 @@ pub fn unsized_info(
  old_info.expect("unsized_info: missing old info for trait upcast")
  }
  (_, &ty::Dynamic(ref data, ..)) => {
- let vtable_ptr = cx.layout_of(cx.tcx.mk_mut_ptr(target))
+ let vtable_ptr = cx.layout_of(cx.tcx().mk_mut_ptr(target))
  .field(cx, abi::FAT_PTR_EXTRA);
- consts::ptrcast(meth::get_vtable(cx, source, data.principal()),
- vtable_ptr.llvm_type(cx))
+ cx.static_ptrcast(meth::get_vtable(cx, source, data.principal()),
+ cx.backend_type(vtable_ptr))
  }
  _ => bug!("unsized_info: invalid unsizing {:?} -> {:?}",
  source,

src/librustc_codegen_llvm/builder.rs

@@ -56,11 +56,11 @@ bitflags! {
  }
 }
 
-impl<'a, 'll: 'a, 'tcx: 'll> HasCodegen<'a> for Builder<'a, 'll, 'tcx, &'ll Value> {
+impl HasCodegen<'a, 'll, 'tcx> for Builder<'a, 'll, 'tcx, &'ll Value> {
  type CodegenCx = CodegenCx<'ll, 'tcx, &'ll Value>;
 }
 
-impl<'a, 'll: 'a, 'tcx: 'll> BuilderMethods<'a, 'll, 'tcx>
+impl BuilderMethods<'a, 'll, 'tcx>
  for Builder<'a, 'll, 'tcx, &'ll Value> {
 
  fn new_block<'b>(

src/librustc_codegen_llvm/callee.rs

@@ -22,7 +22,7 @@ use llvm;
 use monomorphize::Instance;
 use type_of::LayoutLlvmExt;
 use value::Value;
-use interfaces::BaseTypeMethods;
+use interfaces::*;
 
 use rustc::hir::def_id::DefId;
 use rustc::ty::{self, TypeFoldable};
@@ -206,15 +206,16 @@ pub fn get_fn(
  llfn
 }
 
-pub fn resolve_and_get_fn(
- cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
+pub fn resolve_and_get_fn<'ll, 'tcx: 'll,
+ Cx : Backend + MiscMethods<'tcx> + TypeMethods<'ll, 'tcx>
+ >(
+ cx: &Cx,
  def_id: DefId,
  substs: &'tcx Substs<'tcx>,
-) -> &'ll Value {
- get_fn(
- cx,
+) -> Cx::Value {
+ cx.get_fn(
  ty::Instance::resolve(
- cx.tcx,
+ *cx.tcx(),
  ty::ParamEnv::reveal_all(),
  def_id,
  substs

src/librustc_codegen_llvm/common.rs

@@ -321,7 +321,7 @@ impl<'ll, 'tcx : 'll> ConstMethods for CodegenCx<'ll, 'tcx, &'ll Value> {
  fn const_str_slice(&self, s: LocalInternedString) -> &'ll Value {
  let len = s.len();
  let cs = consts::ptrcast(&self.const_cstr(s, false),
- &self.type_ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(&self)));
+ &self.type_ptr_to(&self.layout_of(&self.tcx.mk_str()).llvm_type(self)));
  &self.const_fat_ptr(cs, &self.const_usize(len as u64))
  }
 

src/librustc_codegen_llvm/consts.rs

@@ -201,7 +201,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
  let g = if let Some(id) = self.tcx.hir.as_local_node_id(def_id) {
 
- let llty = &self.layout_of(ty).llvm_type(&self);
+ let llty = &self.layout_of(ty).llvm_type(self);
  let (g, attrs) = match &self.tcx.hir.get(id) {
  Node::Item(&hir::Item {
  ref attrs, span, node: hir::ItemKind::Static(..), ..
@@ -329,7 +329,7 @@ impl StaticMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
  let instance = Instance::mono(self.tcx, def_id);
  let ty = instance.ty(self.tcx);
- let llty = self.layout_of(ty).llvm_type(&self);
+ let llty = self.layout_of(ty).llvm_type(self);
  let g = if val_llty == llty {
  g
  } else {

src/librustc_codegen_llvm/context.rs

@@ -23,7 +23,7 @@ use value::Value;
 use monomorphize::partitioning::CodegenUnit;
 use type_::Type;
 use type_of::PointeeInfo;
-use interfaces::{BaseTypeMethods, DerivedTypeMethods, IntrinsicDeclarationMethods};
+use interfaces::*;
 
 use rustc_data_structures::base_n;
 use rustc_data_structures::small_c_str::SmallCStr;
@@ -323,6 +323,19 @@ impl<'b, 'tcx> CodegenCx<'b, 'tcx, &'b Value> {
  }
 }
 
+impl MiscMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
+ fn vtables(&self) -> &RefCell<FxHashMap<(Ty<'tcx>,
+ Option<ty::PolyExistentialTraitRef<'tcx>>), &'ll Value>>
+ {
+ &self.vtables
+ }
+ fn get_fn(&self, instance: Instance<'tcx>) -> &'ll Value {
+ callee::get_fn(&&self,instance)
+ }
+}
+
+impl<'ll, 'tcx: 'll> CodegenMethods<'ll, 'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {}
+
 impl IntrinsicDeclarationMethods for CodegenCx<'b, 'tcx, &'b Value> {
  fn get_intrinsic(&self, key: &str) -> &'b Value {
  if let Some(v) = self.intrinsics.borrow().get(key).cloned() {

src/librustc_codegen_llvm/debuginfo/metadata.rs

@@ -17,6 +17,7 @@ use super::utils::{debug_context, DIB, span_start,
 use super::namespace::mangled_name_of_instance;
 use super::type_names::compute_debuginfo_type_name;
 use super::{CrateDebugContext};
+use interfaces::*;
 use abi;
 use value::Value;
 
@@ -1744,58 +1745,61 @@ pub fn extend_scope_to_file(
  }
 }
 
-/// Creates debug information for the given vtable, which is for the
-/// given type.
-///
-/// Adds the created metadata nodes directly to the crate's IR.
-pub fn create_vtable_metadata(
- cx: &CodegenCx<'ll, 'tcx, &'ll Value>,
- ty: ty::Ty<'tcx>,
- vtable: &'ll Value,
-) {
- if cx.dbg_cx.is_none() {
- return;
- }
-
- let type_metadata = type_metadata(cx, ty, syntax_pos::DUMMY_SP);
-
- unsafe {
- // LLVMRustDIBuilderCreateStructType() wants an empty array. A null
- // pointer will lead to hard to trace and debug LLVM assertions
- // later on in llvm/lib/IR/Value.cpp.
- let empty_array = create_DIArray(DIB(cx), &[]);
+impl DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx, &'ll Value> {
 
- let name = const_cstr!("vtable");
+ /// Creates debug information for the given vtable, which is for the
+ /// given type.
+ ///
+ /// Adds the created metadata nodes directly to the crate's IR.
+ fn create_vtable_metadata(
+ &self,
+ ty: ty::Ty<'tcx>,
+ vtable: &'ll Value,
+ ) {
+ if self.dbg_cx.is_none() {
+ return;
+ }
 
- // Create a new one each time. We don't want metadata caching
- // here, because each vtable will refer to a unique containing
- // type.
- let vtable_type = llvm::LLVMRustDIBuilderCreateStructType(
- DIB(cx),
- NO_SCOPE_METADATA,
- name.as_ptr(),
- unknown_file_metadata(cx),
- UNKNOWN_LINE_NUMBER,
- Size::ZERO.bits(),
- cx.tcx.data_layout.pointer_align.abi_bits() as u32,
- DIFlags::FlagArtificial,
- None,
- empty_array,
- 0,
- Some(type_metadata),
- name.as_ptr()
- );
+ let type_metadata = type_metadata(&self, ty, syntax_pos::DUMMY_SP);
 
- llvm::LLVMRustDIBuilderCreateStaticVariable(DIB(cx),
- NO_SCOPE_METADATA,
- name.as_ptr(),
- ptr::null(),
- unknown_file_metadata(cx),
- UNKNOWN_LINE_NUMBER,
- vtable_type,
- true,
- vtable,
- None,
- 0);
+ unsafe {
+ // LLVMRustDIBuilderCreateStructType() wants an empty array. A null
+ // pointer will lead to hard to trace and debug LLVM assertions
+ // later on in llvm/lib/IR/Value.cpp.
+ let empty_array = create_DIArray(DIB(&self), &[]);
+
+ let name = const_cstr!("vtable");
+
+ // Create a new one each time. We don't want metadata caching
+ // here, because each vtable will refer to a unique containing
+ // type.
+ let vtable_type = llvm::LLVMRustDIBuilderCreateStructType(
+ DIB(&self),
+ NO_SCOPE_METADATA,
+ name.as_ptr(),
+ unknown_file_metadata(&self),
+ UNKNOWN_LINE_NUMBER,
+ Size::ZERO.bits(),
+ self.tcx.data_layout.pointer_align.abi_bits() as u32,
+ DIFlags::FlagArtificial,
+ None,
+ empty_array,
+ 0,
+ Some(type_metadata),
+ name.as_ptr()
+ );
+
+ llvm::LLVMRustDIBuilderCreateStaticVariable(DIB(&self),
+ NO_SCOPE_METADATA,
+ name.as_ptr(),
+ ptr::null(),
+ unknown_file_metadata(&self),
+ UNKNOWN_LINE_NUMBER,
+ vtable_type,
+ true,
+ vtable,
+ None,
+ 0);
+ }
  }
 }

src/librustc_codegen_llvm/debuginfo/mod.rs

@@ -58,7 +58,6 @@ mod source_loc;
 pub use self::create_scope_map::{create_mir_scopes, MirDebugScope};
 pub use self::source_loc::start_emitting_source_locations;
 pub use self::metadata::create_global_var_metadata;
-pub use self::metadata::create_vtable_metadata;
 pub use self::metadata::extend_scope_to_file;
 pub use self::source_loc::set_source_location;
 

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -15,19 +15,17 @@ use rustc::ty::layout::{Align, Size};
 use rustc::session::Session;
 use builder::MemFlags;
 use super::backend::Backend;
-use super::type_::TypeMethods;
-use super::consts::ConstMethods;
-use super::intrinsic::IntrinsicDeclarationMethods;
+use super::CodegenMethods;
 
 use std::borrow::Cow;
 use std::ops::Range;
 use syntax::ast::AsmDialect;
 
-pub trait HasCodegen<'a> {
- type CodegenCx : 'a + Backend + TypeMethods + ConstMethods + IntrinsicDeclarationMethods;
+pub trait HasCodegen<'a, 'll: 'a, 'tcx :'ll> {
+ type CodegenCx : 'a + CodegenMethods<'ll, 'tcx>;
 }
 
-pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll> : HasCodegen<'a> {
+pub trait BuilderMethods<'a, 'll :'a, 'tcx: 'll> : HasCodegen<'a, 'll, 'tcx> {
  fn new_block<'b>(
  cx: &'a Self::CodegenCx,
  llfn: <Self::CodegenCx as Backend>::Value,

src/librustc_codegen_llvm/interfaces/debuginfo.rs

@@ -0,0 +1,20 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use rustc::ty::Ty;
+use super::backend::Backend;
+
+pub trait DebugInfoMethods<'tcx> : Backend {
+ fn create_vtable_metadata(
+ &self,
+ ty: Ty<'tcx>,
+ vtable: Self::Value,
+ );
+}