Added StaticMethods trait

Author: denismerigoux

src/librustc_codegen_llvm/consts.rs

@@ -13,9 +13,11 @@ mod backend;
 mod consts;
 mod type_;
 mod intrinsic;
+mod statics;
 
 pub use self::builder::BuilderMethods;
 pub use self::backend::Backend;
 pub use self::consts::ConstMethods;
 pub use self::type_::{TypeMethods, BaseTypeMethods, DerivedTypeMethods};
 pub use self::intrinsic::{IntrinsicMethods, BaseIntrinsicMethods, DerivedIntrinsicMethods};
+pub use self::statics::StaticMethods;

src/librustc_codegen_llvm/interfaces/mod.rs

@@ -0,0 +1,36 @@
+// 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::layout::Align;
+use rustc::hir::def_id::DefId;
+use super::backend::Backend;
+
+pub trait StaticMethods<'tcx> : Backend {
+    fn static_ptrcast(&self, val: Self::Value, ty: Self::Type) -> Self::Value;
+    fn static_bitcast(&self, val: Self::Value, ty: Self::Type) -> Self::Value;
+    fn static_addr_of_mut(
+        &self,
+        cv: Self::Value,
+        align: Align,
+        kind: Option<&str>,
+    ) -> Self::Value;
+    fn static_addr_of(
+        &self,
+        cv: Self::Value,
+        align: Align,
+        kind: Option<&str>,
+    ) -> Self::Value;
+    fn get_static(&self, def_id: DefId) -> Self::Value;
+    fn codegen_static(
+        &self,
+        def_id: DefId,
+        is_mutable: bool,
+    );
+}

src/librustc_codegen_llvm/interfaces/statics.rs

@@ -31,7 +31,7 @@ use syntax::symbol::Symbol;
 use builder::Builder;
 use value::Value;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods};
+use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods, StaticMethods};
 
 use rustc::session::Session;
 use syntax_pos::Span;
@@ -845,7 +845,7 @@ fn codegen_msvc_try(
 
         let tcx = cx.tcx;
         let tydesc = match tcx.lang_items().msvc_try_filter() {
-            Some(did) => ::consts::get_static(cx, did),
+            Some(did) => cx.get_static(did),
             None => bug!("msvc_try_filter not defined"),
         };
         let tok = catchpad.catch_pad(cs, &[tydesc, cx.const_i32(0), slot]);

src/librustc_codegen_llvm/intrinsic.rs

@@ -12,11 +12,10 @@ use abi::{FnType, FnTypeExt};
 use callee;
 use context::CodegenCx;
 use builder::Builder;
-use consts;
 use monomorphize;
 use value::Value;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods};
+use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, StaticMethods};
 
 use rustc::ty::{self, Ty};
 use rustc::ty::layout::HasDataLayout;
@@ -120,7 +119,7 @@ pub fn get_vtable(
 
     let vtable_const = cx.const_struct(&components, false);
     let align = cx.data_layout().pointer_align;
-    let vtable = consts::addr_of(cx, vtable_const, align, Some("vtable"));
+    let vtable = cx.static_addr_of(vtable_const, align, Some("vtable"));
 
     debuginfo::create_vtable_metadata(cx, ty, vtable);
 

src/librustc_codegen_llvm/meth.rs

@@ -19,14 +19,13 @@ use base;
 use callee;
 use builder::{Builder, MemFlags};
 use common::{self, IntPredicate};
-use consts;
 use meth;
 use monomorphize;
 use type_of::LayoutLlvmExt;
 use type_::Type;
 use value::Value;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods};
+use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods, StaticMethods};
 
 use syntax::symbol::Symbol;
 use syntax_pos::Pos;
@@ -378,10 +377,11 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                         let index = self.codegen_operand(&mut bx, index).immediate();
 
                         let file_line_col = bx.cx().const_struct(&[filename, line, col], false);
-                        let file_line_col = consts::addr_of(bx.cx(),
-                                                            file_line_col,
-                                                            align,
-                                                            Some("panic_bounds_check_loc"));
+                        let file_line_col = bx.cx().static_addr_of(
+                            file_line_col,
+                            align,
+                            Some("panic_bounds_check_loc")
+                        );
                         (lang_items::PanicBoundsCheckFnLangItem,
                          vec![file_line_col, index, len])
                     }
@@ -393,10 +393,11 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
                             &[msg_str, filename, line, col],
                             false
                         );
-                        let msg_file_line_col = consts::addr_of(bx.cx(),
-                                                                msg_file_line_col,
-                                                                align,
-                                                                Some("panic_loc"));
+                        let msg_file_line_col = bx.cx().static_addr_of(
+                            msg_file_line_col,
+                            align,
+                            Some("panic_loc")
+                        );
                         (lang_items::PanicFnLangItem,
                          vec![msg_file_line_col])
                     }

src/librustc_codegen_llvm/mir/block.rs

@@ -19,13 +19,12 @@ use rustc::ty::{self, Ty};
 use rustc::ty::layout::{self, HasDataLayout, LayoutOf, Size};
 use builder::Builder;
 use common::{CodegenCx};
-use consts;
 use type_of::LayoutLlvmExt;
 use type_::Type;
 use syntax::ast::Mutability;
 use syntax::source_map::Span;
 use value::Value;
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods};
+use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, StaticMethods};
 
 use super::super::callee;
 use super::FunctionCx;
@@ -48,7 +47,7 @@ pub fn scalar_to_llvm(
             if layout.value == layout::Pointer {
                 unsafe { llvm::LLVMConstIntToPtr(llval, llty) }
             } else {
-                consts::bitcast(llval, llty)
+                cx.static_bitcast(llval, llty)
             }
         },
         Scalar::Ptr(ptr) => {
@@ -57,29 +56,29 @@ pub fn scalar_to_llvm(
                 Some(AllocType::Memory(alloc)) => {
                     let init = const_alloc_to_llvm(cx, alloc);
                     if alloc.mutability == Mutability::Mutable {
-                        consts::addr_of_mut(cx, init, alloc.align, None)
+                        cx.static_addr_of_mut(init, alloc.align, None)
                     } else {
-                        consts::addr_of(cx, init, alloc.align, None)
+                        cx.static_addr_of(init, alloc.align, None)
                     }
                 }
                 Some(AllocType::Function(fn_instance)) => {
                     callee::get_fn(cx, fn_instance)
                 }
                 Some(AllocType::Static(def_id)) => {
                     assert!(cx.tcx.is_static(def_id).is_some());
-                    consts::get_static(cx, def_id)
+                    cx.get_static(def_id)
                 }
                 None => bug!("missing allocation {:?}", ptr.alloc_id),
             };
             let llval = unsafe { llvm::LLVMConstInBoundsGEP(
-                consts::bitcast(base_addr, cx.type_i8p()),
+                cx.static_bitcast(base_addr, cx.type_i8p()),
                 &cx.const_usize(ptr.offset.bytes()),
                 1,
             ) };
             if layout.value != layout::Pointer {
                 unsafe { llvm::LLVMConstPtrToInt(llval, llty) }
             } else {
-                consts::bitcast(llval, llty)
+                cx.static_bitcast(llval, llty)
             }
         }
     }

src/librustc_codegen_llvm/mir/constant.rs

@@ -16,13 +16,12 @@ use rustc::mir::tcx::PlaceTy;
 use base;
 use builder::Builder;
 use common::{CodegenCx, IntPredicate};
-use consts;
 use type_of::LayoutLlvmExt;
 use value::Value;
 use glue;
 use mir::constant::const_alloc_to_llvm;
 
-use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods};
+use interfaces::{BuilderMethods, ConstMethods, BaseTypeMethods, DerivedTypeMethods, DerivedIntrinsicMethods, StaticMethods};
 
 use super::{FunctionCx, LocalRef};
 use super::operand::{OperandRef, OperandValue};
@@ -64,14 +63,14 @@ impl PlaceRef<'tcx, &'ll Value> {
         offset: Size,
     ) -> PlaceRef<'tcx, &'ll Value> {
         let init = const_alloc_to_llvm(bx.cx(), alloc);
-        let base_addr = consts::addr_of(bx.cx(), init, layout.align, None);
+        let base_addr = bx.cx().static_addr_of(init, layout.align, None);
 
         let llval = unsafe { LLVMConstInBoundsGEP(
-            consts::bitcast(base_addr, bx.cx().type_i8p()),
+            bx.cx().static_bitcast(base_addr, bx.cx().type_i8p()),
             &bx.cx().const_usize(offset.bytes()),
             1,
         )};
-        let llval = consts::bitcast(llval, bx.cx().type_ptr_to(layout.llvm_type(bx.cx())));
+        let llval = bx.cx().static_bitcast(llval, bx.cx().type_ptr_to(layout.llvm_type(bx.cx())));
         PlaceRef::new_sized(llval, layout, alloc.align)
     }
 
@@ -492,7 +491,7 @@ impl FunctionCx<'a, 'll, 'tcx, &'ll Value> {
             }
             mir::Place::Static(box mir::Static { def_id, ty }) => {
                 let layout = cx.layout_of(self.monomorphize(&ty));
-                PlaceRef::new_sized(consts::get_static(cx, def_id), layout, layout.align)
+                PlaceRef::new_sized(cx.get_static(def_id), layout, layout.align)
             },
             mir::Place::Projection(box mir::Projection {
                 ref base,

src/librustc_codegen_llvm/mir/place.rs

@@ -20,7 +20,6 @@ use base;
 use builder::Builder;
 use callee;
 use common::{self, IntPredicate, RealPredicate};
-use consts;
 use monomorphize;
 use type_::Type;
 use type_of::LayoutLlvmExt;
@@ -841,7 +840,7 @@ fn cast_int_to_float(bx: &Builder<'_, 'll, '_, &'ll Value>,
         let max = bx.cx().const_uint_big(int_ty, MAX_F32_PLUS_HALF_ULP);
         let overflow = bx.icmp(IntPredicate::IntUGE, x, max);
         let infinity_bits = bx.cx().const_u32(ieee::Single::INFINITY.to_bits() as u32);
-        let infinity = consts::bitcast(infinity_bits, float_ty);
+        let infinity = bx.bitcast(infinity_bits, float_ty);
         bx.select(overflow, infinity, bx.uitofp(x, float_ty))
     } else {
         if signed {
@@ -922,7 +921,7 @@ fn cast_float_to_int(bx: &Builder<'_, 'll, '_, &'ll Value>,
             64 => bx.cx().const_u64(bits as u64),
             n => bug!("unsupported float width {}", n),
         };
-        consts::bitcast(bits_llval, float_ty)
+        bx.bitcast(bits_llval, float_ty)
     };
     let (f_min, f_max) = match bx.cx().float_width(float_ty) {
         32 => compute_clamp_bounds_single(signed, int_ty),

src/librustc_codegen_llvm/mir/rvalue.rs

@@ -17,7 +17,6 @@
 use asm;
 use attributes;
 use base;
-use consts;
 use context::CodegenCx;
 use declare;
 use llvm;
@@ -31,6 +30,7 @@ use rustc::ty::TypeFoldable;
 use rustc::ty::layout::LayoutOf;
 use std::fmt;
 use value::Value;
+use interfaces::StaticMethods;
 
 pub use rustc::mir::mono::MonoItem;
 
@@ -55,7 +55,7 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug + BaseMonoItemExt<'a, 'tcx> {
                         bug!("Expected Def::Static for {:?}, found nothing", def_id)
                     }
                 };
-                consts::codegen_static(&cx, def_id, is_mutable);
+                cx.codegen_static(def_id, is_mutable);
             }
             MonoItem::GlobalAsm(node_id) => {
                 let item = cx.tcx.hir.expect_item(node_id);