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