Generalized some base.rs methods

Author: denismerigoux

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};
@@ -55,7 +55,7 @@ use builder::{Builder, MemFlags};
 use callee;
 use rustc_mir::monomorphize::collector::{self, MonoItemCollectionMode};
 use rustc_mir::monomorphize::item::DefPathBasedNames;
-use common::{self, IntPredicate, RealPredicate};
+use common::{self, IntPredicate, RealPredicate, TypeKind};
 use consts;
 use context::CodegenCx;
 use debuginfo;
@@ -67,7 +67,6 @@ use monomorphize::partitioning::{self, PartitioningStrategy, CodegenUnit, Codege
 use rustc_codegen_utils::symbol_names_test;
 use time_graph;
 use mono_item::{MonoItem, BaseMonoItemExt, MonoItemExt};
-use type_::Type;
 use type_of::LayoutLlvmExt;
 use rustc::util::nodemap::{FxHashMap, DefIdSet};
 use CrateInfo;
@@ -334,21 +333,31 @@ pub fn coerce_unsized_into(
     }
 }
 
-pub fn cast_shift_expr_rhs(
-    bx: &Builder<'_, 'll, '_, &'ll Value>, op: hir::BinOpKind, lhs: &'ll Value, rhs: &'ll Value
-) -> &'ll Value {
+pub fn cast_shift_expr_rhs<'a, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+    bx: &Builder,
+    op: hir::BinOpKind,
+    lhs: <Builder::CodegenCx as Backend>::Value,
+    rhs: <Builder::CodegenCx as Backend>::Value
+) -> <Builder::CodegenCx as Backend>::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, '_, &'ll Value>,
-                             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, 'll :'a, 'tcx : 'll, F, G, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+    bx: &Builder,
+    op: hir::BinOpKind,
+    lhs: <Builder::CodegenCx as Backend>::Value,
+    rhs: <Builder::CodegenCx as Backend>::Value,
+    trunc: F,
+    zext: G
+) -> <Builder::CodegenCx as Backend>::Value
+    where F: FnOnce(
+        <Builder::CodegenCx as Backend>::Value,
+        <Builder::CodegenCx as Backend>::Type
+    ) -> <Builder::CodegenCx as Backend>::Value,
+    G: FnOnce(
+        <Builder::CodegenCx as Backend>::Value,
+        <Builder::CodegenCx as Backend>::Type
+    ) -> <Builder::CodegenCx as Backend>::Value
 {
     // Shifts may have any size int on the rhs
     if op.is_shift() {
@@ -390,33 +399,33 @@ pub fn call_assume(bx: &Builder<'_, 'll, '_, &'ll Value>, 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, 'll: 'a, 'tcx: 'll, Builder : BuilderMethods<'a, 'll ,'tcx>>(
+    bx: &Builder,
+    val: <Builder::CodegenCx as Backend>::Value
+) -> <Builder::CodegenCx as Backend>::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, '_, &'ll Value>,
-    val: &'ll Value,
+pub fn to_immediate<'a, 'll, 'tcx, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+    bx: &Builder,
+    val: <Builder::CodegenCx as Backend>::Value,
     layout: layout::TyLayout,
-) -> &'ll Value {
+) -> <Builder::CodegenCx as Backend>::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, '_, &'ll Value>,
-    val: &'ll Value,
+pub fn to_immediate_scalar<'a, 'll, 'tcx, Builder : BuilderMethods<'a, 'll, 'tcx>>(
+    bx: &Builder,
+    val: <Builder::CodegenCx as Backend>::Value,
     scalar: &layout::Scalar,
-) -> &'ll Value {
+) -> <Builder::CodegenCx as Backend>::Value {
     if scalar.is_bool() {
         return bx.trunc(val, bx.cx().type_i1());
     }

src/librustc_codegen_llvm/builder.rs

@@ -19,7 +19,7 @@ use rustc::ty::TyCtxt;
 use rustc::ty::layout::{Align, Size};
 use rustc::session::{config, Session};
 use rustc_data_structures::small_c_str::SmallCStr;
-use interfaces::{BuilderMethods, Backend, ConstMethods, TypeMethods};
+use interfaces::{BuilderMethods, ConstMethods, TypeMethods};
 use syntax;
 
 use std::borrow::Cow;
@@ -56,14 +56,6 @@ bitflags! {
     }
 }
 
-impl Backend for Builder<'a, 'll, 'tcx, &'ll Value>  {
-        type Value = &'ll Value;
-        type BasicBlock = &'ll BasicBlock;
-        type Type = &'ll Type;
-        type TypeKind = llvm::TypeKind;
-        type Context = &'ll llvm::Context;
-}
-
 impl BuilderMethods<'a, 'll, 'tcx>
     for Builder<'a, 'll, 'tcx, &'ll Value> {
 
@@ -1180,7 +1172,7 @@ impl BuilderMethods<'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
@@ -1199,11 +1191,11 @@ impl BuilderMethods<'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;
@@ -133,6 +132,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".
 *
@@ -199,7 +219,6 @@ impl Backend for CodegenCx<'ll, 'tcx, &'ll Value> {
     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;
 }