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