src/librustc_trans/trans/common.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![allow(non_camel_case_types, non_snake_case)]
  12
  13 //! Code that is useful in various trans modules.
  14
  15 pub use self::ExprOrMethodCall::*;
  16
  17 use session::Session;
  18 use llvm;
  19 use llvm::{ValueRef, BasicBlockRef, BuilderRef, ContextRef, TypeKind};
  20 use llvm::{True, False, Bool, OperandBundleDef};
  21 use middle::cfg;
  22 use middle::def::Def;
  23 use middle::def_id::DefId;
  24 use middle::infer;
  25 use middle::lang_items::LangItem;
  26 use middle::subst::{self, Substs};
  27 use trans::base;
  28 use trans::build;
  29 use trans::callee;
  30 use trans::cleanup;
  31 use trans::consts;
  32 use trans::datum;
  33 use trans::debuginfo::{self, DebugLoc};
  34 use trans::declare;
  35 use trans::machine;
  36 use trans::monomorphize;
  37 use trans::type_::Type;
  38 use trans::type_of;
  39 use middle::traits;
  40 use middle::ty::{self, Ty};
  41 use middle::ty::fold::{TypeFolder, TypeFoldable};
  42 use rustc_front::hir;
  43 use rustc::mir::repr::Mir;
  44 use util::nodemap::{FnvHashMap, NodeMap};
  45
  46 use arena::TypedArena;
  47 use libc::{c_uint, c_char};
  48 use std::ffi::CString;
  49 use std::cell::{Cell, RefCell};
  50 use std::vec::Vec;
  51 use syntax::ast;
  52 use syntax::codemap::{DUMMY_SP, Span};
  53 use syntax::parse::token::InternedString;
  54 use syntax::parse::token;
  55
  56 pub use trans::context::CrateContext;
  57
  58 /// Is the type's representation size known at compile time?
  59 pub fn type_is_sized<'tcx>(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
  60     ty.is_sized(&tcx.empty_parameter_environment(), DUMMY_SP)
  61 }
  62
  63 pub fn type_is_fat_ptr<'tcx>(cx: &ty::ctxt<'tcx>, ty: Ty<'tcx>) -> bool {
  64     match ty.sty {
  65         ty::TyRawPtr(ty::TypeAndMut{ty, ..}) |
  66         ty::TyRef(_, ty::TypeAndMut{ty, ..}) |
  67         ty::TyBox(ty) => {
  68             !type_is_sized(cx, ty)
  69         }
  70         _ => {
  71             false
  72         }
  73     }
  74 }
  75
  76 fn type_is_newtype_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
  77     match ty.sty {
  78         ty::TyStruct(def, substs) => {
  79             let fields = &def.struct_variant().fields;
  80             fields.len() == 1 && {
  81                 type_is_immediate(ccx, monomorphize::field_ty(ccx.tcx(), substs, &fields[0]))
  82             }
  83         }
  84         _ => false
  85     }
  86 }
  87
  88 pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
  89     use trans::machine::llsize_of_alloc;
  90     use trans::type_of::sizing_type_of;
  91
  92     let tcx = ccx.tcx();
  93     let simple = ty.is_scalar() ||
  94         ty.is_unique() || ty.is_region_ptr() ||
  95         type_is_newtype_immediate(ccx, ty) ||
  96         ty.is_simd();
  97     if simple && !type_is_fat_ptr(tcx, ty) {
  98         return true;
  99     }
 100     if !type_is_sized(tcx, ty) {
 101         return false;
 102     }
 103     match ty.sty {
 104         ty::TyStruct(..) | ty::TyEnum(..) | ty::TyTuple(..) | ty::TyArray(_, _) |
 105         ty::TyClosure(..) => {
 106             let llty = sizing_type_of(ccx, ty);
 107             llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type())
 108         }
 109         _ => type_is_zero_size(ccx, ty)
 110     }
 111 }
 112
 113 /// Identify types which have size zero at runtime.
 114 pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
 115     use trans::machine::llsize_of_alloc;
 116     use trans::type_of::sizing_type_of;
 117     let llty = sizing_type_of(ccx, ty);
 118     llsize_of_alloc(ccx, llty) == 0
 119 }
 120
 121 /// Identifies types which we declare to be equivalent to `void` in C for the purpose of function
 122 /// return types. These are `()`, bot, uninhabited enums and all other zero-sized types.
 123 pub fn return_type_is_void<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
 124     ty.is_nil() || ty.is_empty(ccx.tcx()) || type_is_zero_size(ccx, ty)
 125 }
 126
 127 /// Generates a unique symbol based off the name given. This is used to create
 128 /// unique symbols for things like closures.
 129 pub fn gensym_name(name: &str) -> ast::Name {
 130     let num = token::gensym(name).0;
 131     // use one colon which will get translated to a period by the mangler, and
 132     // we're guaranteed that `num` is globally unique for this crate.
 133     token::gensym(&format!("{}:{}", name, num))
 134 }
 135
 136 /*
 137 * A note on nomenclature of linking: "extern", "foreign", and "upcall".
 138 *
 139 * An "extern" is an LLVM symbol we wind up emitting an undefined external
 140 * reference to. This means "we don't have the thing in this compilation unit,
 141 * please make sure you link it in at runtime". This could be a reference to
 142 * C code found in a C library, or rust code found in a rust crate.
 143 *
 144 * Most "externs" are implicitly declared (automatically) as a result of a
 145 * user declaring an extern _module_ dependency; this causes the rust driver
 146 * to locate an extern crate, scan its compilation metadata, and emit extern
 147 * declarations for any symbols used by the declaring crate.
 148 *
 149 * A "foreign" is an extern that references C (or other non-rust ABI) code.
 150 * There is no metadata to scan for extern references so in these cases either
 151 * a header-digester like bindgen, or manual function prototypes, have to
 152 * serve as declarators. So these are usually given explicitly as prototype
 153 * declarations, in rust code, with ABI attributes on them noting which ABI to
 154 * link via.
 155 *
 156 * An "upcall" is a foreign call generated by the compiler (not corresponding
 157 * to any user-written call in the code) into the runtime library, to perform
 158 * some helper task such as bringing a task to life, allocating memory, etc.
 159 *
 160 */
 161
 162 use trans::Disr;
 163
 164 #[derive(Copy, Clone)]
 165 pub struct NodeIdAndSpan {
 166     pub id: ast::NodeId,
 167     pub span: Span,
 168 }
 169
 170 pub fn expr_info(expr: &hir::Expr) -> NodeIdAndSpan {
 171     NodeIdAndSpan { id: expr.id, span: expr.span }
 172 }
 173
 174 /// The concrete version of ty::FieldDef. The name is the field index if
 175 /// the field is numeric.
 176 pub struct Field<'tcx>(pub ast::Name, pub Ty<'tcx>);
 177
 178 /// The concrete version of ty::VariantDef
 179 pub struct VariantInfo<'tcx> {
 180     pub discr: Disr,
 181     pub fields: Vec<Field<'tcx>>
 182 }
 183
 184 impl<'tcx> VariantInfo<'tcx> {
 185     pub fn from_ty(tcx: &ty::ctxt<'tcx>,
 186                    ty: Ty<'tcx>,
 187                    opt_def: Option<Def>)
 188                    -> Self
 189     {
 190         match ty.sty {
 191             ty::TyStruct(adt, substs) | ty::TyEnum(adt, substs) => {
 192                 let variant = match opt_def {
 193                     None => adt.struct_variant(),
 194                     Some(def) => adt.variant_of_def(def)
 195                 };
 196
 197                 VariantInfo {
 198                     discr: Disr::from(variant.disr_val),
 199                     fields: variant.fields.iter().map(|f| {
 200                         Field(f.name, monomorphize::field_ty(tcx, substs, f))
 201                     }).collect()
 202                 }
 203             }
 204
 205             ty::TyTuple(ref v) => {
 206                 VariantInfo {
 207                     discr: Disr(0),
 208                     fields: v.iter().enumerate().map(|(i, &t)| {
 209                         Field(token::intern(&i.to_string()), t)
 210                     }).collect()
 211                 }
 212             }
 213
 214             _ => {
 215                 tcx.sess.bug(&format!(
 216                     "cannot get field types from the type {:?}",
 217                     ty));
 218             }
 219         }
 220     }
 221
 222     /// Return the variant corresponding to a given node (e.g. expr)
 223     pub fn of_node(tcx: &ty::ctxt<'tcx>, ty: Ty<'tcx>, id: ast::NodeId) -> Self {
 224         let node_def = tcx.def_map.borrow().get(&id).map(|v| v.full_def());
 225         Self::from_ty(tcx, ty, node_def)
 226     }
 227
 228     pub fn field_index(&self, name: ast::Name) -> usize {
 229         self.fields.iter().position(|&Field(n,_)| n == name).unwrap_or_else(|| {
 230             panic!("unknown field `{}`", name)
 231         })
 232     }
 233 }
 234
 235 pub struct BuilderRef_res {
 236     pub b: BuilderRef,
 237 }
 238
 239 impl Drop for BuilderRef_res {
 240     fn drop(&mut self) {
 241         unsafe {
 242             llvm::LLVMDisposeBuilder(self.b);
 243         }
 244     }
 245 }
 246
 247 pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res {
 248     BuilderRef_res {
 249         b: b
 250     }
 251 }
 252
 253 pub type ExternMap = FnvHashMap<String, ValueRef>;
 254
 255 pub fn validate_substs(substs: &Substs) {
 256     assert!(!substs.types.needs_infer());
 257 }
 258
 259 // work around bizarre resolve errors
 260 type RvalueDatum<'tcx> = datum::Datum<'tcx, datum::Rvalue>;
 261 pub type LvalueDatum<'tcx> = datum::Datum<'tcx, datum::Lvalue>;
 262
 263 #[derive(Clone, Debug)]
 264 struct HintEntry<'tcx> {
 265     // The datum for the dropflag-hint itself; note that many
 266     // source-level Lvalues will be associated with the same
 267     // dropflag-hint datum.
 268     datum: cleanup::DropHintDatum<'tcx>,
 269 }
 270
 271 pub struct DropFlagHintsMap<'tcx> {
 272     // Maps NodeId for expressions that read/write unfragmented state
 273     // to that state's drop-flag "hint."  (A stack-local hint
 274     // indicates either that (1.) it is certain that no-drop is
 275     // needed, or (2.)  inline drop-flag must be consulted.)
 276     node_map: NodeMap<HintEntry<'tcx>>,
 277 }
 278
 279 impl<'tcx> DropFlagHintsMap<'tcx> {
 280     pub fn new() -> DropFlagHintsMap<'tcx> { DropFlagHintsMap { node_map: NodeMap() } }
 281     pub fn has_hint(&self, id: ast::NodeId) -> bool { self.node_map.contains_key(&id) }
 282     pub fn insert(&mut self, id: ast::NodeId, datum: cleanup::DropHintDatum<'tcx>) {
 283         self.node_map.insert(id, HintEntry { datum: datum });
 284     }
 285     pub fn hint_datum(&self, id: ast::NodeId) -> Option<cleanup::DropHintDatum<'tcx>> {
 286         self.node_map.get(&id).map(|t|t.datum)
 287     }
 288 }
 289
 290 // Function context.  Every LLVM function we create will have one of
 291 // these.
 292 pub struct FunctionContext<'a, 'tcx: 'a> {
 293     // The MIR for this function. At present, this is optional because
 294     // we only have MIR available for things that are local to the
 295     // crate.
 296     pub mir: Option<&'a Mir<'tcx>>,
 297
 298     // The ValueRef returned from a call to llvm::LLVMAddFunction; the
 299     // address of the first instruction in the sequence of
 300     // instructions for this function that will go in the .text
 301     // section of the executable we're generating.
 302     pub llfn: ValueRef,
 303
 304     // always an empty parameter-environment NOTE: @jroesch another use of ParamEnv
 305     pub param_env: ty::ParameterEnvironment<'a, 'tcx>,
 306
 307     // The environment argument in a closure.
 308     pub llenv: Option<ValueRef>,
 309
 310     // A pointer to where to store the return value. If the return type is
 311     // immediate, this points to an alloca in the function. Otherwise, it's a
 312     // pointer to the hidden first parameter of the function. After function
 313     // construction, this should always be Some.
 314     pub llretslotptr: Cell<Option<ValueRef>>,
 315
 316     // These pub elements: "hoisted basic blocks" containing
 317     // administrative activities that have to happen in only one place in
 318     // the function, due to LLVM's quirks.
 319     // A marker for the place where we want to insert the function's static
 320     // allocas, so that LLVM will coalesce them into a single alloca call.
 321     pub alloca_insert_pt: Cell<Option<ValueRef>>,
 322     pub llreturn: Cell<Option<BasicBlockRef>>,
 323
 324     // If the function has any nested return's, including something like:
 325     // fn foo() -> Option<Foo> { Some(Foo { x: return None }) }, then
 326     // we use a separate alloca for each return
 327     pub needs_ret_allocas: bool,
 328
 329     // When working with landingpad-based exceptions this value is alloca'd and
 330     // later loaded when using the resume instruction. This ends up being
 331     // critical to chaining landing pads and resuing already-translated
 332     // cleanups.
 333     //
 334     // Note that for cleanuppad-based exceptions this is not used.
 335     pub landingpad_alloca: Cell<Option<ValueRef>>,
 336
 337     // True if the caller expects this fn to use the out pointer to
 338     // return. Either way, your code should write into the slot llretslotptr
 339     // points to, but if this value is false, that slot will be a local alloca.
 340     pub caller_expects_out_pointer: bool,
 341
 342     // Maps the DefId's for local variables to the allocas created for
 343     // them in llallocas.
 344     pub lllocals: RefCell<NodeMap<LvalueDatum<'tcx>>>,
 345
 346     // Same as above, but for closure upvars
 347     pub llupvars: RefCell<NodeMap<ValueRef>>,
 348
 349     // Carries info about drop-flags for local bindings (longer term,
 350     // paths) for the code being compiled.
 351     pub lldropflag_hints: RefCell<DropFlagHintsMap<'tcx>>,
 352
 353     // The NodeId of the function, or -1 if it doesn't correspond to
 354     // a user-defined function.
 355     pub id: ast::NodeId,
 356
 357     // If this function is being monomorphized, this contains the type
 358     // substitutions used.
 359     pub param_substs: &'tcx Substs<'tcx>,
 360
 361     // The source span and nesting context where this function comes from, for
 362     // error reporting and symbol generation.
 363     pub span: Option<Span>,
 364
 365     // The arena that blocks are allocated from.
 366     pub block_arena: &'a TypedArena<BlockS<'a, 'tcx>>,
 367
 368     // This function's enclosing crate context.
 369     pub ccx: &'a CrateContext<'a, 'tcx>,
 370
 371     // Used and maintained by the debuginfo module.
 372     pub debug_context: debuginfo::FunctionDebugContext,
 373
 374     // Cleanup scopes.
 375     pub scopes: RefCell<Vec<cleanup::CleanupScope<'a, 'tcx>>>,
 376
 377     pub cfg: Option<cfg::CFG>,
 378 }
 379
 380 impl<'a, 'tcx> FunctionContext<'a, 'tcx> {
 381     pub fn mir(&self) -> &'a Mir<'tcx> {
 382         self.mir.unwrap()
 383     }
 384
 385     pub fn arg_offset(&self) -> usize {
 386         self.env_arg_pos() + if self.llenv.is_some() { 1 } else { 0 }
 387     }
 388
 389     pub fn env_arg_pos(&self) -> usize {
 390         if self.caller_expects_out_pointer {
 391             1
 392         } else {
 393             0
 394         }
 395     }
 396
 397     pub fn cleanup(&self) {
 398         unsafe {
 399             llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt
 400                                                      .get()
 401                                                      .unwrap());
 402         }
 403     }
 404
 405     pub fn get_llreturn(&self) -> BasicBlockRef {
 406         if self.llreturn.get().is_none() {
 407
 408             self.llreturn.set(Some(unsafe {
 409                 llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(), self.llfn,
 410                                                     "return\0".as_ptr() as *const _)
 411             }))
 412         }
 413
 414         self.llreturn.get().unwrap()
 415     }
 416
 417     pub fn get_ret_slot(&self, bcx: Block<'a, 'tcx>,
 418                         output: ty::FnOutput<'tcx>,
 419                         name: &str) -> ValueRef {
 420         if self.needs_ret_allocas {
 421             base::alloca(bcx, match output {
 422                 ty::FnConverging(output_type) => type_of::type_of(bcx.ccx(), output_type),
 423                 ty::FnDiverging => Type::void(bcx.ccx())
 424             }, name)
 425         } else {
 426             self.llretslotptr.get().unwrap()
 427         }
 428     }
 429
 430     pub fn new_block(&'a self,
 431                      name: &str,
 432                      opt_node_id: Option<ast::NodeId>)
 433                      -> Block<'a, 'tcx> {
 434         unsafe {
 435             let name = CString::new(name).unwrap();
 436             let llbb = llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx(),
 437                                                            self.llfn,
 438                                                            name.as_ptr());
 439             BlockS::new(llbb, opt_node_id, self)
 440         }
 441     }
 442
 443     pub fn new_id_block(&'a self,
 444                         name: &str,
 445                         node_id: ast::NodeId)
 446                         -> Block<'a, 'tcx> {
 447         self.new_block(name, Some(node_id))
 448     }
 449
 450     pub fn new_temp_block(&'a self,
 451                           name: &str)
 452                           -> Block<'a, 'tcx> {
 453         self.new_block(name, None)
 454     }
 455
 456     pub fn join_blocks(&'a self,
 457                        id: ast::NodeId,
 458                        in_cxs: &[Block<'a, 'tcx>])
 459                        -> Block<'a, 'tcx> {
 460         let out = self.new_id_block("join", id);
 461         let mut reachable = false;
 462         for bcx in in_cxs {
 463             if !bcx.unreachable.get() {
 464                 build::Br(*bcx, out.llbb, DebugLoc::None);
 465                 reachable = true;
 466             }
 467         }
 468         if !reachable {
 469             build::Unreachable(out);
 470         }
 471         return out;
 472     }
 473
 474     pub fn monomorphize<T>(&self, value: &T) -> T
 475         where T : TypeFoldable<'tcx>
 476     {
 477         monomorphize::apply_param_substs(self.ccx.tcx(),
 478                                          self.param_substs,
 479                                          value)
 480     }
 481
 482     /// This is the same as `common::type_needs_drop`, except that it
 483     /// may use or update caches within this `FunctionContext`.
 484     pub fn type_needs_drop(&self, ty: Ty<'tcx>) -> bool {
 485         self.ccx.tcx().type_needs_drop_given_env(ty, &self.param_env)
 486     }
 487
 488     pub fn eh_personality(&self) -> ValueRef {
 489         // The exception handling personality function.
 490         //
 491         // If our compilation unit has the `eh_personality` lang item somewhere
 492         // within it, then we just need to translate that. Otherwise, we're
 493         // building an rlib which will depend on some upstream implementation of
 494         // this function, so we just codegen a generic reference to it. We don't
 495         // specify any of the types for the function, we just make it a symbol
 496         // that LLVM can later use.
 497         //
 498         // Note that MSVC is a little special here in that we don't use the
 499         // `eh_personality` lang item at all. Currently LLVM has support for
 500         // both Dwarf and SEH unwind mechanisms for MSVC targets and uses the
 501         // *name of the personality function* to decide what kind of unwind side
 502         // tables/landing pads to emit. It looks like Dwarf is used by default,
 503         // injecting a dependency on the `_Unwind_Resume` symbol for resuming
 504         // an "exception", but for MSVC we want to force SEH. This means that we
 505         // can't actually have the personality function be our standard
 506         // `rust_eh_personality` function, but rather we wired it up to the
 507         // CRT's custom personality function, which forces LLVM to consider
 508         // landing pads as "landing pads for SEH".
 509         let target = &self.ccx.sess().target.target;
 510         match self.ccx.tcx().lang_items.eh_personality() {
 511             Some(def_id) if !base::wants_msvc_seh(self.ccx.sess()) => {
 512                 callee::trans_fn_ref(self.ccx, def_id, ExprId(0),
 513                                      self.param_substs).val
 514             }
 515             _ => {
 516                 let mut personality = self.ccx.eh_personality().borrow_mut();
 517                 match *personality {
 518                     Some(llpersonality) => llpersonality,
 519                     None => {
 520                         let name = if !base::wants_msvc_seh(self.ccx.sess()) {
 521                             "rust_eh_personality"
 522                         } else if target.arch == "x86" {
 523                             "_except_handler3"
 524                         } else {
 525                             "__C_specific_handler"
 526                         };
 527                         let fty = Type::variadic_func(&[], &Type::i32(self.ccx));
 528                         let f = declare::declare_cfn(self.ccx, name, fty,
 529                                                      self.ccx.tcx().types.i32);
 530                         *personality = Some(f);
 531                         f
 532                     }
 533                 }
 534             }
 535         }
 536     }
 537
 538     // Returns a ValueRef of the "eh_unwind_resume" lang item if one is defined,
 539     // otherwise declares it as an external funtion.
 540     pub fn eh_unwind_resume(&self) -> ValueRef {
 541         use trans::attributes;
 542         assert!(self.ccx.sess().target.target.options.custom_unwind_resume);
 543         match self.ccx.tcx().lang_items.eh_unwind_resume() {
 544             Some(def_id) => {
 545                 callee::trans_fn_ref(self.ccx, def_id, ExprId(0),
 546                                      self.param_substs).val
 547             }
 548             None => {
 549                 let mut unwresume = self.ccx.eh_unwind_resume().borrow_mut();
 550                 match *unwresume {
 551                     Some(llfn) => llfn,
 552                     None => {
 553                         let fty = Type::func(&[Type::i8p(self.ccx)], &Type::void(self.ccx));
 554                         let llfn = declare::declare_fn(self.ccx,
 555                                                        "rust_eh_unwind_resume",
 556                                                        llvm::CCallConv,
 557                                                        fty, ty::FnDiverging);
 558                         attributes::unwind(llfn, true);
 559                         *unwresume = Some(llfn);
 560                         llfn
 561                     }
 562                 }
 563             }
 564         }
 565     }
 566 }
 567
 568 // Basic block context.  We create a block context for each basic block
 569 // (single-entry, single-exit sequence of instructions) we generate from Rust
 570 // code.  Each basic block we generate is attached to a function, typically
 571 // with many basic blocks per function.  All the basic blocks attached to a
 572 // function are organized as a directed graph.
 573 pub struct BlockS<'blk, 'tcx: 'blk> {
 574     // The BasicBlockRef returned from a call to
 575     // llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic
 576     // block to the function pointed to by llfn.  We insert
 577     // instructions into that block by way of this block context.
 578     // The block pointing to this one in the function's digraph.
 579     pub llbb: BasicBlockRef,
 580     pub terminated: Cell<bool>,
 581     pub unreachable: Cell<bool>,
 582
 583     // If this block part of a landing pad, then this is `Some` indicating what
 584     // kind of landing pad its in, otherwise this is none.
 585     pub lpad: RefCell<Option<LandingPad>>,
 586
 587     // AST node-id associated with this block, if any. Used for
 588     // debugging purposes only.
 589     pub opt_node_id: Option<ast::NodeId>,
 590
 591     // The function context for the function to which this block is
 592     // attached.
 593     pub fcx: &'blk FunctionContext<'blk, 'tcx>,
 594 }
 595
 596 pub type Block<'blk, 'tcx> = &'blk BlockS<'blk, 'tcx>;
 597
 598 impl<'blk, 'tcx> BlockS<'blk, 'tcx> {
 599     pub fn new(llbb: BasicBlockRef,
 600                opt_node_id: Option<ast::NodeId>,
 601                fcx: &'blk FunctionContext<'blk, 'tcx>)
 602                -> Block<'blk, 'tcx> {
 603         fcx.block_arena.alloc(BlockS {
 604             llbb: llbb,
 605             terminated: Cell::new(false),
 606             unreachable: Cell::new(false),
 607             lpad: RefCell::new(None),
 608             opt_node_id: opt_node_id,
 609             fcx: fcx
 610         })
 611     }
 612
 613     pub fn ccx(&self) -> &'blk CrateContext<'blk, 'tcx> {
 614         self.fcx.ccx
 615     }
 616     pub fn tcx(&self) -> &'blk ty::ctxt<'tcx> {
 617         self.fcx.ccx.tcx()
 618     }
 619     pub fn sess(&self) -> &'blk Session { self.fcx.ccx.sess() }
 620
 621     pub fn mir(&self) -> &'blk Mir<'tcx> {
 622         self.fcx.mir()
 623     }
 624
 625     pub fn name(&self, name: ast::Name) -> String {
 626         name.to_string()
 627     }
 628
 629     pub fn node_id_to_string(&self, id: ast::NodeId) -> String {
 630         self.tcx().map.node_to_string(id).to_string()
 631     }
 632
 633     pub fn def(&self, nid: ast::NodeId) -> Def {
 634         match self.tcx().def_map.borrow().get(&nid) {
 635             Some(v) => v.full_def(),
 636             None => {
 637                 self.tcx().sess.bug(&format!(
 638                     "no def associated with node id {}", nid));
 639             }
 640         }
 641     }
 642
 643     pub fn val_to_string(&self, val: ValueRef) -> String {
 644         self.ccx().tn().val_to_string(val)
 645     }
 646
 647     pub fn llty_str(&self, ty: Type) -> String {
 648         self.ccx().tn().type_to_string(ty)
 649     }
 650
 651     pub fn to_str(&self) -> String {
 652         format!("[block {:p}]", self)
 653     }
 654
 655     pub fn monomorphize<T>(&self, value: &T) -> T
 656         where T : TypeFoldable<'tcx>
 657     {
 658         monomorphize::apply_param_substs(self.tcx(),
 659                                          self.fcx.param_substs,
 660                                          value)
 661     }
 662 }
 663
 664 /// A structure representing an active landing pad for the duration of a basic
 665 /// block.
 666 ///
 667 /// Each `Block` may contain an instance of this, indicating whether the block
 668 /// is part of a landing pad or not. This is used to make decision about whether
 669 /// to emit `invoke` instructions (e.g. in a landing pad we don't continue to
 670 /// use `invoke`) and also about various function call metadata.
 671 ///
 672 /// For GNU exceptions (`landingpad` + `resume` instructions) this structure is
 673 /// just a bunch of `None` instances (not too interesting), but for MSVC
 674 /// exceptions (`cleanuppad` + `cleanupret` instructions) this contains data.
 675 /// When inside of a landing pad, each function call in LLVM IR needs to be
 676 /// annotated with which landing pad it's a part of. This is accomplished via
 677 /// the `OperandBundleDef` value created for MSVC landing pads.
 678 pub struct LandingPad {
 679     cleanuppad: Option<ValueRef>,
 680     operand: Option<OperandBundleDef>,
 681 }
 682
 683 impl LandingPad {
 684     pub fn gnu() -> LandingPad {
 685         LandingPad { cleanuppad: None, operand: None }
 686     }
 687
 688     pub fn msvc(cleanuppad: ValueRef) -> LandingPad {
 689         LandingPad {
 690             cleanuppad: Some(cleanuppad),
 691             operand: Some(OperandBundleDef::new("funclet", &[cleanuppad])),
 692         }
 693     }
 694
 695     pub fn bundle(&self) -> Option<&OperandBundleDef> {
 696         self.operand.as_ref()
 697     }
 698 }
 699
 700 impl Clone for LandingPad {
 701     fn clone(&self) -> LandingPad {
 702         LandingPad {
 703             cleanuppad: self.cleanuppad,
 704             operand: self.cleanuppad.map(|p| {
 705                 OperandBundleDef::new("funclet", &[p])
 706             }),
 707         }
 708     }
 709 }
 710
 711 pub struct Result<'blk, 'tcx: 'blk> {
 712     pub bcx: Block<'blk, 'tcx>,
 713     pub val: ValueRef
 714 }
 715
 716 impl<'b, 'tcx> Result<'b, 'tcx> {
 717     pub fn new(bcx: Block<'b, 'tcx>, val: ValueRef) -> Result<'b, 'tcx> {
 718         Result {
 719             bcx: bcx,
 720             val: val,
 721         }
 722     }
 723 }
 724
 725 pub fn val_ty(v: ValueRef) -> Type {
 726     unsafe {
 727         Type::from_ref(llvm::LLVMTypeOf(v))
 728     }
 729 }
 730
 731 // LLVM constant constructors.
 732 pub fn C_null(t: Type) -> ValueRef {
 733     unsafe {
 734         llvm::LLVMConstNull(t.to_ref())
 735     }
 736 }
 737
 738 pub fn C_undef(t: Type) -> ValueRef {
 739     unsafe {
 740         llvm::LLVMGetUndef(t.to_ref())
 741     }
 742 }
 743
 744 pub fn C_integral(t: Type, u: u64, sign_extend: bool) -> ValueRef {
 745     unsafe {
 746         llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool)
 747     }
 748 }
 749
 750 pub fn C_floating(s: &str, t: Type) -> ValueRef {
 751     unsafe {
 752         let s = CString::new(s).unwrap();
 753         llvm::LLVMConstRealOfString(t.to_ref(), s.as_ptr())
 754     }
 755 }
 756
 757 pub fn C_floating_f64(f: f64, t: Type) -> ValueRef {
 758     unsafe {
 759         llvm::LLVMConstReal(t.to_ref(), f)
 760     }
 761 }
 762
 763 pub fn C_nil(ccx: &CrateContext) -> ValueRef {
 764     C_struct(ccx, &[], false)
 765 }
 766
 767 pub fn C_bool(ccx: &CrateContext, val: bool) -> ValueRef {
 768     C_integral(Type::i1(ccx), val as u64, false)
 769 }
 770
 771 pub fn C_i32(ccx: &CrateContext, i: i32) -> ValueRef {
 772     C_integral(Type::i32(ccx), i as u64, true)
 773 }
 774
 775 pub fn C_u32(ccx: &CrateContext, i: u32) -> ValueRef {
 776     C_integral(Type::i32(ccx), i as u64, false)
 777 }
 778
 779 pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef {
 780     C_integral(Type::i64(ccx), i, false)
 781 }
 782
 783 pub fn C_int<I: AsI64>(ccx: &CrateContext, i: I) -> ValueRef {
 784     let v = i.as_i64();
 785
 786     let bit_size = machine::llbitsize_of_real(ccx, ccx.int_type());
 787
 788     if bit_size < 64 {
 789         // make sure it doesn't overflow
 790         assert!(v < (1<<(bit_size-1)) && v >= -(1<<(bit_size-1)));
 791     }
 792
 793     C_integral(ccx.int_type(), v as u64, true)
 794 }
 795
 796 pub fn C_uint<I: AsU64>(ccx: &CrateContext, i: I) -> ValueRef {
 797     let v = i.as_u64();
 798
 799     let bit_size = machine::llbitsize_of_real(ccx, ccx.int_type());
 800
 801     if bit_size < 64 {
 802         // make sure it doesn't overflow
 803         assert!(v < (1<<bit_size));
 804     }
 805
 806     C_integral(ccx.int_type(), v, false)
 807 }
 808
 809 pub trait AsI64 { fn as_i64(self) -> i64; }
 810 pub trait AsU64 { fn as_u64(self) -> u64; }
 811
 812 // FIXME: remove the intptr conversions, because they
 813 // are host-architecture-dependent
 814 impl AsI64 for i64 { fn as_i64(self) -> i64 { self as i64 }}
 815 impl AsI64 for i32 { fn as_i64(self) -> i64 { self as i64 }}
 816 impl AsI64 for isize { fn as_i64(self) -> i64 { self as i64 }}
 817
 818 impl AsU64 for u64  { fn as_u64(self) -> u64 { self as u64 }}
 819 impl AsU64 for u32  { fn as_u64(self) -> u64 { self as u64 }}
 820 impl AsU64 for usize { fn as_u64(self) -> u64 { self as u64 }}
 821
 822 pub fn C_u8(ccx: &CrateContext, i: u8) -> ValueRef {
 823     C_integral(Type::i8(ccx), i as u64, false)
 824 }
 825
 826
 827 // This is a 'c-like' raw string, which differs from
 828 // our boxed-and-length-annotated strings.
 829 pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef {
 830     unsafe {
 831         match cx.const_cstr_cache().borrow().get(&s) {
 832             Some(&llval) => return llval,
 833             None => ()
 834         }
 835
 836         let sc = llvm::LLVMConstStringInContext(cx.llcx(),
 837                                                 s.as_ptr() as *const c_char,
 838                                                 s.len() as c_uint,
 839                                                 !null_terminated as Bool);
 840
 841         let gsym = token::gensym("str");
 842         let sym = format!("str{}", gsym.0);
 843         let g = declare::define_global(cx, &sym[..], val_ty(sc)).unwrap_or_else(||{
 844             cx.sess().bug(&format!("symbol `{}` is already defined", sym));
 845         });
 846         llvm::LLVMSetInitializer(g, sc);
 847         llvm::LLVMSetGlobalConstant(g, True);
 848         llvm::SetLinkage(g, llvm::InternalLinkage);
 849
 850         cx.const_cstr_cache().borrow_mut().insert(s, g);
 851         g
 852     }
 853 }
 854
 855 // NB: Do not use `do_spill_noroot` to make this into a constant string, or
 856 // you will be kicked off fast isel. See issue #4352 for an example of this.
 857 pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
 858     let len = s.len();
 859     let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx));
 860     C_named_struct(cx.tn().find_type("str_slice").unwrap(), &[cs, C_uint(cx, len)])
 861 }
 862
 863 pub fn C_struct(cx: &CrateContext, elts: &[ValueRef], packed: bool) -> ValueRef {
 864     C_struct_in_context(cx.llcx(), elts, packed)
 865 }
 866
 867 pub fn C_struct_in_context(llcx: ContextRef, elts: &[ValueRef], packed: bool) -> ValueRef {
 868     unsafe {
 869         llvm::LLVMConstStructInContext(llcx,
 870                                        elts.as_ptr(), elts.len() as c_uint,
 871                                        packed as Bool)
 872     }
 873 }
 874
 875 pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef {
 876     unsafe {
 877         llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint)
 878     }
 879 }
 880
 881 pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef {
 882     unsafe {
 883         return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint);
 884     }
 885 }
 886
 887 pub fn C_vector(elts: &[ValueRef]) -> ValueRef {
 888     unsafe {
 889         return llvm::LLVMConstVector(elts.as_ptr(), elts.len() as c_uint);
 890     }
 891 }
 892
 893 pub fn C_bytes(cx: &CrateContext, bytes: &[u8]) -> ValueRef {
 894     C_bytes_in_context(cx.llcx(), bytes)
 895 }
 896
 897 pub fn C_bytes_in_context(llcx: ContextRef, bytes: &[u8]) -> ValueRef {
 898     unsafe {
 899         let ptr = bytes.as_ptr() as *const c_char;
 900         return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True);
 901     }
 902 }
 903
 904 pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint])
 905               -> ValueRef {
 906     unsafe {
 907         let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint);
 908
 909         debug!("const_get_elt(v={}, us={:?}, r={})",
 910                cx.tn().val_to_string(v), us, cx.tn().val_to_string(r));
 911
 912         return r;
 913     }
 914 }
 915
 916 pub fn const_to_int(v: ValueRef) -> i64 {
 917     unsafe {
 918         llvm::LLVMConstIntGetSExtValue(v)
 919     }
 920 }
 921
 922 pub fn const_to_uint(v: ValueRef) -> u64 {
 923     unsafe {
 924         llvm::LLVMConstIntGetZExtValue(v)
 925     }
 926 }
 927
 928 fn is_const_integral(v: ValueRef) -> bool {
 929     unsafe {
 930         !llvm::LLVMIsAConstantInt(v).is_null()
 931     }
 932 }
 933
 934 pub fn const_to_opt_int(v: ValueRef) -> Option<i64> {
 935     unsafe {
 936         if is_const_integral(v) {
 937             Some(llvm::LLVMConstIntGetSExtValue(v))
 938         } else {
 939             None
 940         }
 941     }
 942 }
 943
 944 pub fn const_to_opt_uint(v: ValueRef) -> Option<u64> {
 945     unsafe {
 946         if is_const_integral(v) {
 947             Some(llvm::LLVMConstIntGetZExtValue(v))
 948         } else {
 949             None
 950         }
 951     }
 952 }
 953
 954 pub fn is_undef(val: ValueRef) -> bool {
 955     unsafe {
 956         llvm::LLVMIsUndef(val) != False
 957     }
 958 }
 959
 960 #[allow(dead_code)] // potentially useful
 961 pub fn is_null(val: ValueRef) -> bool {
 962     unsafe {
 963         llvm::LLVMIsNull(val) != False
 964     }
 965 }
 966
 967 pub fn monomorphize_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, t: Ty<'tcx>) -> Ty<'tcx> {
 968     bcx.fcx.monomorphize(&t)
 969 }
 970
 971 pub fn node_id_type<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, id: ast::NodeId) -> Ty<'tcx> {
 972     let tcx = bcx.tcx();
 973     let t = tcx.node_id_to_type(id);
 974     monomorphize_type(bcx, t)
 975 }
 976
 977 pub fn expr_ty<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &hir::Expr) -> Ty<'tcx> {
 978     node_id_type(bcx, ex.id)
 979 }
 980
 981 pub fn expr_ty_adjusted<'blk, 'tcx>(bcx: &BlockS<'blk, 'tcx>, ex: &hir::Expr) -> Ty<'tcx> {
 982     monomorphize_type(bcx, bcx.tcx().expr_ty_adjusted(ex))
 983 }
 984
 985 /// Attempts to resolve an obligation. The result is a shallow vtable resolution -- meaning that we
 986 /// do not (necessarily) resolve all nested obligations on the impl. Note that type check should
 987 /// guarantee to us that all nested obligations *could be* resolved if we wanted to.
 988 pub fn fulfill_obligation<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 989                                     span: Span,
 990                                     trait_ref: ty::PolyTraitRef<'tcx>)
 991                                     -> traits::Vtable<'tcx, ()>
 992 {
 993     let tcx = ccx.tcx();
 994
 995     // Remove any references to regions; this helps improve caching.
 996     let trait_ref = tcx.erase_regions(&trait_ref);
 997
 998     // First check the cache.
 999     match ccx.trait_cache().borrow().get(&trait_ref) {
1000         Some(vtable) => {
1001             info!("Cache hit: {:?}", trait_ref);
1002             return (*vtable).clone();
1003         }
1004         None => { }
1005     }
1006
1007     debug!("trans fulfill_obligation: trait_ref={:?} def_id={:?}",
1008            trait_ref, trait_ref.def_id());
1009
1010
1011     // Do the initial selection for the obligation. This yields the
1012     // shallow result we are looking for -- that is, what specific impl.
1013     let infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables);
1014     let mut selcx = traits::SelectionContext::new(&infcx);
1015
1016     let obligation =
1017         traits::Obligation::new(traits::ObligationCause::misc(span, ast::DUMMY_NODE_ID),
1018                                 trait_ref.to_poly_trait_predicate());
1019     let selection = match selcx.select(&obligation) {
1020         Ok(Some(selection)) => selection,
1021         Ok(None) => {
1022             // Ambiguity can happen when monomorphizing during trans
1023             // expands to some humongo type that never occurred
1024             // statically -- this humongo type can then overflow,
1025             // leading to an ambiguous result. So report this as an
1026             // overflow bug, since I believe this is the only case
1027             // where ambiguity can result.
1028             debug!("Encountered ambiguity selecting `{:?}` during trans, \
1029                     presuming due to overflow",
1030                    trait_ref);
1031             ccx.sess().span_fatal(
1032                 span,
1033                 "reached the recursion limit during monomorphization (selection ambiguity)");
1034         }
1035         Err(e) => {
1036             tcx.sess.span_bug(
1037                 span,
1038                 &format!("Encountered error `{:?}` selecting `{:?}` during trans",
1039                         e,
1040                         trait_ref))
1041         }
1042     };
1043
1044     // Currently, we use a fulfillment context to completely resolve
1045     // all nested obligations. This is because they can inform the
1046     // inference of the impl's type parameters.
1047     let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut();
1048     let vtable = selection.map(|predicate| {
1049         fulfill_cx.register_predicate_obligation(&infcx, predicate);
1050     });
1051     let vtable = infer::drain_fulfillment_cx_or_panic(
1052         span, &infcx, &mut fulfill_cx, &vtable
1053     );
1054
1055     info!("Cache miss: {:?} => {:?}", trait_ref, vtable);
1056
1057     ccx.trait_cache().borrow_mut().insert(trait_ref, vtable.clone());
1058
1059     vtable
1060 }
1061
1062 /// Normalizes the predicates and checks whether they hold.  If this
1063 /// returns false, then either normalize encountered an error or one
1064 /// of the predicates did not hold. Used when creating vtables to
1065 /// check for unsatisfiable methods.
1066 pub fn normalize_and_test_predicates<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
1067                                                predicates: Vec<ty::Predicate<'tcx>>)
1068                                                -> bool
1069 {
1070     debug!("normalize_and_test_predicates(predicates={:?})",
1071            predicates);
1072
1073     let tcx = ccx.tcx();
1074     let infcx = infer::normalizing_infer_ctxt(tcx, &tcx.tables);
1075     let mut selcx = traits::SelectionContext::new(&infcx);
1076     let mut fulfill_cx = infcx.fulfillment_cx.borrow_mut();
1077     let cause = traits::ObligationCause::dummy();
1078     let traits::Normalized { value: predicates, obligations } =
1079         traits::normalize(&mut selcx, cause.clone(), &predicates);
1080     for obligation in obligations {
1081         fulfill_cx.register_predicate_obligation(&infcx, obligation);
1082     }
1083     for predicate in predicates {
1084         let obligation = traits::Obligation::new(cause.clone(), predicate);
1085         fulfill_cx.register_predicate_obligation(&infcx, obligation);
1086     }
1087
1088     infer::drain_fulfillment_cx(&infcx, &mut fulfill_cx, &()).is_ok()
1089 }
1090
1091 // Key used to lookup values supplied for type parameters in an expr.
1092 #[derive(Copy, Clone, PartialEq, Debug)]
1093 pub enum ExprOrMethodCall {
1094     // Type parameters for a path like `None::<int>`
1095     ExprId(ast::NodeId),
1096
1097     // Type parameters for a method call like `a.foo::<int>()`
1098     MethodCallKey(ty::MethodCall)
1099 }
1100
1101 pub fn node_id_substs<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
1102                                 node: ExprOrMethodCall,
1103                                 param_substs: &subst::Substs<'tcx>)
1104                                 -> subst::Substs<'tcx> {
1105     let tcx = ccx.tcx();
1106
1107     let substs = match node {
1108         ExprId(id) => {
1109             tcx.node_id_item_substs(id).substs
1110         }
1111         MethodCallKey(method_call) => {
1112             tcx.tables.borrow().method_map[&method_call].substs.clone()
1113         }
1114     };
1115
1116     if substs.types.needs_infer() {
1117         tcx.sess.bug(&format!("type parameters for node {:?} include inference types: {:?}",
1118                               node, substs));
1119     }
1120
1121     monomorphize::apply_param_substs(tcx,
1122                                      param_substs,
1123                                      &substs.erase_regions())
1124 }
1125
1126 pub fn langcall(bcx: Block,
1127                 span: Option<Span>,
1128                 msg: &str,
1129                 li: LangItem)
1130                 -> DefId {
1131     match bcx.tcx().lang_items.require(li) {
1132         Ok(id) => id,
1133         Err(s) => {
1134             let msg = format!("{} {}", msg, s);
1135             match span {
1136                 Some(span) => bcx.tcx().sess.span_fatal(span, &msg[..]),
1137                 None => bcx.tcx().sess.fatal(&msg[..]),
1138             }
1139         }
1140     }
1141 }
1142
1143 /// Return the VariantDef corresponding to an inlined variant node
1144 pub fn inlined_variant_def<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
1145                                      inlined_vid: ast::NodeId)
1146                                      -> ty::VariantDef<'tcx>
1147 {
1148
1149     let ctor_ty = ccx.tcx().node_id_to_type(inlined_vid);
1150     debug!("inlined_variant_def: ctor_ty={:?} inlined_vid={:?}", ctor_ty,
1151            inlined_vid);
1152     let adt_def = match ctor_ty.sty {
1153         ty::TyBareFn(_, &ty::BareFnTy { sig: ty::Binder(ty::FnSig {
1154             output: ty::FnConverging(ty), ..
1155         }), ..}) => ty,
1156         _ => ctor_ty
1157     }.ty_adt_def().unwrap();
1158     let inlined_vid_def_id = ccx.tcx().map.local_def_id(inlined_vid);
1159     adt_def.variants.iter().find(|v| {
1160         inlined_vid_def_id == v.did ||
1161             ccx.external().borrow().get(&v.did) == Some(&Some(inlined_vid))
1162     }).unwrap_or_else(|| {
1163         ccx.sess().bug(&format!("no variant for {:?}::{}", adt_def, inlined_vid))
1164     })
1165 }
1166
1167 // To avoid UB from LLVM, these two functions mask RHS with an
1168 // appropriate mask unconditionally (i.e. the fallback behavior for
1169 // all shifts). For 32- and 64-bit types, this matches the semantics
1170 // of Java. (See related discussion on #1877 and #10183.)
1171
1172 pub fn build_unchecked_lshift<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
1173                                           lhs: ValueRef,
1174                                           rhs: ValueRef,
1175                                           binop_debug_loc: DebugLoc) -> ValueRef {
1176     let rhs = base::cast_shift_expr_rhs(bcx, hir::BinOp_::BiShl, lhs, rhs);
1177     // #1877, #10183: Ensure that input is always valid
1178     let rhs = shift_mask_rhs(bcx, rhs, binop_debug_loc);
1179     build::Shl(bcx, lhs, rhs, binop_debug_loc)
1180 }
1181
1182 pub fn build_unchecked_rshift<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
1183                                           lhs_t: Ty<'tcx>,
1184                                           lhs: ValueRef,
1185                                           rhs: ValueRef,
1186                                           binop_debug_loc: DebugLoc) -> ValueRef {
1187     let rhs = base::cast_shift_expr_rhs(bcx, hir::BinOp_::BiShr, lhs, rhs);
1188     // #1877, #10183: Ensure that input is always valid
1189     let rhs = shift_mask_rhs(bcx, rhs, binop_debug_loc);
1190     let is_signed = lhs_t.is_signed();
1191     if is_signed {
1192         build::AShr(bcx, lhs, rhs, binop_debug_loc)
1193     } else {
1194         build::LShr(bcx, lhs, rhs, binop_debug_loc)
1195     }
1196 }
1197
1198 fn shift_mask_rhs<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
1199                               rhs: ValueRef,
1200                               debug_loc: DebugLoc) -> ValueRef {
1201     let rhs_llty = val_ty(rhs);
1202     build::And(bcx, rhs, shift_mask_val(bcx, rhs_llty, rhs_llty, false), debug_loc)
1203 }
1204
1205 pub fn shift_mask_val<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
1206                               llty: Type,
1207                               mask_llty: Type,
1208                               invert: bool) -> ValueRef {
1209     let kind = llty.kind();
1210     match kind {
1211         TypeKind::Integer => {
1212             // i8/u8 can shift by at most 7, i16/u16 by at most 15, etc.
1213             let val = llty.int_width() - 1;
1214             if invert {
1215                 C_integral(mask_llty, !val, true)
1216             } else {
1217                 C_integral(mask_llty, val, false)
1218             }
1219         },
1220         TypeKind::Vector => {
1221             let mask = shift_mask_val(bcx, llty.element_type(), mask_llty.element_type(), invert);
1222             build::VectorSplat(bcx, mask_llty.vector_length(), mask)
1223         },
1224         _ => panic!("shift_mask_val: expected Integer or Vector, found {:?}", kind),
1225     }
1226 }
1227
1228 pub fn get_static_val<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
1229                             did: DefId,
1230                             ty: Ty<'tcx>)
1231                             -> ValueRef {
1232     if let Some(node_id) = ccx.tcx().map.as_local_node_id(did) {
1233         base::get_item_val(ccx, node_id)
1234     } else {
1235         base::get_extern_const(ccx, did, ty)
1236     }
1237 }