compiler/rustc_codegen_llvm/src/debuginfo/mod.rs

   1 #![doc = include_str!("doc.md")]
   2
   3 use rustc_codegen_ssa::mir::debuginfo::VariableKind::*;
   4
   5 use self::metadata::{file_metadata, type_di_node};
   6 use self::metadata::{UNKNOWN_COLUMN_NUMBER, UNKNOWN_LINE_NUMBER};
   7 use self::namespace::mangled_name_of_instance;
   8 use self::utils::{create_DIArray, is_node_local_to_unit, DIB};
   9
  10 use crate::abi::FnAbi;
  11 use crate::builder::Builder;
  12 use crate::common::CodegenCx;
  13 use crate::llvm;
  14 use crate::llvm::debuginfo::{
  15     DIArray, DIBuilder, DIFile, DIFlags, DILexicalBlock, DILocation, DISPFlags, DIScope, DIType,
  16     DIVariable,
  17 };
  18 use crate::value::Value;
  19
  20 use rustc_codegen_ssa::debuginfo::type_names;
  21 use rustc_codegen_ssa::mir::debuginfo::{DebugScope, FunctionDebugContext, VariableKind};
  22 use rustc_codegen_ssa::traits::*;
  23 use rustc_data_structures::fx::FxHashMap;
  24 use rustc_data_structures::sync::Lrc;
  25 use rustc_hir::def_id::{DefId, DefIdMap};
  26 use rustc_index::vec::IndexVec;
  27 use rustc_middle::mir;
  28 use rustc_middle::ty::layout::LayoutOf;
  29 use rustc_middle::ty::subst::{GenericArgKind, SubstsRef};
  30 use rustc_middle::ty::{self, Instance, ParamEnv, Ty, TypeVisitable};
  31 use rustc_session::config::{self, DebugInfo};
  32 use rustc_session::Session;
  33 use rustc_span::symbol::Symbol;
  34 use rustc_span::{self, BytePos, Pos, SourceFile, SourceFileAndLine, SourceFileHash, Span};
  35 use rustc_target::abi::Size;
  36
  37 use libc::c_uint;
  38 use smallvec::SmallVec;
  39 use std::cell::OnceCell;
  40 use std::cell::RefCell;
  41 use std::iter;
  42 use std::ops::Range;
  43
  44 mod create_scope_map;
  45 pub mod gdb;
  46 pub mod metadata;
  47 mod namespace;
  48 mod utils;
  49
  50 pub use self::create_scope_map::compute_mir_scopes;
  51 pub use self::metadata::build_global_var_di_node;
  52 pub use self::metadata::extend_scope_to_file;
  53
  54 #[allow(non_upper_case_globals)]
  55 const DW_TAG_auto_variable: c_uint = 0x100;
  56 #[allow(non_upper_case_globals)]
  57 const DW_TAG_arg_variable: c_uint = 0x101;
  58
  59 /// A context object for maintaining all state needed by the debuginfo module.
  60 pub struct CodegenUnitDebugContext<'ll, 'tcx> {
  61     llcontext: &'ll llvm::Context,
  62     llmod: &'ll llvm::Module,
  63     builder: &'ll mut DIBuilder<'ll>,
  64     created_files: RefCell<FxHashMap<Option<(u128, SourceFileHash)>, &'ll DIFile>>,
  65
  66     type_map: metadata::TypeMap<'ll, 'tcx>,
  67     namespace_map: RefCell<DefIdMap<&'ll DIScope>>,
  68     recursion_marker_type: OnceCell<&'ll DIType>,
  69 }
  70
  71 impl Drop for CodegenUnitDebugContext<'_, '_> {
  72     fn drop(&mut self) {
  73         unsafe {
  74             llvm::LLVMRustDIBuilderDispose(&mut *(self.builder as *mut _));
  75         }
  76     }
  77 }
  78
  79 impl<'ll, 'tcx> CodegenUnitDebugContext<'ll, 'tcx> {
  80     pub fn new(llmod: &'ll llvm::Module) -> Self {
  81         debug!("CodegenUnitDebugContext::new");
  82         let builder = unsafe { llvm::LLVMRustDIBuilderCreate(llmod) };
  83         // DIBuilder inherits context from the module, so we'd better use the same one
  84         let llcontext = unsafe { llvm::LLVMGetModuleContext(llmod) };
  85         CodegenUnitDebugContext {
  86             llcontext,
  87             llmod,
  88             builder,
  89             created_files: Default::default(),
  90             type_map: Default::default(),
  91             namespace_map: RefCell::new(Default::default()),
  92             recursion_marker_type: OnceCell::new(),
  93         }
  94     }
  95
  96     pub fn finalize(&self, sess: &Session) {
  97         unsafe {
  98             llvm::LLVMRustDIBuilderFinalize(self.builder);
  99
 100             if !sess.target.is_like_msvc {
 101                 // Debuginfo generation in LLVM by default uses a higher
 102                 // version of dwarf than macOS currently understands. We can
 103                 // instruct LLVM to emit an older version of dwarf, however,
 104                 // for macOS to understand. For more info see #11352
 105                 // This can be overridden using --llvm-opts -dwarf-version,N.
 106                 // Android has the same issue (#22398)
 107                 let dwarf_version = sess
 108                     .opts
 109                     .unstable_opts
 110                     .dwarf_version
 111                     .unwrap_or(sess.target.default_dwarf_version);
 112                 llvm::LLVMRustAddModuleFlag(
 113                     self.llmod,
 114                     llvm::LLVMModFlagBehavior::Warning,
 115                     "Dwarf Version\0".as_ptr().cast(),
 116                     dwarf_version,
 117                 );
 118             } else {
 119                 // Indicate that we want CodeView debug information on MSVC
 120                 llvm::LLVMRustAddModuleFlag(
 121                     self.llmod,
 122                     llvm::LLVMModFlagBehavior::Warning,
 123                     "CodeView\0".as_ptr().cast(),
 124                     1,
 125                 )
 126             }
 127
 128             // Prevent bitcode readers from deleting the debug info.
 129             let ptr = "Debug Info Version\0".as_ptr();
 130             llvm::LLVMRustAddModuleFlag(
 131                 self.llmod,
 132                 llvm::LLVMModFlagBehavior::Warning,
 133                 ptr.cast(),
 134                 llvm::LLVMRustDebugMetadataVersion(),
 135             );
 136         }
 137     }
 138 }
 139
 140 /// Creates any deferred debug metadata nodes
 141 pub fn finalize(cx: &CodegenCx<'_, '_>) {
 142     if let Some(dbg_cx) = &cx.dbg_cx {
 143         debug!("finalize");
 144
 145         if gdb::needs_gdb_debug_scripts_section(cx) {
 146             // Add a .debug_gdb_scripts section to this compile-unit. This will
 147             // cause GDB to try and load the gdb_load_rust_pretty_printers.py file,
 148             // which activates the Rust pretty printers for binary this section is
 149             // contained in.
 150             gdb::get_or_insert_gdb_debug_scripts_section_global(cx);
 151         }
 152
 153         dbg_cx.finalize(cx.sess());
 154     }
 155 }
 156
 157 impl<'ll> DebugInfoBuilderMethods for Builder<'_, 'll, '_> {
 158     // FIXME(eddyb) find a common convention for all of the debuginfo-related
 159     // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
 160     fn dbg_var_addr(
 161         &mut self,
 162         dbg_var: &'ll DIVariable,
 163         dbg_loc: &'ll DILocation,
 164         variable_alloca: Self::Value,
 165         direct_offset: Size,
 166         indirect_offsets: &[Size],
 167         fragment: Option<Range<Size>>,
 168     ) {
 169         // Convert the direct and indirect offsets and fragment byte range to address ops.
 170         // FIXME(eddyb) use `const`s instead of getting the values via FFI,
 171         // the values should match the ones in the DWARF standard anyway.
 172         let op_deref = || unsafe { llvm::LLVMRustDIBuilderCreateOpDeref() };
 173         let op_plus_uconst = || unsafe { llvm::LLVMRustDIBuilderCreateOpPlusUconst() };
 174         let op_llvm_fragment = || unsafe { llvm::LLVMRustDIBuilderCreateOpLLVMFragment() };
 175         let mut addr_ops = SmallVec::<[u64; 8]>::new();
 176
 177         if direct_offset.bytes() > 0 {
 178             addr_ops.push(op_plus_uconst());
 179             addr_ops.push(direct_offset.bytes() as u64);
 180         }
 181         for &offset in indirect_offsets {
 182             addr_ops.push(op_deref());
 183             if offset.bytes() > 0 {
 184                 addr_ops.push(op_plus_uconst());
 185                 addr_ops.push(offset.bytes() as u64);
 186             }
 187         }
 188         if let Some(fragment) = fragment {
 189             // `DW_OP_LLVM_fragment` takes as arguments the fragment's
 190             // offset and size, both of them in bits.
 191             addr_ops.push(op_llvm_fragment());
 192             addr_ops.push(fragment.start.bits() as u64);
 193             addr_ops.push((fragment.end - fragment.start).bits() as u64);
 194         }
 195
 196         unsafe {
 197             // FIXME(eddyb) replace `llvm.dbg.declare` with `llvm.dbg.addr`.
 198             llvm::LLVMRustDIBuilderInsertDeclareAtEnd(
 199                 DIB(self.cx()),
 200                 variable_alloca,
 201                 dbg_var,
 202                 addr_ops.as_ptr(),
 203                 addr_ops.len() as c_uint,
 204                 dbg_loc,
 205                 self.llbb(),
 206             );
 207         }
 208     }
 209
 210     fn set_dbg_loc(&mut self, dbg_loc: &'ll DILocation) {
 211         unsafe {
 212             let dbg_loc_as_llval = llvm::LLVMRustMetadataAsValue(self.cx().llcx, dbg_loc);
 213             llvm::LLVMSetCurrentDebugLocation(self.llbuilder, dbg_loc_as_llval);
 214         }
 215     }
 216
 217     fn insert_reference_to_gdb_debug_scripts_section_global(&mut self) {
 218         gdb::insert_reference_to_gdb_debug_scripts_section_global(self)
 219     }
 220
 221     fn set_var_name(&mut self, value: &'ll Value, name: &str) {
 222         // Avoid wasting time if LLVM value names aren't even enabled.
 223         if self.sess().fewer_names() {
 224             return;
 225         }
 226
 227         // Only function parameters and instructions are local to a function,
 228         // don't change the name of anything else (e.g. globals).
 229         let param_or_inst = unsafe {
 230             llvm::LLVMIsAArgument(value).is_some() || llvm::LLVMIsAInstruction(value).is_some()
 231         };
 232         if !param_or_inst {
 233             return;
 234         }
 235
 236         // Avoid replacing the name if it already exists.
 237         // While we could combine the names somehow, it'd
 238         // get noisy quick, and the usefulness is dubious.
 239         if llvm::get_value_name(value).is_empty() {
 240             llvm::set_value_name(value, name.as_bytes());
 241         }
 242     }
 243 }
 244
 245 /// A source code location used to generate debug information.
 246 // FIXME(eddyb) rename this to better indicate it's a duplicate of
 247 // `rustc_span::Loc` rather than `DILocation`, perhaps by making
 248 // `lookup_char_pos` return the right information instead.
 249 pub struct DebugLoc {
 250     /// Information about the original source file.
 251     pub file: Lrc<SourceFile>,
 252     /// The (1-based) line number.
 253     pub line: u32,
 254     /// The (1-based) column number.
 255     pub col: u32,
 256 }
 257
 258 impl CodegenCx<'_, '_> {
 259     /// Looks up debug source information about a `BytePos`.
 260     // FIXME(eddyb) rename this to better indicate it's a duplicate of
 261     // `lookup_char_pos` rather than `dbg_loc`, perhaps by making
 262     // `lookup_char_pos` return the right information instead.
 263     pub fn lookup_debug_loc(&self, pos: BytePos) -> DebugLoc {
 264         let (file, line, col) = match self.sess().source_map().lookup_line(pos) {
 265             Ok(SourceFileAndLine { sf: file, line }) => {
 266                 let line_pos = file.line_begin_pos(pos);
 267
 268                 // Use 1-based indexing.
 269                 let line = (line + 1) as u32;
 270                 let col = (pos - line_pos).to_u32() + 1;
 271
 272                 (file, line, col)
 273             }
 274             Err(file) => (file, UNKNOWN_LINE_NUMBER, UNKNOWN_COLUMN_NUMBER),
 275         };
 276
 277         // For MSVC, omit the column number.
 278         // Otherwise, emit it. This mimics clang behaviour.
 279         // See discussion in https://github.com/rust-lang/rust/issues/42921
 280         if self.sess().target.is_like_msvc {
 281             DebugLoc { file, line, col: UNKNOWN_COLUMN_NUMBER }
 282         } else {
 283             DebugLoc { file, line, col }
 284         }
 285     }
 286 }
 287
 288 impl<'ll, 'tcx> DebugInfoMethods<'tcx> for CodegenCx<'ll, 'tcx> {
 289     fn create_function_debug_context(
 290         &self,
 291         instance: Instance<'tcx>,
 292         fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
 293         llfn: &'ll Value,
 294         mir: &mir::Body<'tcx>,
 295     ) -> Option<FunctionDebugContext<&'ll DIScope, &'ll DILocation>> {
 296         if self.sess().opts.debuginfo == DebugInfo::None {
 297             return None;
 298         }
 299
 300         // Initialize fn debug context (including scopes).
 301         let empty_scope = DebugScope {
 302             dbg_scope: self.dbg_scope_fn(instance, fn_abi, Some(llfn)),
 303             inlined_at: None,
 304             file_start_pos: BytePos(0),
 305             file_end_pos: BytePos(0),
 306         };
 307         let mut fn_debug_context =
 308             FunctionDebugContext { scopes: IndexVec::from_elem(empty_scope, &mir.source_scopes) };
 309
 310         // Fill in all the scopes, with the information from the MIR body.
 311         compute_mir_scopes(self, instance, mir, &mut fn_debug_context);
 312
 313         Some(fn_debug_context)
 314     }
 315
 316     fn dbg_scope_fn(
 317         &self,
 318         instance: Instance<'tcx>,
 319         fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
 320         maybe_definition_llfn: Option<&'ll Value>,
 321     ) -> &'ll DIScope {
 322         let tcx = self.tcx;
 323
 324         let def_id = instance.def_id();
 325         let containing_scope = get_containing_scope(self, instance);
 326         let span = tcx.def_span(def_id);
 327         let loc = self.lookup_debug_loc(span.lo());
 328         let file_metadata = file_metadata(self, &loc.file);
 329
 330         let function_type_metadata = unsafe {
 331             let fn_signature = get_function_signature(self, fn_abi);
 332             llvm::LLVMRustDIBuilderCreateSubroutineType(DIB(self), fn_signature)
 333         };
 334
 335         let mut name = String::new();
 336         type_names::push_item_name(tcx, def_id, false, &mut name);
 337
 338         // Find the enclosing function, in case this is a closure.
 339         let enclosing_fn_def_id = tcx.typeck_root_def_id(def_id);
 340
 341         // We look up the generics of the enclosing function and truncate the substs
 342         // to their length in order to cut off extra stuff that might be in there for
 343         // closures or generators.
 344         let generics = tcx.generics_of(enclosing_fn_def_id);
 345         let substs = instance.substs.truncate_to(tcx, generics);
 346
 347         type_names::push_generic_params(
 348             tcx,
 349             tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substs),
 350             &mut name,
 351         );
 352
 353         let template_parameters = get_template_parameters(self, generics, substs);
 354
 355         let linkage_name = &mangled_name_of_instance(self, instance).name;
 356         // Omit the linkage_name if it is the same as subprogram name.
 357         let linkage_name = if &name == linkage_name { "" } else { linkage_name };
 358
 359         // FIXME(eddyb) does this need to be separate from `loc.line` for some reason?
 360         let scope_line = loc.line;
 361
 362         let mut flags = DIFlags::FlagPrototyped;
 363
 364         if fn_abi.ret.layout.abi.is_uninhabited() {
 365             flags |= DIFlags::FlagNoReturn;
 366         }
 367
 368         let mut spflags = DISPFlags::SPFlagDefinition;
 369         if is_node_local_to_unit(self, def_id) {
 370             spflags |= DISPFlags::SPFlagLocalToUnit;
 371         }
 372         if self.sess().opts.optimize != config::OptLevel::No {
 373             spflags |= DISPFlags::SPFlagOptimized;
 374         }
 375         if let Some((id, _)) = tcx.entry_fn(()) {
 376             if id == def_id {
 377                 spflags |= DISPFlags::SPFlagMainSubprogram;
 378             }
 379         }
 380
 381         unsafe {
 382             return llvm::LLVMRustDIBuilderCreateFunction(
 383                 DIB(self),
 384                 containing_scope,
 385                 name.as_ptr().cast(),
 386                 name.len(),
 387                 linkage_name.as_ptr().cast(),
 388                 linkage_name.len(),
 389                 file_metadata,
 390                 loc.line,
 391                 function_type_metadata,
 392                 scope_line,
 393                 flags,
 394                 spflags,
 395                 maybe_definition_llfn,
 396                 template_parameters,
 397                 None,
 398             );
 399         }
 400
 401         fn get_function_signature<'ll, 'tcx>(
 402             cx: &CodegenCx<'ll, 'tcx>,
 403             fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
 404         ) -> &'ll DIArray {
 405             if cx.sess().opts.debuginfo == DebugInfo::Limited {
 406                 return create_DIArray(DIB(cx), &[]);
 407             }
 408
 409             let mut signature = Vec::with_capacity(fn_abi.args.len() + 1);
 410
 411             // Return type -- llvm::DIBuilder wants this at index 0
 412             signature.push(if fn_abi.ret.is_ignore() {
 413                 None
 414             } else {
 415                 Some(type_di_node(cx, fn_abi.ret.layout.ty))
 416             });
 417
 418             // Arguments types
 419             if cx.sess().target.is_like_msvc {
 420                 // FIXME(#42800):
 421                 // There is a bug in MSDIA that leads to a crash when it encounters
 422                 // a fixed-size array of `u8` or something zero-sized in a
 423                 // function-type (see #40477).
 424                 // As a workaround, we replace those fixed-size arrays with a
 425                 // pointer-type. So a function `fn foo(a: u8, b: [u8; 4])` would
 426                 // appear as `fn foo(a: u8, b: *const u8)` in debuginfo,
 427                 // and a function `fn bar(x: [(); 7])` as `fn bar(x: *const ())`.
 428                 // This transformed type is wrong, but these function types are
 429                 // already inaccurate due to ABI adjustments (see #42800).
 430                 signature.extend(fn_abi.args.iter().map(|arg| {
 431                     let t = arg.layout.ty;
 432                     let t = match t.kind() {
 433                         ty::Array(ct, _)
 434                             if (*ct == cx.tcx.types.u8) || cx.layout_of(*ct).is_zst() =>
 435                         {
 436                             cx.tcx.mk_imm_ptr(*ct)
 437                         }
 438                         _ => t,
 439                     };
 440                     Some(type_di_node(cx, t))
 441                 }));
 442             } else {
 443                 signature
 444                     .extend(fn_abi.args.iter().map(|arg| Some(type_di_node(cx, arg.layout.ty))));
 445             }
 446
 447             create_DIArray(DIB(cx), &signature[..])
 448         }
 449
 450         fn get_template_parameters<'ll, 'tcx>(
 451             cx: &CodegenCx<'ll, 'tcx>,
 452             generics: &ty::Generics,
 453             substs: SubstsRef<'tcx>,
 454         ) -> &'ll DIArray {
 455             if substs.types().next().is_none() {
 456                 return create_DIArray(DIB(cx), &[]);
 457             }
 458
 459             // Again, only create type information if full debuginfo is enabled
 460             let template_params: Vec<_> = if cx.sess().opts.debuginfo == DebugInfo::Full {
 461                 let names = get_parameter_names(cx, generics);
 462                 iter::zip(substs, names)
 463                     .filter_map(|(kind, name)| {
 464                         if let GenericArgKind::Type(ty) = kind.unpack() {
 465                             let actual_type =
 466                                 cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
 467                             let actual_type_metadata = type_di_node(cx, actual_type);
 468                             let name = name.as_str();
 469                             Some(unsafe {
 470                                 Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
 471                                     DIB(cx),
 472                                     None,
 473                                     name.as_ptr().cast(),
 474                                     name.len(),
 475                                     actual_type_metadata,
 476                                 ))
 477                             })
 478                         } else {
 479                             None
 480                         }
 481                     })
 482                     .collect()
 483             } else {
 484                 vec![]
 485             };
 486
 487             create_DIArray(DIB(cx), &template_params)
 488         }
 489
 490         fn get_parameter_names(cx: &CodegenCx<'_, '_>, generics: &ty::Generics) -> Vec<Symbol> {
 491             let mut names = generics.parent.map_or_else(Vec::new, |def_id| {
 492                 get_parameter_names(cx, cx.tcx.generics_of(def_id))
 493             });
 494             names.extend(generics.params.iter().map(|param| param.name));
 495             names
 496         }
 497
 498         fn get_containing_scope<'ll, 'tcx>(
 499             cx: &CodegenCx<'ll, 'tcx>,
 500             instance: Instance<'tcx>,
 501         ) -> &'ll DIScope {
 502             // First, let's see if this is a method within an inherent impl. Because
 503             // if yes, we want to make the result subroutine DIE a child of the
 504             // subroutine's self-type.
 505             let self_type = cx.tcx.impl_of_method(instance.def_id()).and_then(|impl_def_id| {
 506                 // If the method does *not* belong to a trait, proceed
 507                 if cx.tcx.trait_id_of_impl(impl_def_id).is_none() {
 508                     let impl_self_ty = cx.tcx.subst_and_normalize_erasing_regions(
 509                         instance.substs,
 510                         ty::ParamEnv::reveal_all(),
 511                         cx.tcx.type_of(impl_def_id),
 512                     );
 513
 514                     // Only "class" methods are generally understood by LLVM,
 515                     // so avoid methods on other types (e.g., `<*mut T>::null`).
 516                     match impl_self_ty.kind() {
 517                         ty::Adt(def, ..) if !def.is_box() => {
 518                             // Again, only create type information if full debuginfo is enabled
 519                             if cx.sess().opts.debuginfo == DebugInfo::Full
 520                                 && !impl_self_ty.needs_subst()
 521                             {
 522                                 Some(type_di_node(cx, impl_self_ty))
 523                             } else {
 524                                 Some(namespace::item_namespace(cx, def.did()))
 525                             }
 526                         }
 527                         _ => None,
 528                     }
 529                 } else {
 530                     // For trait method impls we still use the "parallel namespace"
 531                     // strategy
 532                     None
 533                 }
 534             });
 535
 536             self_type.unwrap_or_else(|| {
 537                 namespace::item_namespace(
 538                     cx,
 539                     DefId {
 540                         krate: instance.def_id().krate,
 541                         index: cx
 542                             .tcx
 543                             .def_key(instance.def_id())
 544                             .parent
 545                             .expect("get_containing_scope: missing parent?"),
 546                     },
 547                 )
 548             })
 549         }
 550     }
 551
 552     fn dbg_loc(
 553         &self,
 554         scope: &'ll DIScope,
 555         inlined_at: Option<&'ll DILocation>,
 556         span: Span,
 557     ) -> &'ll DILocation {
 558         let DebugLoc { line, col, .. } = self.lookup_debug_loc(span.lo());
 559
 560         unsafe { llvm::LLVMRustDIBuilderCreateDebugLocation(line, col, scope, inlined_at) }
 561     }
 562
 563     fn create_vtable_debuginfo(
 564         &self,
 565         ty: Ty<'tcx>,
 566         trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
 567         vtable: Self::Value,
 568     ) {
 569         metadata::create_vtable_di_node(self, ty, trait_ref, vtable)
 570     }
 571
 572     fn extend_scope_to_file(
 573         &self,
 574         scope_metadata: &'ll DIScope,
 575         file: &rustc_span::SourceFile,
 576     ) -> &'ll DILexicalBlock {
 577         metadata::extend_scope_to_file(self, scope_metadata, file)
 578     }
 579
 580     fn debuginfo_finalize(&self) {
 581         finalize(self)
 582     }
 583
 584     // FIXME(eddyb) find a common convention for all of the debuginfo-related
 585     // names (choose between `dbg`, `debug`, `debuginfo`, `debug_info` etc.).
 586     fn create_dbg_var(
 587         &self,
 588         variable_name: Symbol,
 589         variable_type: Ty<'tcx>,
 590         scope_metadata: &'ll DIScope,
 591         variable_kind: VariableKind,
 592         span: Span,
 593     ) -> &'ll DIVariable {
 594         let loc = self.lookup_debug_loc(span.lo());
 595         let file_metadata = file_metadata(self, &loc.file);
 596
 597         let type_metadata = type_di_node(self, variable_type);
 598
 599         let (argument_index, dwarf_tag) = match variable_kind {
 600             ArgumentVariable(index) => (index as c_uint, DW_TAG_arg_variable),
 601             LocalVariable => (0, DW_TAG_auto_variable),
 602         };
 603         let align = self.align_of(variable_type);
 604
 605         let name = variable_name.as_str();
 606         unsafe {
 607             llvm::LLVMRustDIBuilderCreateVariable(
 608                 DIB(self),
 609                 dwarf_tag,
 610                 scope_metadata,
 611                 name.as_ptr().cast(),
 612                 name.len(),
 613                 file_metadata,
 614                 loc.line,
 615                 type_metadata,
 616                 true,
 617                 DIFlags::FlagZero,
 618                 argument_index,
 619                 align.bytes() as u32,
 620             )
 621         }
 622     }
 623 }