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