src/librustc_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 use llvm;
  16 use llvm::{ValueRef, ContextRef, TypeKind};
  17 use llvm::{True, False, Bool, OperandBundleDef};
  18 use rustc::hir::def_id::DefId;
  19 use rustc::hir::map::DefPathData;
  20 use rustc::middle::lang_items::LangItem;
  21 use base;
  22 use builder::Builder;
  23 use consts;
  24 use declare;
  25 use machine;
  26 use monomorphize;
  27 use type_::Type;
  28 use value::Value;
  29 use rustc::ty::{self, Ty, TyCtxt};
  30 use rustc::ty::layout::{Layout, LayoutTyper};
  31 use rustc::ty::subst::{Subst, Substs};
  32 use rustc::hir;
  33
  34 use libc::{c_uint, c_char};
  35 use std::iter;
  36
  37 use syntax::attr;
  38 use syntax::symbol::InternedString;
  39 use syntax_pos::Span;
  40
  41 pub use context::{CrateContext, SharedCrateContext};
  42
  43 pub fn type_is_fat_ptr<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
  44     if let Layout::FatPointer { .. } = *ccx.layout_of(ty) {
  45         true
  46     } else {
  47         false
  48     }
  49 }
  50
  51 pub fn type_is_immediate<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
  52     let layout = ccx.layout_of(ty);
  53     match *layout {
  54         Layout::CEnum { .. } |
  55         Layout::Scalar { .. } |
  56         Layout::Vector { .. } => true,
  57
  58         Layout::FatPointer { .. } => false,
  59
  60         Layout::Array { .. } |
  61         Layout::Univariant { .. } |
  62         Layout::General { .. } |
  63         Layout::UntaggedUnion { .. } |
  64         Layout::RawNullablePointer { .. } |
  65         Layout::StructWrappedNullablePointer { .. } => {
  66             !layout.is_unsized() && layout.size(ccx).bytes() == 0
  67         }
  68     }
  69 }
  70
  71 /// Returns Some([a, b]) if the type has a pair of fields with types a and b.
  72 pub fn type_pair_fields<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>)
  73                                   -> Option<[Ty<'tcx>; 2]> {
  74     match ty.sty {
  75         ty::TyAdt(adt, substs) => {
  76             assert_eq!(adt.variants.len(), 1);
  77             let fields = &adt.variants[0].fields;
  78             if fields.len() != 2 {
  79                 return None;
  80             }
  81             Some([monomorphize::field_ty(ccx.tcx(), substs, &fields[0]),
  82                   monomorphize::field_ty(ccx.tcx(), substs, &fields[1])])
  83         }
  84         ty::TyClosure(def_id, substs) => {
  85             let mut tys = substs.upvar_tys(def_id, ccx.tcx());
  86             tys.next().and_then(|first_ty| tys.next().and_then(|second_ty| {
  87                 if tys.next().is_some() {
  88                     None
  89                 } else {
  90                     Some([first_ty, second_ty])
  91                 }
  92             }))
  93         }
  94         ty::TyTuple(tys, _) => {
  95             if tys.len() != 2 {
  96                 return None;
  97             }
  98             Some([tys[0], tys[1]])
  99         }
 100         _ => None
 101     }
 102 }
 103
 104 /// Returns true if the type is represented as a pair of immediates.
 105 pub fn type_is_imm_pair<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>)
 106                                   -> bool {
 107     match *ccx.layout_of(ty) {
 108         Layout::FatPointer { .. } => true,
 109         Layout::Univariant { ref variant, .. } => {
 110             // There must be only 2 fields.
 111             if variant.offsets.len() != 2 {
 112                 return false;
 113             }
 114
 115             match type_pair_fields(ccx, ty) {
 116                 Some([a, b]) => {
 117                     type_is_immediate(ccx, a) && type_is_immediate(ccx, b)
 118                 }
 119                 None => false
 120             }
 121         }
 122         _ => false
 123     }
 124 }
 125
 126 /// Identify types which have size zero at runtime.
 127 pub fn type_is_zero_size<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, ty: Ty<'tcx>) -> bool {
 128     let layout = ccx.layout_of(ty);
 129     !layout.is_unsized() && layout.size(ccx).bytes() == 0
 130 }
 131
 132 /*
 133 * A note on nomenclature of linking: "extern", "foreign", and "upcall".
 134 *
 135 * An "extern" is an LLVM symbol we wind up emitting an undefined external
 136 * reference to. This means "we don't have the thing in this compilation unit,
 137 * please make sure you link it in at runtime". This could be a reference to
 138 * C code found in a C library, or rust code found in a rust crate.
 139 *
 140 * Most "externs" are implicitly declared (automatically) as a result of a
 141 * user declaring an extern _module_ dependency; this causes the rust driver
 142 * to locate an extern crate, scan its compilation metadata, and emit extern
 143 * declarations for any symbols used by the declaring crate.
 144 *
 145 * A "foreign" is an extern that references C (or other non-rust ABI) code.
 146 * There is no metadata to scan for extern references so in these cases either
 147 * a header-digester like bindgen, or manual function prototypes, have to
 148 * serve as declarators. So these are usually given explicitly as prototype
 149 * declarations, in rust code, with ABI attributes on them noting which ABI to
 150 * link via.
 151 *
 152 * An "upcall" is a foreign call generated by the compiler (not corresponding
 153 * to any user-written call in the code) into the runtime library, to perform
 154 * some helper task such as bringing a task to life, allocating memory, etc.
 155 *
 156 */
 157
 158 /// A structure representing an active landing pad for the duration of a basic
 159 /// block.
 160 ///
 161 /// Each `Block` may contain an instance of this, indicating whether the block
 162 /// is part of a landing pad or not. This is used to make decision about whether
 163 /// to emit `invoke` instructions (e.g. in a landing pad we don't continue to
 164 /// use `invoke`) and also about various function call metadata.
 165 ///
 166 /// For GNU exceptions (`landingpad` + `resume` instructions) this structure is
 167 /// just a bunch of `None` instances (not too interesting), but for MSVC
 168 /// exceptions (`cleanuppad` + `cleanupret` instructions) this contains data.
 169 /// When inside of a landing pad, each function call in LLVM IR needs to be
 170 /// annotated with which landing pad it's a part of. This is accomplished via
 171 /// the `OperandBundleDef` value created for MSVC landing pads.
 172 pub struct Funclet {
 173     cleanuppad: ValueRef,
 174     operand: OperandBundleDef,
 175 }
 176
 177 impl Funclet {
 178     pub fn new(cleanuppad: ValueRef) -> Funclet {
 179         Funclet {
 180             cleanuppad: cleanuppad,
 181             operand: OperandBundleDef::new("funclet", &[cleanuppad]),
 182         }
 183     }
 184
 185     pub fn cleanuppad(&self) -> ValueRef {
 186         self.cleanuppad
 187     }
 188
 189     pub fn bundle(&self) -> &OperandBundleDef {
 190         &self.operand
 191     }
 192 }
 193
 194 impl Clone for Funclet {
 195     fn clone(&self) -> Funclet {
 196         Funclet {
 197             cleanuppad: self.cleanuppad,
 198             operand: OperandBundleDef::new("funclet", &[self.cleanuppad]),
 199         }
 200     }
 201 }
 202
 203 pub fn val_ty(v: ValueRef) -> Type {
 204     unsafe {
 205         Type::from_ref(llvm::LLVMTypeOf(v))
 206     }
 207 }
 208
 209 // LLVM constant constructors.
 210 pub fn C_null(t: Type) -> ValueRef {
 211     unsafe {
 212         llvm::LLVMConstNull(t.to_ref())
 213     }
 214 }
 215
 216 pub fn C_undef(t: Type) -> ValueRef {
 217     unsafe {
 218         llvm::LLVMGetUndef(t.to_ref())
 219     }
 220 }
 221
 222 pub fn C_integral(t: Type, u: u64, sign_extend: bool) -> ValueRef {
 223     unsafe {
 224         llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool)
 225     }
 226 }
 227
 228 pub fn C_big_integral(t: Type, u: u128) -> ValueRef {
 229     unsafe {
 230         let words = [u as u64, u.wrapping_shr(64) as u64];
 231         llvm::LLVMConstIntOfArbitraryPrecision(t.to_ref(), 2, words.as_ptr())
 232     }
 233 }
 234
 235 pub fn C_floating_f64(f: f64, t: Type) -> ValueRef {
 236     unsafe {
 237         llvm::LLVMConstReal(t.to_ref(), f)
 238     }
 239 }
 240
 241 pub fn C_nil(ccx: &CrateContext) -> ValueRef {
 242     C_struct(ccx, &[], false)
 243 }
 244
 245 pub fn C_bool(ccx: &CrateContext, val: bool) -> ValueRef {
 246     C_integral(Type::i1(ccx), val as u64, false)
 247 }
 248
 249 pub fn C_i32(ccx: &CrateContext, i: i32) -> ValueRef {
 250     C_integral(Type::i32(ccx), i as u64, true)
 251 }
 252
 253 pub fn C_u32(ccx: &CrateContext, i: u32) -> ValueRef {
 254     C_integral(Type::i32(ccx), i as u64, false)
 255 }
 256
 257 pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef {
 258     C_integral(Type::i64(ccx), i, false)
 259 }
 260
 261 pub fn C_uint<I: AsU64>(ccx: &CrateContext, i: I) -> ValueRef {
 262     let v = i.as_u64();
 263
 264     let bit_size = machine::llbitsize_of_real(ccx, ccx.int_type());
 265
 266     if bit_size < 64 {
 267         // make sure it doesn't overflow
 268         assert!(v < (1<<bit_size));
 269     }
 270
 271     C_integral(ccx.int_type(), v, false)
 272 }
 273
 274 pub trait AsI64 { fn as_i64(self) -> i64; }
 275 pub trait AsU64 { fn as_u64(self) -> u64; }
 276
 277 // FIXME: remove the intptr conversions, because they
 278 // are host-architecture-dependent
 279 impl AsI64 for i64 { fn as_i64(self) -> i64 { self as i64 }}
 280 impl AsI64 for i32 { fn as_i64(self) -> i64 { self as i64 }}
 281 impl AsI64 for isize { fn as_i64(self) -> i64 { self as i64 }}
 282
 283 impl AsU64 for u64  { fn as_u64(self) -> u64 { self as u64 }}
 284 impl AsU64 for u32  { fn as_u64(self) -> u64 { self as u64 }}
 285 impl AsU64 for usize { fn as_u64(self) -> u64 { self as u64 }}
 286
 287 pub fn C_u8(ccx: &CrateContext, i: u8) -> ValueRef {
 288     C_integral(Type::i8(ccx), i as u64, false)
 289 }
 290
 291
 292 // This is a 'c-like' raw string, which differs from
 293 // our boxed-and-length-annotated strings.
 294 pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef {
 295     unsafe {
 296         if let Some(&llval) = cx.const_cstr_cache().borrow().get(&s) {
 297             return llval;
 298         }
 299
 300         let sc = llvm::LLVMConstStringInContext(cx.llcx(),
 301                                                 s.as_ptr() as *const c_char,
 302                                                 s.len() as c_uint,
 303                                                 !null_terminated as Bool);
 304         let sym = cx.generate_local_symbol_name("str");
 305         let g = declare::define_global(cx, &sym[..], val_ty(sc)).unwrap_or_else(||{
 306             bug!("symbol `{}` is already defined", sym);
 307         });
 308         llvm::LLVMSetInitializer(g, sc);
 309         llvm::LLVMSetGlobalConstant(g, True);
 310         llvm::LLVMRustSetLinkage(g, llvm::Linkage::InternalLinkage);
 311
 312         cx.const_cstr_cache().borrow_mut().insert(s, g);
 313         g
 314     }
 315 }
 316
 317 // NB: Do not use `do_spill_noroot` to make this into a constant string, or
 318 // you will be kicked off fast isel. See issue #4352 for an example of this.
 319 pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef {
 320     let len = s.len();
 321     let cs = consts::ptrcast(C_cstr(cx, s, false), Type::i8p(cx));
 322     C_named_struct(cx.str_slice_type(), &[cs, C_uint(cx, len)])
 323 }
 324
 325 pub fn C_struct(cx: &CrateContext, elts: &[ValueRef], packed: bool) -> ValueRef {
 326     C_struct_in_context(cx.llcx(), elts, packed)
 327 }
 328
 329 pub fn C_struct_in_context(llcx: ContextRef, elts: &[ValueRef], packed: bool) -> ValueRef {
 330     unsafe {
 331         llvm::LLVMConstStructInContext(llcx,
 332                                        elts.as_ptr(), elts.len() as c_uint,
 333                                        packed as Bool)
 334     }
 335 }
 336
 337 pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef {
 338     unsafe {
 339         llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint)
 340     }
 341 }
 342
 343 pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef {
 344     unsafe {
 345         return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint);
 346     }
 347 }
 348
 349 pub fn C_vector(elts: &[ValueRef]) -> ValueRef {
 350     unsafe {
 351         return llvm::LLVMConstVector(elts.as_ptr(), elts.len() as c_uint);
 352     }
 353 }
 354
 355 pub fn C_bytes(cx: &CrateContext, bytes: &[u8]) -> ValueRef {
 356     C_bytes_in_context(cx.llcx(), bytes)
 357 }
 358
 359 pub fn C_bytes_in_context(llcx: ContextRef, bytes: &[u8]) -> ValueRef {
 360     unsafe {
 361         let ptr = bytes.as_ptr() as *const c_char;
 362         return llvm::LLVMConstStringInContext(llcx, ptr, bytes.len() as c_uint, True);
 363     }
 364 }
 365
 366 pub fn const_get_elt(v: ValueRef, us: &[c_uint])
 367               -> ValueRef {
 368     unsafe {
 369         let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint);
 370
 371         debug!("const_get_elt(v={:?}, us={:?}, r={:?})",
 372                Value(v), us, Value(r));
 373
 374         r
 375     }
 376 }
 377
 378 pub fn const_to_uint(v: ValueRef) -> u64 {
 379     unsafe {
 380         llvm::LLVMConstIntGetZExtValue(v)
 381     }
 382 }
 383
 384 fn is_const_integral(v: ValueRef) -> bool {
 385     unsafe {
 386         !llvm::LLVMIsAConstantInt(v).is_null()
 387     }
 388 }
 389
 390 #[inline]
 391 fn hi_lo_to_u128(lo: u64, hi: u64) -> u128 {
 392     ((hi as u128) << 64) | (lo as u128)
 393 }
 394
 395 pub fn const_to_opt_u128(v: ValueRef, sign_ext: bool) -> Option<u128> {
 396     unsafe {
 397         if is_const_integral(v) {
 398             let (mut lo, mut hi) = (0u64, 0u64);
 399             let success = llvm::LLVMRustConstInt128Get(v, sign_ext,
 400                                                        &mut hi as *mut u64, &mut lo as *mut u64);
 401             if success {
 402                 Some(hi_lo_to_u128(lo, hi))
 403             } else {
 404                 None
 405             }
 406         } else {
 407             None
 408         }
 409     }
 410 }
 411
 412 pub fn is_undef(val: ValueRef) -> bool {
 413     unsafe {
 414         llvm::LLVMIsUndef(val) != False
 415     }
 416 }
 417
 418 #[allow(dead_code)] // potentially useful
 419 pub fn is_null(val: ValueRef) -> bool {
 420     unsafe {
 421         llvm::LLVMIsNull(val) != False
 422     }
 423 }
 424
 425 pub fn langcall(tcx: TyCtxt,
 426                 span: Option<Span>,
 427                 msg: &str,
 428                 li: LangItem)
 429                 -> DefId {
 430     match tcx.lang_items.require(li) {
 431         Ok(id) => id,
 432         Err(s) => {
 433             let msg = format!("{} {}", msg, s);
 434             match span {
 435                 Some(span) => tcx.sess.span_fatal(span, &msg[..]),
 436                 None => tcx.sess.fatal(&msg[..]),
 437             }
 438         }
 439     }
 440 }
 441
 442 // To avoid UB from LLVM, these two functions mask RHS with an
 443 // appropriate mask unconditionally (i.e. the fallback behavior for
 444 // all shifts). For 32- and 64-bit types, this matches the semantics
 445 // of Java. (See related discussion on #1877 and #10183.)
 446
 447 pub fn build_unchecked_lshift<'a, 'tcx>(
 448     bcx: &Builder<'a, 'tcx>,
 449     lhs: ValueRef,
 450     rhs: ValueRef
 451 ) -> ValueRef {
 452     let rhs = base::cast_shift_expr_rhs(bcx, hir::BinOp_::BiShl, lhs, rhs);
 453     // #1877, #10183: Ensure that input is always valid
 454     let rhs = shift_mask_rhs(bcx, rhs);
 455     bcx.shl(lhs, rhs)
 456 }
 457
 458 pub fn build_unchecked_rshift<'a, 'tcx>(
 459     bcx: &Builder<'a, 'tcx>, lhs_t: Ty<'tcx>, lhs: ValueRef, rhs: ValueRef
 460 ) -> ValueRef {
 461     let rhs = base::cast_shift_expr_rhs(bcx, hir::BinOp_::BiShr, lhs, rhs);
 462     // #1877, #10183: Ensure that input is always valid
 463     let rhs = shift_mask_rhs(bcx, rhs);
 464     let is_signed = lhs_t.is_signed();
 465     if is_signed {
 466         bcx.ashr(lhs, rhs)
 467     } else {
 468         bcx.lshr(lhs, rhs)
 469     }
 470 }
 471
 472 fn shift_mask_rhs<'a, 'tcx>(bcx: &Builder<'a, 'tcx>, rhs: ValueRef) -> ValueRef {
 473     let rhs_llty = val_ty(rhs);
 474     bcx.and(rhs, shift_mask_val(bcx, rhs_llty, rhs_llty, false))
 475 }
 476
 477 pub fn shift_mask_val<'a, 'tcx>(
 478     bcx: &Builder<'a, 'tcx>,
 479     llty: Type,
 480     mask_llty: Type,
 481     invert: bool
 482 ) -> ValueRef {
 483     let kind = llty.kind();
 484     match kind {
 485         TypeKind::Integer => {
 486             // i8/u8 can shift by at most 7, i16/u16 by at most 15, etc.
 487             let val = llty.int_width() - 1;
 488             if invert {
 489                 C_integral(mask_llty, !val, true)
 490             } else {
 491                 C_integral(mask_llty, val, false)
 492             }
 493         },
 494         TypeKind::Vector => {
 495             let mask = shift_mask_val(bcx, llty.element_type(), mask_llty.element_type(), invert);
 496             bcx.vector_splat(mask_llty.vector_length(), mask)
 497         },
 498         _ => bug!("shift_mask_val: expected Integer or Vector, found {:?}", kind),
 499     }
 500 }
 501
 502 pub fn ty_fn_sig<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>,
 503                            ty: Ty<'tcx>)
 504                            -> ty::PolyFnSig<'tcx>
 505 {
 506     match ty.sty {
 507         ty::TyFnDef(_, _, sig) => sig,
 508         // Shims currently have type TyFnPtr. Not sure this should remain.
 509         ty::TyFnPtr(sig) => sig,
 510         ty::TyClosure(def_id, substs) => {
 511             let tcx = ccx.tcx();
 512             let sig = tcx.closure_type(def_id).subst(tcx, substs.substs);
 513
 514             let env_region = ty::ReLateBound(ty::DebruijnIndex::new(1), ty::BrEnv);
 515             let env_ty = match tcx.closure_kind(def_id) {
 516                 ty::ClosureKind::Fn => tcx.mk_imm_ref(tcx.mk_region(env_region), ty),
 517                 ty::ClosureKind::FnMut => tcx.mk_mut_ref(tcx.mk_region(env_region), ty),
 518                 ty::ClosureKind::FnOnce => ty,
 519             };
 520
 521             sig.map_bound(|sig| tcx.mk_fn_sig(
 522                 iter::once(env_ty).chain(sig.inputs().iter().cloned()),
 523                 sig.output(),
 524                 sig.variadic,
 525                 sig.unsafety,
 526                 sig.abi
 527             ))
 528         }
 529         _ => bug!("unexpected type {:?} to ty_fn_sig", ty)
 530     }
 531 }
 532
 533 pub fn requests_inline<'a, 'tcx>(
 534     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 535     instance: &ty::Instance<'tcx>
 536 ) -> bool {
 537     if is_inline_instance(tcx, instance) {
 538         return true
 539     }
 540     if let ty::InstanceDef::DropGlue(..) = instance.def {
 541         // Drop glue wants to be instantiated at every translation
 542         // unit, but without an #[inline] hint. We should make this
 543         // available to normal end-users.
 544         return true
 545     }
 546     attr::requests_inline(&instance.def.attrs(tcx)[..])
 547 }
 548
 549 pub fn is_inline_instance<'a, 'tcx>(
 550     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 551     instance: &ty::Instance<'tcx>
 552 ) -> bool {
 553     let def_id = match instance.def {
 554         ty::InstanceDef::Item(def_id) => def_id,
 555         ty::InstanceDef::DropGlue(_, Some(_)) => return false,
 556         _ => return true
 557     };
 558     match tcx.def_key(def_id).disambiguated_data.data {
 559         DefPathData::StructCtor |
 560         DefPathData::EnumVariant(..) |
 561         DefPathData::ClosureExpr => true,
 562         _ => false
 563     }
 564 }
 565
 566 /// Given a DefId and some Substs, produces the monomorphic item type.
 567 pub fn def_ty<'a, 'tcx>(shared: &SharedCrateContext<'a, 'tcx>,
 568                         def_id: DefId,
 569                         substs: &'tcx Substs<'tcx>)
 570                         -> Ty<'tcx>
 571 {
 572     let ty = shared.tcx().type_of(def_id);
 573     shared.tcx().trans_apply_param_substs(substs, &ty)
 574 }
 575
 576 /// Return the substituted type of an instance.
 577 pub fn instance_ty<'a, 'tcx>(shared: &SharedCrateContext<'a, 'tcx>,
 578                              instance: &ty::Instance<'tcx>)
 579                              -> Ty<'tcx>
 580 {
 581     let ty = instance.def.def_ty(shared.tcx());
 582     shared.tcx().trans_apply_param_substs(instance.substs, &ty)
 583 }