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