lib/CodeGen/AsmPrinter/DwarfDebug.cpp

   1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing dwarf debug info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15 #include "DwarfDebug.h"
  16 #include "DIE.h"
  17 #include "DIEHash.h"
  18 #include "DwarfAccelTable.h"
  19 #include "DwarfCompileUnit.h"
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/ADT/Statistic.h"
  22 #include "llvm/ADT/StringExtras.h"
  23 #include "llvm/ADT/Triple.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/DIBuilder.h"
  27 #include "llvm/DebugInfo.h"
  28 #include "llvm/IR/Constants.h"
  29 #include "llvm/IR/DataLayout.h"
  30 #include "llvm/IR/Instructions.h"
  31 #include "llvm/IR/Module.h"
  32 #include "llvm/MC/MCAsmInfo.h"
  33 #include "llvm/MC/MCSection.h"
  34 #include "llvm/MC/MCStreamer.h"
  35 #include "llvm/MC/MCSymbol.h"
  36 #include "llvm/Support/CommandLine.h"
  37 #include "llvm/Support/Debug.h"
  38 #include "llvm/Support/Dwarf.h"
  39 #include "llvm/Support/ErrorHandling.h"
  40 #include "llvm/Support/FormattedStream.h"
  41 #include "llvm/Support/MD5.h"
  42 #include "llvm/Support/Path.h"
  43 #include "llvm/Support/Timer.h"
  44 #include "llvm/Support/ValueHandle.h"
  45 #include "llvm/Target/TargetFrameLowering.h"
  46 #include "llvm/Target/TargetLoweringObjectFile.h"
  47 #include "llvm/Target/TargetMachine.h"
  48 #include "llvm/Target/TargetOptions.h"
  49 #include "llvm/Target/TargetRegisterInfo.h"
  50 using namespace llvm;
  51
  52 static cl::opt<bool>
  53 DisableDebugInfoPrinting("disable-debug-info-print", cl::Hidden,
  54                          cl::desc("Disable debug info printing"));
  55
  56 static cl::opt<bool> UnknownLocations(
  57     "use-unknown-locations", cl::Hidden,
  58     cl::desc("Make an absence of debug location information explicit."),
  59     cl::init(false));
  60
  61 static cl::opt<bool>
  62 GenerateODRHash("generate-odr-hash", cl::Hidden,
  63                 cl::desc("Add an ODR hash to external type DIEs."),
  64                 cl::init(false));
  65
  66 static cl::opt<bool>
  67 GenerateCUHash("generate-cu-hash", cl::Hidden,
  68                cl::desc("Add the CU hash as the dwo_id."),
  69                cl::init(false));
  70
  71 static cl::opt<bool>
  72 GenerateGnuPubSections("generate-gnu-dwarf-pub-sections", cl::Hidden,
  73                        cl::desc("Generate GNU-style pubnames and pubtypes"),
  74                        cl::init(false));
  75
  76 namespace {
  77 enum DefaultOnOff {
  78   Default,
  79   Enable,
  80   Disable
  81 };
  82 }
  83
  84 static cl::opt<DefaultOnOff>
  85 DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
  86                  cl::desc("Output prototype dwarf accelerator tables."),
  87                  cl::values(clEnumVal(Default, "Default for platform"),
  88                             clEnumVal(Enable, "Enabled"),
  89                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
  90                  cl::init(Default));
  91
  92 static cl::opt<DefaultOnOff>
  93 SplitDwarf("split-dwarf", cl::Hidden,
  94            cl::desc("Output prototype dwarf split debug info."),
  95            cl::values(clEnumVal(Default, "Default for platform"),
  96                       clEnumVal(Enable, "Enabled"),
  97                       clEnumVal(Disable, "Disabled"), clEnumValEnd),
  98            cl::init(Default));
  99
 100 static cl::opt<DefaultOnOff>
 101 DwarfPubSections("generate-dwarf-pub-sections", cl::Hidden,
 102                  cl::desc("Generate DWARF pubnames and pubtypes sections"),
 103                  cl::values(clEnumVal(Default, "Default for platform"),
 104                             clEnumVal(Enable, "Enabled"),
 105                             clEnumVal(Disable, "Disabled"), clEnumValEnd),
 106                  cl::init(Default));
 107
 108 static const char *const DWARFGroupName = "DWARF Emission";
 109 static const char *const DbgTimerName = "DWARF Debug Writer";
 110
 111 //===----------------------------------------------------------------------===//
 112
 113 // Configuration values for initial hash set sizes (log2).
 114 //
 115 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
 116
 117 namespace llvm {
 118
 119 DIType DbgVariable::getType() const {
 120   DIType Ty = Var.getType();
 121   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
 122   // addresses instead.
 123   if (Var.isBlockByrefVariable()) {
 124     /* Byref variables, in Blocks, are declared by the programmer as
 125        "SomeType VarName;", but the compiler creates a
 126        __Block_byref_x_VarName struct, and gives the variable VarName
 127        either the struct, or a pointer to the struct, as its type.  This
 128        is necessary for various behind-the-scenes things the compiler
 129        needs to do with by-reference variables in blocks.
 130
 131        However, as far as the original *programmer* is concerned, the
 132        variable should still have type 'SomeType', as originally declared.
 133
 134        The following function dives into the __Block_byref_x_VarName
 135        struct to find the original type of the variable.  This will be
 136        passed back to the code generating the type for the Debug
 137        Information Entry for the variable 'VarName'.  'VarName' will then
 138        have the original type 'SomeType' in its debug information.
 139
 140        The original type 'SomeType' will be the type of the field named
 141        'VarName' inside the __Block_byref_x_VarName struct.
 142
 143        NOTE: In order for this to not completely fail on the debugger
 144        side, the Debug Information Entry for the variable VarName needs to
 145        have a DW_AT_location that tells the debugger how to unwind through
 146        the pointers and __Block_byref_x_VarName struct to find the actual
 147        value of the variable.  The function addBlockByrefType does this.  */
 148     DIType subType = Ty;
 149     uint16_t tag = Ty.getTag();
 150
 151     if (tag == dwarf::DW_TAG_pointer_type)
 152       subType = DIDerivedType(Ty).getTypeDerivedFrom();
 153
 154     DIArray Elements = DICompositeType(subType).getTypeArray();
 155     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 156       DIDerivedType DT = DIDerivedType(Elements.getElement(i));
 157       if (getName() == DT.getName())
 158         return (DT.getTypeDerivedFrom());
 159     }
 160   }
 161   return Ty;
 162 }
 163
 164 } // end llvm namespace
 165
 166 /// Return Dwarf Version by checking module flags.
 167 static unsigned getDwarfVersionFromModule(const Module *M) {
 168   Value *Val = M->getModuleFlag("Dwarf Version");
 169   if (!Val)
 170     return dwarf::DWARF_VERSION;
 171   return cast<ConstantInt>(Val)->getZExtValue();
 172 }
 173
 174 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 175   : Asm(A), MMI(Asm->MMI), FirstCU(0),
 176     AbbreviationsSet(InitAbbreviationsSetSize),
 177     SourceIdMap(DIEValueAllocator),
 178     PrevLabel(NULL), GlobalCUIndexCount(0),
 179     InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
 180                DIEValueAllocator),
 181     SkeletonAbbrevSet(InitAbbreviationsSetSize),
 182     SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
 183                    DIEValueAllocator) {
 184
 185   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 186   DwarfStrSectionSym = TextSectionSym = 0;
 187   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
 188   DwarfAddrSectionSym = 0;
 189   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
 190   FunctionBeginSym = FunctionEndSym = 0;
 191
 192   // Turn on accelerator tables and older gdb compatibility
 193   // for Darwin by default, pubnames by default for non-Darwin,
 194   // and handle split dwarf.
 195   bool IsDarwin = Triple(A->getTargetTriple()).isOSDarwin();
 196
 197   if (DwarfAccelTables == Default)
 198     HasDwarfAccelTables = IsDarwin;
 199   else
 200     HasDwarfAccelTables = DwarfAccelTables == Enable;
 201
 202   if (SplitDwarf == Default)
 203     HasSplitDwarf = false;
 204   else
 205     HasSplitDwarf = SplitDwarf == Enable;
 206
 207   if (DwarfPubSections == Default)
 208     HasDwarfPubSections = !IsDarwin;
 209   else
 210     HasDwarfPubSections = DwarfPubSections == Enable;
 211
 212   DwarfVersion = getDwarfVersionFromModule(MMI->getModule());
 213
 214   {
 215     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
 216     beginModule();
 217   }
 218 }
 219 DwarfDebug::~DwarfDebug() {
 220 }
 221
 222 // Switch to the specified MCSection and emit an assembler
 223 // temporary label to it if SymbolStem is specified.
 224 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
 225                                 const char *SymbolStem = 0) {
 226   Asm->OutStreamer.SwitchSection(Section);
 227   if (!SymbolStem) return 0;
 228
 229   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
 230   Asm->OutStreamer.EmitLabel(TmpSym);
 231   return TmpSym;
 232 }
 233
 234 MCSymbol *DwarfUnits::getStringPoolSym() {
 235   return Asm->GetTempSymbol(StringPref);
 236 }
 237
 238 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
 239   std::pair<MCSymbol*, unsigned> &Entry =
 240     StringPool.GetOrCreateValue(Str).getValue();
 241   if (Entry.first) return Entry.first;
 242
 243   Entry.second = NextStringPoolNumber++;
 244   return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
 245 }
 246
 247 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
 248   std::pair<MCSymbol*, unsigned> &Entry =
 249     StringPool.GetOrCreateValue(Str).getValue();
 250   if (Entry.first) return Entry.second;
 251
 252   Entry.second = NextStringPoolNumber++;
 253   Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
 254   return Entry.second;
 255 }
 256
 257 unsigned DwarfUnits::getAddrPoolIndex(const MCSymbol *Sym) {
 258   return getAddrPoolIndex(MCSymbolRefExpr::Create(Sym, Asm->OutContext));
 259 }
 260
 261 unsigned DwarfUnits::getAddrPoolIndex(const MCExpr *Sym) {
 262   std::pair<DenseMap<const MCExpr *, unsigned>::iterator, bool> P =
 263       AddressPool.insert(std::make_pair(Sym, NextAddrPoolNumber));
 264   if (P.second)
 265     ++NextAddrPoolNumber;
 266   return P.first->second;
 267 }
 268
 269 // Define a unique number for the abbreviation.
 270 //
 271 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 272   // Check the set for priors.
 273   DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
 274
 275   // If it's newly added.
 276   if (InSet == &Abbrev) {
 277     // Add to abbreviation list.
 278     Abbreviations->push_back(&Abbrev);
 279
 280     // Assign the vector position + 1 as its number.
 281     Abbrev.setNumber(Abbreviations->size());
 282   } else {
 283     // Assign existing abbreviation number.
 284     Abbrev.setNumber(InSet->getNumber());
 285   }
 286 }
 287
 288 static bool isObjCClass(StringRef Name) {
 289   return Name.startswith("+") || Name.startswith("-");
 290 }
 291
 292 static bool hasObjCCategory(StringRef Name) {
 293   if (!isObjCClass(Name)) return false;
 294
 295   return Name.find(") ") != StringRef::npos;
 296 }
 297
 298 static void getObjCClassCategory(StringRef In, StringRef &Class,
 299                                  StringRef &Category) {
 300   if (!hasObjCCategory(In)) {
 301     Class = In.slice(In.find('[') + 1, In.find(' '));
 302     Category = "";
 303     return;
 304   }
 305
 306   Class = In.slice(In.find('[') + 1, In.find('('));
 307   Category = In.slice(In.find('[') + 1, In.find(' '));
 308   return;
 309 }
 310
 311 static StringRef getObjCMethodName(StringRef In) {
 312   return In.slice(In.find(' ') + 1, In.find(']'));
 313 }
 314
 315 // Add the various names to the Dwarf accelerator table names.
 316 // TODO: Determine whether or not we should add names for programs
 317 // that do not have a DW_AT_name or DW_AT_linkage_name field - this
 318 // is only slightly different than the lookup of non-standard ObjC names.
 319 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
 320                                DIE* Die) {
 321   if (!SP.isDefinition()) return;
 322   TheCU->addAccelName(SP.getName(), Die);
 323
 324   // If the linkage name is different than the name, go ahead and output
 325   // that as well into the name table.
 326   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
 327     TheCU->addAccelName(SP.getLinkageName(), Die);
 328
 329   // If this is an Objective-C selector name add it to the ObjC accelerator
 330   // too.
 331   if (isObjCClass(SP.getName())) {
 332     StringRef Class, Category;
 333     getObjCClassCategory(SP.getName(), Class, Category);
 334     TheCU->addAccelObjC(Class, Die);
 335     if (Category != "")
 336       TheCU->addAccelObjC(Category, Die);
 337     // Also add the base method name to the name table.
 338     TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
 339   }
 340 }
 341
 342 /// isSubprogramContext - Return true if Context is either a subprogram
 343 /// or another context nested inside a subprogram.
 344 bool DwarfDebug::isSubprogramContext(const MDNode *Context) {
 345   if (!Context)
 346     return false;
 347   DIDescriptor D(Context);
 348   if (D.isSubprogram())
 349     return true;
 350   if (D.isType())
 351     return isSubprogramContext(resolve(DIType(Context).getContext()));
 352   return false;
 353 }
 354
 355 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 356 // and DW_AT_high_pc attributes. If there are global variables in this
 357 // scope then create and insert DIEs for these variables.
 358 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
 359                                           const MDNode *SPNode) {
 360   DIE *SPDie = SPCU->getDIE(SPNode);
 361
 362   assert(SPDie && "Unable to find subprogram DIE!");
 363   DISubprogram SP(SPNode);
 364
 365   // If we're updating an abstract DIE, then we will be adding the children and
 366   // object pointer later on. But what we don't want to do is process the
 367   // concrete DIE twice.
 368   DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
 369   if (AbsSPDIE) {
 370     bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
 371     // Pick up abstract subprogram DIE.
 372     SPDie = new DIE(dwarf::DW_TAG_subprogram);
 373     // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
 374     // DW_FORM_ref4.
 375     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
 376                       InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 377                       AbsSPDIE);
 378     SPCU->addDie(SPDie);
 379   } else {
 380     DISubprogram SPDecl = SP.getFunctionDeclaration();
 381     if (!SPDecl.isSubprogram()) {
 382       // There is not any need to generate specification DIE for a function
 383       // defined at compile unit level. If a function is defined inside another
 384       // function then gdb prefers the definition at top level and but does not
 385       // expect specification DIE in parent function. So avoid creating
 386       // specification DIE for a function defined inside a function.
 387       if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
 388           !SP.getContext().isFile() &&
 389           !isSubprogramContext(SP.getContext())) {
 390         SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
 391
 392         // Add arguments.
 393         DICompositeType SPTy = SP.getType();
 394         DIArray Args = SPTy.getTypeArray();
 395         uint16_t SPTag = SPTy.getTag();
 396         if (SPTag == dwarf::DW_TAG_subroutine_type)
 397           for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
 398             DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 399             DIType ATy = DIType(Args.getElement(i));
 400             SPCU->addType(Arg, ATy);
 401             if (ATy.isArtificial())
 402               SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
 403             if (ATy.isObjectPointer())
 404               SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
 405                                 dwarf::DW_FORM_ref4, Arg);
 406             SPDie->addChild(Arg);
 407           }
 408         DIE *SPDeclDie = SPDie;
 409         SPDie = new DIE(dwarf::DW_TAG_subprogram);
 410         SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
 411                           dwarf::DW_FORM_ref4, SPDeclDie);
 412         SPCU->addDie(SPDie);
 413       }
 414     }
 415   }
 416
 417   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
 418                         Asm->GetTempSymbol("func_begin",
 419                                            Asm->getFunctionNumber()));
 420   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
 421                         Asm->GetTempSymbol("func_end",
 422                                            Asm->getFunctionNumber()));
 423   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 424   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
 425   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
 426
 427   // Add name to the name table, we do this here because we're guaranteed
 428   // to have concrete versions of our DW_TAG_subprogram nodes.
 429   addSubprogramNames(SPCU, SP, SPDie);
 430
 431   return SPDie;
 432 }
 433
 434 /// Check whether we should create a DIE for the given Scope, return true
 435 /// if we don't create a DIE (the corresponding DIE is null).
 436 bool DwarfDebug::isLexicalScopeDIENull(LexicalScope *Scope) {
 437   if (Scope->isAbstractScope())
 438     return false;
 439
 440   // We don't create a DIE if there is no Range.
 441   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
 442   if (Ranges.empty())
 443     return true;
 444
 445   if (Ranges.size() > 1)
 446     return false;
 447
 448   // We don't create a DIE if we have a single Range and the end label
 449   // is null.
 450   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
 451   MCSymbol *End = getLabelAfterInsn(RI->second);
 452   return !End;
 453 }
 454
 455 // Construct new DW_TAG_lexical_block for this scope and attach
 456 // DW_AT_low_pc/DW_AT_high_pc labels.
 457 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
 458                                           LexicalScope *Scope) {
 459   if (isLexicalScopeDIENull(Scope))
 460     return 0;
 461
 462   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
 463   if (Scope->isAbstractScope())
 464     return ScopeDIE;
 465
 466   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
 467   // If we have multiple ranges, emit them into the range section.
 468   if (Ranges.size() > 1) {
 469     // .debug_range section has not been laid out yet. Emit offset in
 470     // .debug_range as a uint, size 4, for now. emitDIE will handle
 471     // DW_AT_ranges appropriately.
 472     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 473                    DebugRangeSymbols.size()
 474                    * Asm->getDataLayout().getPointerSize());
 475     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
 476          RE = Ranges.end(); RI != RE; ++RI) {
 477       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 478       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 479     }
 480
 481     // Terminate the range list.
 482     DebugRangeSymbols.push_back(NULL);
 483     DebugRangeSymbols.push_back(NULL);
 484     return ScopeDIE;
 485   }
 486
 487   // Construct the address range for this DIE.
 488   SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
 489   MCSymbol *Start = getLabelBeforeInsn(RI->first);
 490   MCSymbol *End = getLabelAfterInsn(RI->second);
 491   assert(End && "End label should not be null!");
 492
 493   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
 494   assert(End->isDefined() && "Invalid end label for an inlined scope!");
 495
 496   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
 497   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
 498
 499   return ScopeDIE;
 500 }
 501
 502 // This scope represents inlined body of a function. Construct DIE to
 503 // represent this concrete inlined copy of the function.
 504 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
 505                                           LexicalScope *Scope) {
 506   const SmallVectorImpl<InsnRange> &Ranges = Scope->getRanges();
 507   assert(Ranges.empty() == false &&
 508          "LexicalScope does not have instruction markers!");
 509
 510   if (!Scope->getScopeNode())
 511     return NULL;
 512   DIScope DS(Scope->getScopeNode());
 513   DISubprogram InlinedSP = getDISubprogram(DS);
 514   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
 515   if (!OriginDIE) {
 516     DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
 517     return NULL;
 518   }
 519
 520   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
 521   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
 522                      dwarf::DW_FORM_ref4, OriginDIE);
 523
 524   if (Ranges.size() > 1) {
 525     // .debug_range section has not been laid out yet. Emit offset in
 526     // .debug_range as a uint, size 4, for now. emitDIE will handle
 527     // DW_AT_ranges appropriately.
 528     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 529                    DebugRangeSymbols.size()
 530                    * Asm->getDataLayout().getPointerSize());
 531     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
 532          RE = Ranges.end(); RI != RE; ++RI) {
 533       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 534       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 535     }
 536     DebugRangeSymbols.push_back(NULL);
 537     DebugRangeSymbols.push_back(NULL);
 538   } else {
 539     SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin();
 540     MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
 541     MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
 542
 543     if (StartLabel == 0 || EndLabel == 0)
 544       llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
 545
 546     assert(StartLabel->isDefined() &&
 547            "Invalid starting label for an inlined scope!");
 548     assert(EndLabel->isDefined() && "Invalid end label for an inlined scope!");
 549
 550     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
 551     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
 552   }
 553
 554   InlinedSubprogramDIEs.insert(OriginDIE);
 555
 556   // Add the call site information to the DIE.
 557   DILocation DL(Scope->getInlinedAt());
 558   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
 559                  getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
 560                                      TheCU->getUniqueID()));
 561   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
 562
 563   // Add name to the name table, we do this here because we're guaranteed
 564   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
 565   addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
 566
 567   return ScopeDIE;
 568 }
 569
 570 DIE *DwarfDebug::createScopeChildrenDIE(CompileUnit *TheCU, LexicalScope *Scope,
 571                                         SmallVectorImpl<DIE*> &Children) {
 572     DIE *ObjectPointer = NULL;
 573
 574   // Collect arguments for current function.
 575   if (LScopes.isCurrentFunctionScope(Scope))
 576     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
 577       if (DbgVariable *ArgDV = CurrentFnArguments[i])
 578         if (DIE *Arg =
 579             TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
 580           Children.push_back(Arg);
 581           if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
 582         }
 583
 584   // Collect lexical scope children first.
 585   const SmallVectorImpl<DbgVariable *> &Variables =ScopeVariables.lookup(Scope);
 586   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
 587     if (DIE *Variable =
 588         TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
 589       Children.push_back(Variable);
 590       if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
 591     }
 592   const SmallVectorImpl<LexicalScope *> &Scopes = Scope->getChildren();
 593   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
 594     if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
 595       Children.push_back(Nested);
 596   return ObjectPointer;
 597 }
 598
 599 // Construct a DIE for this scope.
 600 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
 601   if (!Scope || !Scope->getScopeNode())
 602     return NULL;
 603
 604   DIScope DS(Scope->getScopeNode());
 605
 606   SmallVector<DIE *, 8> Children;
 607   DIE *ObjectPointer = NULL;
 608   bool ChildrenCreated = false;
 609
 610   // We try to create the scope DIE first, then the children DIEs. This will
 611   // avoid creating un-used children then removing them later when we find out
 612   // the scope DIE is null.
 613   DIE *ScopeDIE = NULL;
 614   if (Scope->getInlinedAt())
 615     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
 616   else if (DS.isSubprogram()) {
 617     ProcessedSPNodes.insert(DS);
 618     if (Scope->isAbstractScope()) {
 619       ScopeDIE = TheCU->getDIE(DS);
 620       // Note down abstract DIE.
 621       if (ScopeDIE)
 622         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
 623     }
 624     else
 625       ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
 626   }
 627   else {
 628     // Early exit when we know the scope DIE is going to be null.
 629     if (isLexicalScopeDIENull(Scope))
 630       return NULL;
 631
 632     // We create children here when we know the scope DIE is not going to be
 633     // null and the children will be added to the scope DIE.
 634     ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
 635     ChildrenCreated = true;
 636
 637     // There is no need to emit empty lexical block DIE.
 638     std::pair<ImportedEntityMap::const_iterator,
 639               ImportedEntityMap::const_iterator> Range = std::equal_range(
 640         ScopesWithImportedEntities.begin(), ScopesWithImportedEntities.end(),
 641         std::pair<const MDNode *, const MDNode *>(DS, (const MDNode*)0),
 642         less_first());
 643     if (Children.empty() && Range.first == Range.second)
 644       return NULL;
 645     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
 646     assert(ScopeDIE && "Scope DIE should not be null.");
 647     for (ImportedEntityMap::const_iterator i = Range.first; i != Range.second;
 648          ++i)
 649       constructImportedEntityDIE(TheCU, i->second, ScopeDIE);
 650   }
 651
 652   if (!ScopeDIE) {
 653     assert(Children.empty() &&
 654            "We create children only when the scope DIE is not null.");
 655     return NULL;
 656   }
 657   if (!ChildrenCreated)
 658     // We create children when the scope DIE is not null.
 659     ObjectPointer = createScopeChildrenDIE(TheCU, Scope, Children);
 660
 661   // Add children
 662   for (SmallVectorImpl<DIE *>::iterator I = Children.begin(),
 663          E = Children.end(); I != E; ++I)
 664     ScopeDIE->addChild(*I);
 665
 666   if (DS.isSubprogram() && ObjectPointer != NULL)
 667     TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
 668                        dwarf::DW_FORM_ref4, ObjectPointer);
 669
 670   if (DS.isSubprogram())
 671     TheCU->addPubTypes(DISubprogram(DS));
 672
 673   return ScopeDIE;
 674 }
 675
 676 // Look up the source id with the given directory and source file names.
 677 // If none currently exists, create a new id and insert it in the
 678 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
 679 // as well.
 680 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
 681                                          StringRef DirName, unsigned CUID) {
 682   // If we use .loc in assembly, we can't separate .file entries according to
 683   // compile units. Thus all files will belong to the default compile unit.
 684   if (Asm->TM.hasMCUseLoc() &&
 685       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
 686     CUID = 0;
 687
 688   // If FE did not provide a file name, then assume stdin.
 689   if (FileName.empty())
 690     return getOrCreateSourceID("<stdin>", StringRef(), CUID);
 691
 692   // TODO: this might not belong here. See if we can factor this better.
 693   if (DirName == CompilationDir)
 694     DirName = "";
 695
 696   // FileIDCUMap stores the current ID for the given compile unit.
 697   unsigned SrcId = FileIDCUMap[CUID] + 1;
 698
 699   // We look up the CUID/file/dir by concatenating them with a zero byte.
 700   SmallString<128> NamePair;
 701   NamePair += utostr(CUID);
 702   NamePair += '\0';
 703   NamePair += DirName;
 704   NamePair += '\0'; // Zero bytes are not allowed in paths.
 705   NamePair += FileName;
 706
 707   StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
 708   if (Ent.getValue() != SrcId)
 709     return Ent.getValue();
 710
 711   FileIDCUMap[CUID] = SrcId;
 712   // Print out a .file directive to specify files for .loc directives.
 713   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
 714
 715   return SrcId;
 716 }
 717
 718 // Create new CompileUnit for the given metadata node with tag
 719 // DW_TAG_compile_unit.
 720 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
 721   DICompileUnit DIUnit(N);
 722   StringRef FN = DIUnit.getFilename();
 723   CompilationDir = DIUnit.getDirectory();
 724
 725   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
 726   CompileUnit *NewCU =
 727       new CompileUnit(GlobalCUIndexCount++, Die, N, Asm, this, &InfoHolder);
 728
 729   FileIDCUMap[NewCU->getUniqueID()] = 0;
 730   // Call this to emit a .file directive if it wasn't emitted for the source
 731   // file this CU comes from yet.
 732   getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
 733
 734   NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
 735   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
 736                  DIUnit.getLanguage());
 737   NewCU->addString(Die, dwarf::DW_AT_name, FN);
 738
 739   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
 740   // into an entity. We're using 0 (or a NULL label) for this. For
 741   // split dwarf it's in the skeleton CU so omit it here.
 742   if (!useSplitDwarf())
 743     NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
 744
 745   // Define start line table label for each Compile Unit.
 746   MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
 747                                                    NewCU->getUniqueID());
 748   Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
 749                                                      NewCU->getUniqueID());
 750
 751   // Use a single line table if we are using .loc and generating assembly.
 752   bool UseTheFirstCU =
 753     (Asm->TM.hasMCUseLoc() &&
 754      Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer) ||
 755     (NewCU->getUniqueID() == 0);
 756
 757   if (!useSplitDwarf()) {
 758     // DW_AT_stmt_list is a offset of line number information for this
 759     // compile unit in debug_line section. For split dwarf this is
 760     // left in the skeleton CU and so not included.
 761     // The line table entries are not always emitted in assembly, so it
 762     // is not okay to use line_table_start here.
 763     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 764       NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
 765                       UseTheFirstCU ? Asm->GetTempSymbol("section_line")
 766                                     : LineTableStartSym);
 767     else if (UseTheFirstCU)
 768       NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
 769     else
 770       NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
 771                       LineTableStartSym, DwarfLineSectionSym);
 772
 773     // If we're using split dwarf the compilation dir is going to be in the
 774     // skeleton CU and so we don't need to duplicate it here.
 775     if (!CompilationDir.empty())
 776       NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
 777
 778     // Flag to let the linker know we have emitted new style pubnames. Only
 779     // emit it here if we don't have a skeleton CU for split dwarf.
 780     if (GenerateGnuPubSections) {
 781       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 782         NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames,
 783                         dwarf::DW_FORM_sec_offset,
 784                         Asm->GetTempSymbol("gnu_pubnames",
 785                                            NewCU->getUniqueID()));
 786       else
 787         NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
 788                         Asm->GetTempSymbol("gnu_pubnames",
 789                                            NewCU->getUniqueID()),
 790                         DwarfGnuPubNamesSectionSym);
 791
 792       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 793         NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes,
 794                         dwarf::DW_FORM_sec_offset,
 795                         Asm->GetTempSymbol("gnu_pubtypes",
 796                                            NewCU->getUniqueID()));
 797       else
 798         NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
 799                         Asm->GetTempSymbol("gnu_pubnames",
 800                                            NewCU->getUniqueID()),
 801                         DwarfGnuPubTypesSectionSym);
 802     }
 803   }
 804
 805   if (DIUnit.isOptimized())
 806     NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
 807
 808   StringRef Flags = DIUnit.getFlags();
 809   if (!Flags.empty())
 810     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
 811
 812   if (unsigned RVer = DIUnit.getRunTimeVersion())
 813     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
 814             dwarf::DW_FORM_data1, RVer);
 815
 816   if (!FirstCU)
 817     FirstCU = NewCU;
 818
 819   InfoHolder.addUnit(NewCU);
 820
 821   CUMap.insert(std::make_pair(N, NewCU));
 822   return NewCU;
 823 }
 824
 825 // Construct subprogram DIE.
 826 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
 827                                         const MDNode *N) {
 828   CompileUnit *&CURef = SPMap[N];
 829   if (CURef)
 830     return;
 831   CURef = TheCU;
 832
 833   DISubprogram SP(N);
 834   if (!SP.isDefinition())
 835     // This is a method declaration which will be handled while constructing
 836     // class type.
 837     return;
 838
 839   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
 840
 841   // Add to map.
 842   TheCU->insertDIE(N, SubprogramDie);
 843
 844   // Add to context owner.
 845   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
 846
 847   // Expose as a global name.
 848   TheCU->addGlobalName(SP.getName(), SubprogramDie);
 849 }
 850
 851 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 852                                             const MDNode *N) {
 853   DIImportedEntity Module(N);
 854   if (!Module.Verify())
 855     return;
 856   if (DIE *D = TheCU->getOrCreateContextDIE(Module.getContext()))
 857     constructImportedEntityDIE(TheCU, Module, D);
 858 }
 859
 860 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU, const MDNode *N,
 861                                             DIE *Context) {
 862   DIImportedEntity Module(N);
 863   if (!Module.Verify())
 864     return;
 865   return constructImportedEntityDIE(TheCU, Module, Context);
 866 }
 867
 868 void DwarfDebug::constructImportedEntityDIE(CompileUnit *TheCU,
 869                                             const DIImportedEntity &Module,
 870                                             DIE *Context) {
 871   assert(Module.Verify() &&
 872          "Use one of the MDNode * overloads to handle invalid metadata");
 873   assert(Context && "Should always have a context for an imported_module");
 874   DIE *IMDie = new DIE(Module.getTag());
 875   TheCU->insertDIE(Module, IMDie);
 876   DIE *EntityDie;
 877   DIDescriptor Entity = Module.getEntity();
 878   if (Entity.isNameSpace())
 879     EntityDie = TheCU->getOrCreateNameSpace(DINameSpace(Entity));
 880   else if (Entity.isSubprogram())
 881     EntityDie = TheCU->getOrCreateSubprogramDIE(DISubprogram(Entity));
 882   else if (Entity.isType())
 883     EntityDie = TheCU->getOrCreateTypeDIE(DIType(Entity));
 884   else
 885     EntityDie = TheCU->getDIE(Entity);
 886   unsigned FileID = getOrCreateSourceID(Module.getContext().getFilename(),
 887                                         Module.getContext().getDirectory(),
 888                                         TheCU->getUniqueID());
 889   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_file, 0, FileID);
 890   TheCU->addUInt(IMDie, dwarf::DW_AT_decl_line, 0, Module.getLineNumber());
 891   TheCU->addDIEEntry(IMDie, dwarf::DW_AT_import, dwarf::DW_FORM_ref4,
 892                      EntityDie);
 893   StringRef Name = Module.getName();
 894   if (!Name.empty())
 895     TheCU->addString(IMDie, dwarf::DW_AT_name, Name);
 896   Context->addChild(IMDie);
 897 }
 898
 899 // Emit all Dwarf sections that should come prior to the content. Create
 900 // global DIEs and emit initial debug info sections. This is invoked by
 901 // the target AsmPrinter.
 902 void DwarfDebug::beginModule() {
 903   if (DisableDebugInfoPrinting)
 904     return;
 905
 906   const Module *M = MMI->getModule();
 907
 908   // If module has named metadata anchors then use them, otherwise scan the
 909   // module using debug info finder to collect debug info.
 910   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 911   if (!CU_Nodes)
 912     return;
 913   TypeIdentifierMap = generateDITypeIdentifierMap(CU_Nodes);
 914
 915   // Emit initial sections so we can reference labels later.
 916   emitSectionLabels();
 917
 918   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 919     DICompileUnit CUNode(CU_Nodes->getOperand(i));
 920     CompileUnit *CU = constructCompileUnit(CUNode);
 921     DIArray ImportedEntities = CUNode.getImportedEntities();
 922     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 923       ScopesWithImportedEntities.push_back(std::make_pair(
 924           DIImportedEntity(ImportedEntities.getElement(i)).getContext(),
 925           ImportedEntities.getElement(i)));
 926     std::sort(ScopesWithImportedEntities.begin(),
 927               ScopesWithImportedEntities.end(), less_first());
 928     DIArray GVs = CUNode.getGlobalVariables();
 929     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 930       CU->createGlobalVariableDIE(GVs.getElement(i));
 931     DIArray SPs = CUNode.getSubprograms();
 932     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 933       constructSubprogramDIE(CU, SPs.getElement(i));
 934     DIArray EnumTypes = CUNode.getEnumTypes();
 935     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 936       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 937     DIArray RetainedTypes = CUNode.getRetainedTypes();
 938     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 939       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 940     // Emit imported_modules last so that the relevant context is already
 941     // available.
 942     for (unsigned i = 0, e = ImportedEntities.getNumElements(); i != e; ++i)
 943       constructImportedEntityDIE(CU, ImportedEntities.getElement(i));
 944   }
 945
 946   // Tell MMI that we have debug info.
 947   MMI->setDebugInfoAvailability(true);
 948
 949   // Prime section data.
 950   SectionMap[Asm->getObjFileLowering().getTextSection()];
 951 }
 952
 953 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 954 void DwarfDebug::computeInlinedDIEs() {
 955   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 956   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 957          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 958     DIE *ISP = *AI;
 959     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 960   }
 961   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 962          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 963     DIE *ISP = AI->second;
 964     if (InlinedSubprogramDIEs.count(ISP))
 965       continue;
 966     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 967   }
 968 }
 969
 970 // Collect info for variables that were optimized out.
 971 void DwarfDebug::collectDeadVariables() {
 972   const Module *M = MMI->getModule();
 973   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 974
 975   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 976     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 977       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 978       DIArray Subprograms = TheCU.getSubprograms();
 979       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 980         DISubprogram SP(Subprograms.getElement(i));
 981         if (ProcessedSPNodes.count(SP) != 0) continue;
 982         if (!SP.isSubprogram()) continue;
 983         if (!SP.isDefinition()) continue;
 984         DIArray Variables = SP.getVariables();
 985         if (Variables.getNumElements() == 0) continue;
 986
 987         LexicalScope *Scope =
 988           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 989         DeadFnScopeMap[SP] = Scope;
 990
 991         // Construct subprogram DIE and add variables DIEs.
 992         CompileUnit *SPCU = CUMap.lookup(TheCU);
 993         assert(SPCU && "Unable to find Compile Unit!");
 994         constructSubprogramDIE(SPCU, SP);
 995         DIE *ScopeDIE = SPCU->getDIE(SP);
 996         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 997           DIVariable DV(Variables.getElement(vi));
 998           if (!DV.isVariable()) continue;
 999           DbgVariable NewVar(DV, NULL);
1000           if (DIE *VariableDIE =
1001               SPCU->constructVariableDIE(&NewVar, Scope->isAbstractScope()))
1002             ScopeDIE->addChild(VariableDIE);
1003         }
1004       }
1005     }
1006   }
1007   DeleteContainerSeconds(DeadFnScopeMap);
1008 }
1009
1010 // Type Signature [7.27] and ODR Hash code.
1011
1012 /// \brief Grabs the string in whichever attribute is passed in and returns
1013 /// a reference to it. Returns "" if the attribute doesn't exist.
1014 static StringRef getDIEStringAttr(DIE *Die, unsigned Attr) {
1015   DIEValue *V = Die->findAttribute(Attr);
1016
1017   if (DIEString *S = dyn_cast_or_null<DIEString>(V))
1018     return S->getString();
1019
1020   return StringRef("");
1021 }
1022
1023 /// Return true if the current DIE is contained within an anonymous namespace.
1024 static bool isContainedInAnonNamespace(DIE *Die) {
1025   DIE *Parent = Die->getParent();
1026
1027   while (Parent) {
1028     if (Parent->getTag() == dwarf::DW_TAG_namespace &&
1029         getDIEStringAttr(Parent, dwarf::DW_AT_name) == "")
1030       return true;
1031     Parent = Parent->getParent();
1032   }
1033
1034   return false;
1035 }
1036
1037 /// Test if the current CU language is C++ and that we have
1038 /// a named type that is not contained in an anonymous namespace.
1039 static bool shouldAddODRHash(CompileUnit *CU, DIE *Die) {
1040   return CU->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1041          getDIEStringAttr(Die, dwarf::DW_AT_name) != "" &&
1042          !isContainedInAnonNamespace(Die);
1043 }
1044
1045 void DwarfDebug::finalizeModuleInfo() {
1046   // Collect info for variables that were optimized out.
1047   collectDeadVariables();
1048
1049   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1050   computeInlinedDIEs();
1051
1052   // Split out type units and conditionally add an ODR tag to the split
1053   // out type.
1054   // FIXME: Do type splitting.
1055   for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1056     DIE *Die = TypeUnits[i];
1057     DIEHash Hash;
1058     // If we've requested ODR hashes and it's applicable for an ODR hash then
1059     // add the ODR signature now.
1060     // FIXME: This should be added onto the type unit, not the type, but this
1061     // works as an intermediate stage.
1062     if (GenerateODRHash && shouldAddODRHash(CUMap.begin()->second, Die))
1063       CUMap.begin()->second->addUInt(Die, dwarf::DW_AT_GNU_odr_signature,
1064                                      dwarf::DW_FORM_data8,
1065                                      Hash.computeDIEODRSignature(Die));
1066   }
1067
1068   // Handle anything that needs to be done on a per-cu basis.
1069   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1070                                                          CUE = CUMap.end();
1071        CUI != CUE; ++CUI) {
1072     CompileUnit *TheCU = CUI->second;
1073     // Emit DW_AT_containing_type attribute to connect types with their
1074     // vtable holding type.
1075     TheCU->constructContainingTypeDIEs();
1076
1077     // If we're splitting the dwarf out now that we've got the entire
1078     // CU then construct a skeleton CU based upon it.
1079     if (useSplitDwarf()) {
1080       uint64_t ID = 0;
1081       if (GenerateCUHash) {
1082         DIEHash CUHash;
1083         ID = CUHash.computeCUSignature(TheCU->getCUDie());
1084       }
1085       // This should be a unique identifier when we want to build .dwp files.
1086       TheCU->addUInt(TheCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1087                      dwarf::DW_FORM_data8, ID);
1088       // Now construct the skeleton CU associated.
1089       CompileUnit *SkCU = constructSkeletonCU(TheCU);
1090       // This should be a unique identifier when we want to build .dwp files.
1091       SkCU->addUInt(SkCU->getCUDie(), dwarf::DW_AT_GNU_dwo_id,
1092                     dwarf::DW_FORM_data8, ID);
1093     }
1094   }
1095
1096   // Compute DIE offsets and sizes.
1097   InfoHolder.computeSizeAndOffsets();
1098   if (useSplitDwarf())
1099     SkeletonHolder.computeSizeAndOffsets();
1100 }
1101
1102 void DwarfDebug::endSections() {
1103    // Filter labels by section.
1104   for (size_t n = 0; n < Labels.size(); n++) {
1105     const SymbolCU &SCU = Labels[n];
1106     if (SCU.Sym->isInSection()) {
1107       // Make a note of this symbol and it's section.
1108       const MCSection *Section = &SCU.Sym->getSection();
1109       if (!Section->getKind().isMetadata())
1110         SectionMap[Section].push_back(SCU);
1111     } else {
1112       // Some symbols (e.g. common/bss on mach-o) can have no section but still
1113       // appear in the output. This sucks as we rely on sections to build
1114       // arange spans. We can do it without, but it's icky.
1115       SectionMap[NULL].push_back(SCU);
1116     }
1117   }
1118
1119   // Add terminating symbols for each section.
1120   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
1121        it++) {
1122     const MCSection *Section = it->first;
1123     MCSymbol *Sym = NULL;
1124
1125     if (Section) {
1126       Sym = Asm->GetTempSymbol(Section->getLabelEndName());
1127       Asm->OutStreamer.SwitchSection(Section);
1128       Asm->OutStreamer.EmitLabel(Sym);
1129     }
1130
1131     // Insert a final terminator.
1132     SymbolCU Entry;
1133     Entry.CU = NULL;
1134     Entry.Sym = Sym;
1135     SectionMap[Section].push_back(Entry);
1136   }
1137 }
1138
1139 // Emit all Dwarf sections that should come after the content.
1140 void DwarfDebug::endModule() {
1141
1142   if (!FirstCU) return;
1143
1144   // End any existing sections.
1145   // TODO: Does this need to happen?
1146   endSections();
1147
1148   // Finalize the debug info for the module.
1149   finalizeModuleInfo();
1150
1151   if (!useSplitDwarf()) {
1152     emitDebugStr();
1153
1154     // Emit all the DIEs into a debug info section.
1155     emitDebugInfo();
1156
1157     // Corresponding abbreviations into a abbrev section.
1158     emitAbbreviations();
1159
1160     // Emit info into a debug loc section.
1161     emitDebugLoc();
1162
1163     // Emit info into a debug aranges section.
1164     emitDebugARanges();
1165
1166     // Emit info into a debug ranges section.
1167     emitDebugRanges();
1168
1169     // Emit info into a debug macinfo section.
1170     emitDebugMacInfo();
1171
1172   } else {
1173     // TODO: Fill this in for separated debug sections and separate
1174     // out information into new sections.
1175     emitDebugStr();
1176     if (useSplitDwarf())
1177       emitDebugStrDWO();
1178
1179     // Emit the debug info section and compile units.
1180     emitDebugInfo();
1181     emitDebugInfoDWO();
1182
1183     // Corresponding abbreviations into a abbrev section.
1184     emitAbbreviations();
1185     emitDebugAbbrevDWO();
1186
1187     // Emit info into a debug loc section.
1188     emitDebugLoc();
1189
1190     // Emit info into a debug aranges section.
1191     emitDebugARanges();
1192
1193     // Emit info into a debug ranges section.
1194     emitDebugRanges();
1195
1196     // Emit info into a debug macinfo section.
1197     emitDebugMacInfo();
1198
1199     // Emit DWO addresses.
1200     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1201
1202   }
1203
1204   // Emit info into the dwarf accelerator table sections.
1205   if (useDwarfAccelTables()) {
1206     emitAccelNames();
1207     emitAccelObjC();
1208     emitAccelNamespaces();
1209     emitAccelTypes();
1210   }
1211
1212   // Emit the pubnames and pubtypes sections if requested.
1213   if (HasDwarfPubSections) {
1214     emitDebugPubNames(GenerateGnuPubSections);
1215     emitDebugPubTypes(GenerateGnuPubSections);
1216   }
1217
1218   // clean up.
1219   SPMap.clear();
1220   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1221          E = CUMap.end(); I != E; ++I)
1222     delete I->second;
1223
1224   for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1225          E = SkeletonCUs.end(); I != E; ++I)
1226     delete *I;
1227
1228   // Reset these for the next Module if we have one.
1229   FirstCU = NULL;
1230 }
1231
1232 // Find abstract variable, if any, associated with Var.
1233 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1234                                               DebugLoc ScopeLoc) {
1235   LLVMContext &Ctx = DV->getContext();
1236   // More then one inlined variable corresponds to one abstract variable.
1237   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1238   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1239   if (AbsDbgVariable)
1240     return AbsDbgVariable;
1241
1242   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1243   if (!Scope)
1244     return NULL;
1245
1246   AbsDbgVariable = new DbgVariable(Var, NULL);
1247   addScopeVariable(Scope, AbsDbgVariable);
1248   AbstractVariables[Var] = AbsDbgVariable;
1249   return AbsDbgVariable;
1250 }
1251
1252 // If Var is a current function argument then add it to CurrentFnArguments list.
1253 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1254                                       DbgVariable *Var, LexicalScope *Scope) {
1255   if (!LScopes.isCurrentFunctionScope(Scope))
1256     return false;
1257   DIVariable DV = Var->getVariable();
1258   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1259     return false;
1260   unsigned ArgNo = DV.getArgNumber();
1261   if (ArgNo == 0)
1262     return false;
1263
1264   size_t Size = CurrentFnArguments.size();
1265   if (Size == 0)
1266     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1267   // llvm::Function argument size is not good indicator of how many
1268   // arguments does the function have at source level.
1269   if (ArgNo > Size)
1270     CurrentFnArguments.resize(ArgNo * 2);
1271   CurrentFnArguments[ArgNo - 1] = Var;
1272   return true;
1273 }
1274
1275 // Collect variable information from side table maintained by MMI.
1276 void
1277 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1278                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1279   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1280   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1281          VE = VMap.end(); VI != VE; ++VI) {
1282     const MDNode *Var = VI->first;
1283     if (!Var) continue;
1284     Processed.insert(Var);
1285     DIVariable DV(Var);
1286     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1287
1288     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1289
1290     // If variable scope is not found then skip this variable.
1291     if (Scope == 0)
1292       continue;
1293
1294     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1295     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1296     RegVar->setFrameIndex(VP.first);
1297     if (!addCurrentFnArgument(MF, RegVar, Scope))
1298       addScopeVariable(Scope, RegVar);
1299     if (AbsDbgVariable)
1300       AbsDbgVariable->setFrameIndex(VP.first);
1301   }
1302 }
1303
1304 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1305 // defined reg.
1306 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1307   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1308   return MI->getNumOperands() == 3 &&
1309          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1310          (MI->getOperand(1).isImm() ||
1311           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1312 }
1313
1314 // Get .debug_loc entry for the instruction range starting at MI.
1315 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1316                                          const MCSymbol *FLabel,
1317                                          const MCSymbol *SLabel,
1318                                          const MachineInstr *MI) {
1319   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1320
1321   assert(MI->getNumOperands() == 3);
1322   if (MI->getOperand(0).isReg()) {
1323     MachineLocation MLoc;
1324     // If the second operand is an immediate, this is a
1325     // register-indirect address.
1326     if (!MI->getOperand(1).isImm())
1327       MLoc.set(MI->getOperand(0).getReg());
1328     else
1329       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1330     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1331   }
1332   if (MI->getOperand(0).isImm())
1333     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1334   if (MI->getOperand(0).isFPImm())
1335     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1336   if (MI->getOperand(0).isCImm())
1337     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1338
1339   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1340 }
1341
1342 // Find variables for each lexical scope.
1343 void
1344 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1345                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1346
1347   // Grab the variable info that was squirreled away in the MMI side-table.
1348   collectVariableInfoFromMMITable(MF, Processed);
1349
1350   for (SmallVectorImpl<const MDNode*>::const_iterator
1351          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1352          ++UVI) {
1353     const MDNode *Var = *UVI;
1354     if (Processed.count(Var))
1355       continue;
1356
1357     // History contains relevant DBG_VALUE instructions for Var and instructions
1358     // clobbering it.
1359     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1360     if (History.empty())
1361       continue;
1362     const MachineInstr *MInsn = History.front();
1363
1364     DIVariable DV(Var);
1365     LexicalScope *Scope = NULL;
1366     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1367         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1368       Scope = LScopes.getCurrentFunctionScope();
1369     else if (MDNode *IA = DV.getInlinedAt())
1370       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1371     else
1372       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1373     // If variable scope is not found then skip this variable.
1374     if (!Scope)
1375       continue;
1376
1377     Processed.insert(DV);
1378     assert(MInsn->isDebugValue() && "History must begin with debug value");
1379     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1380     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1381     if (!addCurrentFnArgument(MF, RegVar, Scope))
1382       addScopeVariable(Scope, RegVar);
1383     if (AbsVar)
1384       AbsVar->setMInsn(MInsn);
1385
1386     // Simplify ranges that are fully coalesced.
1387     if (History.size() <= 1 || (History.size() == 2 &&
1388                                 MInsn->isIdenticalTo(History.back()))) {
1389       RegVar->setMInsn(MInsn);
1390       continue;
1391     }
1392
1393     // Handle multiple DBG_VALUE instructions describing one variable.
1394     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1395
1396     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1397            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1398       const MachineInstr *Begin = *HI;
1399       assert(Begin->isDebugValue() && "Invalid History entry");
1400
1401       // Check if DBG_VALUE is truncating a range.
1402       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1403           && !Begin->getOperand(0).getReg())
1404         continue;
1405
1406       // Compute the range for a register location.
1407       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1408       const MCSymbol *SLabel = 0;
1409
1410       if (HI + 1 == HE)
1411         // If Begin is the last instruction in History then its value is valid
1412         // until the end of the function.
1413         SLabel = FunctionEndSym;
1414       else {
1415         const MachineInstr *End = HI[1];
1416         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1417               << "\t" << *Begin << "\t" << *End << "\n");
1418         if (End->isDebugValue())
1419           SLabel = getLabelBeforeInsn(End);
1420         else {
1421           // End is a normal instruction clobbering the range.
1422           SLabel = getLabelAfterInsn(End);
1423           assert(SLabel && "Forgot label after clobber instruction");
1424           ++HI;
1425         }
1426       }
1427
1428       // The value is valid until the next DBG_VALUE or clobber.
1429       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1430                                                     Begin));
1431     }
1432     DotDebugLocEntries.push_back(DotDebugLocEntry());
1433   }
1434
1435   // Collect info for variables that were optimized out.
1436   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1437   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1438   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1439     DIVariable DV(Variables.getElement(i));
1440     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1441       continue;
1442     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1443       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1444   }
1445 }
1446
1447 // Return Label preceding the instruction.
1448 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1449   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1450   assert(Label && "Didn't insert label before instruction");
1451   return Label;
1452 }
1453
1454 // Return Label immediately following the instruction.
1455 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1456   return LabelsAfterInsn.lookup(MI);
1457 }
1458
1459 // Process beginning of an instruction.
1460 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1461   // Check if source location changes, but ignore DBG_VALUE locations.
1462   if (!MI->isDebugValue()) {
1463     DebugLoc DL = MI->getDebugLoc();
1464     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1465       unsigned Flags = 0;
1466       PrevInstLoc = DL;
1467       if (DL == PrologEndLoc) {
1468         Flags |= DWARF2_FLAG_PROLOGUE_END;
1469         PrologEndLoc = DebugLoc();
1470       }
1471       if (PrologEndLoc.isUnknown())
1472         Flags |= DWARF2_FLAG_IS_STMT;
1473
1474       if (!DL.isUnknown()) {
1475         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1476         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1477       } else
1478         recordSourceLine(0, 0, 0, 0);
1479     }
1480   }
1481
1482   // Insert labels where requested.
1483   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1484     LabelsBeforeInsn.find(MI);
1485
1486   // No label needed.
1487   if (I == LabelsBeforeInsn.end())
1488     return;
1489
1490   // Label already assigned.
1491   if (I->second)
1492     return;
1493
1494   if (!PrevLabel) {
1495     PrevLabel = MMI->getContext().CreateTempSymbol();
1496     Asm->OutStreamer.EmitLabel(PrevLabel);
1497   }
1498   I->second = PrevLabel;
1499 }
1500
1501 // Process end of an instruction.
1502 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1503   // Don't create a new label after DBG_VALUE instructions.
1504   // They don't generate code.
1505   if (!MI->isDebugValue())
1506     PrevLabel = 0;
1507
1508   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1509     LabelsAfterInsn.find(MI);
1510
1511   // No label needed.
1512   if (I == LabelsAfterInsn.end())
1513     return;
1514
1515   // Label already assigned.
1516   if (I->second)
1517     return;
1518
1519   // We need a label after this instruction.
1520   if (!PrevLabel) {
1521     PrevLabel = MMI->getContext().CreateTempSymbol();
1522     Asm->OutStreamer.EmitLabel(PrevLabel);
1523   }
1524   I->second = PrevLabel;
1525 }
1526
1527 // Each LexicalScope has first instruction and last instruction to mark
1528 // beginning and end of a scope respectively. Create an inverse map that list
1529 // scopes starts (and ends) with an instruction. One instruction may start (or
1530 // end) multiple scopes. Ignore scopes that are not reachable.
1531 void DwarfDebug::identifyScopeMarkers() {
1532   SmallVector<LexicalScope *, 4> WorkList;
1533   WorkList.push_back(LScopes.getCurrentFunctionScope());
1534   while (!WorkList.empty()) {
1535     LexicalScope *S = WorkList.pop_back_val();
1536
1537     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1538     if (!Children.empty())
1539       for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1540              SE = Children.end(); SI != SE; ++SI)
1541         WorkList.push_back(*SI);
1542
1543     if (S->isAbstractScope())
1544       continue;
1545
1546     const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1547     if (Ranges.empty())
1548       continue;
1549     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1550            RE = Ranges.end(); RI != RE; ++RI) {
1551       assert(RI->first && "InsnRange does not have first instruction!");
1552       assert(RI->second && "InsnRange does not have second instruction!");
1553       requestLabelBeforeInsn(RI->first);
1554       requestLabelAfterInsn(RI->second);
1555     }
1556   }
1557 }
1558
1559 // Get MDNode for DebugLoc's scope.
1560 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1561   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1562     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1563   return DL.getScope(Ctx);
1564 }
1565
1566 // Walk up the scope chain of given debug loc and find line number info
1567 // for the function.
1568 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1569   const MDNode *Scope = getScopeNode(DL, Ctx);
1570   DISubprogram SP = getDISubprogram(Scope);
1571   if (SP.isSubprogram()) {
1572     // Check for number of operands since the compatibility is
1573     // cheap here.
1574     if (SP->getNumOperands() > 19)
1575       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1576     else
1577       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1578   }
1579
1580   return DebugLoc();
1581 }
1582
1583 // Gather pre-function debug information.  Assumes being called immediately
1584 // after the function entry point has been emitted.
1585 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1586   if (!MMI->hasDebugInfo()) return;
1587   LScopes.initialize(*MF);
1588   if (LScopes.empty()) return;
1589   identifyScopeMarkers();
1590
1591   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1592   // belongs to.
1593   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1594   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1595   assert(TheCU && "Unable to find compile unit!");
1596   if (Asm->TM.hasMCUseLoc() &&
1597       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1598     // Use a single line table if we are using .loc and generating assembly.
1599     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1600   else
1601     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1602
1603   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1604                                         Asm->getFunctionNumber());
1605   // Assumes in correct section after the entry point.
1606   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1607
1608   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1609
1610   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1611   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1612   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1613
1614   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1615        I != E; ++I) {
1616     bool AtBlockEntry = true;
1617     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1618          II != IE; ++II) {
1619       const MachineInstr *MI = II;
1620
1621       if (MI->isDebugValue()) {
1622         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1623
1624         // Keep track of user variables.
1625         const MDNode *Var =
1626           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1627
1628         // Variable is in a register, we need to check for clobbers.
1629         if (isDbgValueInDefinedReg(MI))
1630           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1631
1632         // Check the history of this variable.
1633         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1634         if (History.empty()) {
1635           UserVariables.push_back(Var);
1636           // The first mention of a function argument gets the FunctionBeginSym
1637           // label, so arguments are visible when breaking at function entry.
1638           DIVariable DV(Var);
1639           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1640               DISubprogram(getDISubprogram(DV.getContext()))
1641                 .describes(MF->getFunction()))
1642             LabelsBeforeInsn[MI] = FunctionBeginSym;
1643         } else {
1644           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1645           const MachineInstr *Prev = History.back();
1646           if (Prev->isDebugValue()) {
1647             // Coalesce identical entries at the end of History.
1648             if (History.size() >= 2 &&
1649                 Prev->isIdenticalTo(History[History.size() - 2])) {
1650               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1651                     << "\t" << *Prev
1652                     << "\t" << *History[History.size() - 2] << "\n");
1653               History.pop_back();
1654             }
1655
1656             // Terminate old register assignments that don't reach MI;
1657             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1658             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1659                 isDbgValueInDefinedReg(Prev)) {
1660               // Previous register assignment needs to terminate at the end of
1661               // its basic block.
1662               MachineBasicBlock::const_iterator LastMI =
1663                 PrevMBB->getLastNonDebugInstr();
1664               if (LastMI == PrevMBB->end()) {
1665                 // Drop DBG_VALUE for empty range.
1666                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1667                       << "\t" << *Prev << "\n");
1668                 History.pop_back();
1669               } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1670                 // Terminate after LastMI.
1671                 History.push_back(LastMI);
1672             }
1673           }
1674         }
1675         History.push_back(MI);
1676       } else {
1677         // Not a DBG_VALUE instruction.
1678         if (!MI->isLabel())
1679           AtBlockEntry = false;
1680
1681         // First known non-DBG_VALUE and non-frame setup location marks
1682         // the beginning of the function body.
1683         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1684             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1685           PrologEndLoc = MI->getDebugLoc();
1686
1687         // Check if the instruction clobbers any registers with debug vars.
1688         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1689                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1690           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1691             continue;
1692           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1693                AI.isValid(); ++AI) {
1694             unsigned Reg = *AI;
1695             const MDNode *Var = LiveUserVar[Reg];
1696             if (!Var)
1697               continue;
1698             // Reg is now clobbered.
1699             LiveUserVar[Reg] = 0;
1700
1701             // Was MD last defined by a DBG_VALUE referring to Reg?
1702             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1703             if (HistI == DbgValues.end())
1704               continue;
1705             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1706             if (History.empty())
1707               continue;
1708             const MachineInstr *Prev = History.back();
1709             // Sanity-check: Register assignments are terminated at the end of
1710             // their block.
1711             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1712               continue;
1713             // Is the variable still in Reg?
1714             if (!isDbgValueInDefinedReg(Prev) ||
1715                 Prev->getOperand(0).getReg() != Reg)
1716               continue;
1717             // Var is clobbered. Make sure the next instruction gets a label.
1718             History.push_back(MI);
1719           }
1720         }
1721       }
1722     }
1723   }
1724
1725   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1726        I != E; ++I) {
1727     SmallVectorImpl<const MachineInstr*> &History = I->second;
1728     if (History.empty())
1729       continue;
1730
1731     // Make sure the final register assignments are terminated.
1732     const MachineInstr *Prev = History.back();
1733     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1734       const MachineBasicBlock *PrevMBB = Prev->getParent();
1735       MachineBasicBlock::const_iterator LastMI =
1736         PrevMBB->getLastNonDebugInstr();
1737       if (LastMI == PrevMBB->end())
1738         // Drop DBG_VALUE for empty range.
1739         History.pop_back();
1740       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1741         // Terminate after LastMI.
1742         History.push_back(LastMI);
1743       }
1744     }
1745     // Request labels for the full history.
1746     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1747       const MachineInstr *MI = History[i];
1748       if (MI->isDebugValue())
1749         requestLabelBeforeInsn(MI);
1750       else
1751         requestLabelAfterInsn(MI);
1752     }
1753   }
1754
1755   PrevInstLoc = DebugLoc();
1756   PrevLabel = FunctionBeginSym;
1757
1758   // Record beginning of function.
1759   if (!PrologEndLoc.isUnknown()) {
1760     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1761                                        MF->getFunction()->getContext());
1762     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1763                      FnStartDL.getScope(MF->getFunction()->getContext()),
1764     // We'd like to list the prologue as "not statements" but GDB behaves
1765     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1766                      DWARF2_FLAG_IS_STMT);
1767   }
1768 }
1769
1770 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1771   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1772   DIVariable DV = Var->getVariable();
1773   // Variables with positive arg numbers are parameters.
1774   if (unsigned ArgNum = DV.getArgNumber()) {
1775     // Keep all parameters in order at the start of the variable list to ensure
1776     // function types are correct (no out-of-order parameters)
1777     //
1778     // This could be improved by only doing it for optimized builds (unoptimized
1779     // builds have the right order to begin with), searching from the back (this
1780     // would catch the unoptimized case quickly), or doing a binary search
1781     // rather than linear search.
1782     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1783     while (I != Vars.end()) {
1784       unsigned CurNum = (*I)->getVariable().getArgNumber();
1785       // A local (non-parameter) variable has been found, insert immediately
1786       // before it.
1787       if (CurNum == 0)
1788         break;
1789       // A later indexed parameter has been found, insert immediately before it.
1790       if (CurNum > ArgNum)
1791         break;
1792       ++I;
1793     }
1794     Vars.insert(I, Var);
1795     return;
1796   }
1797
1798   Vars.push_back(Var);
1799 }
1800
1801 // Gather and emit post-function debug information.
1802 void DwarfDebug::endFunction(const MachineFunction *MF) {
1803   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1804
1805   // Define end label for subprogram.
1806   FunctionEndSym = Asm->GetTempSymbol("func_end",
1807                                       Asm->getFunctionNumber());
1808   // Assumes in correct section after the entry point.
1809   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1810   // Set DwarfCompileUnitID in MCContext to default value.
1811   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1812
1813   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1814   collectVariableInfo(MF, ProcessedVars);
1815
1816   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1817   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1818   assert(TheCU && "Unable to find compile unit!");
1819
1820   // Construct abstract scopes.
1821   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1822   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1823     LexicalScope *AScope = AList[i];
1824     DISubprogram SP(AScope->getScopeNode());
1825     if (SP.isSubprogram()) {
1826       // Collect info for variables that were optimized out.
1827       DIArray Variables = SP.getVariables();
1828       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1829         DIVariable DV(Variables.getElement(i));
1830         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1831           continue;
1832         // Check that DbgVariable for DV wasn't created earlier, when
1833         // findAbstractVariable() was called for inlined instance of DV.
1834         LLVMContext &Ctx = DV->getContext();
1835         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1836         if (AbstractVariables.lookup(CleanDV))
1837           continue;
1838         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1839           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1840       }
1841     }
1842     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1843       constructScopeDIE(TheCU, AScope);
1844   }
1845
1846   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1847
1848   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1849     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1850
1851   // Clear debug info
1852   for (ScopeVariablesMap::iterator
1853          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1854     DeleteContainerPointers(I->second);
1855   ScopeVariables.clear();
1856   DeleteContainerPointers(CurrentFnArguments);
1857   UserVariables.clear();
1858   DbgValues.clear();
1859   AbstractVariables.clear();
1860   LabelsBeforeInsn.clear();
1861   LabelsAfterInsn.clear();
1862   PrevLabel = NULL;
1863 }
1864
1865 // Register a source line with debug info. Returns the  unique label that was
1866 // emitted and which provides correspondence to the source line list.
1867 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1868                                   unsigned Flags) {
1869   StringRef Fn;
1870   StringRef Dir;
1871   unsigned Src = 1;
1872   if (S) {
1873     DIDescriptor Scope(S);
1874
1875     if (Scope.isCompileUnit()) {
1876       DICompileUnit CU(S);
1877       Fn = CU.getFilename();
1878       Dir = CU.getDirectory();
1879     } else if (Scope.isFile()) {
1880       DIFile F(S);
1881       Fn = F.getFilename();
1882       Dir = F.getDirectory();
1883     } else if (Scope.isSubprogram()) {
1884       DISubprogram SP(S);
1885       Fn = SP.getFilename();
1886       Dir = SP.getDirectory();
1887     } else if (Scope.isLexicalBlockFile()) {
1888       DILexicalBlockFile DBF(S);
1889       Fn = DBF.getFilename();
1890       Dir = DBF.getDirectory();
1891     } else if (Scope.isLexicalBlock()) {
1892       DILexicalBlock DB(S);
1893       Fn = DB.getFilename();
1894       Dir = DB.getDirectory();
1895     } else
1896       llvm_unreachable("Unexpected scope info");
1897
1898     Src = getOrCreateSourceID(Fn, Dir,
1899             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1900   }
1901   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1902 }
1903
1904 //===----------------------------------------------------------------------===//
1905 // Emit Methods
1906 //===----------------------------------------------------------------------===//
1907
1908 // Compute the size and offset of a DIE.
1909 unsigned
1910 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1911   // Get the children.
1912   const std::vector<DIE *> &Children = Die->getChildren();
1913
1914   // Record the abbreviation.
1915   assignAbbrevNumber(Die->getAbbrev());
1916
1917   // Get the abbreviation for this DIE.
1918   unsigned AbbrevNumber = Die->getAbbrevNumber();
1919   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1920
1921   // Set DIE offset
1922   Die->setOffset(Offset);
1923
1924   // Start the size with the size of abbreviation code.
1925   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1926
1927   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1928   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1929
1930   // Size the DIE attribute values.
1931   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1932     // Size attribute value.
1933     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1934
1935   // Size the DIE children if any.
1936   if (!Children.empty()) {
1937     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1938            "Children flag not set");
1939
1940     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1941       Offset = computeSizeAndOffset(Children[j], Offset);
1942
1943     // End of children marker.
1944     Offset += sizeof(int8_t);
1945   }
1946
1947   Die->setSize(Offset - Die->getOffset());
1948   return Offset;
1949 }
1950
1951 // Compute the size and offset of all the DIEs.
1952 void DwarfUnits::computeSizeAndOffsets() {
1953   // Offset from the beginning of debug info section.
1954   unsigned SecOffset = 0;
1955   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1956          E = CUs.end(); I != E; ++I) {
1957     (*I)->setDebugInfoOffset(SecOffset);
1958     unsigned Offset =
1959       sizeof(int32_t) + // Length of Compilation Unit Info
1960       sizeof(int16_t) + // DWARF version number
1961       sizeof(int32_t) + // Offset Into Abbrev. Section
1962       sizeof(int8_t);   // Pointer Size (in bytes)
1963
1964     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1965     SecOffset += EndOffset;
1966   }
1967 }
1968
1969 // Emit initial Dwarf sections with a label at the start of each one.
1970 void DwarfDebug::emitSectionLabels() {
1971   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1972
1973   // Dwarf sections base addresses.
1974   DwarfInfoSectionSym =
1975     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1976   DwarfAbbrevSectionSym =
1977     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1978   if (useSplitDwarf())
1979     DwarfAbbrevDWOSectionSym =
1980       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1981                      "section_abbrev_dwo");
1982   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1983
1984   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1985     emitSectionSym(Asm, MacroInfo);
1986
1987   DwarfLineSectionSym =
1988     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1989   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1990   if (GenerateGnuPubSections) {
1991     DwarfGnuPubNamesSectionSym =
1992         emitSectionSym(Asm, TLOF.getDwarfGnuPubNamesSection());
1993     DwarfGnuPubTypesSectionSym =
1994         emitSectionSym(Asm, TLOF.getDwarfGnuPubTypesSection());
1995   } else if (HasDwarfPubSections) {
1996     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1997     emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1998   }
1999
2000   DwarfStrSectionSym =
2001     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2002   if (useSplitDwarf()) {
2003     DwarfStrDWOSectionSym =
2004       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2005     DwarfAddrSectionSym =
2006       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2007   }
2008   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2009                                              "debug_range");
2010
2011   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2012                                            "section_debug_loc");
2013
2014   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2015   emitSectionSym(Asm, TLOF.getDataSection());
2016 }
2017
2018 // Recursively emits a debug information entry.
2019 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2020   // Get the abbreviation for this DIE.
2021   unsigned AbbrevNumber = Die->getAbbrevNumber();
2022   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2023
2024   // Emit the code (index) for the abbreviation.
2025   if (Asm->isVerbose())
2026     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2027                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2028                                 Twine::utohexstr(Die->getSize()) + " " +
2029                                 dwarf::TagString(Abbrev->getTag()));
2030   Asm->EmitULEB128(AbbrevNumber);
2031
2032   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2033   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2034
2035   // Emit the DIE attribute values.
2036   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2037     unsigned Attr = AbbrevData[i].getAttribute();
2038     unsigned Form = AbbrevData[i].getForm();
2039     assert(Form && "Too many attributes for DIE (check abbreviation)");
2040
2041     if (Asm->isVerbose())
2042       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2043
2044     switch (Attr) {
2045     case dwarf::DW_AT_abstract_origin: {
2046       DIEEntry *E = cast<DIEEntry>(Values[i]);
2047       DIE *Origin = E->getEntry();
2048       unsigned Addr = Origin->getOffset();
2049       if (Form == dwarf::DW_FORM_ref_addr) {
2050         // For DW_FORM_ref_addr, output the offset from beginning of debug info
2051         // section. Origin->getOffset() returns the offset from start of the
2052         // compile unit.
2053         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2054         Addr += Holder.getCUOffset(Origin->getCompileUnit());
2055       }
2056       Asm->OutStreamer.EmitIntValue(Addr,
2057           Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2058       break;
2059     }
2060     case dwarf::DW_AT_ranges: {
2061       // DW_AT_range Value encodes offset in debug_range section.
2062       DIEInteger *V = cast<DIEInteger>(Values[i]);
2063
2064       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2065         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2066                                  V->getValue(),
2067                                  4);
2068       } else {
2069         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2070                                        V->getValue(),
2071                                        DwarfDebugRangeSectionSym,
2072                                        4);
2073       }
2074       break;
2075     }
2076     case dwarf::DW_AT_location: {
2077       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2078         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2079           Asm->EmitLabelReference(L->getValue(), 4);
2080         else
2081           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2082       } else {
2083         Values[i]->EmitValue(Asm, Form);
2084       }
2085       break;
2086     }
2087     case dwarf::DW_AT_accessibility: {
2088       if (Asm->isVerbose()) {
2089         DIEInteger *V = cast<DIEInteger>(Values[i]);
2090         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2091       }
2092       Values[i]->EmitValue(Asm, Form);
2093       break;
2094     }
2095     default:
2096       // Emit an attribute using the defined form.
2097       Values[i]->EmitValue(Asm, Form);
2098       break;
2099     }
2100   }
2101
2102   // Emit the DIE children if any.
2103   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2104     const std::vector<DIE *> &Children = Die->getChildren();
2105
2106     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2107       emitDIE(Children[j], Abbrevs);
2108
2109     if (Asm->isVerbose())
2110       Asm->OutStreamer.AddComment("End Of Children Mark");
2111     Asm->EmitInt8(0);
2112   }
2113 }
2114
2115 // Emit the various dwarf units to the unit section USection with
2116 // the abbreviations going into ASection.
2117 void DwarfUnits::emitUnits(DwarfDebug *DD,
2118                            const MCSection *USection,
2119                            const MCSection *ASection,
2120                            const MCSymbol *ASectionSym) {
2121   Asm->OutStreamer.SwitchSection(USection);
2122   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2123          E = CUs.end(); I != E; ++I) {
2124     CompileUnit *TheCU = *I;
2125     DIE *Die = TheCU->getCUDie();
2126
2127     // Emit the compile units header.
2128     Asm->OutStreamer
2129       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2130                                     TheCU->getUniqueID()));
2131
2132     // Emit size of content not including length itself
2133     unsigned ContentSize = Die->getSize() +
2134       sizeof(int16_t) + // DWARF version number
2135       sizeof(int32_t) + // Offset Into Abbrev. Section
2136       sizeof(int8_t);   // Pointer Size (in bytes)
2137
2138     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2139     Asm->EmitInt32(ContentSize);
2140     Asm->OutStreamer.AddComment("DWARF version number");
2141     Asm->EmitInt16(DD->getDwarfVersion());
2142     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2143     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2144                            ASectionSym);
2145     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2146     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2147
2148     DD->emitDIE(Die, Abbreviations);
2149     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2150                                                   TheCU->getUniqueID()));
2151   }
2152 }
2153
2154 /// For a given compile unit DIE, returns offset from beginning of debug info.
2155 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2156   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
2157          "Input DIE should be compile unit in getCUOffset.");
2158   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(), E = CUs.end();
2159        I != E; ++I) {
2160     CompileUnit *TheCU = *I;
2161     if (TheCU->getCUDie() == Die)
2162       return TheCU->getDebugInfoOffset();
2163   }
2164   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2165 }
2166
2167 // Emit the debug info section.
2168 void DwarfDebug::emitDebugInfo() {
2169   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2170
2171   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2172                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2173                    DwarfAbbrevSectionSym);
2174 }
2175
2176 // Emit the abbreviation section.
2177 void DwarfDebug::emitAbbreviations() {
2178   if (!useSplitDwarf())
2179     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2180                 &Abbreviations);
2181   else
2182     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2183 }
2184
2185 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2186                              std::vector<DIEAbbrev *> *Abbrevs) {
2187   // Check to see if it is worth the effort.
2188   if (!Abbrevs->empty()) {
2189     // Start the debug abbrev section.
2190     Asm->OutStreamer.SwitchSection(Section);
2191
2192     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2193     Asm->OutStreamer.EmitLabel(Begin);
2194
2195     // For each abbrevation.
2196     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2197       // Get abbreviation data
2198       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2199
2200       // Emit the abbrevations code (base 1 index.)
2201       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2202
2203       // Emit the abbreviations data.
2204       Abbrev->Emit(Asm);
2205     }
2206
2207     // Mark end of abbreviations.
2208     Asm->EmitULEB128(0, "EOM(3)");
2209
2210     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2211     Asm->OutStreamer.EmitLabel(End);
2212   }
2213 }
2214
2215 // Emit the last address of the section and the end of the line matrix.
2216 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2217   // Define last address of section.
2218   Asm->OutStreamer.AddComment("Extended Op");
2219   Asm->EmitInt8(0);
2220
2221   Asm->OutStreamer.AddComment("Op size");
2222   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2223   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2224   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2225
2226   Asm->OutStreamer.AddComment("Section end label");
2227
2228   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2229                                    Asm->getDataLayout().getPointerSize());
2230
2231   // Mark end of matrix.
2232   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2233   Asm->EmitInt8(0);
2234   Asm->EmitInt8(1);
2235   Asm->EmitInt8(1);
2236 }
2237
2238 // Emit visible names into a hashed accelerator table section.
2239 void DwarfDebug::emitAccelNames() {
2240   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2241                                            dwarf::DW_FORM_data4));
2242   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2243          E = CUMap.end(); I != E; ++I) {
2244     CompileUnit *TheCU = I->second;
2245     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2246     for (StringMap<std::vector<DIE*> >::const_iterator
2247            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2248       StringRef Name = GI->getKey();
2249       const std::vector<DIE *> &Entities = GI->second;
2250       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2251              DE = Entities.end(); DI != DE; ++DI)
2252         AT.AddName(Name, (*DI));
2253     }
2254   }
2255
2256   AT.FinalizeTable(Asm, "Names");
2257   Asm->OutStreamer.SwitchSection(
2258     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2259   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2260   Asm->OutStreamer.EmitLabel(SectionBegin);
2261
2262   // Emit the full data.
2263   AT.Emit(Asm, SectionBegin, &InfoHolder);
2264 }
2265
2266 // Emit objective C classes and categories into a hashed accelerator table
2267 // section.
2268 void DwarfDebug::emitAccelObjC() {
2269   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2270                                            dwarf::DW_FORM_data4));
2271   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2272          E = CUMap.end(); I != E; ++I) {
2273     CompileUnit *TheCU = I->second;
2274     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2275     for (StringMap<std::vector<DIE*> >::const_iterator
2276            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2277       StringRef Name = GI->getKey();
2278       const std::vector<DIE *> &Entities = GI->second;
2279       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2280              DE = Entities.end(); DI != DE; ++DI)
2281         AT.AddName(Name, (*DI));
2282     }
2283   }
2284
2285   AT.FinalizeTable(Asm, "ObjC");
2286   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2287                                  .getDwarfAccelObjCSection());
2288   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2289   Asm->OutStreamer.EmitLabel(SectionBegin);
2290
2291   // Emit the full data.
2292   AT.Emit(Asm, SectionBegin, &InfoHolder);
2293 }
2294
2295 // Emit namespace dies into a hashed accelerator table.
2296 void DwarfDebug::emitAccelNamespaces() {
2297   DwarfAccelTable AT(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2298                                            dwarf::DW_FORM_data4));
2299   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2300          E = CUMap.end(); I != E; ++I) {
2301     CompileUnit *TheCU = I->second;
2302     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2303     for (StringMap<std::vector<DIE*> >::const_iterator
2304            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2305       StringRef Name = GI->getKey();
2306       const std::vector<DIE *> &Entities = GI->second;
2307       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2308              DE = Entities.end(); DI != DE; ++DI)
2309         AT.AddName(Name, (*DI));
2310     }
2311   }
2312
2313   AT.FinalizeTable(Asm, "namespac");
2314   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2315                                  .getDwarfAccelNamespaceSection());
2316   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2317   Asm->OutStreamer.EmitLabel(SectionBegin);
2318
2319   // Emit the full data.
2320   AT.Emit(Asm, SectionBegin, &InfoHolder);
2321 }
2322
2323 // Emit type dies into a hashed accelerator table.
2324 void DwarfDebug::emitAccelTypes() {
2325   std::vector<DwarfAccelTable::Atom> Atoms;
2326   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_offset,
2327                                         dwarf::DW_FORM_data4));
2328   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_die_tag,
2329                                         dwarf::DW_FORM_data2));
2330   Atoms.push_back(DwarfAccelTable::Atom(dwarf::DW_ATOM_type_flags,
2331                                         dwarf::DW_FORM_data1));
2332   DwarfAccelTable AT(Atoms);
2333   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2334          E = CUMap.end(); I != E; ++I) {
2335     CompileUnit *TheCU = I->second;
2336     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2337       = TheCU->getAccelTypes();
2338     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2339            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2340       StringRef Name = GI->getKey();
2341       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2342       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2343              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2344         AT.AddName(Name, (*DI).first, (*DI).second);
2345     }
2346   }
2347
2348   AT.FinalizeTable(Asm, "types");
2349   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2350                                  .getDwarfAccelTypesSection());
2351   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2352   Asm->OutStreamer.EmitLabel(SectionBegin);
2353
2354   // Emit the full data.
2355   AT.Emit(Asm, SectionBegin, &InfoHolder);
2356 }
2357
2358 // Public name handling.
2359 // The format for the various pubnames:
2360 //
2361 // dwarf pubnames - offset/name pairs where the offset is the offset into the CU
2362 // for the DIE that is named.
2363 //
2364 // gnu pubnames - offset/index value/name tuples where the offset is the offset
2365 // into the CU and the index value is computed according to the type of value
2366 // for the DIE that is named.
2367 //
2368 // For type units the offset is the offset of the skeleton DIE. For split dwarf
2369 // it's the offset within the debug_info/debug_types dwo section, however, the
2370 // reference in the pubname header doesn't change.
2371
2372 /// computeIndexValue - Compute the gdb index value for the DIE and CU.
2373 static dwarf::PubIndexEntryDescriptor computeIndexValue(CompileUnit *CU,
2374                                                         DIE *Die) {
2375   dwarf::GDBIndexEntryLinkage Linkage =
2376       Die->findAttribute(dwarf::DW_AT_external) ? dwarf::GIEL_EXTERNAL
2377                                                 : dwarf::GIEL_STATIC;
2378
2379   switch (Die->getTag()) {
2380   case dwarf::DW_TAG_class_type:
2381   case dwarf::DW_TAG_structure_type:
2382   case dwarf::DW_TAG_union_type:
2383   case dwarf::DW_TAG_enumeration_type:
2384     return dwarf::PubIndexEntryDescriptor(
2385         dwarf::GIEK_TYPE, CU->getLanguage() != dwarf::DW_LANG_C_plus_plus
2386                               ? dwarf::GIEL_STATIC
2387                               : dwarf::GIEL_EXTERNAL);
2388   case dwarf::DW_TAG_typedef:
2389   case dwarf::DW_TAG_base_type:
2390   case dwarf::DW_TAG_subrange_type:
2391     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_TYPE, dwarf::GIEL_STATIC);
2392   case dwarf::DW_TAG_namespace:
2393     return dwarf::GIEK_TYPE;
2394   case dwarf::DW_TAG_subprogram:
2395     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_FUNCTION, Linkage);
2396   case dwarf::DW_TAG_constant:
2397   case dwarf::DW_TAG_variable:
2398     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE, Linkage);
2399   case dwarf::DW_TAG_enumerator:
2400     return dwarf::PubIndexEntryDescriptor(dwarf::GIEK_VARIABLE,
2401                                           dwarf::GIEL_STATIC);
2402   default:
2403     return dwarf::GIEK_NONE;
2404   }
2405 }
2406
2407 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
2408 ///
2409 void DwarfDebug::emitDebugPubNames(bool GnuStyle) {
2410   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2411   const MCSection *PSec =
2412       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubNamesSection()
2413                : Asm->getObjFileLowering().getDwarfPubNamesSection();
2414
2415   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2416   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2417     CompileUnit *TheCU = I->second;
2418     unsigned ID = TheCU->getUniqueID();
2419
2420     if (TheCU->getGlobalNames().empty())
2421       continue;
2422
2423     // Start the dwarf pubnames section.
2424     Asm->OutStreamer.SwitchSection(PSec);
2425
2426     // Emit a label so we can reference the beginning of this pubname section.
2427     if (GnuStyle)
2428       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubnames",
2429                                                     TheCU->getUniqueID()));
2430
2431     // Emit the header.
2432     Asm->OutStreamer.AddComment("Length of Public Names Info");
2433     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2434                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2435
2436     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2437
2438     Asm->OutStreamer.AddComment("DWARF Version");
2439     Asm->EmitInt16(dwarf::DW_PUBNAMES_VERSION);
2440
2441     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2442     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2443                            DwarfInfoSectionSym);
2444
2445     Asm->OutStreamer.AddComment("Compilation Unit Length");
2446     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2447                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2448                              4);
2449
2450     // Emit the pubnames for this compilation unit.
2451     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2452     for (StringMap<DIE*>::const_iterator
2453            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2454       const char *Name = GI->getKeyData();
2455       DIE *Entity = GI->second;
2456
2457       Asm->OutStreamer.AddComment("DIE offset");
2458       Asm->EmitInt32(Entity->getOffset());
2459
2460       if (GnuStyle) {
2461         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2462         Asm->OutStreamer.AddComment(
2463             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2464             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2465         Asm->EmitInt8(Desc.toBits());
2466       }
2467
2468       if (Asm->isVerbose())
2469         Asm->OutStreamer.AddComment("External Name");
2470       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2471     }
2472
2473     Asm->OutStreamer.AddComment("End Mark");
2474     Asm->EmitInt32(0);
2475     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2476   }
2477 }
2478
2479 void DwarfDebug::emitDebugPubTypes(bool GnuStyle) {
2480   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2481   const MCSection *PSec =
2482       GnuStyle ? Asm->getObjFileLowering().getDwarfGnuPubTypesSection()
2483                : Asm->getObjFileLowering().getDwarfPubTypesSection();
2484
2485   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2486                                                          E = CUMap.end();
2487        I != E; ++I) {
2488     CompileUnit *TheCU = I->second;
2489     // Start the dwarf pubtypes section.
2490     Asm->OutStreamer.SwitchSection(PSec);
2491
2492     // Emit a label so we can reference the beginning of this pubtype section.
2493     if (GnuStyle)
2494       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("gnu_pubtypes",
2495                                                     TheCU->getUniqueID()));
2496
2497     // Emit the header.
2498     Asm->OutStreamer.AddComment("Length of Public Types Info");
2499     Asm->EmitLabelDifference(
2500         Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2501         Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2502
2503     Asm->OutStreamer.EmitLabel(
2504         Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()));
2505
2506     if (Asm->isVerbose())
2507       Asm->OutStreamer.AddComment("DWARF Version");
2508     Asm->EmitInt16(dwarf::DW_PUBTYPES_VERSION);
2509
2510     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2511     Asm->EmitSectionOffset(
2512         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()),
2513         DwarfInfoSectionSym);
2514
2515     Asm->OutStreamer.AddComment("Compilation Unit Length");
2516     Asm->EmitLabelDifference(
2517         Asm->GetTempSymbol(ISec->getLabelEndName(), TheCU->getUniqueID()),
2518         Asm->GetTempSymbol(ISec->getLabelBeginName(), TheCU->getUniqueID()), 4);
2519
2520     // Emit the pubtypes.
2521     const StringMap<DIE *> &Globals = TheCU->getGlobalTypes();
2522     for (StringMap<DIE *>::const_iterator GI = Globals.begin(),
2523                                           GE = Globals.end();
2524          GI != GE; ++GI) {
2525       const char *Name = GI->getKeyData();
2526       DIE *Entity = GI->second;
2527
2528       if (Asm->isVerbose())
2529         Asm->OutStreamer.AddComment("DIE offset");
2530       Asm->EmitInt32(Entity->getOffset());
2531
2532       if (GnuStyle) {
2533         dwarf::PubIndexEntryDescriptor Desc = computeIndexValue(TheCU, Entity);
2534         Asm->OutStreamer.AddComment(
2535             Twine("Kind: ") + dwarf::GDBIndexEntryKindString(Desc.Kind) + ", " +
2536             dwarf::GDBIndexEntryLinkageString(Desc.Linkage));
2537         Asm->EmitInt8(Desc.toBits());
2538       }
2539
2540       if (Asm->isVerbose())
2541         Asm->OutStreamer.AddComment("External Name");
2542
2543       // Emit the name with a terminating null byte.
2544       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength() + 1));
2545     }
2546
2547     Asm->OutStreamer.AddComment("End Mark");
2548     Asm->EmitInt32(0);
2549     Asm->OutStreamer.EmitLabel(
2550         Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()));
2551   }
2552 }
2553
2554 // Emit strings into a string section.
2555 void DwarfUnits::emitStrings(const MCSection *StrSection,
2556                              const MCSection *OffsetSection = NULL,
2557                              const MCSymbol *StrSecSym = NULL) {
2558
2559   if (StringPool.empty()) return;
2560
2561   // Start the dwarf str section.
2562   Asm->OutStreamer.SwitchSection(StrSection);
2563
2564   // Get all of the string pool entries and put them in an array by their ID so
2565   // we can sort them.
2566   SmallVector<std::pair<unsigned,
2567                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2568
2569   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2570          I = StringPool.begin(), E = StringPool.end();
2571        I != E; ++I)
2572     Entries.push_back(std::make_pair(I->second.second, &*I));
2573
2574   array_pod_sort(Entries.begin(), Entries.end());
2575
2576   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2577     // Emit a label for reference from debug information entries.
2578     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2579
2580     // Emit the string itself with a terminating null byte.
2581     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2582                                          Entries[i].second->getKeyLength()+1));
2583   }
2584
2585   // If we've got an offset section go ahead and emit that now as well.
2586   if (OffsetSection) {
2587     Asm->OutStreamer.SwitchSection(OffsetSection);
2588     unsigned offset = 0;
2589     unsigned size = 4; // FIXME: DWARF64 is 8.
2590     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2591       Asm->OutStreamer.EmitIntValue(offset, size);
2592       offset += Entries[i].second->getKeyLength() + 1;
2593     }
2594   }
2595 }
2596
2597 // Emit strings into a string section.
2598 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2599
2600   if (AddressPool.empty()) return;
2601
2602   // Start the dwarf addr section.
2603   Asm->OutStreamer.SwitchSection(AddrSection);
2604
2605   // Order the address pool entries by ID
2606   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2607
2608   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2609                                                     E = AddressPool.end();
2610        I != E; ++I)
2611     Entries[I->second] = I->first;
2612
2613   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2614     // Emit an expression for reference from debug information entries.
2615     if (const MCExpr *Expr = Entries[i])
2616       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2617     else
2618       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2619   }
2620
2621 }
2622
2623 // Emit visible names into a debug str section.
2624 void DwarfDebug::emitDebugStr() {
2625   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2626   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2627 }
2628
2629 // Emit locations into the debug loc section.
2630 void DwarfDebug::emitDebugLoc() {
2631   if (DotDebugLocEntries.empty())
2632     return;
2633
2634   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2635          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2636        I != E; ++I) {
2637     DotDebugLocEntry &Entry = *I;
2638     if (I + 1 != DotDebugLocEntries.end())
2639       Entry.Merge(I+1);
2640   }
2641
2642   // Start the dwarf loc section.
2643   Asm->OutStreamer.SwitchSection(
2644     Asm->getObjFileLowering().getDwarfLocSection());
2645   unsigned char Size = Asm->getDataLayout().getPointerSize();
2646   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2647   unsigned index = 1;
2648   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2649          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2650        I != E; ++I, ++index) {
2651     DotDebugLocEntry &Entry = *I;
2652     if (Entry.isMerged()) continue;
2653     if (Entry.isEmpty()) {
2654       Asm->OutStreamer.EmitIntValue(0, Size);
2655       Asm->OutStreamer.EmitIntValue(0, Size);
2656       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2657     } else {
2658       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2659       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2660       DIVariable DV(Entry.getVariable());
2661       Asm->OutStreamer.AddComment("Loc expr size");
2662       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2663       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2664       Asm->EmitLabelDifference(end, begin, 2);
2665       Asm->OutStreamer.EmitLabel(begin);
2666       if (Entry.isInt()) {
2667         DIBasicType BTy(DV.getType());
2668         if (BTy.Verify() &&
2669             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2670              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2671           Asm->OutStreamer.AddComment("DW_OP_consts");
2672           Asm->EmitInt8(dwarf::DW_OP_consts);
2673           Asm->EmitSLEB128(Entry.getInt());
2674         } else {
2675           Asm->OutStreamer.AddComment("DW_OP_constu");
2676           Asm->EmitInt8(dwarf::DW_OP_constu);
2677           Asm->EmitULEB128(Entry.getInt());
2678         }
2679       } else if (Entry.isLocation()) {
2680         MachineLocation Loc = Entry.getLoc();
2681         if (!DV.hasComplexAddress())
2682           // Regular entry.
2683           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2684         else {
2685           // Complex address entry.
2686           unsigned N = DV.getNumAddrElements();
2687           unsigned i = 0;
2688           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2689             if (Loc.getOffset()) {
2690               i = 2;
2691               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2692               Asm->OutStreamer.AddComment("DW_OP_deref");
2693               Asm->EmitInt8(dwarf::DW_OP_deref);
2694               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2695               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2696               Asm->EmitSLEB128(DV.getAddrElement(1));
2697             } else {
2698               // If first address element is OpPlus then emit
2699               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2700               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2701               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2702               i = 2;
2703             }
2704           } else {
2705             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2706           }
2707
2708           // Emit remaining complex address elements.
2709           for (; i < N; ++i) {
2710             uint64_t Element = DV.getAddrElement(i);
2711             if (Element == DIBuilder::OpPlus) {
2712               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2713               Asm->EmitULEB128(DV.getAddrElement(++i));
2714             } else if (Element == DIBuilder::OpDeref) {
2715               if (!Loc.isReg())
2716                 Asm->EmitInt8(dwarf::DW_OP_deref);
2717             } else
2718               llvm_unreachable("unknown Opcode found in complex address");
2719           }
2720         }
2721       }
2722       // else ... ignore constant fp. There is not any good way to
2723       // to represent them here in dwarf.
2724       Asm->OutStreamer.EmitLabel(end);
2725     }
2726   }
2727 }
2728
2729 struct SymbolCUSorter {
2730   SymbolCUSorter(const MCStreamer &s) : Streamer(s) {}
2731   const MCStreamer &Streamer;
2732
2733   bool operator() (const SymbolCU &A, const SymbolCU &B) {
2734     unsigned IA = A.Sym ? Streamer.GetSymbolOrder(A.Sym) : 0;
2735     unsigned IB = B.Sym ? Streamer.GetSymbolOrder(B.Sym) : 0;
2736
2737     // Symbols with no order assigned should be placed at the end.
2738     // (e.g. section end labels)
2739     if (IA == 0)
2740       IA = (unsigned)(-1);
2741     if (IB == 0)
2742       IB = (unsigned)(-1);
2743     return IA < IB;
2744   }
2745 };
2746
2747 static bool SectionSort(const MCSection *A, const MCSection *B) {
2748     std::string LA = (A ? A->getLabelBeginName() : "");
2749     std::string LB = (B ? B->getLabelBeginName() : "");
2750     return LA < LB;
2751 }
2752
2753 static bool CUSort(const CompileUnit *A, const CompileUnit *B) {
2754     return (A->getUniqueID() < B->getUniqueID());
2755 }
2756
2757 struct ArangeSpan {
2758   const MCSymbol *Start, *End;
2759 };
2760
2761 // Emit a debug aranges section, containing a CU lookup for any
2762 // address we can tie back to a CU.
2763 void DwarfDebug::emitDebugARanges() {
2764   // Start the dwarf aranges section.
2765   Asm->OutStreamer
2766       .SwitchSection(Asm->getObjFileLowering().getDwarfARangesSection());
2767
2768   typedef DenseMap<CompileUnit *, std::vector<ArangeSpan> > SpansType;
2769
2770   SpansType Spans;
2771
2772   // Build a list of sections used.
2773   std::vector<const MCSection *> Sections;
2774   for (SectionMapType::iterator it = SectionMap.begin(); it != SectionMap.end();
2775        it++) {
2776     const MCSection *Section = it->first;
2777     Sections.push_back(Section);
2778   }
2779
2780   // Sort the sections into order.
2781   // This is only done to ensure consistent output order across different runs.
2782   std::sort(Sections.begin(), Sections.end(), SectionSort);
2783
2784   // Build a set of address spans, sorted by CU.
2785   for (size_t SecIdx=0;SecIdx<Sections.size();SecIdx++) {
2786     const MCSection *Section = Sections[SecIdx];
2787     SmallVector<SymbolCU, 8> &List = SectionMap[Section];
2788     if (List.size() < 2)
2789       continue;
2790
2791     // Sort the symbols by offset within the section.
2792     SymbolCUSorter sorter(Asm->OutStreamer);
2793     std::sort(List.begin(), List.end(), sorter);
2794
2795     // If we have no section (e.g. common), just write out
2796     // individual spans for each symbol.
2797     if (Section == NULL) {
2798       for (size_t n = 0; n < List.size(); n++) {
2799         const SymbolCU &Cur = List[n];
2800
2801         ArangeSpan Span;
2802         Span.Start = Cur.Sym;
2803         Span.End = NULL;
2804         if (Cur.CU)
2805           Spans[Cur.CU].push_back(Span);
2806       }
2807     } else {
2808       // Build spans between each label.
2809       const MCSymbol *StartSym = List[0].Sym;
2810       for (size_t n = 1; n < List.size(); n++) {
2811         const SymbolCU &Prev = List[n - 1];
2812         const SymbolCU &Cur = List[n];
2813
2814         // Try and build the longest span we can within the same CU.
2815         if (Cur.CU != Prev.CU) {
2816           ArangeSpan Span;
2817           Span.Start = StartSym;
2818           Span.End = Cur.Sym;
2819           Spans[Prev.CU].push_back(Span);
2820           StartSym = Cur.Sym;
2821         }
2822       }
2823     }
2824   }
2825
2826   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2827   unsigned PtrSize = Asm->getDataLayout().getPointerSize();
2828
2829   // Build a list of CUs used.
2830   std::vector<CompileUnit *> CUs;
2831   for (SpansType::iterator it = Spans.begin(); it != Spans.end(); it++) {
2832     CompileUnit *CU = it->first;
2833     CUs.push_back(CU);
2834   }
2835
2836   // Sort the CU list (again, to ensure consistent output order).
2837   std::sort(CUs.begin(), CUs.end(), CUSort);
2838
2839   // Emit an arange table for each CU we used.
2840   for (size_t CUIdx=0;CUIdx<CUs.size();CUIdx++) {
2841     CompileUnit *CU = CUs[CUIdx];
2842     std::vector<ArangeSpan> &List = Spans[CU];
2843
2844     // Emit size of content not including length itself.
2845     unsigned ContentSize
2846         = sizeof(int16_t) // DWARF ARange version number
2847         + sizeof(int32_t) // Offset of CU in the .debug_info section
2848         + sizeof(int8_t)  // Pointer Size (in bytes)
2849         + sizeof(int8_t); // Segment Size (in bytes)
2850
2851     unsigned TupleSize = PtrSize * 2;
2852
2853     // 7.20 in the Dwarf specs requires the table to be aligned to a tuple.
2854     unsigned Padding = 0;
2855     while (((sizeof(int32_t) + ContentSize + Padding) % TupleSize) != 0)
2856       Padding++;
2857
2858     ContentSize += Padding;
2859     ContentSize += (List.size() + 1) * TupleSize;
2860
2861     // For each compile unit, write the list of spans it covers.
2862     Asm->OutStreamer.AddComment("Length of ARange Set");
2863     Asm->EmitInt32(ContentSize);
2864     Asm->OutStreamer.AddComment("DWARF Arange version number");
2865     Asm->EmitInt16(dwarf::DW_ARANGES_VERSION);
2866     Asm->OutStreamer.AddComment("Offset Into Debug Info Section");
2867     Asm->EmitSectionOffset(
2868         Asm->GetTempSymbol(ISec->getLabelBeginName(), CU->getUniqueID()),
2869         DwarfInfoSectionSym);
2870     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2871     Asm->EmitInt8(PtrSize);
2872     Asm->OutStreamer.AddComment("Segment Size (in bytes)");
2873     Asm->EmitInt8(0);
2874
2875     for (unsigned n = 0; n < Padding; n++)
2876       Asm->EmitInt8(0xff);
2877
2878     for (unsigned n = 0; n < List.size(); n++) {
2879       const ArangeSpan &Span = List[n];
2880       Asm->EmitLabelReference(Span.Start, PtrSize);
2881
2882       // Calculate the size as being from the span start to it's end.
2883       if (Span.End) {
2884         Asm->EmitLabelDifference(Span.End, Span.Start, PtrSize);
2885       } else {
2886         // For symbols without an end marker (e.g. common), we
2887         // write a single arange entry containing just that one symbol.
2888         uint64_t Size = SymSize[Span.Start];
2889         if (Size == 0)
2890           Size = 1;
2891
2892         Asm->OutStreamer.EmitIntValue(Size, PtrSize);
2893       }
2894     }
2895
2896     Asm->OutStreamer.AddComment("ARange terminator");
2897     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2898     Asm->OutStreamer.EmitIntValue(0, PtrSize);
2899   }
2900 }
2901
2902 // Emit visible names into a debug ranges section.
2903 void DwarfDebug::emitDebugRanges() {
2904   // Start the dwarf ranges section.
2905   Asm->OutStreamer
2906       .SwitchSection(Asm->getObjFileLowering().getDwarfRangesSection());
2907   unsigned char Size = Asm->getDataLayout().getPointerSize();
2908   for (SmallVectorImpl<const MCSymbol *>::iterator
2909          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2910        I != E; ++I) {
2911     if (*I)
2912       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2913     else
2914       Asm->OutStreamer.EmitIntValue(0, Size);
2915   }
2916 }
2917
2918 // Emit visible names into a debug macinfo section.
2919 void DwarfDebug::emitDebugMacInfo() {
2920   if (const MCSection *LineInfo =
2921       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2922     // Start the dwarf macinfo section.
2923     Asm->OutStreamer.SwitchSection(LineInfo);
2924   }
2925 }
2926
2927 // DWARF5 Experimental Separate Dwarf emitters.
2928
2929 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2930 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2931 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2932 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2933 CompileUnit *DwarfDebug::constructSkeletonCU(const CompileUnit *CU) {
2934
2935   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2936   CompileUnit *NewCU = new CompileUnit(CU->getUniqueID(), Die, CU->getNode(),
2937                                        Asm, this, &SkeletonHolder);
2938
2939   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2940                         DICompileUnit(CU->getNode()).getSplitDebugFilename());
2941
2942   // Relocate to the beginning of the addr_base section, else 0 for the
2943   // beginning of the one for this compile unit.
2944   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2945     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2946                     DwarfAddrSectionSym);
2947   else
2948     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2949                    dwarf::DW_FORM_sec_offset, 0);
2950
2951   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2952   // into an entity. We're using 0, or a NULL label for this.
2953   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2954
2955   // DW_AT_stmt_list is a offset of line number information for this
2956   // compile unit in debug_line section.
2957   // FIXME: Should handle multiple compile units.
2958   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2959     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2960                     DwarfLineSectionSym);
2961   else
2962     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2963
2964   if (!CompilationDir.empty())
2965     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2966
2967   // Flag to let the linker know we have emitted new style pubnames.
2968   if (GenerateGnuPubSections) {
2969     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2970       NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_sec_offset,
2971                       Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()));
2972     else
2973       NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubnames, dwarf::DW_FORM_data4,
2974                       Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2975                       DwarfGnuPubNamesSectionSym);
2976
2977     if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2978       NewCU->addLabel(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_sec_offset,
2979                       Asm->GetTempSymbol("gnu_pubtypes", NewCU->getUniqueID()));
2980     else
2981       NewCU->addDelta(Die, dwarf::DW_AT_GNU_pubtypes, dwarf::DW_FORM_data4,
2982                       Asm->GetTempSymbol("gnu_pubnames", NewCU->getUniqueID()),
2983                       DwarfGnuPubTypesSectionSym);
2984   }
2985
2986   SkeletonHolder.addUnit(NewCU);
2987   SkeletonCUs.push_back(NewCU);
2988
2989   return NewCU;
2990 }
2991
2992 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2993   assert(useSplitDwarf() && "No split dwarf debug info?");
2994   emitAbbrevs(Section, &SkeletonAbbrevs);
2995 }
2996
2997 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2998 // compile units that would normally be in debug_info.
2999 void DwarfDebug::emitDebugInfoDWO() {
3000   assert(useSplitDwarf() && "No split dwarf debug info?");
3001   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
3002                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3003                        DwarfAbbrevDWOSectionSym);
3004 }
3005
3006 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
3007 // abbreviations for the .debug_info.dwo section.
3008 void DwarfDebug::emitDebugAbbrevDWO() {
3009   assert(useSplitDwarf() && "No split dwarf?");
3010   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
3011               &Abbreviations);
3012 }
3013
3014 // Emit the .debug_str.dwo section for separated dwarf. This contains the
3015 // string section and is identical in format to traditional .debug_str
3016 // sections.
3017 void DwarfDebug::emitDebugStrDWO() {
3018   assert(useSplitDwarf() && "No split dwarf?");
3019   const MCSection *OffSec = Asm->getObjFileLowering()
3020                             .getDwarfStrOffDWOSection();
3021   const MCSymbol *StrSym = DwarfStrSectionSym;
3022   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
3023                          OffSec, StrSym);
3024 }