// Copyright 2012-2014 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 or the MIT license // , at your // option. This file may not be copied, modified, or distributed // except according to those terms. #![allow(non_camel_case_types, non_snake_case_functions)] //! Code that is useful in various trans modules. use driver::session::Session; use llvm; use llvm::{ValueRef, BasicBlockRef, BuilderRef}; use llvm::{True, False, Bool}; use middle::def; use middle::freevars; use middle::lang_items::LangItem; use middle::mem_categorization as mc; use middle::subst; use middle::subst::Subst; use middle::trans::base; use middle::trans::build; use middle::trans::cleanup; use middle::trans::datum; use middle::trans::debuginfo; use middle::trans::type_::Type; use middle::trans::type_of; use middle::ty; use middle::typeck; use util::ppaux::Repr; use util::nodemap::{DefIdMap, NodeMap}; use arena::TypedArena; use std::collections::HashMap; use libc::{c_uint, c_longlong, c_ulonglong, c_char}; use std::c_str::ToCStr; use std::cell::{Cell, RefCell}; use std::vec::Vec; use syntax::ast::Ident; use syntax::ast; use syntax::ast_map::{PathElem, PathName}; use syntax::codemap::Span; use syntax::parse::token::InternedString; use syntax::parse::token; pub use middle::trans::context::CrateContext; fn type_is_newtype_immediate(ccx: &CrateContext, ty: ty::t) -> bool { match ty::get(ty).sty { ty::ty_struct(def_id, ref substs) => { let fields = ty::struct_fields(ccx.tcx(), def_id, substs); fields.len() == 1 && fields.get(0).ident.name == token::special_idents::unnamed_field.name && type_is_immediate(ccx, fields.get(0).mt.ty) } _ => false } } pub fn type_is_immediate(ccx: &CrateContext, ty: ty::t) -> bool { use middle::trans::machine::llsize_of_alloc; use middle::trans::type_of::sizing_type_of; let tcx = ccx.tcx(); let simple = ty::type_is_scalar(ty) || ty::type_is_boxed(ty) || ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) || type_is_newtype_immediate(ccx, ty) || ty::type_is_bot(ty) || ty::type_is_simd(tcx, ty); if simple && !ty::type_is_fat_ptr(tcx, ty) { return true; } match ty::get(ty).sty { ty::ty_bot => true, ty::ty_struct(..) | ty::ty_enum(..) | ty::ty_tup(..) | ty::ty_unboxed_closure(..) => { let llty = sizing_type_of(ccx, ty); llsize_of_alloc(ccx, llty) <= llsize_of_alloc(ccx, ccx.int_type) } _ => type_is_zero_size(ccx, ty) } } pub fn type_is_zero_size(ccx: &CrateContext, ty: ty::t) -> bool { /*! * Identify types which have size zero at runtime. */ use middle::trans::machine::llsize_of_alloc; use middle::trans::type_of::sizing_type_of; let llty = sizing_type_of(ccx, ty); llsize_of_alloc(ccx, llty) == 0 } pub fn return_type_is_void(ccx: &CrateContext, ty: ty::t) -> bool { /*! * Identifies types which we declare to be equivalent to `void` * in C for the purpose of function return types. These are * `()`, bot, and uninhabited enums. Note that all such types * are also zero-size, but not all zero-size types use a `void` * return type (in order to aid with C ABI compatibility). */ ty::type_is_nil(ty) || ty::type_is_bot(ty) || ty::type_is_empty(ccx.tcx(), ty) } /// Generates a unique symbol based off the name given. This is used to create /// unique symbols for things like closures. pub fn gensym_name(name: &str) -> PathElem { let num = token::gensym(name).uint(); // use one colon which will get translated to a period by the mangler, and // we're guaranteed that `num` is globally unique for this crate. PathName(token::gensym(format!("{}:{}", name, num).as_slice())) } pub struct tydesc_info { pub ty: ty::t, pub tydesc: ValueRef, pub size: ValueRef, pub align: ValueRef, pub name: ValueRef, pub visit_glue: Cell>, } /* * A note on nomenclature of linking: "extern", "foreign", and "upcall". * * An "extern" is an LLVM symbol we wind up emitting an undefined external * reference to. This means "we don't have the thing in this compilation unit, * please make sure you link it in at runtime". This could be a reference to * C code found in a C library, or rust code found in a rust crate. * * Most "externs" are implicitly declared (automatically) as a result of a * user declaring an extern _module_ dependency; this causes the rust driver * to locate an extern crate, scan its compilation metadata, and emit extern * declarations for any symbols used by the declaring crate. * * A "foreign" is an extern that references C (or other non-rust ABI) code. * There is no metadata to scan for extern references so in these cases either * a header-digester like bindgen, or manual function prototypes, have to * serve as declarators. So these are usually given explicitly as prototype * declarations, in rust code, with ABI attributes on them noting which ABI to * link via. * * An "upcall" is a foreign call generated by the compiler (not corresponding * to any user-written call in the code) into the runtime library, to perform * some helper task such as bringing a task to life, allocating memory, etc. * */ pub struct NodeInfo { pub id: ast::NodeId, pub span: Span, } pub fn expr_info(expr: &ast::Expr) -> NodeInfo { NodeInfo { id: expr.id, span: expr.span } } pub struct BuilderRef_res { pub b: BuilderRef, } impl Drop for BuilderRef_res { fn drop(&mut self) { unsafe { llvm::LLVMDisposeBuilder(self.b); } } } pub fn BuilderRef_res(b: BuilderRef) -> BuilderRef_res { BuilderRef_res { b: b } } pub type ExternMap = HashMap; // Here `self_ty` is the real type of the self parameter to this method. It // will only be set in the case of default methods. pub struct param_substs { pub substs: subst::Substs, pub vtables: typeck::vtable_res, } impl param_substs { pub fn empty() -> param_substs { param_substs { substs: subst::Substs::trans_empty(), vtables: subst::VecPerParamSpace::empty(), } } pub fn validate(&self) { assert!(self.substs.types.all(|t| !ty::type_needs_infer(*t))); } } fn param_substs_to_string(this: ¶m_substs, tcx: &ty::ctxt) -> String { format!("param_substs(substs={},vtables={})", this.substs.repr(tcx), this.vtables.repr(tcx)) } impl Repr for param_substs { fn repr(&self, tcx: &ty::ctxt) -> String { param_substs_to_string(self, tcx) } } pub trait SubstP { fn substp(&self, tcx: &ty::ctxt, param_substs: ¶m_substs) -> Self; } impl SubstP for T { fn substp(&self, tcx: &ty::ctxt, substs: ¶m_substs) -> T { self.subst(tcx, &substs.substs) } } // work around bizarre resolve errors pub type RvalueDatum = datum::Datum; pub type LvalueDatum = datum::Datum; // Function context. Every LLVM function we create will have one of // these. pub struct FunctionContext<'a> { // The ValueRef returned from a call to llvm::LLVMAddFunction; the // address of the first instruction in the sequence of // instructions for this function that will go in the .text // section of the executable we're generating. pub llfn: ValueRef, // The environment argument in a closure. pub llenv: Option, // A pointer to where to store the return value. If the return type is // immediate, this points to an alloca in the function. Otherwise, it's a // pointer to the hidden first parameter of the function. After function // construction, this should always be Some. pub llretslotptr: Cell>, // These pub elements: "hoisted basic blocks" containing // administrative activities that have to happen in only one place in // the function, due to LLVM's quirks. // A marker for the place where we want to insert the function's static // allocas, so that LLVM will coalesce them into a single alloca call. pub alloca_insert_pt: Cell>, pub llreturn: Cell>, // If the function has any nested return's, including something like: // fn foo() -> Option { Some(Foo { x: return None }) }, then // we use a separate alloca for each return pub needs_ret_allocas: bool, // The a value alloca'd for calls to upcalls.rust_personality. Used when // outputting the resume instruction. pub personality: Cell>, // True if the caller expects this fn to use the out pointer to // return. Either way, your code should write into the slot llretslotptr // points to, but if this value is false, that slot will be a local alloca. pub caller_expects_out_pointer: bool, // Maps arguments to allocas created for them in llallocas. pub llargs: RefCell>, // Maps the def_ids for local variables to the allocas created for // them in llallocas. pub lllocals: RefCell>, // Same as above, but for closure upvars pub llupvars: RefCell>, // The NodeId of the function, or -1 if it doesn't correspond to // a user-defined function. pub id: ast::NodeId, // If this function is being monomorphized, this contains the type // substitutions used. pub param_substs: &'a param_substs, // The source span and nesting context where this function comes from, for // error reporting and symbol generation. pub span: Option, // The arena that blocks are allocated from. pub block_arena: &'a TypedArena>, // This function's enclosing crate context. pub ccx: &'a CrateContext, // Used and maintained by the debuginfo module. pub debug_context: debuginfo::FunctionDebugContext, // Cleanup scopes. pub scopes: RefCell> >, } impl<'a> FunctionContext<'a> { pub fn arg_pos(&self, arg: uint) -> uint { let arg = self.env_arg_pos() + arg; if self.llenv.is_some() { arg + 1 } else { arg } } pub fn out_arg_pos(&self) -> uint { assert!(self.caller_expects_out_pointer); 0u } pub fn env_arg_pos(&self) -> uint { if self.caller_expects_out_pointer { 1u } else { 0u } } pub fn cleanup(&self) { unsafe { llvm::LLVMInstructionEraseFromParent(self.alloca_insert_pt .get() .unwrap()); } } pub fn get_llreturn(&self) -> BasicBlockRef { if self.llreturn.get().is_none() { self.llreturn.set(Some(unsafe { "return".with_c_str(|buf| { llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx, self.llfn, buf) }) })) } self.llreturn.get().unwrap() } pub fn get_ret_slot(&self, bcx: &Block, ty: ty::t, name: &str) -> ValueRef { if self.needs_ret_allocas { base::alloca_no_lifetime(bcx, type_of::type_of(bcx.ccx(), ty), name) } else { self.llretslotptr.get().unwrap() } } pub fn new_block(&'a self, is_lpad: bool, name: &str, opt_node_id: Option) -> &'a Block<'a> { unsafe { let llbb = name.with_c_str(|buf| { llvm::LLVMAppendBasicBlockInContext(self.ccx.llcx, self.llfn, buf) }); Block::new(llbb, is_lpad, opt_node_id, self) } } pub fn new_id_block(&'a self, name: &str, node_id: ast::NodeId) -> &'a Block<'a> { self.new_block(false, name, Some(node_id)) } pub fn new_temp_block(&'a self, name: &str) -> &'a Block<'a> { self.new_block(false, name, None) } pub fn join_blocks(&'a self, id: ast::NodeId, in_cxs: &[&'a Block<'a>]) -> &'a Block<'a> { let out = self.new_id_block("join", id); let mut reachable = false; for bcx in in_cxs.iter() { if !bcx.unreachable.get() { build::Br(*bcx, out.llbb); reachable = true; } } if !reachable { build::Unreachable(out); } return out; } } // Basic block context. We create a block context for each basic block // (single-entry, single-exit sequence of instructions) we generate from Rust // code. Each basic block we generate is attached to a function, typically // with many basic blocks per function. All the basic blocks attached to a // function are organized as a directed graph. pub struct Block<'a> { // The BasicBlockRef returned from a call to // llvm::LLVMAppendBasicBlock(llfn, name), which adds a basic // block to the function pointed to by llfn. We insert // instructions into that block by way of this block context. // The block pointing to this one in the function's digraph. pub llbb: BasicBlockRef, pub terminated: Cell, pub unreachable: Cell, // Is this block part of a landing pad? pub is_lpad: bool, // AST node-id associated with this block, if any. Used for // debugging purposes only. pub opt_node_id: Option, // The function context for the function to which this block is // attached. pub fcx: &'a FunctionContext<'a>, } impl<'a> Block<'a> { pub fn new<'a>( llbb: BasicBlockRef, is_lpad: bool, opt_node_id: Option, fcx: &'a FunctionContext<'a>) -> &'a Block<'a> { fcx.block_arena.alloc(Block { llbb: llbb, terminated: Cell::new(false), unreachable: Cell::new(false), is_lpad: is_lpad, opt_node_id: opt_node_id, fcx: fcx }) } pub fn ccx(&self) -> &'a CrateContext { self.fcx.ccx } pub fn tcx(&self) -> &'a ty::ctxt { &self.fcx.ccx.tcx } pub fn sess(&self) -> &'a Session { self.fcx.ccx.sess() } pub fn ident(&self, ident: Ident) -> String { token::get_ident(ident).get().to_string() } pub fn node_id_to_string(&self, id: ast::NodeId) -> String { self.tcx().map.node_to_string(id).to_string() } pub fn expr_to_string(&self, e: &ast::Expr) -> String { e.repr(self.tcx()) } pub fn def(&self, nid: ast::NodeId) -> def::Def { match self.tcx().def_map.borrow().find(&nid) { Some(&v) => v, None => { self.tcx().sess.bug(format!( "no def associated with node id {:?}", nid).as_slice()); } } } pub fn val_to_string(&self, val: ValueRef) -> String { self.ccx().tn.val_to_string(val) } pub fn llty_str(&self, ty: Type) -> String { self.ccx().tn.type_to_string(ty) } pub fn ty_to_string(&self, t: ty::t) -> String { t.repr(self.tcx()) } pub fn to_str(&self) -> String { let blk: *const Block = self; format!("[block {}]", blk) } } impl<'a> mc::Typer for Block<'a> { fn tcx<'a>(&'a self) -> &'a ty::ctxt { self.tcx() } fn node_ty(&self, id: ast::NodeId) -> mc::McResult { Ok(node_id_type(self, id)) } fn node_method_ty(&self, method_call: typeck::MethodCall) -> Option { self.tcx().method_map.borrow().find(&method_call).map(|method| method.ty) } fn adjustments<'a>(&'a self) -> &'a RefCell> { &self.tcx().adjustments } fn is_method_call(&self, id: ast::NodeId) -> bool { self.tcx().method_map.borrow().contains_key(&typeck::MethodCall::expr(id)) } fn temporary_scope(&self, rvalue_id: ast::NodeId) -> Option { self.tcx().region_maps.temporary_scope(rvalue_id) } fn unboxed_closures<'a>(&'a self) -> &'a RefCell> { &self.tcx().unboxed_closures } fn upvar_borrow(&self, upvar_id: ty::UpvarId) -> ty::UpvarBorrow { self.tcx().upvar_borrow_map.borrow().get_copy(&upvar_id) } fn capture_mode(&self, closure_expr_id: ast::NodeId) -> freevars::CaptureMode { self.tcx().capture_modes.borrow().get_copy(&closure_expr_id) } } pub struct Result<'a> { pub bcx: &'a Block<'a>, pub val: ValueRef } impl<'a> Result<'a> { pub fn new(bcx: &'a Block<'a>, val: ValueRef) -> Result<'a> { Result { bcx: bcx, val: val, } } } pub fn val_ty(v: ValueRef) -> Type { unsafe { Type::from_ref(llvm::LLVMTypeOf(v)) } } // LLVM constant constructors. pub fn C_null(t: Type) -> ValueRef { unsafe { llvm::LLVMConstNull(t.to_ref()) } } pub fn C_undef(t: Type) -> ValueRef { unsafe { llvm::LLVMGetUndef(t.to_ref()) } } pub fn C_integral(t: Type, u: u64, sign_extend: bool) -> ValueRef { unsafe { llvm::LLVMConstInt(t.to_ref(), u, sign_extend as Bool) } } pub fn C_floating(s: &str, t: Type) -> ValueRef { unsafe { s.with_c_str(|buf| llvm::LLVMConstRealOfString(t.to_ref(), buf)) } } pub fn C_nil(ccx: &CrateContext) -> ValueRef { C_struct(ccx, [], false) } pub fn C_bool(ccx: &CrateContext, val: bool) -> ValueRef { C_integral(Type::i1(ccx), val as u64, false) } pub fn C_i32(ccx: &CrateContext, i: i32) -> ValueRef { C_integral(Type::i32(ccx), i as u64, true) } pub fn C_i64(ccx: &CrateContext, i: i64) -> ValueRef { C_integral(Type::i64(ccx), i as u64, true) } pub fn C_u64(ccx: &CrateContext, i: u64) -> ValueRef { C_integral(Type::i64(ccx), i, false) } pub fn C_int(ccx: &CrateContext, i: int) -> ValueRef { C_integral(ccx.int_type, i as u64, true) } pub fn C_uint(ccx: &CrateContext, i: uint) -> ValueRef { C_integral(ccx.int_type, i as u64, false) } pub fn C_u8(ccx: &CrateContext, i: uint) -> ValueRef { C_integral(Type::i8(ccx), i as u64, false) } // This is a 'c-like' raw string, which differs from // our boxed-and-length-annotated strings. pub fn C_cstr(cx: &CrateContext, s: InternedString, null_terminated: bool) -> ValueRef { unsafe { match cx.const_cstr_cache.borrow().find(&s) { Some(&llval) => return llval, None => () } let sc = llvm::LLVMConstStringInContext(cx.llcx, s.get().as_ptr() as *const c_char, s.get().len() as c_uint, !null_terminated as Bool); let gsym = token::gensym("str"); let g = format!("str{}", gsym.uint()).with_c_str(|buf| { llvm::LLVMAddGlobal(cx.llmod, val_ty(sc).to_ref(), buf) }); llvm::LLVMSetInitializer(g, sc); llvm::LLVMSetGlobalConstant(g, True); llvm::SetLinkage(g, llvm::InternalLinkage); cx.const_cstr_cache.borrow_mut().insert(s, g); g } } // NB: Do not use `do_spill_noroot` to make this into a constant string, or // you will be kicked off fast isel. See issue #4352 for an example of this. pub fn C_str_slice(cx: &CrateContext, s: InternedString) -> ValueRef { unsafe { let len = s.get().len(); let cs = llvm::LLVMConstPointerCast(C_cstr(cx, s, false), Type::i8p(cx).to_ref()); C_named_struct(cx.tn.find_type("str_slice").unwrap(), [cs, C_uint(cx, len)]) } } pub fn C_binary_slice(cx: &CrateContext, data: &[u8]) -> ValueRef { unsafe { let len = data.len(); let lldata = C_bytes(cx, data); let gsym = token::gensym("binary"); let g = format!("binary{}", gsym.uint()).with_c_str(|buf| { llvm::LLVMAddGlobal(cx.llmod, val_ty(lldata).to_ref(), buf) }); llvm::LLVMSetInitializer(g, lldata); llvm::LLVMSetGlobalConstant(g, True); llvm::SetLinkage(g, llvm::InternalLinkage); let cs = llvm::LLVMConstPointerCast(g, Type::i8p(cx).to_ref()); C_struct(cx, [cs, C_uint(cx, len)], false) } } pub fn C_struct(ccx: &CrateContext, elts: &[ValueRef], packed: bool) -> ValueRef { unsafe { llvm::LLVMConstStructInContext(ccx.llcx, elts.as_ptr(), elts.len() as c_uint, packed as Bool) } } pub fn C_named_struct(t: Type, elts: &[ValueRef]) -> ValueRef { unsafe { llvm::LLVMConstNamedStruct(t.to_ref(), elts.as_ptr(), elts.len() as c_uint) } } pub fn C_array(ty: Type, elts: &[ValueRef]) -> ValueRef { unsafe { return llvm::LLVMConstArray(ty.to_ref(), elts.as_ptr(), elts.len() as c_uint); } } pub fn C_bytes(ccx: &CrateContext, bytes: &[u8]) -> ValueRef { unsafe { let ptr = bytes.as_ptr() as *const c_char; return llvm::LLVMConstStringInContext(ccx.llcx, ptr, bytes.len() as c_uint, True); } } pub fn const_get_elt(cx: &CrateContext, v: ValueRef, us: &[c_uint]) -> ValueRef { unsafe { let r = llvm::LLVMConstExtractValue(v, us.as_ptr(), us.len() as c_uint); debug!("const_get_elt(v={}, us={:?}, r={})", cx.tn.val_to_string(v), us, cx.tn.val_to_string(r)); return r; } } pub fn is_const(v: ValueRef) -> bool { unsafe { llvm::LLVMIsConstant(v) == True } } pub fn const_to_int(v: ValueRef) -> c_longlong { unsafe { llvm::LLVMConstIntGetSExtValue(v) } } pub fn const_to_uint(v: ValueRef) -> c_ulonglong { unsafe { llvm::LLVMConstIntGetZExtValue(v) } } pub fn is_undef(val: ValueRef) -> bool { unsafe { llvm::LLVMIsUndef(val) != False } } pub fn is_null(val: ValueRef) -> bool { unsafe { llvm::LLVMIsNull(val) != False } } pub fn monomorphize_type(bcx: &Block, t: ty::t) -> ty::t { t.subst(bcx.tcx(), &bcx.fcx.param_substs.substs) } pub fn node_id_type(bcx: &Block, id: ast::NodeId) -> ty::t { let tcx = bcx.tcx(); let t = ty::node_id_to_type(tcx, id); monomorphize_type(bcx, t) } pub fn expr_ty(bcx: &Block, ex: &ast::Expr) -> ty::t { node_id_type(bcx, ex.id) } pub fn expr_ty_adjusted(bcx: &Block, ex: &ast::Expr) -> ty::t { monomorphize_type(bcx, ty::expr_ty_adjusted(bcx.tcx(), ex)) } // Key used to lookup values supplied for type parameters in an expr. #[deriving(PartialEq)] pub enum ExprOrMethodCall { // Type parameters for a path like `None::` ExprId(ast::NodeId), // Type parameters for a method call like `a.foo::()` MethodCall(typeck::MethodCall) } pub fn node_id_substs(bcx: &Block, node: ExprOrMethodCall) -> subst::Substs { let tcx = bcx.tcx(); let substs = match node { ExprId(id) => { ty::node_id_item_substs(tcx, id).substs } MethodCall(method_call) => { tcx.method_map.borrow().get(&method_call).substs.clone() } }; if substs.types.any(|t| ty::type_needs_infer(*t)) { bcx.sess().bug( format!("type parameters for node {:?} include inference types: \ {}", node, substs.repr(bcx.tcx())).as_slice()); } substs.substp(tcx, bcx.fcx.param_substs) } pub fn node_vtables(bcx: &Block, id: typeck::MethodCall) -> typeck::vtable_res { bcx.tcx().vtable_map.borrow().find(&id).map(|vts| { resolve_vtables_in_fn_ctxt(bcx.fcx, vts) }).unwrap_or_else(|| subst::VecPerParamSpace::empty()) } // Apply the typaram substitutions in the FunctionContext to some // vtables. This should eliminate any vtable_params. pub fn resolve_vtables_in_fn_ctxt(fcx: &FunctionContext, vts: &typeck::vtable_res) -> typeck::vtable_res { resolve_vtables_under_param_substs(fcx.ccx.tcx(), fcx.param_substs, vts) } pub fn resolve_vtables_under_param_substs(tcx: &ty::ctxt, param_substs: ¶m_substs, vts: &typeck::vtable_res) -> typeck::vtable_res { vts.map(|ds| { resolve_param_vtables_under_param_substs(tcx, param_substs, ds) }) } pub fn resolve_param_vtables_under_param_substs(tcx: &ty::ctxt, param_substs: ¶m_substs, ds: &typeck::vtable_param_res) -> typeck::vtable_param_res { ds.iter().map(|d| { resolve_vtable_under_param_substs(tcx, param_substs, d) }).collect() } pub fn resolve_vtable_under_param_substs(tcx: &ty::ctxt, param_substs: ¶m_substs, vt: &typeck::vtable_origin) -> typeck::vtable_origin { match *vt { typeck::vtable_static(trait_id, ref vtable_substs, ref sub) => { let vtable_substs = vtable_substs.substp(tcx, param_substs); typeck::vtable_static( trait_id, vtable_substs, resolve_vtables_under_param_substs(tcx, param_substs, sub)) } typeck::vtable_param(n_param, n_bound) => { find_vtable(tcx, param_substs, n_param, n_bound) } typeck::vtable_unboxed_closure(def_id) => { typeck::vtable_unboxed_closure(def_id) } typeck::vtable_error => typeck::vtable_error } } pub fn find_vtable(tcx: &ty::ctxt, ps: ¶m_substs, n_param: typeck::param_index, n_bound: uint) -> typeck::vtable_origin { debug!("find_vtable(n_param={:?}, n_bound={}, ps={})", n_param, n_bound, ps.repr(tcx)); let param_bounds = ps.vtables.get(n_param.space, n_param.index); param_bounds.get(n_bound).clone() } pub fn langcall(bcx: &Block, span: Option, msg: &str, li: LangItem) -> ast::DefId { match bcx.tcx().lang_items.require(li) { Ok(id) => id, Err(s) => { let msg = format!("{} {}", msg, s); match span { Some(span) => bcx.tcx().sess.span_fatal(span, msg.as_slice()), None => bcx.tcx().sess.fatal(msg.as_slice()), } } } }