src/librustc/middle/trans/context.rs

   1 // Copyright 2013 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 use driver::config::NoDebugInfo;
  12 use driver::session::Session;
  13 use llvm;
  14 use llvm::{ContextRef, ModuleRef, ValueRef};
  15 use llvm::{TargetData};
  16 use llvm::mk_target_data;
  17 use metadata::common::LinkMeta;
  18 use middle::resolve;
  19 use middle::trans::adt;
  20 use middle::trans::base;
  21 use middle::trans::builder::Builder;
  22 use middle::trans::common::{ExternMap,tydesc_info,BuilderRef_res};
  23 use middle::trans::debuginfo;
  24 use middle::trans::monomorphize::MonoId;
  25 use middle::trans::type_::{Type, TypeNames};
  26 use middle::ty;
  27 use util::sha2::Sha256;
  28 use util::nodemap::{NodeMap, NodeSet, DefIdMap};
  29
  30 use std::cell::{Cell, RefCell};
  31 use std::c_str::ToCStr;
  32 use std::ptr;
  33 use std::rc::Rc;
  34 use std::collections::{HashMap, HashSet};
  35 use syntax::abi;
  36 use syntax::ast;
  37 use syntax::parse::token::InternedString;
  38
  39 pub struct Stats {
  40     pub n_static_tydescs: Cell<uint>,
  41     pub n_glues_created: Cell<uint>,
  42     pub n_null_glues: Cell<uint>,
  43     pub n_real_glues: Cell<uint>,
  44     pub n_fns: Cell<uint>,
  45     pub n_monos: Cell<uint>,
  46     pub n_inlines: Cell<uint>,
  47     pub n_closures: Cell<uint>,
  48     pub n_llvm_insns: Cell<uint>,
  49     pub llvm_insns: RefCell<HashMap<String, uint>>,
  50     // (ident, time-in-ms, llvm-instructions)
  51     pub fn_stats: RefCell<Vec<(String, uint, uint)> >,
  52 }
  53
  54 pub struct CrateContext {
  55     pub llmod: ModuleRef,
  56     pub llcx: ContextRef,
  57     pub metadata_llmod: ModuleRef,
  58     pub td: TargetData,
  59     pub tn: TypeNames,
  60     pub externs: RefCell<ExternMap>,
  61     pub item_vals: RefCell<NodeMap<ValueRef>>,
  62     pub exp_map2: resolve::ExportMap2,
  63     pub reachable: NodeSet,
  64     pub item_symbols: RefCell<NodeMap<String>>,
  65     pub link_meta: LinkMeta,
  66     pub drop_glues: RefCell<HashMap<ty::t, ValueRef>>,
  67     pub tydescs: RefCell<HashMap<ty::t, Rc<tydesc_info>>>,
  68     /// Set when running emit_tydescs to enforce that no more tydescs are
  69     /// created.
  70     pub finished_tydescs: Cell<bool>,
  71     /// Track mapping of external ids to local items imported for inlining
  72     pub external: RefCell<DefIdMap<Option<ast::NodeId>>>,
  73     /// Backwards version of the `external` map (inlined items to where they
  74     /// came from)
  75     pub external_srcs: RefCell<NodeMap<ast::DefId>>,
  76     /// A set of static items which cannot be inlined into other crates. This
  77     /// will prevent in IIItem() structures from being encoded into the metadata
  78     /// that is generated
  79     pub non_inlineable_statics: RefCell<NodeSet>,
  80     /// Cache instances of monomorphized functions
  81     pub monomorphized: RefCell<HashMap<MonoId, ValueRef>>,
  82     pub monomorphizing: RefCell<DefIdMap<uint>>,
  83     /// Cache generated vtables
  84     pub vtables: RefCell<HashMap<(ty::t, MonoId), ValueRef>>,
  85     /// Cache of constant strings,
  86     pub const_cstr_cache: RefCell<HashMap<InternedString, ValueRef>>,
  87
  88     /// Reverse-direction for const ptrs cast from globals.
  89     /// Key is an int, cast from a ValueRef holding a *T,
  90     /// Val is a ValueRef holding a *[T].
  91     ///
  92     /// Needed because LLVM loses pointer->pointee association
  93     /// when we ptrcast, and we have to ptrcast during translation
  94     /// of a [T] const because we form a slice, a [*T,int] pair, not
  95     /// a pointer to an LLVM array type.
  96     pub const_globals: RefCell<HashMap<int, ValueRef>>,
  97
  98     /// Cache of emitted const values
  99     pub const_values: RefCell<NodeMap<ValueRef>>,
 100
 101     /// Cache of external const values
 102     pub extern_const_values: RefCell<DefIdMap<ValueRef>>,
 103
 104     pub impl_method_cache: RefCell<HashMap<(ast::DefId, ast::Name), ast::DefId>>,
 105
 106     /// Cache of closure wrappers for bare fn's.
 107     pub closure_bare_wrapper_cache: RefCell<HashMap<ValueRef, ValueRef>>,
 108
 109     pub lltypes: RefCell<HashMap<ty::t, Type>>,
 110     pub llsizingtypes: RefCell<HashMap<ty::t, Type>>,
 111     pub adt_reprs: RefCell<HashMap<ty::t, Rc<adt::Repr>>>,
 112     pub symbol_hasher: RefCell<Sha256>,
 113     pub type_hashcodes: RefCell<HashMap<ty::t, String>>,
 114     pub all_llvm_symbols: RefCell<HashSet<String>>,
 115     pub tcx: ty::ctxt,
 116     pub stats: Stats,
 117     pub int_type: Type,
 118     pub opaque_vec_type: Type,
 119     pub builder: BuilderRef_res,
 120     /// Set when at least one function uses GC. Needed so that
 121     /// decl_gc_metadata knows whether to link to the module metadata, which
 122     /// is not emitted by LLVM's GC pass when no functions use GC.
 123     pub uses_gc: bool,
 124     pub dbg_cx: Option<debuginfo::CrateDebugContext>,
 125
 126     pub eh_personality: RefCell<Option<ValueRef>>,
 127
 128     intrinsics: RefCell<HashMap<&'static str, ValueRef>>,
 129 }
 130
 131 impl CrateContext {
 132     pub fn new(name: &str,
 133                tcx: ty::ctxt,
 134                emap2: resolve::ExportMap2,
 135                symbol_hasher: Sha256,
 136                link_meta: LinkMeta,
 137                reachable: NodeSet)
 138                -> CrateContext {
 139         unsafe {
 140             let llcx = llvm::LLVMContextCreate();
 141             let llmod = name.with_c_str(|buf| {
 142                 llvm::LLVMModuleCreateWithNameInContext(buf, llcx)
 143             });
 144             let metadata_llmod = format!("{}_metadata", name).with_c_str(|buf| {
 145                 llvm::LLVMModuleCreateWithNameInContext(buf, llcx)
 146             });
 147             tcx.sess
 148                .targ_cfg
 149                .target_strs
 150                .data_layout
 151                .as_slice()
 152                .with_c_str(|buf| {
 153                 llvm::LLVMSetDataLayout(llmod, buf);
 154                 llvm::LLVMSetDataLayout(metadata_llmod, buf);
 155             });
 156             tcx.sess
 157                .targ_cfg
 158                .target_strs
 159                .target_triple
 160                .as_slice()
 161                .with_c_str(|buf| {
 162                 llvm::LLVMRustSetNormalizedTarget(llmod, buf);
 163                 llvm::LLVMRustSetNormalizedTarget(metadata_llmod, buf);
 164             });
 165
 166             let td = mk_target_data(tcx.sess
 167                                        .targ_cfg
 168                                        .target_strs
 169                                        .data_layout
 170                                        .as_slice());
 171
 172             let dbg_cx = if tcx.sess.opts.debuginfo != NoDebugInfo {
 173                 Some(debuginfo::CrateDebugContext::new(llmod))
 174             } else {
 175                 None
 176             };
 177
 178             let mut ccx = CrateContext {
 179                 llmod: llmod,
 180                 llcx: llcx,
 181                 metadata_llmod: metadata_llmod,
 182                 td: td,
 183                 tn: TypeNames::new(),
 184                 externs: RefCell::new(HashMap::new()),
 185                 item_vals: RefCell::new(NodeMap::new()),
 186                 exp_map2: emap2,
 187                 reachable: reachable,
 188                 item_symbols: RefCell::new(NodeMap::new()),
 189                 link_meta: link_meta,
 190                 drop_glues: RefCell::new(HashMap::new()),
 191                 tydescs: RefCell::new(HashMap::new()),
 192                 finished_tydescs: Cell::new(false),
 193                 external: RefCell::new(DefIdMap::new()),
 194                 external_srcs: RefCell::new(NodeMap::new()),
 195                 non_inlineable_statics: RefCell::new(NodeSet::new()),
 196                 monomorphized: RefCell::new(HashMap::new()),
 197                 monomorphizing: RefCell::new(DefIdMap::new()),
 198                 vtables: RefCell::new(HashMap::new()),
 199                 const_cstr_cache: RefCell::new(HashMap::new()),
 200                 const_globals: RefCell::new(HashMap::new()),
 201                 const_values: RefCell::new(NodeMap::new()),
 202                 extern_const_values: RefCell::new(DefIdMap::new()),
 203                 impl_method_cache: RefCell::new(HashMap::new()),
 204                 closure_bare_wrapper_cache: RefCell::new(HashMap::new()),
 205                 lltypes: RefCell::new(HashMap::new()),
 206                 llsizingtypes: RefCell::new(HashMap::new()),
 207                 adt_reprs: RefCell::new(HashMap::new()),
 208                 symbol_hasher: RefCell::new(symbol_hasher),
 209                 type_hashcodes: RefCell::new(HashMap::new()),
 210                 all_llvm_symbols: RefCell::new(HashSet::new()),
 211                 tcx: tcx,
 212                 stats: Stats {
 213                     n_static_tydescs: Cell::new(0u),
 214                     n_glues_created: Cell::new(0u),
 215                     n_null_glues: Cell::new(0u),
 216                     n_real_glues: Cell::new(0u),
 217                     n_fns: Cell::new(0u),
 218                     n_monos: Cell::new(0u),
 219                     n_inlines: Cell::new(0u),
 220                     n_closures: Cell::new(0u),
 221                     n_llvm_insns: Cell::new(0u),
 222                     llvm_insns: RefCell::new(HashMap::new()),
 223                     fn_stats: RefCell::new(Vec::new()),
 224                 },
 225                 int_type: Type::from_ref(ptr::mut_null()),
 226                 opaque_vec_type: Type::from_ref(ptr::mut_null()),
 227                 builder: BuilderRef_res(llvm::LLVMCreateBuilderInContext(llcx)),
 228                 uses_gc: false,
 229                 dbg_cx: dbg_cx,
 230                 eh_personality: RefCell::new(None),
 231                 intrinsics: RefCell::new(HashMap::new()),
 232             };
 233
 234             ccx.int_type = Type::int(&ccx);
 235             ccx.opaque_vec_type = Type::opaque_vec(&ccx);
 236
 237             let mut str_slice_ty = Type::named_struct(&ccx, "str_slice");
 238             str_slice_ty.set_struct_body([Type::i8p(&ccx), ccx.int_type], false);
 239             ccx.tn.associate_type("str_slice", &str_slice_ty);
 240
 241             ccx.tn.associate_type("tydesc", &Type::tydesc(&ccx, str_slice_ty));
 242
 243             if ccx.sess().count_llvm_insns() {
 244                 base::init_insn_ctxt()
 245             }
 246
 247             ccx
 248         }
 249     }
 250
 251     pub fn tcx<'a>(&'a self) -> &'a ty::ctxt {
 252         &self.tcx
 253     }
 254
 255     pub fn sess<'a>(&'a self) -> &'a Session {
 256         &self.tcx.sess
 257     }
 258
 259     pub fn builder<'a>(&'a self) -> Builder<'a> {
 260         Builder::new(self)
 261     }
 262
 263     pub fn tydesc_type(&self) -> Type {
 264         self.tn.find_type("tydesc").unwrap()
 265     }
 266
 267     pub fn get_intrinsic(&self, key: & &'static str) -> ValueRef {
 268         match self.intrinsics.borrow().find_copy(key) {
 269             Some(v) => return v,
 270             _ => {}
 271         }
 272         match declare_intrinsic(self, key) {
 273             Some(v) => return v,
 274             None => fail!()
 275         }
 276     }
 277
 278     // Although there is an experimental implementation of LLVM which
 279     // supports SS on armv7 it wasn't approved by Apple, see:
 280     // http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20140505/216350.html
 281     // It looks like it might be never accepted to upstream LLVM.
 282     //
 283     // So far the decision was to disable them in default builds
 284     // but it could be enabled (with patched LLVM)
 285     pub fn is_split_stack_supported(&self) -> bool {
 286         let ref cfg = self.sess().targ_cfg;
 287         cfg.os != abi::OsiOS || cfg.arch != abi::Arm
 288     }
 289 }
 290
 291 fn declare_intrinsic(ccx: &CrateContext, key: & &'static str) -> Option<ValueRef> {
 292     macro_rules! ifn (
 293         ($name:expr fn() -> $ret:expr) => (
 294             if *key == $name {
 295                 let f = base::decl_cdecl_fn(ccx, $name, Type::func([], &$ret), ty::mk_nil());
 296                 ccx.intrinsics.borrow_mut().insert($name, f.clone());
 297                 return Some(f);
 298             }
 299         );
 300         ($name:expr fn($($arg:expr),*) -> $ret:expr) => (
 301             if *key == $name {
 302                 let f = base::decl_cdecl_fn(ccx, $name,
 303                                   Type::func([$($arg),*], &$ret), ty::mk_nil());
 304                 ccx.intrinsics.borrow_mut().insert($name, f.clone());
 305                 return Some(f);
 306             }
 307         )
 308     )
 309     macro_rules! mk_struct (
 310         ($($field_ty:expr),*) => (Type::struct_(ccx, [$($field_ty),*], false))
 311     )
 312
 313     let i8p = Type::i8p(ccx);
 314     let void = Type::void(ccx);
 315     let i1 = Type::i1(ccx);
 316     let t_i8 = Type::i8(ccx);
 317     let t_i16 = Type::i16(ccx);
 318     let t_i32 = Type::i32(ccx);
 319     let t_i64 = Type::i64(ccx);
 320     let t_f32 = Type::f32(ccx);
 321     let t_f64 = Type::f64(ccx);
 322
 323     ifn!("llvm.memcpy.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void);
 324     ifn!("llvm.memcpy.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void);
 325     ifn!("llvm.memmove.p0i8.p0i8.i32" fn(i8p, i8p, t_i32, t_i32, i1) -> void);
 326     ifn!("llvm.memmove.p0i8.p0i8.i64" fn(i8p, i8p, t_i64, t_i32, i1) -> void);
 327     ifn!("llvm.memset.p0i8.i32" fn(i8p, t_i8, t_i32, t_i32, i1) -> void);
 328     ifn!("llvm.memset.p0i8.i64" fn(i8p, t_i8, t_i64, t_i32, i1) -> void);
 329
 330     ifn!("llvm.trap" fn() -> void);
 331     ifn!("llvm.debugtrap" fn() -> void);
 332     ifn!("llvm.frameaddress" fn(t_i32) -> i8p);
 333
 334     ifn!("llvm.powi.f32" fn(t_f32, t_i32) -> t_f32);
 335     ifn!("llvm.powi.f64" fn(t_f64, t_i32) -> t_f64);
 336     ifn!("llvm.pow.f32" fn(t_f32, t_f32) -> t_f32);
 337     ifn!("llvm.pow.f64" fn(t_f64, t_f64) -> t_f64);
 338
 339     ifn!("llvm.sqrt.f32" fn(t_f32) -> t_f32);
 340     ifn!("llvm.sqrt.f64" fn(t_f64) -> t_f64);
 341     ifn!("llvm.sin.f32" fn(t_f32) -> t_f32);
 342     ifn!("llvm.sin.f64" fn(t_f64) -> t_f64);
 343     ifn!("llvm.cos.f32" fn(t_f32) -> t_f32);
 344     ifn!("llvm.cos.f64" fn(t_f64) -> t_f64);
 345     ifn!("llvm.exp.f32" fn(t_f32) -> t_f32);
 346     ifn!("llvm.exp.f64" fn(t_f64) -> t_f64);
 347     ifn!("llvm.exp2.f32" fn(t_f32) -> t_f32);
 348     ifn!("llvm.exp2.f64" fn(t_f64) -> t_f64);
 349     ifn!("llvm.log.f32" fn(t_f32) -> t_f32);
 350     ifn!("llvm.log.f64" fn(t_f64) -> t_f64);
 351     ifn!("llvm.log10.f32" fn(t_f32) -> t_f32);
 352     ifn!("llvm.log10.f64" fn(t_f64) -> t_f64);
 353     ifn!("llvm.log2.f32" fn(t_f32) -> t_f32);
 354     ifn!("llvm.log2.f64" fn(t_f64) -> t_f64);
 355
 356     ifn!("llvm.fma.f32" fn(t_f32, t_f32, t_f32) -> t_f32);
 357     ifn!("llvm.fma.f64" fn(t_f64, t_f64, t_f64) -> t_f64);
 358
 359     ifn!("llvm.fabs.f32" fn(t_f32) -> t_f32);
 360     ifn!("llvm.fabs.f64" fn(t_f64) -> t_f64);
 361
 362     ifn!("llvm.floor.f32" fn(t_f32) -> t_f32);
 363     ifn!("llvm.floor.f64" fn(t_f64) -> t_f64);
 364     ifn!("llvm.ceil.f32" fn(t_f32) -> t_f32);
 365     ifn!("llvm.ceil.f64" fn(t_f64) -> t_f64);
 366     ifn!("llvm.trunc.f32" fn(t_f32) -> t_f32);
 367     ifn!("llvm.trunc.f64" fn(t_f64) -> t_f64);
 368
 369     ifn!("llvm.rint.f32" fn(t_f32) -> t_f32);
 370     ifn!("llvm.rint.f64" fn(t_f64) -> t_f64);
 371     ifn!("llvm.nearbyint.f32" fn(t_f32) -> t_f32);
 372     ifn!("llvm.nearbyint.f64" fn(t_f64) -> t_f64);
 373
 374     ifn!("llvm.ctpop.i8" fn(t_i8) -> t_i8);
 375     ifn!("llvm.ctpop.i16" fn(t_i16) -> t_i16);
 376     ifn!("llvm.ctpop.i32" fn(t_i32) -> t_i32);
 377     ifn!("llvm.ctpop.i64" fn(t_i64) -> t_i64);
 378
 379     ifn!("llvm.ctlz.i8" fn(t_i8 , i1) -> t_i8);
 380     ifn!("llvm.ctlz.i16" fn(t_i16, i1) -> t_i16);
 381     ifn!("llvm.ctlz.i32" fn(t_i32, i1) -> t_i32);
 382     ifn!("llvm.ctlz.i64" fn(t_i64, i1) -> t_i64);
 383
 384     ifn!("llvm.cttz.i8" fn(t_i8 , i1) -> t_i8);
 385     ifn!("llvm.cttz.i16" fn(t_i16, i1) -> t_i16);
 386     ifn!("llvm.cttz.i32" fn(t_i32, i1) -> t_i32);
 387     ifn!("llvm.cttz.i64" fn(t_i64, i1) -> t_i64);
 388
 389     ifn!("llvm.bswap.i16" fn(t_i16) -> t_i16);
 390     ifn!("llvm.bswap.i32" fn(t_i32) -> t_i32);
 391     ifn!("llvm.bswap.i64" fn(t_i64) -> t_i64);
 392
 393     ifn!("llvm.sadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
 394     ifn!("llvm.sadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
 395     ifn!("llvm.sadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
 396     ifn!("llvm.sadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
 397
 398     ifn!("llvm.uadd.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
 399     ifn!("llvm.uadd.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
 400     ifn!("llvm.uadd.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
 401     ifn!("llvm.uadd.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
 402
 403     ifn!("llvm.ssub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
 404     ifn!("llvm.ssub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
 405     ifn!("llvm.ssub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
 406     ifn!("llvm.ssub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
 407
 408     ifn!("llvm.usub.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
 409     ifn!("llvm.usub.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
 410     ifn!("llvm.usub.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
 411     ifn!("llvm.usub.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
 412
 413     ifn!("llvm.smul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
 414     ifn!("llvm.smul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
 415     ifn!("llvm.smul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
 416     ifn!("llvm.smul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
 417
 418     ifn!("llvm.umul.with.overflow.i8" fn(t_i8, t_i8) -> mk_struct!{t_i8, i1});
 419     ifn!("llvm.umul.with.overflow.i16" fn(t_i16, t_i16) -> mk_struct!{t_i16, i1});
 420     ifn!("llvm.umul.with.overflow.i32" fn(t_i32, t_i32) -> mk_struct!{t_i32, i1});
 421     ifn!("llvm.umul.with.overflow.i64" fn(t_i64, t_i64) -> mk_struct!{t_i64, i1});
 422
 423     ifn!("llvm.expect.i1" fn(i1, i1) -> i1);
 424
 425     // Some intrinsics were introduced in later versions of LLVM, but they have
 426     // fallbacks in libc or libm and such. Currently, all of these intrinsics
 427     // were introduced in LLVM 3.4, so we case on that.
 428     macro_rules! compatible_ifn (
 429         ($name:expr, $cname:ident ($($arg:expr),*) -> $ret:expr) => (
 430             if unsafe { llvm::LLVMVersionMinor() >= 4 } {
 431                 // The `if key == $name` is already in ifn!
 432                 ifn!($name fn($($arg),*) -> $ret);
 433             } else if *key == $name {
 434                 let f = base::decl_cdecl_fn(ccx, stringify!($cname),
 435                                       Type::func([$($arg),*], &$ret),
 436                                       ty::mk_nil());
 437                 ccx.intrinsics.borrow_mut().insert($name, f.clone());
 438                 return Some(f);
 439             }
 440         )
 441     )
 442
 443     compatible_ifn!("llvm.copysign.f32", copysignf(t_f32, t_f32) -> t_f32);
 444     compatible_ifn!("llvm.copysign.f64", copysign(t_f64, t_f64) -> t_f64);
 445     compatible_ifn!("llvm.round.f32", roundf(t_f32) -> t_f32);
 446     compatible_ifn!("llvm.round.f64", round(t_f64) -> t_f64);
 447
 448
 449     if ccx.sess().opts.debuginfo != NoDebugInfo {
 450         ifn!("llvm.dbg.declare" fn(Type::metadata(ccx), Type::metadata(ccx)) -> void);
 451         ifn!("llvm.dbg.value" fn(Type::metadata(ccx), t_i64, Type::metadata(ccx)) -> void);
 452     }
 453     return None;
 454 }