src/librustc_codegen_llvm/debuginfo/metadata.rs

   1 use self::RecursiveTypeDescription::*;
   2 use self::MemberDescriptionFactory::*;
   3 use self::EnumDiscriminantInfo::*;
   4
   5 use super::utils::{debug_context, DIB, span_start,
   6                    get_namespace_for_item, create_DIArray, is_node_local_to_unit};
   7 use super::namespace::mangled_name_of_instance;
   8 use super::type_names::compute_debuginfo_type_name;
   9 use super::{CrateDebugContext};
  10 use crate::abi;
  11 use crate::value::Value;
  12 use rustc_codegen_ssa::traits::*;
  13
  14 use crate::llvm;
  15 use crate::llvm::debuginfo::{DIArray, DIType, DIFile, DIScope, DIDescriptor,
  16                       DICompositeType, DILexicalBlock, DIFlags, DebugEmissionKind};
  17 use crate::llvm_util;
  18
  19 use crate::common::CodegenCx;
  20 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
  21 use rustc::hir::CodegenFnAttrFlags;
  22 use rustc::hir::def::CtorKind;
  23 use rustc::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};
  24 use rustc::ich::NodeIdHashingMode;
  25 use rustc::mir::Field;
  26 use rustc::mir::GeneratorLayout;
  27 use rustc::mir::interpret::truncate;
  28 use rustc_data_structures::fingerprint::Fingerprint;
  29 use rustc::ty::Instance;
  30 use rustc::ty::{self, AdtKind, ParamEnv, Ty, TyCtxt};
  31 use rustc::ty::layout::{self, Align, Integer, IntegerExt, LayoutOf,
  32                         PrimitiveExt, Size, TyLayout, VariantIdx};
  33 use rustc::ty::subst::UnpackedKind;
  34 use rustc::session::config;
  35 use rustc::util::nodemap::FxHashMap;
  36 use rustc_fs_util::path_to_c_string;
  37 use rustc_data_structures::small_c_str::SmallCStr;
  38 use rustc_target::abi::HasDataLayout;
  39
  40 use libc::{c_uint, c_longlong};
  41 use std::collections::hash_map::Entry;
  42 use std::ffi::CString;
  43 use std::fmt::{self, Write};
  44 use std::hash::{Hash, Hasher};
  45 use std::iter;
  46 use std::ptr;
  47 use std::path::{Path, PathBuf};
  48 use syntax::ast;
  49 use syntax::symbol::{Interner, InternedString};
  50 use syntax_pos::{self, Span, FileName};
  51
  52 impl PartialEq for llvm::Metadata {
  53     fn eq(&self, other: &Self) -> bool {
  54         ptr::eq(self, other)
  55     }
  56 }
  57
  58 impl Eq for llvm::Metadata {}
  59
  60 impl Hash for llvm::Metadata {
  61     fn hash<H: Hasher>(&self, hasher: &mut H) {
  62         (self as *const Self).hash(hasher);
  63     }
  64 }
  65
  66 impl fmt::Debug for llvm::Metadata {
  67     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  68         (self as *const Self).fmt(f)
  69     }
  70 }
  71
  72 // From DWARF 5.
  73 // See http://www.dwarfstd.org/ShowIssue.php?issue=140129.1
  74 const DW_LANG_RUST: c_uint = 0x1c;
  75 #[allow(non_upper_case_globals)]
  76 const DW_ATE_boolean: c_uint = 0x02;
  77 #[allow(non_upper_case_globals)]
  78 const DW_ATE_float: c_uint = 0x04;
  79 #[allow(non_upper_case_globals)]
  80 const DW_ATE_signed: c_uint = 0x05;
  81 #[allow(non_upper_case_globals)]
  82 const DW_ATE_unsigned: c_uint = 0x07;
  83 #[allow(non_upper_case_globals)]
  84 const DW_ATE_unsigned_char: c_uint = 0x08;
  85
  86 pub const UNKNOWN_LINE_NUMBER: c_uint = 0;
  87 pub const UNKNOWN_COLUMN_NUMBER: c_uint = 0;
  88
  89 pub const NO_SCOPE_METADATA: Option<&DIScope> = None;
  90
  91 #[derive(Copy, Debug, Hash, Eq, PartialEq, Clone)]
  92 pub struct UniqueTypeId(ast::Name);
  93
  94 // The TypeMap is where the CrateDebugContext holds the type metadata nodes
  95 // created so far. The metadata nodes are indexed by UniqueTypeId, and, for
  96 // faster lookup, also by Ty. The TypeMap is responsible for creating
  97 // UniqueTypeIds.
  98 #[derive(Default)]
  99 pub struct TypeMap<'ll, 'tcx> {
 100     // The UniqueTypeIds created so far
 101     unique_id_interner: Interner,
 102     // A map from UniqueTypeId to debuginfo metadata for that type. This is a 1:1 mapping.
 103     unique_id_to_metadata: FxHashMap<UniqueTypeId, &'ll DIType>,
 104     // A map from types to debuginfo metadata. This is a N:1 mapping.
 105     type_to_metadata: FxHashMap<Ty<'tcx>, &'ll DIType>,
 106     // A map from types to UniqueTypeId. This is a N:1 mapping.
 107     type_to_unique_id: FxHashMap<Ty<'tcx>, UniqueTypeId>
 108 }
 109
 110 impl TypeMap<'ll, 'tcx> {
 111     // Adds a Ty to metadata mapping to the TypeMap. The method will fail if
 112     // the mapping already exists.
 113     fn register_type_with_metadata(
 114         &mut self,
 115         type_: Ty<'tcx>,
 116         metadata: &'ll DIType,
 117     ) {
 118         if self.type_to_metadata.insert(type_, metadata).is_some() {
 119             bug!("Type metadata for Ty '{}' is already in the TypeMap!", type_);
 120         }
 121     }
 122
 123     // Removes a Ty to metadata mapping
 124     // This is useful when computing the metadata for a potentially
 125     // recursive type (e.g. a function ptr of the form:
 126     //
 127     // fn foo() -> impl Copy { foo }
 128     //
 129     // This kind of type cannot be properly represented
 130     // via LLVM debuginfo. As a workaround,
 131     // we register a temporary Ty to metadata mapping
 132     // for the function before we compute its actual metadata.
 133     // If the metadata computation ends up recursing back to the
 134     // original function, it will use the temporary mapping
 135     // for the inner self-reference, preventing us from
 136     // recursing forever.
 137     //
 138     // This function is used to remove the temporary metadata
 139     // mapping after we've computed the actual metadata
 140     fn remove_type(
 141         &mut self,
 142         type_: Ty<'tcx>,
 143     ) {
 144         if self.type_to_metadata.remove(type_).is_none() {
 145             bug!("Type metadata Ty '{}' is not in the TypeMap!", type_);
 146         }
 147     }
 148
 149     // Adds a UniqueTypeId to metadata mapping to the TypeMap. The method will
 150     // fail if the mapping already exists.
 151     fn register_unique_id_with_metadata(
 152         &mut self,
 153         unique_type_id: UniqueTypeId,
 154         metadata: &'ll DIType,
 155     ) {
 156         if self.unique_id_to_metadata.insert(unique_type_id, metadata).is_some() {
 157             bug!("Type metadata for unique id '{}' is already in the TypeMap!",
 158                  self.get_unique_type_id_as_string(unique_type_id));
 159         }
 160     }
 161
 162     fn find_metadata_for_type(&self, type_: Ty<'tcx>) -> Option<&'ll DIType> {
 163         self.type_to_metadata.get(&type_).cloned()
 164     }
 165
 166     fn find_metadata_for_unique_id(&self, unique_type_id: UniqueTypeId) -> Option<&'ll DIType> {
 167         self.unique_id_to_metadata.get(&unique_type_id).cloned()
 168     }
 169
 170     // Get the string representation of a UniqueTypeId. This method will fail if
 171     // the id is unknown.
 172     fn get_unique_type_id_as_string(&self, unique_type_id: UniqueTypeId) -> &str {
 173         let UniqueTypeId(interner_key) = unique_type_id;
 174         self.unique_id_interner.get(interner_key)
 175     }
 176
 177     // Get the UniqueTypeId for the given type. If the UniqueTypeId for the given
 178     // type has been requested before, this is just a table lookup. Otherwise an
 179     // ID will be generated and stored for later lookup.
 180     fn get_unique_type_id_of_type<'a>(&mut self, cx: &CodegenCx<'a, 'tcx>,
 181                                       type_: Ty<'tcx>) -> UniqueTypeId {
 182         // Let's see if we already have something in the cache
 183         if let Some(unique_type_id) = self.type_to_unique_id.get(&type_).cloned() {
 184             return unique_type_id;
 185         }
 186         // if not, generate one
 187
 188         // The hasher we are using to generate the UniqueTypeId. We want
 189         // something that provides more than the 64 bits of the DefaultHasher.
 190         let mut hasher = StableHasher::<Fingerprint>::new();
 191         let mut hcx = cx.tcx.create_stable_hashing_context();
 192         let type_ = cx.tcx.erase_regions(&type_);
 193         hcx.while_hashing_spans(false, |hcx| {
 194             hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
 195                 type_.hash_stable(hcx, &mut hasher);
 196             });
 197         });
 198         let unique_type_id = hasher.finish().to_hex();
 199
 200         let key = self.unique_id_interner.intern(&unique_type_id);
 201         self.type_to_unique_id.insert(type_, UniqueTypeId(key));
 202
 203         return UniqueTypeId(key);
 204     }
 205
 206     // Get the UniqueTypeId for an enum variant. Enum variants are not really
 207     // types of their own, so they need special handling. We still need a
 208     // UniqueTypeId for them, since to debuginfo they *are* real types.
 209     fn get_unique_type_id_of_enum_variant<'a>(&mut self,
 210                                               cx: &CodegenCx<'a, 'tcx>,
 211                                               enum_type: Ty<'tcx>,
 212                                               variant_name: &str)
 213                                               -> UniqueTypeId {
 214         let enum_type_id = self.get_unique_type_id_of_type(cx, enum_type);
 215         let enum_variant_type_id = format!("{}::{}",
 216                                            self.get_unique_type_id_as_string(enum_type_id),
 217                                            variant_name);
 218         let interner_key = self.unique_id_interner.intern(&enum_variant_type_id);
 219         UniqueTypeId(interner_key)
 220     }
 221
 222     // Get the unique type id string for an enum variant part.
 223     // Variant parts are not types and shouldn't really have their own id,
 224     // but it makes set_members_of_composite_type() simpler.
 225     fn get_unique_type_id_str_of_enum_variant_part<'a>(&mut self,
 226                                                        enum_type_id: UniqueTypeId) -> &str {
 227         let variant_part_type_id = format!("{}_variant_part",
 228                                            self.get_unique_type_id_as_string(enum_type_id));
 229         let interner_key = self.unique_id_interner.intern(&variant_part_type_id);
 230         self.unique_id_interner.get(interner_key)
 231     }
 232 }
 233
 234 // A description of some recursive type. It can either be already finished (as
 235 // with FinalMetadata) or it is not yet finished, but contains all information
 236 // needed to generate the missing parts of the description. See the
 237 // documentation section on Recursive Types at the top of this file for more
 238 // information.
 239 enum RecursiveTypeDescription<'ll, 'tcx> {
 240     UnfinishedMetadata {
 241         unfinished_type: Ty<'tcx>,
 242         unique_type_id: UniqueTypeId,
 243         metadata_stub: &'ll DICompositeType,
 244         member_holding_stub: &'ll DICompositeType,
 245         member_description_factory: MemberDescriptionFactory<'ll, 'tcx>,
 246     },
 247     FinalMetadata(&'ll DICompositeType)
 248 }
 249
 250 fn create_and_register_recursive_type_forward_declaration(
 251     cx: &CodegenCx<'ll, 'tcx>,
 252     unfinished_type: Ty<'tcx>,
 253     unique_type_id: UniqueTypeId,
 254     metadata_stub: &'ll DICompositeType,
 255     member_holding_stub: &'ll DICompositeType,
 256     member_description_factory: MemberDescriptionFactory<'ll, 'tcx>,
 257 ) -> RecursiveTypeDescription<'ll, 'tcx> {
 258
 259     // Insert the stub into the TypeMap in order to allow for recursive references
 260     let mut type_map = debug_context(cx).type_map.borrow_mut();
 261     type_map.register_unique_id_with_metadata(unique_type_id, metadata_stub);
 262     type_map.register_type_with_metadata(unfinished_type, metadata_stub);
 263
 264     UnfinishedMetadata {
 265         unfinished_type,
 266         unique_type_id,
 267         metadata_stub,
 268         member_holding_stub,
 269         member_description_factory,
 270     }
 271 }
 272
 273 impl RecursiveTypeDescription<'ll, 'tcx> {
 274     // Finishes up the description of the type in question (mostly by providing
 275     // descriptions of the fields of the given type) and returns the final type
 276     // metadata.
 277     fn finalize(&self, cx: &CodegenCx<'ll, 'tcx>) -> MetadataCreationResult<'ll> {
 278         match *self {
 279             FinalMetadata(metadata) => MetadataCreationResult::new(metadata, false),
 280             UnfinishedMetadata {
 281                 unfinished_type,
 282                 unique_type_id,
 283                 metadata_stub,
 284                 member_holding_stub,
 285                 ref member_description_factory,
 286             } => {
 287                 // Make sure that we have a forward declaration of the type in
 288                 // the TypeMap so that recursive references are possible. This
 289                 // will always be the case if the RecursiveTypeDescription has
 290                 // been properly created through the
 291                 // create_and_register_recursive_type_forward_declaration()
 292                 // function.
 293                 {
 294                     let type_map = debug_context(cx).type_map.borrow();
 295                     if type_map.find_metadata_for_unique_id(unique_type_id).is_none() ||
 296                        type_map.find_metadata_for_type(unfinished_type).is_none() {
 297                         bug!("Forward declaration of potentially recursive type \
 298                               '{:?}' was not found in TypeMap!",
 299                              unfinished_type);
 300                     }
 301                 }
 302
 303                 // ... then create the member descriptions ...
 304                 let member_descriptions =
 305                     member_description_factory.create_member_descriptions(cx);
 306
 307                 // ... and attach them to the stub to complete it.
 308                 set_members_of_composite_type(cx,
 309                                               unfinished_type,
 310                                               member_holding_stub,
 311                                               member_descriptions);
 312                 return MetadataCreationResult::new(metadata_stub, true);
 313             }
 314         }
 315     }
 316 }
 317
 318 // Returns from the enclosing function if the type metadata with the given
 319 // unique id can be found in the type map
 320 macro_rules! return_if_metadata_created_in_meantime {
 321     ($cx: expr, $unique_type_id: expr) => (
 322         if let Some(metadata) = debug_context($cx).type_map
 323             .borrow()
 324             .find_metadata_for_unique_id($unique_type_id)
 325         {
 326             return MetadataCreationResult::new(metadata, true);
 327         }
 328     )
 329 }
 330
 331 fn fixed_vec_metadata(
 332     cx: &CodegenCx<'ll, 'tcx>,
 333     unique_type_id: UniqueTypeId,
 334     array_or_slice_type: Ty<'tcx>,
 335     element_type: Ty<'tcx>,
 336     span: Span,
 337 ) -> MetadataCreationResult<'ll> {
 338     let element_type_metadata = type_metadata(cx, element_type, span);
 339
 340     return_if_metadata_created_in_meantime!(cx, unique_type_id);
 341
 342     let (size, align) = cx.size_and_align_of(array_or_slice_type);
 343
 344     let upper_bound = match array_or_slice_type.sty {
 345         ty::Array(_, len) => {
 346             len.unwrap_usize(cx.tcx) as c_longlong
 347         }
 348         _ => -1
 349     };
 350
 351     let subrange = unsafe {
 352         Some(llvm::LLVMRustDIBuilderGetOrCreateSubrange(DIB(cx), 0, upper_bound))
 353     };
 354
 355     let subscripts = create_DIArray(DIB(cx), &[subrange]);
 356     let metadata = unsafe {
 357         llvm::LLVMRustDIBuilderCreateArrayType(
 358             DIB(cx),
 359             size.bits(),
 360             align.bits() as u32,
 361             element_type_metadata,
 362             subscripts)
 363     };
 364
 365     return MetadataCreationResult::new(metadata, false);
 366 }
 367
 368 fn vec_slice_metadata(
 369     cx: &CodegenCx<'ll, 'tcx>,
 370     slice_ptr_type: Ty<'tcx>,
 371     element_type: Ty<'tcx>,
 372     unique_type_id: UniqueTypeId,
 373     span: Span,
 374 ) -> MetadataCreationResult<'ll> {
 375     let data_ptr_type = cx.tcx.mk_imm_ptr(element_type);
 376
 377     let data_ptr_metadata = type_metadata(cx, data_ptr_type, span);
 378
 379     return_if_metadata_created_in_meantime!(cx, unique_type_id);
 380
 381     let slice_type_name = compute_debuginfo_type_name(cx.tcx, slice_ptr_type, true);
 382
 383     let (pointer_size, pointer_align) = cx.size_and_align_of(data_ptr_type);
 384     let (usize_size, usize_align) = cx.size_and_align_of(cx.tcx.types.usize);
 385
 386     let member_descriptions = vec![
 387         MemberDescription {
 388             name: "data_ptr".to_owned(),
 389             type_metadata: data_ptr_metadata,
 390             offset: Size::ZERO,
 391             size: pointer_size,
 392             align: pointer_align,
 393             flags: DIFlags::FlagZero,
 394             discriminant: None,
 395         },
 396         MemberDescription {
 397             name: "length".to_owned(),
 398             type_metadata: type_metadata(cx, cx.tcx.types.usize, span),
 399             offset: pointer_size,
 400             size: usize_size,
 401             align: usize_align,
 402             flags: DIFlags::FlagZero,
 403             discriminant: None,
 404         },
 405     ];
 406
 407     let file_metadata = unknown_file_metadata(cx);
 408
 409     let metadata = composite_type_metadata(cx,
 410                                            slice_ptr_type,
 411                                            &slice_type_name[..],
 412                                            unique_type_id,
 413                                            member_descriptions,
 414                                            NO_SCOPE_METADATA,
 415                                            file_metadata,
 416                                            span);
 417     MetadataCreationResult::new(metadata, false)
 418 }
 419
 420 fn subroutine_type_metadata(
 421     cx: &CodegenCx<'ll, 'tcx>,
 422     unique_type_id: UniqueTypeId,
 423     signature: ty::PolyFnSig<'tcx>,
 424     span: Span,
 425 ) -> MetadataCreationResult<'ll> {
 426     let signature = cx.tcx.normalize_erasing_late_bound_regions(
 427         ty::ParamEnv::reveal_all(),
 428         &signature,
 429     );
 430
 431     let signature_metadata: Vec<_> = iter::once(
 432         // return type
 433         match signature.output().sty {
 434             ty::Tuple(ref tys) if tys.is_empty() => None,
 435             _ => Some(type_metadata(cx, signature.output(), span))
 436         }
 437     ).chain(
 438         // regular arguments
 439         signature.inputs().iter().map(|argument_type| {
 440             Some(type_metadata(cx, argument_type, span))
 441         })
 442     ).collect();
 443
 444     return_if_metadata_created_in_meantime!(cx, unique_type_id);
 445
 446     return MetadataCreationResult::new(
 447         unsafe {
 448             llvm::LLVMRustDIBuilderCreateSubroutineType(
 449                 DIB(cx),
 450                 unknown_file_metadata(cx),
 451                 create_DIArray(DIB(cx), &signature_metadata[..]))
 452         },
 453         false);
 454 }
 455
 456 // FIXME(1563) This is all a bit of a hack because 'trait pointer' is an ill-
 457 // defined concept. For the case of an actual trait pointer (i.e., Box<Trait>,
 458 // &Trait), trait_object_type should be the whole thing (e.g, Box<Trait>) and
 459 // trait_type should be the actual trait (e.g., Trait). Where the trait is part
 460 // of a DST struct, there is no trait_object_type and the results of this
 461 // function will be a little bit weird.
 462 fn trait_pointer_metadata(
 463     cx: &CodegenCx<'ll, 'tcx>,
 464     trait_type: Ty<'tcx>,
 465     trait_object_type: Option<Ty<'tcx>>,
 466     unique_type_id: UniqueTypeId,
 467 ) -> &'ll DIType {
 468     // The implementation provided here is a stub. It makes sure that the trait
 469     // type is assigned the correct name, size, namespace, and source location.
 470     // But it does not describe the trait's methods.
 471
 472     let containing_scope = match trait_type.sty {
 473         ty::Dynamic(ref data, ..) =>
 474             data.principal_def_id().map(|did| get_namespace_for_item(cx, did)),
 475         _ => {
 476             bug!("debuginfo: Unexpected trait-object type in \
 477                   trait_pointer_metadata(): {:?}",
 478                  trait_type);
 479         }
 480     };
 481
 482     let trait_object_type = trait_object_type.unwrap_or(trait_type);
 483     let trait_type_name =
 484         compute_debuginfo_type_name(cx.tcx, trait_object_type, false);
 485
 486     let file_metadata = unknown_file_metadata(cx);
 487
 488     let layout = cx.layout_of(cx.tcx.mk_mut_ptr(trait_type));
 489
 490     assert_eq!(abi::FAT_PTR_ADDR, 0);
 491     assert_eq!(abi::FAT_PTR_EXTRA, 1);
 492
 493     let data_ptr_field = layout.field(cx, 0);
 494     let vtable_field = layout.field(cx, 1);
 495     let member_descriptions = vec![
 496         MemberDescription {
 497             name: "pointer".to_owned(),
 498             type_metadata: type_metadata(cx,
 499                 cx.tcx.mk_mut_ptr(cx.tcx.types.u8),
 500                 syntax_pos::DUMMY_SP),
 501             offset: layout.fields.offset(0),
 502             size: data_ptr_field.size,
 503             align: data_ptr_field.align.abi,
 504             flags: DIFlags::FlagArtificial,
 505             discriminant: None,
 506         },
 507         MemberDescription {
 508             name: "vtable".to_owned(),
 509             type_metadata: type_metadata(cx, vtable_field.ty, syntax_pos::DUMMY_SP),
 510             offset: layout.fields.offset(1),
 511             size: vtable_field.size,
 512             align: vtable_field.align.abi,
 513             flags: DIFlags::FlagArtificial,
 514             discriminant: None,
 515         },
 516     ];
 517
 518     composite_type_metadata(cx,
 519                             trait_object_type,
 520                             &trait_type_name[..],
 521                             unique_type_id,
 522                             member_descriptions,
 523                             containing_scope,
 524                             file_metadata,
 525                             syntax_pos::DUMMY_SP)
 526 }
 527
 528 pub fn type_metadata(
 529     cx: &CodegenCx<'ll, 'tcx>,
 530     t: Ty<'tcx>,
 531     usage_site_span: Span,
 532 ) -> &'ll DIType {
 533     // Get the unique type id of this type.
 534     let unique_type_id = {
 535         let mut type_map = debug_context(cx).type_map.borrow_mut();
 536         // First, try to find the type in TypeMap. If we have seen it before, we
 537         // can exit early here.
 538         match type_map.find_metadata_for_type(t) {
 539             Some(metadata) => {
 540                 return metadata;
 541             },
 542             None => {
 543                 // The Ty is not in the TypeMap but maybe we have already seen
 544                 // an equivalent type (e.g., only differing in region arguments).
 545                 // In order to find out, generate the unique type id and look
 546                 // that up.
 547                 let unique_type_id = type_map.get_unique_type_id_of_type(cx, t);
 548                 match type_map.find_metadata_for_unique_id(unique_type_id) {
 549                     Some(metadata) => {
 550                         // There is already an equivalent type in the TypeMap.
 551                         // Register this Ty as an alias in the cache and
 552                         // return the cached metadata.
 553                         type_map.register_type_with_metadata(t, metadata);
 554                         return metadata;
 555                     },
 556                     None => {
 557                         // There really is no type metadata for this type, so
 558                         // proceed by creating it.
 559                         unique_type_id
 560                     }
 561                 }
 562             }
 563         }
 564     };
 565
 566     debug!("type_metadata: {:?}", t);
 567
 568     let ptr_metadata = |ty: Ty<'tcx>| {
 569         match ty.sty {
 570             ty::Slice(typ) => {
 571                 Ok(vec_slice_metadata(cx, t, typ, unique_type_id, usage_site_span))
 572             }
 573             ty::Str => {
 574                 Ok(vec_slice_metadata(cx, t, cx.tcx.types.u8, unique_type_id, usage_site_span))
 575             }
 576             ty::Dynamic(..) => {
 577                 Ok(MetadataCreationResult::new(
 578                     trait_pointer_metadata(cx, ty, Some(t), unique_type_id),
 579                     false))
 580             }
 581             _ => {
 582                 let pointee_metadata = type_metadata(cx, ty, usage_site_span);
 583
 584                 if let Some(metadata) = debug_context(cx).type_map
 585                     .borrow()
 586                     .find_metadata_for_unique_id(unique_type_id)
 587                 {
 588                     return Err(metadata);
 589                 }
 590
 591                 Ok(MetadataCreationResult::new(pointer_type_metadata(cx, t, pointee_metadata),
 592                    false))
 593             }
 594         }
 595     };
 596
 597     let MetadataCreationResult { metadata, already_stored_in_typemap } = match t.sty {
 598         ty::Never    |
 599         ty::Bool     |
 600         ty::Char     |
 601         ty::Int(_)   |
 602         ty::Uint(_)  |
 603         ty::Float(_) => {
 604             MetadataCreationResult::new(basic_type_metadata(cx, t), false)
 605         }
 606         ty::Tuple(ref elements) if elements.is_empty() => {
 607             MetadataCreationResult::new(basic_type_metadata(cx, t), false)
 608         }
 609         ty::Array(typ, _) |
 610         ty::Slice(typ) => {
 611             fixed_vec_metadata(cx, unique_type_id, t, typ, usage_site_span)
 612         }
 613         ty::Str => {
 614             fixed_vec_metadata(cx, unique_type_id, t, cx.tcx.types.i8, usage_site_span)
 615         }
 616         ty::Dynamic(..) => {
 617             MetadataCreationResult::new(
 618                 trait_pointer_metadata(cx, t, None, unique_type_id),
 619                 false)
 620         }
 621         ty::Foreign(..) => {
 622             MetadataCreationResult::new(
 623             foreign_type_metadata(cx, t, unique_type_id),
 624             false)
 625         }
 626         ty::RawPtr(ty::TypeAndMut{ty, ..}) |
 627         ty::Ref(_, ty, _) => {
 628             match ptr_metadata(ty) {
 629                 Ok(res) => res,
 630                 Err(metadata) => return metadata,
 631             }
 632         }
 633         ty::Adt(def, _) if def.is_box() => {
 634             match ptr_metadata(t.boxed_ty()) {
 635                 Ok(res) => res,
 636                 Err(metadata) => return metadata,
 637             }
 638         }
 639         ty::FnDef(..) | ty::FnPtr(_) => {
 640
 641             if let Some(metadata) = debug_context(cx).type_map
 642                .borrow()
 643                .find_metadata_for_unique_id(unique_type_id)
 644             {
 645                 return metadata;
 646             }
 647
 648             // It's possible to create a self-referential
 649             // type in Rust by using 'impl trait':
 650             //
 651             // fn foo() -> impl Copy { foo }
 652             //
 653             // See TypeMap::remove_type for more detals
 654             // about the workaround
 655
 656             let temp_type = {
 657                 unsafe {
 658                     // The choice of type here is pretty arbitrary -
 659                     // anything reading the debuginfo for a recursive
 660                     // type is going to see *somthing* weird - the only
 661                     // question is what exactly it will see
 662                     let (size, align) = cx.size_and_align_of(t);
 663                     llvm::LLVMRustDIBuilderCreateBasicType(
 664                         DIB(cx),
 665                         SmallCStr::new("<recur_type>").as_ptr(),
 666                         size.bits(),
 667                         align.bits() as u32,
 668                         DW_ATE_unsigned)
 669                 }
 670             };
 671
 672             let type_map = &debug_context(cx).type_map;
 673             type_map.borrow_mut().register_type_with_metadata(t, temp_type);
 674
 675             let fn_metadata = subroutine_type_metadata(cx,
 676                                                        unique_type_id,
 677                                                        t.fn_sig(cx.tcx),
 678                                                        usage_site_span).metadata;
 679
 680             type_map.borrow_mut().remove_type(t);
 681
 682
 683             // This is actually a function pointer, so wrap it in pointer DI
 684             MetadataCreationResult::new(pointer_type_metadata(cx, t, fn_metadata), false)
 685
 686         }
 687         ty::Closure(def_id, substs) => {
 688             let upvar_tys : Vec<_> = substs.upvar_tys(def_id, cx.tcx).collect();
 689             prepare_tuple_metadata(cx,
 690                                    t,
 691                                    &upvar_tys,
 692                                    unique_type_id,
 693                                    usage_site_span).finalize(cx)
 694         }
 695         ty::Generator(def_id, substs,  _) => {
 696             let upvar_tys : Vec<_> = substs.prefix_tys(def_id, cx.tcx).map(|t| {
 697                 cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), t)
 698             }).collect();
 699             prepare_enum_metadata(cx,
 700                                   t,
 701                                   def_id,
 702                                   unique_type_id,
 703                                   usage_site_span,
 704                                   upvar_tys).finalize(cx)
 705         }
 706         ty::Adt(def, ..) => match def.adt_kind() {
 707             AdtKind::Struct => {
 708                 prepare_struct_metadata(cx,
 709                                         t,
 710                                         unique_type_id,
 711                                         usage_site_span).finalize(cx)
 712             }
 713             AdtKind::Union => {
 714                 prepare_union_metadata(cx,
 715                                        t,
 716                                        unique_type_id,
 717                                        usage_site_span).finalize(cx)
 718             }
 719             AdtKind::Enum => {
 720                 prepare_enum_metadata(cx,
 721                                       t,
 722                                       def.did,
 723                                       unique_type_id,
 724                                       usage_site_span,
 725                                       vec![]).finalize(cx)
 726             }
 727         },
 728         ty::Tuple(ref elements) => {
 729             let tys: Vec<_> = elements.iter().map(|k| k.expect_ty()).collect();
 730             prepare_tuple_metadata(cx,
 731                                    t,
 732                                    &tys,
 733                                    unique_type_id,
 734                                    usage_site_span).finalize(cx)
 735         }
 736         _ => {
 737             bug!("debuginfo: unexpected type in type_metadata: {:?}", t)
 738         }
 739     };
 740
 741     {
 742         let mut type_map = debug_context(cx).type_map.borrow_mut();
 743
 744         if already_stored_in_typemap {
 745             // Also make sure that we already have a TypeMap entry for the unique type id.
 746             let metadata_for_uid = match type_map.find_metadata_for_unique_id(unique_type_id) {
 747                 Some(metadata) => metadata,
 748                 None => {
 749                     span_bug!(usage_site_span,
 750                               "Expected type metadata for unique \
 751                                type id '{}' to already be in \
 752                                the debuginfo::TypeMap but it \
 753                                was not. (Ty = {})",
 754                               type_map.get_unique_type_id_as_string(unique_type_id),
 755                               t);
 756                 }
 757             };
 758
 759             match type_map.find_metadata_for_type(t) {
 760                 Some(metadata) => {
 761                     if metadata != metadata_for_uid {
 762                         span_bug!(usage_site_span,
 763                                   "Mismatch between Ty and \
 764                                    UniqueTypeId maps in \
 765                                    debuginfo::TypeMap. \
 766                                    UniqueTypeId={}, Ty={}",
 767                                   type_map.get_unique_type_id_as_string(unique_type_id),
 768                                   t);
 769                     }
 770                 }
 771                 None => {
 772                     type_map.register_type_with_metadata(t, metadata);
 773                 }
 774             }
 775         } else {
 776             type_map.register_type_with_metadata(t, metadata);
 777             type_map.register_unique_id_with_metadata(unique_type_id, metadata);
 778         }
 779     }
 780
 781     metadata
 782 }
 783
 784 pub fn file_metadata(cx: &CodegenCx<'ll, '_>,
 785                      file_name: &FileName,
 786                      defining_crate: CrateNum) -> &'ll DIFile {
 787     debug!("file_metadata: file_name: {}, defining_crate: {}",
 788            file_name,
 789            defining_crate);
 790
 791     let file_name = Some(file_name.to_string());
 792     let directory = if defining_crate == LOCAL_CRATE {
 793         Some(cx.sess().working_dir.0.to_string_lossy().to_string())
 794     } else {
 795         // If the path comes from an upstream crate we assume it has been made
 796         // independent of the compiler's working directory one way or another.
 797         None
 798     };
 799     file_metadata_raw(cx, file_name, directory)
 800 }
 801
 802 pub fn unknown_file_metadata(cx: &CodegenCx<'ll, '_>) -> &'ll DIFile {
 803     file_metadata_raw(cx, None, None)
 804 }
 805
 806 fn file_metadata_raw(cx: &CodegenCx<'ll, '_>,
 807                      file_name: Option<String>,
 808                      directory: Option<String>)
 809                      -> &'ll DIFile {
 810     let key = (file_name, directory);
 811
 812     match debug_context(cx).created_files.borrow_mut().entry(key) {
 813         Entry::Occupied(o) => return o.get(),
 814         Entry::Vacant(v) => {
 815             let (file_name, directory) = v.key();
 816             debug!("file_metadata: file_name: {:?}, directory: {:?}", file_name, directory);
 817
 818             let file_name = SmallCStr::new(
 819                 if let Some(file_name) = file_name { &file_name } else { "<unknown>" });
 820             let directory = SmallCStr::new(
 821                 if let Some(directory) = directory { &directory } else { "" });
 822
 823             let file_metadata = unsafe {
 824                 llvm::LLVMRustDIBuilderCreateFile(DIB(cx),
 825                                                   file_name.as_ptr(),
 826                                                   directory.as_ptr())
 827             };
 828
 829             v.insert(file_metadata);
 830             file_metadata
 831         }
 832     }
 833 }
 834
 835 fn basic_type_metadata(cx: &CodegenCx<'ll, 'tcx>, t: Ty<'tcx>) -> &'ll DIType {
 836     debug!("basic_type_metadata: {:?}", t);
 837
 838     let (name, encoding) = match t.sty {
 839         ty::Never => ("!", DW_ATE_unsigned),
 840         ty::Tuple(ref elements) if elements.is_empty() =>
 841             ("()", DW_ATE_unsigned),
 842         ty::Bool => ("bool", DW_ATE_boolean),
 843         ty::Char => ("char", DW_ATE_unsigned_char),
 844         ty::Int(int_ty) => {
 845             (int_ty.ty_to_string(), DW_ATE_signed)
 846         },
 847         ty::Uint(uint_ty) => {
 848             (uint_ty.ty_to_string(), DW_ATE_unsigned)
 849         },
 850         ty::Float(float_ty) => {
 851             (float_ty.ty_to_string(), DW_ATE_float)
 852         },
 853         _ => bug!("debuginfo::basic_type_metadata - t is invalid type")
 854     };
 855
 856     let (size, align) = cx.size_and_align_of(t);
 857     let name = SmallCStr::new(name);
 858     let ty_metadata = unsafe {
 859         llvm::LLVMRustDIBuilderCreateBasicType(
 860             DIB(cx),
 861             name.as_ptr(),
 862             size.bits(),
 863             align.bits() as u32,
 864             encoding)
 865     };
 866
 867     return ty_metadata;
 868 }
 869
 870 fn foreign_type_metadata(
 871     cx: &CodegenCx<'ll, 'tcx>,
 872     t: Ty<'tcx>,
 873     unique_type_id: UniqueTypeId,
 874 ) -> &'ll DIType {
 875     debug!("foreign_type_metadata: {:?}", t);
 876
 877     let name = compute_debuginfo_type_name(cx.tcx, t, false);
 878     create_struct_stub(cx, t, &name, unique_type_id, NO_SCOPE_METADATA)
 879 }
 880
 881 fn pointer_type_metadata(
 882     cx: &CodegenCx<'ll, 'tcx>,
 883     pointer_type: Ty<'tcx>,
 884     pointee_type_metadata: &'ll DIType,
 885 ) -> &'ll DIType {
 886     let (pointer_size, pointer_align) = cx.size_and_align_of(pointer_type);
 887     let name = compute_debuginfo_type_name(cx.tcx, pointer_type, false);
 888     let name = SmallCStr::new(&name);
 889     unsafe {
 890         llvm::LLVMRustDIBuilderCreatePointerType(
 891             DIB(cx),
 892             pointee_type_metadata,
 893             pointer_size.bits(),
 894             pointer_align.bits() as u32,
 895             name.as_ptr())
 896     }
 897 }
 898
 899 pub fn compile_unit_metadata(tcx: TyCtxt<'_, '_, '_>,
 900                              codegen_unit_name: &str,
 901                              debug_context: &CrateDebugContext<'ll, '_>)
 902                              -> &'ll DIDescriptor {
 903     let mut name_in_debuginfo = match tcx.sess.local_crate_source_file {
 904         Some(ref path) => path.clone(),
 905         None => PathBuf::from(&*tcx.crate_name(LOCAL_CRATE).as_str()),
 906     };
 907
 908     // The OSX linker has an idiosyncrasy where it will ignore some debuginfo
 909     // if multiple object files with the same DW_AT_name are linked together.
 910     // As a workaround we generate unique names for each object file. Those do
 911     // not correspond to an actual source file but that should be harmless.
 912     if tcx.sess.target.target.options.is_like_osx {
 913         name_in_debuginfo.push("@");
 914         name_in_debuginfo.push(codegen_unit_name);
 915     }
 916
 917     debug!("compile_unit_metadata: {:?}", name_in_debuginfo);
 918     // FIXME(#41252) Remove "clang LLVM" if we can get GDB and LLVM to play nice.
 919     let producer = format!("clang LLVM (rustc version {})",
 920                            (option_env!("CFG_VERSION")).expect("CFG_VERSION"));
 921
 922     let name_in_debuginfo = name_in_debuginfo.to_string_lossy();
 923     let name_in_debuginfo = SmallCStr::new(&name_in_debuginfo);
 924     let work_dir = SmallCStr::new(&tcx.sess.working_dir.0.to_string_lossy());
 925     let producer = CString::new(producer).unwrap();
 926     let flags = "\0";
 927     let split_name = "\0";
 928     let kind = DebugEmissionKind::from_generic(tcx.sess.opts.debuginfo);
 929
 930     unsafe {
 931         let file_metadata = llvm::LLVMRustDIBuilderCreateFile(
 932             debug_context.builder, name_in_debuginfo.as_ptr(), work_dir.as_ptr());
 933
 934         let unit_metadata = llvm::LLVMRustDIBuilderCreateCompileUnit(
 935             debug_context.builder,
 936             DW_LANG_RUST,
 937             file_metadata,
 938             producer.as_ptr(),
 939             tcx.sess.opts.optimize != config::OptLevel::No,
 940             flags.as_ptr() as *const _,
 941             0,
 942             split_name.as_ptr() as *const _,
 943             kind);
 944
 945         if tcx.sess.opts.debugging_opts.profile {
 946             let cu_desc_metadata = llvm::LLVMRustMetadataAsValue(debug_context.llcontext,
 947                                                                  unit_metadata);
 948
 949             let gcov_cu_info = [
 950                 path_to_mdstring(debug_context.llcontext,
 951                                  &tcx.output_filenames(LOCAL_CRATE).with_extension("gcno")),
 952                 path_to_mdstring(debug_context.llcontext,
 953                                  &tcx.output_filenames(LOCAL_CRATE).with_extension("gcda")),
 954                 cu_desc_metadata,
 955             ];
 956             let gcov_metadata = llvm::LLVMMDNodeInContext(debug_context.llcontext,
 957                                                           gcov_cu_info.as_ptr(),
 958                                                           gcov_cu_info.len() as c_uint);
 959
 960             let llvm_gcov_ident = const_cstr!("llvm.gcov");
 961             llvm::LLVMAddNamedMetadataOperand(debug_context.llmod,
 962                                               llvm_gcov_ident.as_ptr(),
 963                                               gcov_metadata);
 964         }
 965
 966         return unit_metadata;
 967     };
 968
 969     fn path_to_mdstring(llcx: &'ll llvm::Context, path: &Path) -> &'ll Value {
 970         let path_str = path_to_c_string(path);
 971         unsafe {
 972             llvm::LLVMMDStringInContext(llcx,
 973                                         path_str.as_ptr(),
 974                                         path_str.as_bytes().len() as c_uint)
 975         }
 976     }
 977 }
 978
 979 struct MetadataCreationResult<'ll> {
 980     metadata: &'ll DIType,
 981     already_stored_in_typemap: bool
 982 }
 983
 984 impl MetadataCreationResult<'ll> {
 985     fn new(metadata: &'ll DIType, already_stored_in_typemap: bool) -> Self {
 986         MetadataCreationResult {
 987             metadata,
 988             already_stored_in_typemap,
 989         }
 990     }
 991 }
 992
 993 // Description of a type member, which can either be a regular field (as in
 994 // structs or tuples) or an enum variant.
 995 #[derive(Debug)]
 996 struct MemberDescription<'ll> {
 997     name: String,
 998     type_metadata: &'ll DIType,
 999     offset: Size,
1000     size: Size,
1001     align: Align,
1002     flags: DIFlags,
1003     discriminant: Option<u64>,
1004 }
1005
1006 impl<'ll> MemberDescription<'ll> {
1007     fn into_metadata(self,
1008                      cx: &CodegenCx<'ll, '_>,
1009                      composite_type_metadata: &'ll DIScope) -> &'ll DIType {
1010         let member_name = CString::new(self.name).unwrap();
1011         unsafe {
1012             llvm::LLVMRustDIBuilderCreateVariantMemberType(
1013                 DIB(cx),
1014                 composite_type_metadata,
1015                 member_name.as_ptr(),
1016                 unknown_file_metadata(cx),
1017                 UNKNOWN_LINE_NUMBER,
1018                 self.size.bits(),
1019                 self.align.bits() as u32,
1020                 self.offset.bits(),
1021                 match self.discriminant {
1022                     None => None,
1023                     Some(value) => Some(cx.const_u64(value)),
1024                 },
1025                 self.flags,
1026                 self.type_metadata)
1027         }
1028     }
1029 }
1030
1031 // A factory for MemberDescriptions. It produces a list of member descriptions
1032 // for some record-like type. MemberDescriptionFactories are used to defer the
1033 // creation of type member descriptions in order to break cycles arising from
1034 // recursive type definitions.
1035 enum MemberDescriptionFactory<'ll, 'tcx> {
1036     StructMDF(StructMemberDescriptionFactory<'tcx>),
1037     TupleMDF(TupleMemberDescriptionFactory<'tcx>),
1038     EnumMDF(EnumMemberDescriptionFactory<'ll, 'tcx>),
1039     UnionMDF(UnionMemberDescriptionFactory<'tcx>),
1040     VariantMDF(VariantMemberDescriptionFactory<'ll, 'tcx>)
1041 }
1042
1043 impl MemberDescriptionFactory<'ll, 'tcx> {
1044     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
1045                                   -> Vec<MemberDescription<'ll>> {
1046         match *self {
1047             StructMDF(ref this) => {
1048                 this.create_member_descriptions(cx)
1049             }
1050             TupleMDF(ref this) => {
1051                 this.create_member_descriptions(cx)
1052             }
1053             EnumMDF(ref this) => {
1054                 this.create_member_descriptions(cx)
1055             }
1056             UnionMDF(ref this) => {
1057                 this.create_member_descriptions(cx)
1058             }
1059             VariantMDF(ref this) => {
1060                 this.create_member_descriptions(cx)
1061             }
1062         }
1063     }
1064 }
1065
1066 //=-----------------------------------------------------------------------------
1067 // Structs
1068 //=-----------------------------------------------------------------------------
1069
1070 // Creates MemberDescriptions for the fields of a struct
1071 struct StructMemberDescriptionFactory<'tcx> {
1072     ty: Ty<'tcx>,
1073     variant: &'tcx ty::VariantDef,
1074     span: Span,
1075 }
1076
1077 impl<'tcx> StructMemberDescriptionFactory<'tcx> {
1078     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
1079                                   -> Vec<MemberDescription<'ll>> {
1080         let layout = cx.layout_of(self.ty);
1081         self.variant.fields.iter().enumerate().map(|(i, f)| {
1082             let name = if self.variant.ctor_kind == CtorKind::Fn {
1083                 format!("__{}", i)
1084             } else {
1085                 f.ident.to_string()
1086             };
1087             let field = layout.field(cx, i);
1088             MemberDescription {
1089                 name,
1090                 type_metadata: type_metadata(cx, field.ty, self.span),
1091                 offset: layout.fields.offset(i),
1092                 size: field.size,
1093                 align: field.align.abi,
1094                 flags: DIFlags::FlagZero,
1095                 discriminant: None,
1096             }
1097         }).collect()
1098     }
1099 }
1100
1101
1102 fn prepare_struct_metadata(
1103     cx: &CodegenCx<'ll, 'tcx>,
1104     struct_type: Ty<'tcx>,
1105     unique_type_id: UniqueTypeId,
1106     span: Span,
1107 ) -> RecursiveTypeDescription<'ll, 'tcx> {
1108     let struct_name = compute_debuginfo_type_name(cx.tcx, struct_type, false);
1109
1110     let (struct_def_id, variant) = match struct_type.sty {
1111         ty::Adt(def, _) => (def.did, def.non_enum_variant()),
1112         _ => bug!("prepare_struct_metadata on a non-ADT")
1113     };
1114
1115     let containing_scope = get_namespace_for_item(cx, struct_def_id);
1116
1117     let struct_metadata_stub = create_struct_stub(cx,
1118                                                   struct_type,
1119                                                   &struct_name,
1120                                                   unique_type_id,
1121                                                   Some(containing_scope));
1122
1123     create_and_register_recursive_type_forward_declaration(
1124         cx,
1125         struct_type,
1126         unique_type_id,
1127         struct_metadata_stub,
1128         struct_metadata_stub,
1129         StructMDF(StructMemberDescriptionFactory {
1130             ty: struct_type,
1131             variant,
1132             span,
1133         })
1134     )
1135 }
1136
1137 //=-----------------------------------------------------------------------------
1138 // Tuples
1139 //=-----------------------------------------------------------------------------
1140
1141 // Creates MemberDescriptions for the fields of a tuple
1142 struct TupleMemberDescriptionFactory<'tcx> {
1143     ty: Ty<'tcx>,
1144     component_types: Vec<Ty<'tcx>>,
1145     span: Span,
1146 }
1147
1148 impl<'tcx> TupleMemberDescriptionFactory<'tcx> {
1149     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
1150                                   -> Vec<MemberDescription<'ll>> {
1151         let layout = cx.layout_of(self.ty);
1152         self.component_types.iter().enumerate().map(|(i, &component_type)| {
1153             let (size, align) = cx.size_and_align_of(component_type);
1154             MemberDescription {
1155                 name: format!("__{}", i),
1156                 type_metadata: type_metadata(cx, component_type, self.span),
1157                 offset: layout.fields.offset(i),
1158                 size,
1159                 align,
1160                 flags: DIFlags::FlagZero,
1161                 discriminant: None,
1162             }
1163         }).collect()
1164     }
1165 }
1166
1167 fn prepare_tuple_metadata(
1168     cx: &CodegenCx<'ll, 'tcx>,
1169     tuple_type: Ty<'tcx>,
1170     component_types: &[Ty<'tcx>],
1171     unique_type_id: UniqueTypeId,
1172     span: Span,
1173 ) -> RecursiveTypeDescription<'ll, 'tcx> {
1174     let tuple_name = compute_debuginfo_type_name(cx.tcx, tuple_type, false);
1175
1176     let struct_stub = create_struct_stub(cx,
1177                                          tuple_type,
1178                                          &tuple_name[..],
1179                                          unique_type_id,
1180                                          NO_SCOPE_METADATA);
1181
1182     create_and_register_recursive_type_forward_declaration(
1183         cx,
1184         tuple_type,
1185         unique_type_id,
1186         struct_stub,
1187         struct_stub,
1188         TupleMDF(TupleMemberDescriptionFactory {
1189             ty: tuple_type,
1190             component_types: component_types.to_vec(),
1191             span,
1192         })
1193     )
1194 }
1195
1196 //=-----------------------------------------------------------------------------
1197 // Unions
1198 //=-----------------------------------------------------------------------------
1199
1200 struct UnionMemberDescriptionFactory<'tcx> {
1201     layout: TyLayout<'tcx>,
1202     variant: &'tcx ty::VariantDef,
1203     span: Span,
1204 }
1205
1206 impl<'tcx> UnionMemberDescriptionFactory<'tcx> {
1207     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
1208                                   -> Vec<MemberDescription<'ll>> {
1209         self.variant.fields.iter().enumerate().map(|(i, f)| {
1210             let field = self.layout.field(cx, i);
1211             MemberDescription {
1212                 name: f.ident.to_string(),
1213                 type_metadata: type_metadata(cx, field.ty, self.span),
1214                 offset: Size::ZERO,
1215                 size: field.size,
1216                 align: field.align.abi,
1217                 flags: DIFlags::FlagZero,
1218                 discriminant: None,
1219             }
1220         }).collect()
1221     }
1222 }
1223
1224 fn prepare_union_metadata(
1225     cx: &CodegenCx<'ll, 'tcx>,
1226     union_type: Ty<'tcx>,
1227     unique_type_id: UniqueTypeId,
1228     span: Span,
1229 ) -> RecursiveTypeDescription<'ll, 'tcx> {
1230     let union_name = compute_debuginfo_type_name(cx.tcx, union_type, false);
1231
1232     let (union_def_id, variant) = match union_type.sty {
1233         ty::Adt(def, _) => (def.did, def.non_enum_variant()),
1234         _ => bug!("prepare_union_metadata on a non-ADT")
1235     };
1236
1237     let containing_scope = get_namespace_for_item(cx, union_def_id);
1238
1239     let union_metadata_stub = create_union_stub(cx,
1240                                                 union_type,
1241                                                 &union_name,
1242                                                 unique_type_id,
1243                                                 containing_scope);
1244
1245     create_and_register_recursive_type_forward_declaration(
1246         cx,
1247         union_type,
1248         unique_type_id,
1249         union_metadata_stub,
1250         union_metadata_stub,
1251         UnionMDF(UnionMemberDescriptionFactory {
1252             layout: cx.layout_of(union_type),
1253             variant,
1254             span,
1255         })
1256     )
1257 }
1258
1259 //=-----------------------------------------------------------------------------
1260 // Enums
1261 //=-----------------------------------------------------------------------------
1262
1263 // DWARF variant support is only available starting in LLVM 8.
1264 // Although the earlier enum debug info output did not work properly
1265 // in all situations, it is better for the time being to continue to
1266 // sometimes emit the old style rather than emit something completely
1267 // useless when rust is compiled against LLVM 6 or older. LLVM 7
1268 // contains an early version of the DWARF variant support, and will
1269 // crash when handling the new debug info format. This function
1270 // decides which representation will be emitted.
1271 fn use_enum_fallback(cx: &CodegenCx<'_, '_>) -> bool {
1272     // On MSVC we have to use the fallback mode, because LLVM doesn't
1273     // lower variant parts to PDB.
1274     return cx.sess().target.target.options.is_like_msvc
1275         // LLVM version 7 did not release with an important bug fix;
1276         // but the required patch is in the LLVM 8.  Rust LLVM reports
1277         // 8 as well.
1278         || llvm_util::get_major_version() < 8;
1279 }
1280
1281 // Describes the members of an enum value: An enum is described as a union of
1282 // structs in DWARF. This MemberDescriptionFactory provides the description for
1283 // the members of this union; so for every variant of the given enum, this
1284 // factory will produce one MemberDescription (all with no name and a fixed
1285 // offset of zero bytes).
1286 struct EnumMemberDescriptionFactory<'ll, 'tcx> {
1287     enum_type: Ty<'tcx>,
1288     layout: TyLayout<'tcx>,
1289     discriminant_type_metadata: Option<&'ll DIType>,
1290     containing_scope: &'ll DIScope,
1291     span: Span,
1292 }
1293
1294 impl EnumMemberDescriptionFactory<'ll, 'tcx> {
1295     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
1296                                   -> Vec<MemberDescription<'ll>> {
1297         let variant_info_for = |index: VariantIdx| {
1298             match &self.enum_type.sty {
1299                 ty::Adt(adt, _) => VariantInfo::Adt(&adt.variants[index]),
1300                 ty::Generator(def_id, substs, _) => {
1301                     let generator_layout = cx.tcx.generator_layout(*def_id);
1302                     VariantInfo::Generator(*substs, generator_layout, index)
1303                 }
1304                 _ => bug!(),
1305             }
1306         };
1307
1308         // This will always find the metadata in the type map.
1309         let fallback = use_enum_fallback(cx);
1310         let self_metadata = if fallback {
1311             self.containing_scope
1312         } else {
1313             type_metadata(cx, self.enum_type, self.span)
1314         };
1315
1316         match self.layout.variants {
1317             layout::Variants::Single { index } => {
1318                 if let ty::Adt(adt, _) = &self.enum_type.sty {
1319                     if adt.variants.is_empty() {
1320                         return vec![];
1321                     }
1322                 }
1323
1324                 let variant_info = variant_info_for(index);
1325                 let (variant_type_metadata, member_description_factory) =
1326                     describe_enum_variant(cx,
1327                                           self.layout,
1328                                           variant_info,
1329                                           NoDiscriminant,
1330                                           self_metadata,
1331                                           self.span);
1332
1333                 let member_descriptions =
1334                     member_description_factory.create_member_descriptions(cx);
1335
1336                 set_members_of_composite_type(cx,
1337                                               self.enum_type,
1338                                               variant_type_metadata,
1339                                               member_descriptions);
1340                 vec![
1341                     MemberDescription {
1342                         name: if fallback {
1343                             String::new()
1344                         } else {
1345                             variant_info.variant_name()
1346                         },
1347                         type_metadata: variant_type_metadata,
1348                         offset: Size::ZERO,
1349                         size: self.layout.size,
1350                         align: self.layout.align.abi,
1351                         flags: DIFlags::FlagZero,
1352                         discriminant: None,
1353                     }
1354                 ]
1355             }
1356             layout::Variants::Multiple {
1357                 discr_kind: layout::DiscriminantKind::Tag,
1358                 discr_index,
1359                 ref variants,
1360                 ..
1361             } => {
1362                 let discriminant_info = if fallback {
1363                     RegularDiscriminant {
1364                         discr_field: Field::from(discr_index),
1365                         discr_type_metadata: self.discriminant_type_metadata.unwrap()
1366                     }
1367                 } else {
1368                     // This doesn't matter in this case.
1369                     NoDiscriminant
1370                 };
1371                 variants.iter_enumerated().map(|(i, _)| {
1372                     let variant = self.layout.for_variant(cx, i);
1373                     let variant_info = variant_info_for(i);
1374                     let (variant_type_metadata, member_desc_factory) =
1375                         describe_enum_variant(cx,
1376                                               variant,
1377                                               variant_info,
1378                                               discriminant_info,
1379                                               self_metadata,
1380                                               self.span);
1381
1382                     let member_descriptions = member_desc_factory
1383                         .create_member_descriptions(cx);
1384
1385                     set_members_of_composite_type(cx,
1386                                                   self.enum_type,
1387                                                   variant_type_metadata,
1388                                                   member_descriptions);
1389
1390                     MemberDescription {
1391                         name: if fallback {
1392                             String::new()
1393                         } else {
1394                             variant_info.variant_name()
1395                         },
1396                         type_metadata: variant_type_metadata,
1397                         offset: Size::ZERO,
1398                         size: self.layout.size,
1399                         align: self.layout.align.abi,
1400                         flags: DIFlags::FlagZero,
1401                         discriminant: Some(
1402                             self.layout.ty.discriminant_for_variant(cx.tcx, i).unwrap().val as u64
1403                         ),
1404                     }
1405                 }).collect()
1406             }
1407             layout::Variants::Multiple {
1408                 discr_kind: layout::DiscriminantKind::Niche {
1409                     ref niche_variants,
1410                     niche_start,
1411                     dataful_variant,
1412                 },
1413                 ref discr,
1414                 ref variants,
1415                 discr_index,
1416             } => {
1417                 if fallback {
1418                     let variant = self.layout.for_variant(cx, dataful_variant);
1419                     // Create a description of the non-null variant
1420                     let (variant_type_metadata, member_description_factory) =
1421                         describe_enum_variant(cx,
1422                                               variant,
1423                                               variant_info_for(dataful_variant),
1424                                               OptimizedDiscriminant,
1425                                               self.containing_scope,
1426                                               self.span);
1427
1428                     let variant_member_descriptions =
1429                         member_description_factory.create_member_descriptions(cx);
1430
1431                     set_members_of_composite_type(cx,
1432                                                   self.enum_type,
1433                                                   variant_type_metadata,
1434                                                   variant_member_descriptions);
1435
1436                     // Encode the information about the null variant in the union
1437                     // member's name.
1438                     let mut name = String::from("RUST$ENCODED$ENUM$");
1439                     // Right now it's not even going to work for `niche_start > 0`,
1440                     // and for multiple niche variants it only supports the first.
1441                     fn compute_field_path<'a, 'tcx>(cx: &CodegenCx<'a, 'tcx>,
1442                                                     name: &mut String,
1443                                                     layout: TyLayout<'tcx>,
1444                                                     offset: Size,
1445                                                     size: Size) {
1446                         for i in 0..layout.fields.count() {
1447                             let field_offset = layout.fields.offset(i);
1448                             if field_offset > offset {
1449                                 continue;
1450                             }
1451                             let inner_offset = offset - field_offset;
1452                             let field = layout.field(cx, i);
1453                             if inner_offset + size <= field.size {
1454                                 write!(name, "{}$", i).unwrap();
1455                                 compute_field_path(cx, name, field, inner_offset, size);
1456                             }
1457                         }
1458                     }
1459                     compute_field_path(cx, &mut name,
1460                                        self.layout,
1461                                        self.layout.fields.offset(discr_index),
1462                                        self.layout.field(cx, discr_index).size);
1463                     variant_info_for(*niche_variants.start()).map_struct_name(|variant_name| {
1464                         name.push_str(variant_name);
1465                     });
1466
1467                     // Create the (singleton) list of descriptions of union members.
1468                     vec![
1469                         MemberDescription {
1470                             name,
1471                             type_metadata: variant_type_metadata,
1472                             offset: Size::ZERO,
1473                             size: variant.size,
1474                             align: variant.align.abi,
1475                             flags: DIFlags::FlagZero,
1476                             discriminant: None,
1477                         }
1478                     ]
1479                 } else {
1480                     variants.iter_enumerated().map(|(i, _)| {
1481                         let variant = self.layout.for_variant(cx, i);
1482                         let variant_info = variant_info_for(i);
1483                         let (variant_type_metadata, member_desc_factory) =
1484                             describe_enum_variant(cx,
1485                                                   variant,
1486                                                   variant_info,
1487                                                   OptimizedDiscriminant,
1488                                                   self_metadata,
1489                                                   self.span);
1490
1491                         let member_descriptions = member_desc_factory
1492                             .create_member_descriptions(cx);
1493
1494                         set_members_of_composite_type(cx,
1495                                                       self.enum_type,
1496                                                       variant_type_metadata,
1497                                                       member_descriptions);
1498
1499                         let niche_value = if i == dataful_variant {
1500                             None
1501                         } else {
1502                             let value = (i.as_u32() as u128)
1503                                 .wrapping_sub(niche_variants.start().as_u32() as u128)
1504                                 .wrapping_add(niche_start);
1505                             let value = truncate(value, discr.value.size(cx));
1506                             // NOTE(eddyb) do *NOT* remove this assert, until
1507                             // we pass the full 128-bit value to LLVM, otherwise
1508                             // truncation will be silent and remain undetected.
1509                             assert_eq!(value as u64 as u128, value);
1510                             Some(value as u64)
1511                         };
1512
1513                         MemberDescription {
1514                             name: variant_info.variant_name(),
1515                             type_metadata: variant_type_metadata,
1516                             offset: Size::ZERO,
1517                             size: self.layout.size,
1518                             align: self.layout.align.abi,
1519                             flags: DIFlags::FlagZero,
1520                             discriminant: niche_value,
1521                         }
1522                     }).collect()
1523                 }
1524             }
1525         }
1526     }
1527 }
1528
1529 // Creates MemberDescriptions for the fields of a single enum variant.
1530 struct VariantMemberDescriptionFactory<'ll, 'tcx> {
1531     // Cloned from the layout::Struct describing the variant.
1532     offsets: Vec<layout::Size>,
1533     args: Vec<(String, Ty<'tcx>)>,
1534     discriminant_type_metadata: Option<&'ll DIType>,
1535     span: Span,
1536 }
1537
1538 impl VariantMemberDescriptionFactory<'ll, 'tcx> {
1539     fn create_member_descriptions(&self, cx: &CodegenCx<'ll, 'tcx>)
1540                                       -> Vec<MemberDescription<'ll>> {
1541         self.args.iter().enumerate().map(|(i, &(ref name, ty))| {
1542             let (size, align) = cx.size_and_align_of(ty);
1543             MemberDescription {
1544                 name: name.to_string(),
1545                 type_metadata: if use_enum_fallback(cx) {
1546                     match self.discriminant_type_metadata {
1547                         // Discriminant is always the first field of our variant
1548                         // when using the enum fallback.
1549                         Some(metadata) if i == 0 => metadata,
1550                         _ => type_metadata(cx, ty, self.span)
1551                     }
1552                 } else {
1553                     type_metadata(cx, ty, self.span)
1554                 },
1555                 offset: self.offsets[i],
1556                 size,
1557                 align,
1558                 flags: DIFlags::FlagZero,
1559                 discriminant: None,
1560             }
1561         }).collect()
1562     }
1563 }
1564
1565 #[derive(Copy, Clone)]
1566 enum EnumDiscriminantInfo<'ll> {
1567     RegularDiscriminant{ discr_field: Field, discr_type_metadata: &'ll DIType },
1568     OptimizedDiscriminant,
1569     NoDiscriminant
1570 }
1571
1572 #[derive(Copy, Clone)]
1573 enum VariantInfo<'tcx> {
1574     Adt(&'tcx ty::VariantDef),
1575     Generator(ty::GeneratorSubsts<'tcx>, &'tcx GeneratorLayout<'tcx>, VariantIdx),
1576 }
1577
1578 impl<'tcx> VariantInfo<'tcx> {
1579     fn map_struct_name<R>(&self, f: impl FnOnce(&str) -> R) -> R {
1580         match self {
1581             VariantInfo::Adt(variant) => f(&variant.ident.as_str()),
1582             VariantInfo::Generator(substs, _, variant_index) =>
1583                 f(&substs.variant_name(*variant_index)),
1584         }
1585     }
1586
1587     fn variant_name(&self) -> String {
1588         match self {
1589             VariantInfo::Adt(variant) => variant.ident.to_string(),
1590             VariantInfo::Generator(_, _, variant_index) => {
1591                 // Since GDB currently prints out the raw discriminant along
1592                 // with every variant, make each variant name be just the value
1593                 // of the discriminant. The struct name for the variant includes
1594                 // the actual variant description.
1595                 format!("{}", variant_index.as_usize()).to_string()
1596             }
1597         }
1598     }
1599
1600     fn field_name(&self, i: usize) -> String {
1601         let field_name = match self {
1602             VariantInfo::Adt(variant) if variant.ctor_kind != CtorKind::Fn =>
1603                 Some(variant.fields[i].ident.to_string()),
1604             VariantInfo::Generator(_, generator_layout, variant_index) => {
1605                 let field = generator_layout.variant_fields[*variant_index][i.into()];
1606                 let decl = &generator_layout.__local_debuginfo_codegen_only_do_not_use[field];
1607                 decl.name.map(|name| name.to_string())
1608             }
1609             _ => None,
1610         };
1611         field_name.unwrap_or_else(|| format!("__{}", i))
1612     }
1613 }
1614
1615 // Returns a tuple of (1) type_metadata_stub of the variant, (2) a
1616 // MemberDescriptionFactory for producing the descriptions of the
1617 // fields of the variant. This is a rudimentary version of a full
1618 // RecursiveTypeDescription.
1619 fn describe_enum_variant(
1620     cx: &CodegenCx<'ll, 'tcx>,
1621     layout: layout::TyLayout<'tcx>,
1622     variant: VariantInfo<'tcx>,
1623     discriminant_info: EnumDiscriminantInfo<'ll>,
1624     containing_scope: &'ll DIScope,
1625     span: Span,
1626 ) -> (&'ll DICompositeType, MemberDescriptionFactory<'ll, 'tcx>) {
1627     let metadata_stub = variant.map_struct_name(|variant_name| {
1628         let unique_type_id = debug_context(cx).type_map
1629                                               .borrow_mut()
1630                                               .get_unique_type_id_of_enum_variant(
1631                                                   cx,
1632                                                   layout.ty,
1633                                                   &variant_name);
1634         create_struct_stub(cx,
1635                            layout.ty,
1636                            &variant_name,
1637                            unique_type_id,
1638                            Some(containing_scope))
1639     });
1640
1641     // Build an array of (field name, field type) pairs to be captured in the factory closure.
1642     let (offsets, args) = if use_enum_fallback(cx) {
1643         // If this is not a univariant enum, there is also the discriminant field.
1644         let (discr_offset, discr_arg) = match discriminant_info {
1645             RegularDiscriminant { discr_field, .. } => {
1646                 // We have the layout of an enum variant, we need the layout of the outer enum
1647                 let enum_layout = cx.layout_of(layout.ty);
1648                 let offset = enum_layout.fields.offset(discr_field.as_usize());
1649                 let args = (
1650                     "RUST$ENUM$DISR".to_owned(),
1651                     enum_layout.field(cx, discr_field.as_usize()).ty);
1652                 (Some(offset), Some(args))
1653             }
1654             _ => (None, None),
1655         };
1656         (
1657             discr_offset.into_iter().chain((0..layout.fields.count()).map(|i| {
1658                 layout.fields.offset(i)
1659             })).collect(),
1660             discr_arg.into_iter().chain((0..layout.fields.count()).map(|i| {
1661                 (variant.field_name(i), layout.field(cx, i).ty)
1662             })).collect()
1663         )
1664     } else {
1665         (
1666             (0..layout.fields.count()).map(|i| {
1667                 layout.fields.offset(i)
1668             }).collect(),
1669             (0..layout.fields.count()).map(|i| {
1670                 (variant.field_name(i), layout.field(cx, i).ty)
1671             }).collect()
1672         )
1673     };
1674
1675     let member_description_factory =
1676         VariantMDF(VariantMemberDescriptionFactory {
1677             offsets,
1678             args,
1679             discriminant_type_metadata: match discriminant_info {
1680                 RegularDiscriminant { discr_type_metadata, .. } => {
1681                     Some(discr_type_metadata)
1682                 }
1683                 _ => None
1684             },
1685             span,
1686         });
1687
1688     (metadata_stub, member_description_factory)
1689 }
1690
1691 fn prepare_enum_metadata(
1692     cx: &CodegenCx<'ll, 'tcx>,
1693     enum_type: Ty<'tcx>,
1694     enum_def_id: DefId,
1695     unique_type_id: UniqueTypeId,
1696     span: Span,
1697     outer_field_tys: Vec<Ty<'tcx>>,
1698 ) -> RecursiveTypeDescription<'ll, 'tcx> {
1699     let enum_name = compute_debuginfo_type_name(cx.tcx, enum_type, false);
1700
1701     let containing_scope = get_namespace_for_item(cx, enum_def_id);
1702     // FIXME: This should emit actual file metadata for the enum, but we
1703     // currently can't get the necessary information when it comes to types
1704     // imported from other crates. Formerly we violated the ODR when performing
1705     // LTO because we emitted debuginfo for the same type with varying file
1706     // metadata, so as a workaround we pretend that the type comes from
1707     // <unknown>
1708     let file_metadata = unknown_file_metadata(cx);
1709
1710     let discriminant_type_metadata = |discr: layout::Primitive| {
1711         let enumerators_metadata: Vec<_> = match enum_type.sty {
1712             ty::Adt(def, _) => def
1713                 .discriminants(cx.tcx)
1714                 .zip(&def.variants)
1715                 .map(|((_, discr), v)| {
1716                     let name = SmallCStr::new(&v.ident.as_str());
1717                     unsafe {
1718                         Some(llvm::LLVMRustDIBuilderCreateEnumerator(
1719                             DIB(cx),
1720                             name.as_ptr(),
1721                             // FIXME: what if enumeration has i128 discriminant?
1722                             discr.val as u64))
1723                     }
1724                 })
1725                 .collect(),
1726             ty::Generator(_, substs, _) => substs
1727                 .variant_range(enum_def_id, cx.tcx)
1728                 .map(|variant_index| {
1729                     let name = SmallCStr::new(&substs.variant_name(variant_index));
1730                     unsafe {
1731                         Some(llvm::LLVMRustDIBuilderCreateEnumerator(
1732                             DIB(cx),
1733                             name.as_ptr(),
1734                             // FIXME: what if enumeration has i128 discriminant?
1735                             variant_index.as_usize() as u64))
1736                     }
1737                 })
1738                 .collect(),
1739             _ => bug!(),
1740         };
1741
1742         let disr_type_key = (enum_def_id, discr);
1743         let cached_discriminant_type_metadata = debug_context(cx).created_enum_disr_types
1744                                                                  .borrow()
1745                                                                  .get(&disr_type_key).cloned();
1746         match cached_discriminant_type_metadata {
1747             Some(discriminant_type_metadata) => discriminant_type_metadata,
1748             None => {
1749                 let (discriminant_size, discriminant_align) =
1750                     (discr.size(cx), discr.align(cx));
1751                 let discriminant_base_type_metadata =
1752                     type_metadata(cx, discr.to_ty(cx.tcx), syntax_pos::DUMMY_SP);
1753
1754                 let discriminant_name = match enum_type.sty {
1755                     ty::Adt(..) => SmallCStr::new(&cx.tcx.item_name(enum_def_id).as_str()),
1756                     ty::Generator(..) => SmallCStr::new(&enum_name),
1757                     _ => bug!(),
1758                 };
1759
1760                 let discriminant_type_metadata = unsafe {
1761                     llvm::LLVMRustDIBuilderCreateEnumerationType(
1762                         DIB(cx),
1763                         containing_scope,
1764                         discriminant_name.as_ptr(),
1765                         file_metadata,
1766                         UNKNOWN_LINE_NUMBER,
1767                         discriminant_size.bits(),
1768                         discriminant_align.abi.bits() as u32,
1769                         create_DIArray(DIB(cx), &enumerators_metadata),
1770                         discriminant_base_type_metadata, true)
1771                 };
1772
1773                 debug_context(cx).created_enum_disr_types
1774                                  .borrow_mut()
1775                                  .insert(disr_type_key, discriminant_type_metadata);
1776
1777                 discriminant_type_metadata
1778             }
1779         }
1780     };
1781
1782     let layout = cx.layout_of(enum_type);
1783
1784     match (&layout.abi, &layout.variants) {
1785         (&layout::Abi::Scalar(_), &layout::Variants::Multiple {
1786             discr_kind: layout::DiscriminantKind::Tag,
1787             ref discr,
1788             ..
1789         }) => return FinalMetadata(discriminant_type_metadata(discr.value)),
1790         _ => {}
1791     }
1792
1793     let enum_name = SmallCStr::new(&enum_name);
1794     let unique_type_id_str = SmallCStr::new(
1795         debug_context(cx).type_map.borrow().get_unique_type_id_as_string(unique_type_id)
1796     );
1797
1798     if use_enum_fallback(cx) {
1799         let discriminant_type_metadata = match layout.variants {
1800             layout::Variants::Single { .. } |
1801             layout::Variants::Multiple {
1802                 discr_kind: layout::DiscriminantKind::Niche { .. },
1803                 ..
1804             } => None,
1805             layout::Variants::Multiple {
1806                 discr_kind: layout::DiscriminantKind::Tag,
1807                 ref discr,
1808                 ..
1809             } => {
1810                 Some(discriminant_type_metadata(discr.value))
1811             }
1812         };
1813
1814         let enum_metadata = unsafe {
1815             llvm::LLVMRustDIBuilderCreateUnionType(
1816                 DIB(cx),
1817                 containing_scope,
1818                 enum_name.as_ptr(),
1819                 file_metadata,
1820                 UNKNOWN_LINE_NUMBER,
1821                 layout.size.bits(),
1822                 layout.align.abi.bits() as u32,
1823                 DIFlags::FlagZero,
1824                 None,
1825                 0, // RuntimeLang
1826                 unique_type_id_str.as_ptr())
1827         };
1828
1829         return create_and_register_recursive_type_forward_declaration(
1830             cx,
1831             enum_type,
1832             unique_type_id,
1833             enum_metadata,
1834             enum_metadata,
1835             EnumMDF(EnumMemberDescriptionFactory {
1836                 enum_type,
1837                 layout,
1838                 discriminant_type_metadata,
1839                 containing_scope,
1840                 span,
1841             }),
1842         );
1843     }
1844
1845     let discriminator_name = match &enum_type.sty {
1846         ty::Generator(..) => Some(SmallCStr::new(&"__state")),
1847         _ => None,
1848     };
1849     let discriminator_name = discriminator_name.map(|n| n.as_ptr()).unwrap_or(ptr::null_mut());
1850     let discriminator_metadata = match layout.variants {
1851         // A single-variant enum has no discriminant.
1852         layout::Variants::Single { .. } => None,
1853
1854         layout::Variants::Multiple {
1855             discr_kind: layout::DiscriminantKind::Niche { .. },
1856             ref discr,
1857             discr_index,
1858             ..
1859         } => {
1860             // Find the integer type of the correct size.
1861             let size = discr.value.size(cx);
1862             let align = discr.value.align(cx);
1863
1864             let discr_type = match discr.value {
1865                 layout::Int(t, _) => t,
1866                 layout::Float(layout::FloatTy::F32) => Integer::I32,
1867                 layout::Float(layout::FloatTy::F64) => Integer::I64,
1868                 layout::Pointer => cx.data_layout().ptr_sized_integer(),
1869             }.to_ty(cx.tcx, false);
1870
1871             let discr_metadata = basic_type_metadata(cx, discr_type);
1872             unsafe {
1873                 Some(llvm::LLVMRustDIBuilderCreateMemberType(
1874                     DIB(cx),
1875                     containing_scope,
1876                     discriminator_name,
1877                     file_metadata,
1878                     UNKNOWN_LINE_NUMBER,
1879                     size.bits(),
1880                     align.abi.bits() as u32,
1881                     layout.fields.offset(discr_index).bits(),
1882                     DIFlags::FlagArtificial,
1883                     discr_metadata))
1884             }
1885         },
1886
1887         layout::Variants::Multiple {
1888             discr_kind: layout::DiscriminantKind::Tag,
1889             ref discr,
1890             discr_index,
1891             ..
1892         } => {
1893             let discr_type = discr.value.to_ty(cx.tcx);
1894             let (size, align) = cx.size_and_align_of(discr_type);
1895
1896             let discr_metadata = basic_type_metadata(cx, discr_type);
1897             unsafe {
1898                 Some(llvm::LLVMRustDIBuilderCreateMemberType(
1899                     DIB(cx),
1900                     containing_scope,
1901                     discriminator_name,
1902                     file_metadata,
1903                     UNKNOWN_LINE_NUMBER,
1904                     size.bits(),
1905                     align.bits() as u32,
1906                     layout.fields.offset(discr_index).bits(),
1907                     DIFlags::FlagArtificial,
1908                     discr_metadata))
1909             }
1910         },
1911     };
1912
1913     let mut outer_fields = match layout.variants {
1914         layout::Variants::Single { .. } => vec![],
1915         layout::Variants::Multiple { .. } => {
1916             let tuple_mdf = TupleMemberDescriptionFactory {
1917                 ty: enum_type,
1918                 component_types: outer_field_tys,
1919                 span
1920             };
1921             tuple_mdf
1922                 .create_member_descriptions(cx)
1923                 .into_iter()
1924                 .map(|desc| Some(desc.into_metadata(cx, containing_scope)))
1925                 .collect()
1926         }
1927     };
1928
1929     let variant_part_unique_type_id_str = SmallCStr::new(
1930         debug_context(cx).type_map
1931             .borrow_mut()
1932             .get_unique_type_id_str_of_enum_variant_part(unique_type_id)
1933     );
1934     let empty_array = create_DIArray(DIB(cx), &[]);
1935     let variant_part = unsafe {
1936         llvm::LLVMRustDIBuilderCreateVariantPart(
1937             DIB(cx),
1938             containing_scope,
1939             ptr::null_mut(),
1940             file_metadata,
1941             UNKNOWN_LINE_NUMBER,
1942             layout.size.bits(),
1943             layout.align.abi.bits() as u32,
1944             DIFlags::FlagZero,
1945             discriminator_metadata,
1946             empty_array,
1947             variant_part_unique_type_id_str.as_ptr())
1948     };
1949     outer_fields.push(Some(variant_part));
1950
1951     // The variant part must be wrapped in a struct according to DWARF.
1952     let type_array = create_DIArray(DIB(cx), &outer_fields);
1953     let struct_wrapper = unsafe {
1954         llvm::LLVMRustDIBuilderCreateStructType(
1955             DIB(cx),
1956             Some(containing_scope),
1957             enum_name.as_ptr(),
1958             file_metadata,
1959             UNKNOWN_LINE_NUMBER,
1960             layout.size.bits(),
1961             layout.align.abi.bits() as u32,
1962             DIFlags::FlagZero,
1963             None,
1964             type_array,
1965             0,
1966             None,
1967             unique_type_id_str.as_ptr())
1968     };
1969
1970     return create_and_register_recursive_type_forward_declaration(
1971         cx,
1972         enum_type,
1973         unique_type_id,
1974         struct_wrapper,
1975         variant_part,
1976         EnumMDF(EnumMemberDescriptionFactory {
1977             enum_type,
1978             layout,
1979             discriminant_type_metadata: None,
1980             containing_scope,
1981             span,
1982         }),
1983     );
1984 }
1985
1986 /// Creates debug information for a composite type, that is, anything that
1987 /// results in a LLVM struct.
1988 ///
1989 /// Examples of Rust types to use this are: structs, tuples, boxes, vecs, and enums.
1990 fn composite_type_metadata(
1991     cx: &CodegenCx<'ll, 'tcx>,
1992     composite_type: Ty<'tcx>,
1993     composite_type_name: &str,
1994     composite_type_unique_id: UniqueTypeId,
1995     member_descriptions: Vec<MemberDescription<'ll>>,
1996     containing_scope: Option<&'ll DIScope>,
1997
1998     // Ignore source location information as long as it
1999     // can't be reconstructed for non-local crates.
2000     _file_metadata: &'ll DIFile,
2001     _definition_span: Span,
2002 ) -> &'ll DICompositeType {
2003     // Create the (empty) struct metadata node ...
2004     let composite_type_metadata = create_struct_stub(cx,
2005                                                      composite_type,
2006                                                      composite_type_name,
2007                                                      composite_type_unique_id,
2008                                                      containing_scope);
2009     // ... and immediately create and add the member descriptions.
2010     set_members_of_composite_type(cx,
2011                                   composite_type,
2012                                   composite_type_metadata,
2013                                   member_descriptions);
2014
2015     composite_type_metadata
2016 }
2017
2018 fn set_members_of_composite_type(cx: &CodegenCx<'ll, 'tcx>,
2019                                  composite_type: Ty<'tcx>,
2020                                  composite_type_metadata: &'ll DICompositeType,
2021                                  member_descriptions: Vec<MemberDescription<'ll>>) {
2022     // In some rare cases LLVM metadata uniquing would lead to an existing type
2023     // description being used instead of a new one created in
2024     // create_struct_stub. This would cause a hard to trace assertion in
2025     // DICompositeType::SetTypeArray(). The following check makes sure that we
2026     // get a better error message if this should happen again due to some
2027     // regression.
2028     {
2029         let mut composite_types_completed =
2030             debug_context(cx).composite_types_completed.borrow_mut();
2031         if composite_types_completed.contains(&composite_type_metadata) {
2032             bug!("debuginfo::set_members_of_composite_type() - \
2033                   Already completed forward declaration re-encountered.");
2034         } else {
2035             composite_types_completed.insert(composite_type_metadata);
2036         }
2037     }
2038
2039     let member_metadata: Vec<_> = member_descriptions
2040         .into_iter()
2041         .map(|desc| Some(desc.into_metadata(cx, composite_type_metadata)))
2042         .collect();
2043
2044     let type_params = compute_type_parameters(cx, composite_type);
2045     unsafe {
2046         let type_array = create_DIArray(DIB(cx), &member_metadata[..]);
2047         llvm::LLVMRustDICompositeTypeReplaceArrays(
2048             DIB(cx), composite_type_metadata, Some(type_array), type_params);
2049     }
2050 }
2051
2052 // Compute the type parameters for a type, if any, for the given
2053 // metadata.
2054 fn compute_type_parameters(cx: &CodegenCx<'ll, 'tcx>, ty: Ty<'tcx>) -> Option<&'ll DIArray> {
2055     if let ty::Adt(def, substs) = ty.sty {
2056         if !substs.types().next().is_none() {
2057             let generics = cx.tcx.generics_of(def.did);
2058             let names = get_parameter_names(cx, generics);
2059             let template_params: Vec<_> = substs.iter().zip(names).filter_map(|(kind, name)| {
2060                 if let UnpackedKind::Type(ty) = kind.unpack() {
2061                     let actual_type = cx.tcx.normalize_erasing_regions(ParamEnv::reveal_all(), ty);
2062                     let actual_type_metadata =
2063                         type_metadata(cx, actual_type, syntax_pos::DUMMY_SP);
2064                     let name = SmallCStr::new(&name.as_str());
2065                     Some(unsafe {
2066
2067                         Some(llvm::LLVMRustDIBuilderCreateTemplateTypeParameter(
2068                             DIB(cx),
2069                             None,
2070                             name.as_ptr(),
2071                             actual_type_metadata,
2072                             unknown_file_metadata(cx),
2073                             0,
2074                             0,
2075                         ))
2076                     })
2077                 } else {
2078                     None
2079                 }
2080             }).collect();
2081
2082             return Some(create_DIArray(DIB(cx), &template_params[..]));
2083         }
2084     }
2085     return Some(create_DIArray(DIB(cx), &[]));
2086
2087     fn get_parameter_names(cx: &CodegenCx<'_, '_>,
2088                            generics: &ty::Generics)
2089                            -> Vec<InternedString> {
2090         let mut names = generics.parent.map_or(vec![], |def_id| {
2091             get_parameter_names(cx, cx.tcx.generics_of(def_id))
2092         });
2093         names.extend(generics.params.iter().map(|param| param.name));
2094         names
2095     }
2096 }
2097
2098 // A convenience wrapper around LLVMRustDIBuilderCreateStructType(). Does not do
2099 // any caching, does not add any fields to the struct. This can be done later
2100 // with set_members_of_composite_type().
2101 fn create_struct_stub(
2102     cx: &CodegenCx<'ll, 'tcx>,
2103     struct_type: Ty<'tcx>,
2104     struct_type_name: &str,
2105     unique_type_id: UniqueTypeId,
2106     containing_scope: Option<&'ll DIScope>,
2107 ) -> &'ll DICompositeType {
2108     let (struct_size, struct_align) = cx.size_and_align_of(struct_type);
2109
2110     let name = SmallCStr::new(struct_type_name);
2111     let unique_type_id = SmallCStr::new(
2112         debug_context(cx).type_map.borrow().get_unique_type_id_as_string(unique_type_id)
2113     );
2114     let metadata_stub = unsafe {
2115         // LLVMRustDIBuilderCreateStructType() wants an empty array. A null
2116         // pointer will lead to hard to trace and debug LLVM assertions
2117         // later on in llvm/lib/IR/Value.cpp.
2118         let empty_array = create_DIArray(DIB(cx), &[]);
2119
2120         llvm::LLVMRustDIBuilderCreateStructType(
2121             DIB(cx),
2122             containing_scope,
2123             name.as_ptr(),
2124             unknown_file_metadata(cx),
2125             UNKNOWN_LINE_NUMBER,
2126             struct_size.bits(),
2127             struct_align.bits() as u32,
2128             DIFlags::FlagZero,
2129             None,
2130             empty_array,
2131             0,
2132             None,
2133             unique_type_id.as_ptr())
2134     };
2135
2136     metadata_stub
2137 }
2138
2139 fn create_union_stub(
2140     cx: &CodegenCx<'ll, 'tcx>,
2141     union_type: Ty<'tcx>,
2142     union_type_name: &str,
2143     unique_type_id: UniqueTypeId,
2144     containing_scope: &'ll DIScope,
2145 ) -> &'ll DICompositeType {
2146     let (union_size, union_align) = cx.size_and_align_of(union_type);
2147
2148     let name = SmallCStr::new(union_type_name);
2149     let unique_type_id = SmallCStr::new(
2150         debug_context(cx).type_map.borrow().get_unique_type_id_as_string(unique_type_id)
2151     );
2152     let metadata_stub = unsafe {
2153         // LLVMRustDIBuilderCreateUnionType() wants an empty array. A null
2154         // pointer will lead to hard to trace and debug LLVM assertions
2155         // later on in llvm/lib/IR/Value.cpp.
2156         let empty_array = create_DIArray(DIB(cx), &[]);
2157
2158         llvm::LLVMRustDIBuilderCreateUnionType(
2159             DIB(cx),
2160             containing_scope,
2161             name.as_ptr(),
2162             unknown_file_metadata(cx),
2163             UNKNOWN_LINE_NUMBER,
2164             union_size.bits(),
2165             union_align.bits() as u32,
2166             DIFlags::FlagZero,
2167             Some(empty_array),
2168             0, // RuntimeLang
2169             unique_type_id.as_ptr())
2170     };
2171
2172     metadata_stub
2173 }
2174
2175 /// Creates debug information for the given global variable.
2176 ///
2177 /// Adds the created metadata nodes directly to the crate's IR.
2178 pub fn create_global_var_metadata(
2179     cx: &CodegenCx<'ll, '_>,
2180     def_id: DefId,
2181     global: &'ll Value,
2182 ) {
2183     if cx.dbg_cx.is_none() {
2184         return;
2185     }
2186
2187     let tcx = cx.tcx;
2188     let attrs = tcx.codegen_fn_attrs(def_id);
2189
2190     if attrs.flags.contains(CodegenFnAttrFlags::NO_DEBUG) {
2191         return;
2192     }
2193
2194     let no_mangle = attrs.flags.contains(CodegenFnAttrFlags::NO_MANGLE);
2195     // We may want to remove the namespace scope if we're in an extern block, see:
2196     // https://github.com/rust-lang/rust/pull/46457#issuecomment-351750952
2197     let var_scope = get_namespace_for_item(cx, def_id);
2198     let span = tcx.def_span(def_id);
2199
2200     let (file_metadata, line_number) = if !span.is_dummy() {
2201         let loc = span_start(cx, span);
2202         (file_metadata(cx, &loc.file.name, LOCAL_CRATE), loc.line as c_uint)
2203     } else {
2204         (unknown_file_metadata(cx), UNKNOWN_LINE_NUMBER)
2205     };
2206
2207     let is_local_to_unit = is_node_local_to_unit(cx, def_id);
2208     let variable_type = Instance::mono(cx.tcx, def_id).ty(cx.tcx);
2209     let type_metadata = type_metadata(cx, variable_type, span);
2210     let var_name = SmallCStr::new(&tcx.item_name(def_id).as_str());
2211     let linkage_name = if no_mangle {
2212         None
2213     } else {
2214         let linkage_name = mangled_name_of_instance(cx, Instance::mono(tcx, def_id));
2215         Some(SmallCStr::new(&linkage_name.as_str()))
2216     };
2217
2218     let global_align = cx.align_of(variable_type);
2219
2220     unsafe {
2221         llvm::LLVMRustDIBuilderCreateStaticVariable(DIB(cx),
2222                                                     Some(var_scope),
2223                                                     var_name.as_ptr(),
2224                                                     // If null, linkage_name field is omitted,
2225                                                     // which is what we want for no_mangle statics
2226                                                     linkage_name.as_ref()
2227                                                      .map_or(ptr::null(), |name| name.as_ptr()),
2228                                                     file_metadata,
2229                                                     line_number,
2230                                                     type_metadata,
2231                                                     is_local_to_unit,
2232                                                     global,
2233                                                     None,
2234                                                     global_align.bytes() as u32,
2235         );
2236     }
2237 }
2238
2239 /// Creates debug information for the given vtable, which is for the
2240 /// given type.
2241 ///
2242 /// Adds the created metadata nodes directly to the crate's IR.
2243 pub fn create_vtable_metadata(
2244     cx: &CodegenCx<'ll, 'tcx>,
2245     ty: ty::Ty<'tcx>,
2246     vtable: &'ll Value,
2247 ) {
2248     if cx.dbg_cx.is_none() {
2249         return;
2250     }
2251
2252     let type_metadata = type_metadata(cx, ty, syntax_pos::DUMMY_SP);
2253
2254     unsafe {
2255         // LLVMRustDIBuilderCreateStructType() wants an empty array. A null
2256         // pointer will lead to hard to trace and debug LLVM assertions
2257         // later on in llvm/lib/IR/Value.cpp.
2258         let empty_array = create_DIArray(DIB(cx), &[]);
2259
2260         let name = const_cstr!("vtable");
2261
2262         // Create a new one each time.  We don't want metadata caching
2263         // here, because each vtable will refer to a unique containing
2264         // type.
2265         let vtable_type = llvm::LLVMRustDIBuilderCreateStructType(
2266             DIB(cx),
2267             NO_SCOPE_METADATA,
2268             name.as_ptr(),
2269             unknown_file_metadata(cx),
2270             UNKNOWN_LINE_NUMBER,
2271             Size::ZERO.bits(),
2272             cx.tcx.data_layout.pointer_align.abi.bits() as u32,
2273             DIFlags::FlagArtificial,
2274             None,
2275             empty_array,
2276             0,
2277             Some(type_metadata),
2278             name.as_ptr()
2279         );
2280
2281         llvm::LLVMRustDIBuilderCreateStaticVariable(DIB(cx),
2282                                                     NO_SCOPE_METADATA,
2283                                                     name.as_ptr(),
2284                                                     ptr::null(),
2285                                                     unknown_file_metadata(cx),
2286                                                     UNKNOWN_LINE_NUMBER,
2287                                                     vtable_type,
2288                                                     true,
2289                                                     vtable,
2290                                                     None,
2291                                                     0);
2292     }
2293 }
2294
2295 // Creates an "extension" of an existing DIScope into another file.
2296 pub fn extend_scope_to_file(
2297     cx: &CodegenCx<'ll, '_>,
2298     scope_metadata: &'ll DIScope,
2299     file: &syntax_pos::SourceFile,
2300     defining_crate: CrateNum,
2301 ) -> &'ll DILexicalBlock {
2302     let file_metadata = file_metadata(cx, &file.name, defining_crate);
2303     unsafe {
2304         llvm::LLVMRustDIBuilderCreateLexicalBlockFile(
2305             DIB(cx),
2306             scope_metadata,
2307             file_metadata)
2308     }
2309 }