src/librustc_trans/trans/debuginfo/mod.rs

   1 // Copyright 2012-2015 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 // See doc.rs for documentation.
  12 mod doc;
  13
  14 use self::VariableAccess::*;
  15 use self::VariableKind::*;
  16
  17 use self::utils::{DIB, span_start, assert_type_for_node_id, contains_nodebug_attribute,
  18                   create_DIArray, is_node_local_to_unit};
  19 use self::namespace::{namespace_for_item, NamespaceTreeNode};
  20 use self::type_names::compute_debuginfo_type_name;
  21 use self::metadata::{type_metadata, diverging_type_metadata};
  22 use self::metadata::{file_metadata, scope_metadata, TypeMap, compile_unit_metadata};
  23 use self::source_loc::InternalDebugLocation;
  24
  25 use llvm;
  26 use llvm::{ModuleRef, ContextRef, ValueRef};
  27 use llvm::debuginfo::{DIFile, DIType, DIScope, DIBuilderRef, DISubprogram, DIArray,
  28                       DIDescriptor, FlagPrototyped};
  29 use middle::def_id::DefId;
  30 use middle::infer::normalize_associated_type;
  31 use middle::subst::{self, Substs};
  32 use rustc_front;
  33 use rustc_front::hir;
  34
  35 use trans::common::{NodeIdAndSpan, CrateContext, FunctionContext, Block};
  36 use trans;
  37 use trans::{monomorphize, type_of};
  38 use middle::infer;
  39 use middle::ty::{self, Ty};
  40 use session::config::{self, FullDebugInfo, LimitedDebugInfo, NoDebugInfo};
  41 use util::nodemap::{NodeMap, FnvHashMap, FnvHashSet};
  42 use rustc::front::map as hir_map;
  43
  44 use libc::c_uint;
  45 use std::cell::{Cell, RefCell};
  46 use std::ffi::CString;
  47 use std::ptr;
  48 use std::rc::Rc;
  49
  50 use syntax::codemap::{Span, Pos};
  51 use syntax::{ast, codemap};
  52 use syntax::abi::Abi;
  53 use syntax::attr::IntType;
  54 use syntax::parse::token::{self, special_idents};
  55
  56 pub mod gdb;
  57 mod utils;
  58 mod namespace;
  59 mod type_names;
  60 mod metadata;
  61 mod create_scope_map;
  62 mod source_loc;
  63
  64 pub use self::source_loc::set_source_location;
  65 pub use self::source_loc::clear_source_location;
  66 pub use self::source_loc::start_emitting_source_locations;
  67 pub use self::source_loc::get_cleanup_debug_loc_for_ast_node;
  68 pub use self::source_loc::with_source_location_override;
  69 pub use self::metadata::create_match_binding_metadata;
  70 pub use self::metadata::create_argument_metadata;
  71 pub use self::metadata::create_captured_var_metadata;
  72 pub use self::metadata::create_global_var_metadata;
  73 pub use self::metadata::create_local_var_metadata;
  74
  75 #[allow(non_upper_case_globals)]
  76 const DW_TAG_auto_variable: c_uint = 0x100;
  77 #[allow(non_upper_case_globals)]
  78 const DW_TAG_arg_variable: c_uint = 0x101;
  79
  80 /// A context object for maintaining all state needed by the debuginfo module.
  81 pub struct CrateDebugContext<'tcx> {
  82     llcontext: ContextRef,
  83     builder: DIBuilderRef,
  84     current_debug_location: Cell<InternalDebugLocation>,
  85     created_files: RefCell<FnvHashMap<String, DIFile>>,
  86     created_enum_disr_types: RefCell<FnvHashMap<(DefId, IntType), DIType>>,
  87
  88     type_map: RefCell<TypeMap<'tcx>>,
  89     namespace_map: RefCell<FnvHashMap<Vec<ast::Name>, Rc<NamespaceTreeNode>>>,
  90
  91     // This collection is used to assert that composite types (structs, enums,
  92     // ...) have their members only set once:
  93     composite_types_completed: RefCell<FnvHashSet<DIType>>,
  94 }
  95
  96 impl<'tcx> CrateDebugContext<'tcx> {
  97     pub fn new(llmod: ModuleRef) -> CrateDebugContext<'tcx> {
  98         debug!("CrateDebugContext::new");
  99         let builder = unsafe { llvm::LLVMDIBuilderCreate(llmod) };
 100         // DIBuilder inherits context from the module, so we'd better use the same one
 101         let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
 102         return CrateDebugContext {
 103             llcontext: llcontext,
 104             builder: builder,
 105             current_debug_location: Cell::new(InternalDebugLocation::UnknownLocation),
 106             created_files: RefCell::new(FnvHashMap()),
 107             created_enum_disr_types: RefCell::new(FnvHashMap()),
 108             type_map: RefCell::new(TypeMap::new()),
 109             namespace_map: RefCell::new(FnvHashMap()),
 110             composite_types_completed: RefCell::new(FnvHashSet()),
 111         };
 112     }
 113 }
 114
 115 pub enum FunctionDebugContext {
 116     RegularContext(Box<FunctionDebugContextData>),
 117     DebugInfoDisabled,
 118     FunctionWithoutDebugInfo,
 119 }
 120
 121 impl FunctionDebugContext {
 122     fn get_ref<'a>(&'a self,
 123                    cx: &CrateContext,
 124                    span: Span)
 125                    -> &'a FunctionDebugContextData {
 126         match *self {
 127             FunctionDebugContext::RegularContext(box ref data) => data,
 128             FunctionDebugContext::DebugInfoDisabled => {
 129                 cx.sess().span_bug(span,
 130                                    FunctionDebugContext::debuginfo_disabled_message());
 131             }
 132             FunctionDebugContext::FunctionWithoutDebugInfo => {
 133                 cx.sess().span_bug(span,
 134                                    FunctionDebugContext::should_be_ignored_message());
 135             }
 136         }
 137     }
 138
 139     fn debuginfo_disabled_message() -> &'static str {
 140         "debuginfo: Error trying to access FunctionDebugContext although debug info is disabled!"
 141     }
 142
 143     fn should_be_ignored_message() -> &'static str {
 144         "debuginfo: Error trying to access FunctionDebugContext for function that should be \
 145          ignored by debug info!"
 146     }
 147 }
 148
 149 pub struct FunctionDebugContextData {
 150     scope_map: RefCell<NodeMap<DIScope>>,
 151     fn_metadata: DISubprogram,
 152     argument_counter: Cell<usize>,
 153     source_locations_enabled: Cell<bool>,
 154     source_location_override: Cell<bool>,
 155 }
 156
 157 pub enum VariableAccess<'a> {
 158     // The llptr given is an alloca containing the variable's value
 159     DirectVariable { alloca: ValueRef },
 160     // The llptr given is an alloca containing the start of some pointer chain
 161     // leading to the variable's content.
 162     IndirectVariable { alloca: ValueRef, address_operations: &'a [i64] }
 163 }
 164
 165 pub enum VariableKind {
 166     ArgumentVariable(usize /*index*/),
 167     LocalVariable,
 168     CapturedVariable,
 169 }
 170
 171 /// Create any deferred debug metadata nodes
 172 pub fn finalize(cx: &CrateContext) {
 173     if cx.dbg_cx().is_none() {
 174         return;
 175     }
 176
 177     debug!("finalize");
 178     let _ = compile_unit_metadata(cx);
 179
 180     if gdb::needs_gdb_debug_scripts_section(cx) {
 181         // Add a .debug_gdb_scripts section to this compile-unit. This will
 182         // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
 183         // which activates the Rust pretty printers for binary this section is
 184         // contained in.
 185         gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
 186     }
 187
 188     unsafe {
 189         llvm::LLVMDIBuilderFinalize(DIB(cx));
 190         llvm::LLVMDIBuilderDispose(DIB(cx));
 191         // Debuginfo generation in LLVM by default uses a higher
 192         // version of dwarf than OS X currently understands. We can
 193         // instruct LLVM to emit an older version of dwarf, however,
 194         // for OS X to understand. For more info see #11352
 195         // This can be overridden using --llvm-opts -dwarf-version,N.
 196         // Android has the same issue (#22398)
 197         if cx.sess().target.target.options.is_like_osx ||
 198            cx.sess().target.target.options.is_like_android {
 199             llvm::LLVMRustAddModuleFlag(cx.llmod(),
 200                                         "Dwarf Version\0".as_ptr() as *const _,
 201                                         2)
 202         }
 203
 204         // Indicate that we want CodeView debug information on MSVC
 205         if cx.sess().target.target.options.is_like_msvc {
 206             llvm::LLVMRustAddModuleFlag(cx.llmod(),
 207                                         "CodeView\0".as_ptr() as *const _,
 208                                         1)
 209         }
 210
 211         // Prevent bitcode readers from deleting the debug info.
 212         let ptr = "Debug Info Version\0".as_ptr();
 213         llvm::LLVMRustAddModuleFlag(cx.llmod(), ptr as *const _,
 214                                     llvm::LLVMRustDebugMetadataVersion());
 215     };
 216 }
 217
 218 /// Creates the function-specific debug context.
 219 ///
 220 /// Returns the FunctionDebugContext for the function which holds state needed
 221 /// for debug info creation. The function may also return another variant of the
 222 /// FunctionDebugContext enum which indicates why no debuginfo should be created
 223 /// for the function.
 224 pub fn create_function_debug_context<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 225                                                fn_ast_id: ast::NodeId,
 226                                                param_substs: &Substs<'tcx>,
 227                                                llfn: ValueRef) -> FunctionDebugContext {
 228     if cx.sess().opts.debuginfo == NoDebugInfo {
 229         return FunctionDebugContext::DebugInfoDisabled;
 230     }
 231
 232     // Clear the debug location so we don't assign them in the function prelude.
 233     // Do this here already, in case we do an early exit from this function.
 234     source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation);
 235
 236     if fn_ast_id == ast::DUMMY_NODE_ID {
 237         // This is a function not linked to any source location, so don't
 238         // generate debuginfo for it.
 239         return FunctionDebugContext::FunctionWithoutDebugInfo;
 240     }
 241
 242     let empty_generics = rustc_front::util::empty_generics();
 243
 244     let fnitem = cx.tcx().map.get(fn_ast_id);
 245
 246     let (name, fn_decl, generics, top_level_block, span, has_path) = match fnitem {
 247         hir_map::NodeItem(ref item) => {
 248             if contains_nodebug_attribute(&item.attrs) {
 249                 return FunctionDebugContext::FunctionWithoutDebugInfo;
 250             }
 251
 252             match item.node {
 253                 hir::ItemFn(ref fn_decl, _, _, _, ref generics, ref top_level_block) => {
 254                     (item.name, fn_decl, generics, top_level_block, item.span, true)
 255                 }
 256                 _ => {
 257                     cx.sess().span_bug(item.span,
 258                         "create_function_debug_context: item bound to non-function");
 259                 }
 260             }
 261         }
 262         hir_map::NodeImplItem(impl_item) => {
 263             match impl_item.node {
 264                 hir::ImplItemKind::Method(ref sig, ref body) => {
 265                     if contains_nodebug_attribute(&impl_item.attrs) {
 266                         return FunctionDebugContext::FunctionWithoutDebugInfo;
 267                     }
 268
 269                     (impl_item.name,
 270                      &sig.decl,
 271                      &sig.generics,
 272                      body,
 273                      impl_item.span,
 274                      true)
 275                 }
 276                 _ => {
 277                     cx.sess().span_bug(impl_item.span,
 278                                        "create_function_debug_context() \
 279                                         called on non-method impl item?!")
 280                 }
 281             }
 282         }
 283         hir_map::NodeExpr(ref expr) => {
 284             match expr.node {
 285                 hir::ExprClosure(_, ref fn_decl, ref top_level_block) => {
 286                     let name = format!("fn{}", token::gensym("fn"));
 287                     let name = token::intern(&name[..]);
 288                     (name, fn_decl,
 289                         // This is not quite right. It should actually inherit
 290                         // the generics of the enclosing function.
 291                         &empty_generics,
 292                         top_level_block,
 293                         expr.span,
 294                         // Don't try to lookup the item path:
 295                         false)
 296                 }
 297                 _ => cx.sess().span_bug(expr.span,
 298                         "create_function_debug_context: expected an expr_fn_block here")
 299             }
 300         }
 301         hir_map::NodeTraitItem(trait_item) => {
 302             match trait_item.node {
 303                 hir::MethodTraitItem(ref sig, Some(ref body)) => {
 304                     if contains_nodebug_attribute(&trait_item.attrs) {
 305                         return FunctionDebugContext::FunctionWithoutDebugInfo;
 306                     }
 307
 308                     (trait_item.name,
 309                      &sig.decl,
 310                      &sig.generics,
 311                      body,
 312                      trait_item.span,
 313                      true)
 314                 }
 315                 _ => {
 316                     cx.sess()
 317                       .bug(&format!("create_function_debug_context: \
 318                                     unexpected sort of node: {:?}",
 319                                     fnitem))
 320                 }
 321             }
 322         }
 323         hir_map::NodeForeignItem(..) |
 324         hir_map::NodeVariant(..) |
 325         hir_map::NodeStructCtor(..) => {
 326             return FunctionDebugContext::FunctionWithoutDebugInfo;
 327         }
 328         _ => cx.sess().bug(&format!("create_function_debug_context: \
 329                                     unexpected sort of node: {:?}",
 330                                    fnitem))
 331     };
 332
 333     // This can be the case for functions inlined from another crate
 334     if span == codemap::DUMMY_SP {
 335         return FunctionDebugContext::FunctionWithoutDebugInfo;
 336     }
 337
 338     let loc = span_start(cx, span);
 339     let file_metadata = file_metadata(cx, &loc.file.name);
 340
 341     let function_type_metadata = unsafe {
 342         let fn_signature = get_function_signature(cx,
 343                                                   fn_ast_id,
 344                                                   param_substs,
 345                                                   span);
 346         llvm::LLVMDIBuilderCreateSubroutineType(DIB(cx), file_metadata, fn_signature)
 347     };
 348
 349     // Get_template_parameters() will append a `<...>` clause to the function
 350     // name if necessary.
 351     let mut function_name = name.to_string();
 352     let template_parameters = get_template_parameters(cx,
 353                                                       generics,
 354                                                       param_substs,
 355                                                       file_metadata,
 356                                                       &mut function_name);
 357
 358     // There is no hir_map::Path for hir::ExprClosure-type functions. For now,
 359     // just don't put them into a namespace. In the future this could be improved
 360     // somehow (storing a path in the hir_map, or construct a path using the
 361     // enclosing function).
 362     let (linkage_name, containing_scope) = if has_path {
 363         let fn_ast_def_id = cx.tcx().map.local_def_id(fn_ast_id);
 364         let namespace_node = namespace_for_item(cx, fn_ast_def_id);
 365         let linkage_name = namespace_node.mangled_name_of_contained_item(
 366             &function_name[..]);
 367         let containing_scope = namespace_node.scope;
 368         (linkage_name, containing_scope)
 369     } else {
 370         (function_name.clone(), file_metadata)
 371     };
 372
 373     // Clang sets this parameter to the opening brace of the function's block,
 374     // so let's do this too.
 375     let scope_line = span_start(cx, top_level_block.span).line;
 376
 377     let is_local_to_unit = is_node_local_to_unit(cx, fn_ast_id);
 378
 379     let function_name = CString::new(function_name).unwrap();
 380     let linkage_name = CString::new(linkage_name).unwrap();
 381     let fn_metadata = unsafe {
 382         llvm::LLVMDIBuilderCreateFunction(
 383             DIB(cx),
 384             containing_scope,
 385             function_name.as_ptr(),
 386             linkage_name.as_ptr(),
 387             file_metadata,
 388             loc.line as c_uint,
 389             function_type_metadata,
 390             is_local_to_unit,
 391             true,
 392             scope_line as c_uint,
 393             FlagPrototyped as c_uint,
 394             cx.sess().opts.optimize != config::OptLevel::No,
 395             llfn,
 396             template_parameters,
 397             ptr::null_mut())
 398     };
 399
 400     let scope_map = create_scope_map::create_scope_map(cx,
 401                                                        &fn_decl.inputs,
 402                                                        &top_level_block,
 403                                                        fn_metadata,
 404                                                        fn_ast_id);
 405
 406     // Initialize fn debug context (including scope map and namespace map)
 407     let fn_debug_context = box FunctionDebugContextData {
 408         scope_map: RefCell::new(scope_map),
 409         fn_metadata: fn_metadata,
 410         argument_counter: Cell::new(1),
 411         source_locations_enabled: Cell::new(false),
 412         source_location_override: Cell::new(false),
 413     };
 414
 415
 416
 417     return FunctionDebugContext::RegularContext(fn_debug_context);
 418
 419     fn get_function_signature<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 420                                         fn_ast_id: ast::NodeId,
 421                                         param_substs: &Substs<'tcx>,
 422                                         error_reporting_span: Span) -> DIArray {
 423         if cx.sess().opts.debuginfo == LimitedDebugInfo {
 424             return create_DIArray(DIB(cx), &[]);
 425         }
 426
 427         // Return type -- llvm::DIBuilder wants this at index 0
 428         assert_type_for_node_id(cx, fn_ast_id, error_reporting_span);
 429         let fn_type = cx.tcx().node_id_to_type(fn_ast_id);
 430         let fn_type = monomorphize::apply_param_substs(cx.tcx(), param_substs, &fn_type);
 431
 432         let (sig, abi) = match fn_type.sty {
 433             ty::TyFnDef(_, ref barefnty) | ty::TyFnPtr(ref barefnty) => {
 434                 let sig = cx.tcx().erase_late_bound_regions(&barefnty.sig);
 435                 let sig = infer::normalize_associated_type(cx.tcx(), &sig);
 436                 (sig, barefnty.abi)
 437             }
 438             ty::TyClosure(def_id, ref substs) => {
 439                 let closure_type = cx.tcx().closure_type(def_id, substs);
 440                 let sig = cx.tcx().erase_late_bound_regions(&closure_type.sig);
 441                 let sig = infer::normalize_associated_type(cx.tcx(), &sig);
 442                 (sig, closure_type.abi)
 443             }
 444
 445             _ => cx.sess().bug("get_function_metdata: Expected a function type!")
 446         };
 447
 448         let mut signature = Vec::with_capacity(sig.inputs.len() + 1);
 449
 450         // Return type -- llvm::DIBuilder wants this at index 0
 451         signature.push(match sig.output {
 452             ty::FnConverging(ret_ty) => match ret_ty.sty {
 453                 ty::TyTuple(ref tys) if tys.is_empty() => ptr::null_mut(),
 454                 _ => type_metadata(cx, ret_ty, codemap::DUMMY_SP)
 455             },
 456             ty::FnDiverging => diverging_type_metadata(cx)
 457         });
 458
 459         let inputs = &if abi == Abi::RustCall {
 460             type_of::untuple_arguments(cx, &sig.inputs)
 461         } else {
 462             sig.inputs
 463         };
 464
 465         // Arguments types
 466         for &argument_type in inputs {
 467             signature.push(type_metadata(cx, argument_type, codemap::DUMMY_SP));
 468         }
 469
 470         return create_DIArray(DIB(cx), &signature[..]);
 471     }
 472
 473     fn get_template_parameters<'a, 'tcx>(cx: &CrateContext<'a, 'tcx>,
 474                                          generics: &hir::Generics,
 475                                          param_substs: &Substs<'tcx>,
 476                                          file_metadata: DIFile,
 477                                          name_to_append_suffix_to: &mut String)
 478                                          -> DIArray
 479     {
 480         let self_type = param_substs.self_ty();
 481         let self_type = normalize_associated_type(cx.tcx(), &self_type);
 482
 483         // Only true for static default methods:
 484         let has_self_type = self_type.is_some();
 485
 486         if !generics.is_type_parameterized() && !has_self_type {
 487             return create_DIArray(DIB(cx), &[]);
 488         }
 489
 490         name_to_append_suffix_to.push('<');
 491
 492         // The list to be filled with template parameters:
 493         let mut template_params: Vec<DIDescriptor> =
 494             Vec::with_capacity(generics.ty_params.len() + 1);
 495
 496         // Handle self type
 497         if has_self_type {
 498             let actual_self_type = self_type.unwrap();
 499             // Add self type name to <...> clause of function name
 500             let actual_self_type_name = compute_debuginfo_type_name(
 501                 cx,
 502                 actual_self_type,
 503                 true);
 504
 505             name_to_append_suffix_to.push_str(&actual_self_type_name[..]);
 506
 507             if generics.is_type_parameterized() {
 508                 name_to_append_suffix_to.push_str(",");
 509             }
 510
 511             // Only create type information if full debuginfo is enabled
 512             if cx.sess().opts.debuginfo == FullDebugInfo {
 513                 let actual_self_type_metadata = type_metadata(cx,
 514                                                               actual_self_type,
 515                                                               codemap::DUMMY_SP);
 516
 517                 let name = special_idents::type_self.name.as_str();
 518
 519                 let name = CString::new(name.as_bytes()).unwrap();
 520                 let param_metadata = unsafe {
 521                     llvm::LLVMDIBuilderCreateTemplateTypeParameter(
 522                         DIB(cx),
 523                         ptr::null_mut(),
 524                         name.as_ptr(),
 525                         actual_self_type_metadata,
 526                         file_metadata,
 527                         0,
 528                         0)
 529                 };
 530
 531                 template_params.push(param_metadata);
 532             }
 533         }
 534
 535         // Handle other generic parameters
 536         let actual_types = param_substs.types.get_slice(subst::FnSpace);
 537         for (index, &hir::TyParam{ name, .. }) in generics.ty_params.iter().enumerate() {
 538             let actual_type = actual_types[index];
 539             // Add actual type name to <...> clause of function name
 540             let actual_type_name = compute_debuginfo_type_name(cx,
 541                                                                actual_type,
 542                                                                true);
 543             name_to_append_suffix_to.push_str(&actual_type_name[..]);
 544
 545             if index != generics.ty_params.len() - 1 {
 546                 name_to_append_suffix_to.push_str(",");
 547             }
 548
 549             // Again, only create type information if full debuginfo is enabled
 550             if cx.sess().opts.debuginfo == FullDebugInfo {
 551                 let actual_type_metadata = type_metadata(cx, actual_type, codemap::DUMMY_SP);
 552                 let name = CString::new(name.as_str().as_bytes()).unwrap();
 553                 let param_metadata = unsafe {
 554                     llvm::LLVMDIBuilderCreateTemplateTypeParameter(
 555                         DIB(cx),
 556                         ptr::null_mut(),
 557                         name.as_ptr(),
 558                         actual_type_metadata,
 559                         file_metadata,
 560                         0,
 561                         0)
 562                 };
 563                 template_params.push(param_metadata);
 564             }
 565         }
 566
 567         name_to_append_suffix_to.push('>');
 568
 569         return create_DIArray(DIB(cx), &template_params[..]);
 570     }
 571 }
 572
 573 fn declare_local<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
 574                              variable_name: ast::Name,
 575                              variable_type: Ty<'tcx>,
 576                              scope_metadata: DIScope,
 577                              variable_access: VariableAccess,
 578                              variable_kind: VariableKind,
 579                              span: Span) {
 580     let cx: &CrateContext = bcx.ccx();
 581
 582     let filename = span_start(cx, span).file.name.clone();
 583     let file_metadata = file_metadata(cx, &filename[..]);
 584
 585     let loc = span_start(cx, span);
 586     let type_metadata = type_metadata(cx, variable_type, span);
 587
 588     let (argument_index, dwarf_tag) = match variable_kind {
 589         ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
 590         LocalVariable    |
 591         CapturedVariable => (0, DW_TAG_auto_variable)
 592     };
 593
 594     let name = CString::new(variable_name.as_str().as_bytes()).unwrap();
 595     match (variable_access, &[][..]) {
 596         (DirectVariable { alloca }, address_operations) |
 597         (IndirectVariable {alloca, address_operations}, _) => {
 598             let metadata = unsafe {
 599                 llvm::LLVMDIBuilderCreateVariable(
 600                     DIB(cx),
 601                     dwarf_tag,
 602                     scope_metadata,
 603                     name.as_ptr(),
 604                     file_metadata,
 605                     loc.line as c_uint,
 606                     type_metadata,
 607                     cx.sess().opts.optimize != config::OptLevel::No,
 608                     0,
 609                     address_operations.as_ptr(),
 610                     address_operations.len() as c_uint,
 611                     argument_index)
 612             };
 613             source_loc::set_debug_location(cx, InternalDebugLocation::new(scope_metadata,
 614                                                                           loc.line,
 615                                                                           loc.col.to_usize()));
 616             unsafe {
 617                 let debug_loc = llvm::LLVMGetCurrentDebugLocation(cx.raw_builder());
 618                 let instr = llvm::LLVMDIBuilderInsertDeclareAtEnd(
 619                     DIB(cx),
 620                     alloca,
 621                     metadata,
 622                     address_operations.as_ptr(),
 623                     address_operations.len() as c_uint,
 624                     debug_loc,
 625                     bcx.llbb);
 626
 627                 llvm::LLVMSetInstDebugLocation(trans::build::B(bcx).llbuilder, instr);
 628             }
 629         }
 630     }
 631
 632     match variable_kind {
 633         ArgumentVariable(_) | CapturedVariable => {
 634             assert!(!bcx.fcx
 635                         .debug_context
 636                         .get_ref(cx, span)
 637                         .source_locations_enabled
 638                         .get());
 639             source_loc::set_debug_location(cx, InternalDebugLocation::UnknownLocation);
 640         }
 641         _ => { /* nothing to do */ }
 642     }
 643 }
 644
 645 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
 646 pub enum DebugLoc {
 647     At(ast::NodeId, Span),
 648     None
 649 }
 650
 651 impl DebugLoc {
 652     pub fn apply(&self, fcx: &FunctionContext) {
 653         match *self {
 654             DebugLoc::At(node_id, span) => {
 655                 source_loc::set_source_location(fcx, node_id, span);
 656             }
 657             DebugLoc::None => {
 658                 source_loc::clear_source_location(fcx);
 659             }
 660         }
 661     }
 662 }
 663
 664 pub trait ToDebugLoc {
 665     fn debug_loc(&self) -> DebugLoc;
 666 }
 667
 668 impl ToDebugLoc for hir::Expr {
 669     fn debug_loc(&self) -> DebugLoc {
 670         DebugLoc::At(self.id, self.span)
 671     }
 672 }
 673
 674 impl ToDebugLoc for NodeIdAndSpan {
 675     fn debug_loc(&self) -> DebugLoc {
 676         DebugLoc::At(self.id, self.span)
 677     }
 678 }
 679
 680 impl ToDebugLoc for Option<NodeIdAndSpan> {
 681     fn debug_loc(&self) -> DebugLoc {
 682         match *self {
 683             Some(NodeIdAndSpan { id, span }) => DebugLoc::At(id, span),
 684             None => DebugLoc::None
 685         }
 686     }
 687 }