Generalized some base.rs methods

src/librustc_codegen_llvm/base.rs

@@ -30,7 +30,7 @@ use super::CachedModuleCodegen;
 
 use abi;
 use back::write::{self, OngoingCodegen};
-use llvm::{self, TypeKind, get_param};
+use llvm::{self, get_param};
 use metadata;
 use rustc::dep_graph::cgu_reuse_tracker::CguReuse;
 use rustc::hir::def_id::{CrateNum, DefId, LOCAL_CRATE};
@@ -54,7 +54,7 @@ use attributes;
 use builder::{Builder, MemFlags};
 use callee;
 use rustc_mir::monomorphize::item::DefPathBasedNames;
-use common::{self, IntPredicate, RealPredicate};
+use common::{self, IntPredicate, RealPredicate, TypeKind};
 use consts;
 use context::CodegenCx;
 use debuginfo;
@@ -66,7 +66,6 @@ use monomorphize::partitioning::{CodegenUnit, CodegenUnitExt};
 use rustc_codegen_utils::symbol_names_test;
 use time_graph;
 use mono_item::{MonoItem, MonoItemExt};
-use type_::Type;
 use type_of::LayoutLlvmExt;
 use rustc::util::nodemap::FxHashMap;
 use CrateInfo;
@@ -333,21 +332,31 @@ pub fn coerce_unsized_into(
     }
 }
 
-pub fn cast_shift_expr_rhs(
-    bx: &Builder<'_, 'll, '_>, op: hir::BinOpKind, lhs: &'ll Value, rhs: &'ll Value
-) -> &'ll Value {
+pub fn cast_shift_expr_rhs<'a, 'tcx: 'a, Builder: BuilderMethods<'a, 'tcx>>(
+    bx: &Builder,
+    op: hir::BinOpKind,
+    lhs: Builder::Value,
+    rhs: Builder::Value
+) -> Builder::Value {
     cast_shift_rhs(bx, op, lhs, rhs, |a, b| bx.trunc(a, b), |a, b| bx.zext(a, b))
 }
 
-fn cast_shift_rhs<'ll, F, G>(bx: &Builder<'_, 'll, '_>,
-                             op: hir::BinOpKind,
-                             lhs: &'ll Value,
-                             rhs: &'ll Value,
-                             trunc: F,
-                             zext: G)
-                             -> &'ll Value
-    where F: FnOnce(&'ll Value, &'ll Type) -> &'ll Value,
-          G: FnOnce(&'ll Value, &'ll Type) -> &'ll Value
+fn cast_shift_rhs<'a, 'tcx: 'a, F, G, Builder: BuilderMethods<'a, 'tcx>>(
+    bx: &Builder,
+    op: hir::BinOpKind,
+    lhs: Builder::Value,
+    rhs: Builder::Value,
+    trunc: F,
+    zext: G
+) -> Builder::Value
+    where F: FnOnce(
+        Builder::Value,
+        Builder::Type
+    ) -> Builder::Value,
+    G: FnOnce(
+        Builder::Value,
+        Builder::Type
+    ) -> Builder::Value
 {
     // Shifts may have any size int on the rhs
     if op.is_shift() {
@@ -389,41 +398,41 @@ pub fn call_assume(bx: &Builder<'_, 'll, '_>, val: &'ll Value) {
     bx.call(assume_intrinsic, &[val], None);
 }
 
-pub fn from_immediate<'a, 'll: 'a, 'tcx: 'll>(
-    bx: &Builder<'_ ,'ll, '_, &'ll Value>,
-    val: &'ll Value
-) -> &'ll Value {
+pub fn from_immediate<'a, 'tcx: 'a, Builder: BuilderMethods<'a, 'tcx>>(
+    bx: &Builder,
+    val: Builder::Value
+) -> Builder::Value {
     if bx.cx().val_ty(val) == bx.cx().type_i1() {
         bx.zext(val, bx.cx().type_i8())
     } else {
         val
     }
 }
 
-pub fn to_immediate(
-    bx: &Builder<'_, 'll, '_>,
-    val: &'ll Value,
+pub fn to_immediate<'a, 'tcx: 'a, Builder: BuilderMethods<'a, 'tcx>>(
+    bx: &Builder,
+    val: Builder::Value,
     layout: layout::TyLayout,
-) -> &'ll Value {
+) -> Builder::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,
+pub fn to_immediate_scalar<'a, 'tcx: 'a, Builder: BuilderMethods<'a, 'tcx>>(
+    bx: &Builder,
+    val: Builder::Value,
     scalar: &layout::Scalar,
-) -> &'ll Value {
+) -> Builder::Value {
     if scalar.is_bool() {
         return bx.trunc(val, bx.cx().type_i1());
     }
     val
 }
 
-pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll>(
-    bx: &Builder<'_ ,'ll, '_, &'ll Value>,
+pub fn call_memcpy(
+    bx: &Builder<'_, 'll, '_>,
     dst: &'ll Value,
     dst_align: Align,
     src: &'ll Value,
@@ -446,8 +455,8 @@ pub fn call_memcpy<'a, 'll: 'a, 'tcx: 'll>(
     bx.memcpy(dst_ptr, dst_align.abi(), src_ptr, src_align.abi(), size, volatile);
 }
 
-pub fn memcpy_ty<'a, 'll: 'a, 'tcx: 'll>(
-    bx: &Builder<'_ ,'ll, '_, &'ll Value>,
+pub fn memcpy_ty(
+    bx: &Builder<'_, 'll, '_>,
     dst: &'ll Value,
     dst_align: Align,
     src: &'ll Value,

src/librustc_codegen_llvm/builder.rs

@@ -60,7 +60,6 @@ impl Backend for Builder<'a, 'll, 'tcx>  {
     type Value = &'ll Value;
     type BasicBlock = &'ll BasicBlock;
     type Type = &'ll Type;
-    type TypeKind = llvm::TypeKind;
     type Context = &'ll llvm::Context;
 }
 
@@ -1146,7 +1145,7 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         let stored_ty = self.cx.val_ty(val);
         let stored_ptr_ty = self.cx.type_ptr_to(stored_ty);
 
-        assert_eq!(self.cx.type_kind(dest_ptr_ty), llvm::TypeKind::Pointer);
+        assert_eq!(self.cx.type_kind(dest_ptr_ty), TypeKind::Pointer);
 
         if dest_ptr_ty == stored_ptr_ty {
             ptr
@@ -1165,11 +1164,11 @@ impl BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
                       args: &'b [&'ll Value]) -> Cow<'b, [&'ll Value]> {
         let mut fn_ty = self.cx.val_ty(llfn);
         // Strip off pointers
-        while self.cx.type_kind(fn_ty) == llvm::TypeKind::Pointer {
+        while self.cx.type_kind(fn_ty) == TypeKind::Pointer {
             fn_ty = self.cx.element_type(fn_ty);
         }
 
-        assert!(self.cx.type_kind(fn_ty) == llvm::TypeKind::Function,
+        assert!(self.cx.type_kind(fn_ty) == TypeKind::Function,
                 "builder::{} not passed a function, but {:?}", typ, fn_ty);
 
         let param_tys = self.cx.func_params_types(fn_ty);

src/librustc_codegen_llvm/common.rs

@@ -12,8 +12,7 @@
 
 //! Code that is useful in various codegen modules.
 
-use llvm::{self, TypeKind};
-use llvm::{True, False, Bool, BasicBlock};
+use llvm::{self, True, False, Bool, BasicBlock};
 use rustc::hir::def_id::DefId;
 use rustc::middle::lang_items::LangItem;
 use abi;
@@ -131,6 +130,27 @@ pub enum SynchronizationScope {
     CrossThread,
 }
 
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum TypeKind {
+    Void,
+    Half,
+    Float,
+    Double,
+    X86_FP80,
+    FP128,
+    PPc_FP128,
+    Label,
+    Integer,
+    Function,
+    Struct,
+    Array,
+    Pointer,
+    Vector,
+    Metadata,
+    X86_MMX,
+    Token,
+}
+
 /*
 * A note on nomenclature of linking: "extern", "foreign", and "upcall".
 *
@@ -197,7 +217,6 @@ impl Backend for CodegenCx<'ll, 'tcx> {
     type Value = &'ll Value;
     type BasicBlock = &'ll BasicBlock;
     type Type = &'ll Type;
-    type TypeKind = llvm::TypeKind;
     type Context = &'ll llvm::Context;
 }
 

src/librustc_codegen_llvm/interfaces/backend.rs

@@ -11,9 +11,8 @@
 use std::fmt::Debug;
 
 pub trait Backend {
-    type Value: Debug + PartialEq;
+    type Value: Debug + PartialEq + Copy;
     type BasicBlock;
-    type Type: Debug + PartialEq;
-    type TypeKind;
+    type Type: Debug + PartialEq + Copy;
     type Context;
 }

src/librustc_codegen_llvm/interfaces/builder.rs

@@ -23,13 +23,11 @@ use std::ops::Range;
 use syntax::ast::AsmDialect;
 
 
-
 pub trait BuilderMethods<'a, 'tcx: 'a>: Backend {
-    type CodegenCx: TypeMethods + ConstMethods + Backend<
+    type CodegenCx: 'a + TypeMethods + ConstMethods + Backend<
         Value = Self::Value,
         BasicBlock = Self::BasicBlock,
         Type = Self::Type,
-        TypeKind = Self::TypeKind,
         Context = Self::Context,
     >;
 

src/librustc_codegen_llvm/interfaces/type_.rs

@@ -9,6 +9,7 @@
 // except according to those terms.
 
 use super::backend::Backend;
+use common::TypeKind;
 
 pub trait TypeMethods: Backend {
     fn type_void(&self) -> Self::Type;
@@ -30,7 +31,7 @@ pub trait TypeMethods: Backend {
     fn type_named_struct(&self, name: &str) -> Self::Type;
     fn type_array(&self, ty: Self::Type, len: u64) -> Self::Type;
     fn type_vector(&self, ty: Self::Type, len: u64) -> Self::Type;
-    fn type_kind(&self, ty: Self::Type) -> Self::TypeKind;
+    fn type_kind(&self, ty: Self::Type) -> TypeKind;
     fn set_struct_body(&self, ty: Self::Type, els: &[Self::Type], packed: bool);
     fn type_ptr_to(&self, ty: Self::Type) -> Self::Type;
     fn element_type(&self, ty: Self::Type) -> Self::Type;

src/librustc_codegen_llvm/intrinsic.rs

@@ -12,7 +12,7 @@
 
 use attributes;
 use intrinsics::{self, Intrinsic};
-use llvm::{self, TypeKind};
+use llvm;
 use llvm_util;
 use abi::{Abi, FnType, LlvmType, PassMode};
 use mir::place::PlaceRef;

src/librustc_codegen_llvm/llvm/ffi.rs

@@ -228,6 +228,30 @@ pub enum TypeKind {
     Token = 16,
 }
 
+impl TypeKind {
+    pub fn to_generic(self) -> common::TypeKind {
+        match self {
+            TypeKind::Void => common::TypeKind::Void,
+            TypeKind::Half => common::TypeKind::Half,
+            TypeKind::Float => common::TypeKind::Float,
+            TypeKind::Double => common::TypeKind::Double,
+            TypeKind::X86_FP80 => common::TypeKind::X86_FP80,
+            TypeKind::FP128 => common::TypeKind::FP128,
+            TypeKind::PPc_FP128 => common::TypeKind::PPc_FP128,
+            TypeKind::Label => common::TypeKind::Label,
+            TypeKind::Integer => common::TypeKind::Integer,
+            TypeKind::Function => common::TypeKind::Function,
+            TypeKind::Struct => common::TypeKind::Struct,
+            TypeKind::Array => common::TypeKind::Array,
+            TypeKind::Pointer => common::TypeKind::Pointer,
+            TypeKind::Vector => common::TypeKind::Vector,
+            TypeKind::Metadata => common::TypeKind::Metadata,
+            TypeKind::X86_MMX => common::TypeKind::X86_MMX,
+            TypeKind::Token => common::TypeKind::Token,
+        }
+    }
+}
+
 /// LLVMAtomicRmwBinOp
 #[derive(Copy, Clone)]
 #[repr(C)]

src/librustc_codegen_llvm/type_.rs

@@ -13,16 +13,16 @@
 pub use llvm::Type;
 
 use llvm;
-use llvm::{Bool, False, True, TypeKind};
-
+use llvm::{Bool, False, True};
 use context::CodegenCx;
 use interfaces::TypeMethods;
 use value::Value;
 
+
 use syntax::ast;
 use rustc::ty::layout::{self, Align, Size};
 use rustc_data_structures::small_c_str::SmallCStr;
-use common;
+use common::{self, TypeKind};
 
 use std::fmt;
 
@@ -175,7 +175,7 @@ impl TypeMethods for CodegenCx<'ll, 'tcx> {
 
     fn type_kind(&self, ty: &'ll Type) -> TypeKind {
         unsafe {
-            llvm::LLVMRustGetTypeKind(ty)
+            llvm::LLVMRustGetTypeKind(ty).to_generic()
         }
     }