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 = new DbgVariable(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   uint64_t Signature;
1063   memcpy(&Signature, &Result[8], 8);
1064
1065   // FIXME: This should be added onto the type unit, not the type, but this
1066   // works as an intermediate stage.
1067   CU->addUInt(Die, dwarf::DW_AT_GNU_odr_signature, dwarf::DW_FORM_data8,
1068               Signature);
1069 }
1070
1071 /// Return true if the current DIE is contained within an anonymous namespace.
1072 static bool isContainedInAnonNamespace(DIE *Die) {
1073   DIE *Parent = Die->getParent();
1074
1075   while (Parent) {
1076     if (Die->getTag() == dwarf::DW_TAG_namespace &&
1077         getDIEStringAttr(Die, dwarf::DW_AT_name) == "")
1078       return true;
1079     Parent = Parent->getParent();
1080   }
1081
1082   return false;
1083 }
1084
1085 void DwarfDebug::finalizeModuleInfo() {
1086   // Collect info for variables that were optimized out.
1087   collectDeadVariables();
1088
1089   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
1090   computeInlinedDIEs();
1091
1092   // Emit DW_AT_containing_type attribute to connect types with their
1093   // vtable holding type.
1094   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
1095          CUE = CUMap.end(); CUI != CUE; ++CUI) {
1096     CompileUnit *TheCU = CUI->second;
1097     TheCU->constructContainingTypeDIEs();
1098   }
1099
1100   // For types that we'd like to move to type units or ODR check go ahead
1101   // and either move the types out or add the ODR attribute now.
1102   // FIXME: Do type splitting.
1103   for (unsigned i = 0, e = TypeUnits.size(); i != e; ++i) {
1104     MD5 Hash;
1105     DIE *Die = TypeUnits[i];
1106     // If we're in C++ and we want to generate the hash then go ahead and do
1107     // that now.
1108     if (GenerateODRHash &&
1109         CUMap.begin()->second->getLanguage() == dwarf::DW_LANG_C_plus_plus &&
1110         !isContainedInAnonNamespace(Die))
1111       addDIEODRSignature(Hash, CUMap.begin()->second, Die);
1112   }
1113
1114    // Compute DIE offsets and sizes.
1115   InfoHolder.computeSizeAndOffsets();
1116   if (useSplitDwarf())
1117     SkeletonHolder.computeSizeAndOffsets();
1118 }
1119
1120 void DwarfDebug::endSections() {
1121   // Standard sections final addresses.
1122   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
1123   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
1124   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
1125   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
1126
1127   // End text sections.
1128   for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
1129     Asm->OutStreamer.SwitchSection(SectionMap[I]);
1130     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
1131   }
1132 }
1133
1134 // Emit all Dwarf sections that should come after the content.
1135 void DwarfDebug::endModule() {
1136
1137   if (!FirstCU) return;
1138
1139   // End any existing sections.
1140   // TODO: Does this need to happen?
1141   endSections();
1142
1143   // Finalize the debug info for the module.
1144   finalizeModuleInfo();
1145
1146   if (!useSplitDwarf()) {
1147     // Emit all the DIEs into a debug info section.
1148     emitDebugInfo();
1149
1150     // Corresponding abbreviations into a abbrev section.
1151     emitAbbreviations();
1152
1153     // Emit info into a debug loc section.
1154     emitDebugLoc();
1155
1156     // Emit info into a debug aranges section.
1157     emitDebugARanges();
1158
1159     // Emit info into a debug ranges section.
1160     emitDebugRanges();
1161
1162     // Emit info into a debug macinfo section.
1163     emitDebugMacInfo();
1164
1165     // Emit inline info.
1166     // TODO: When we don't need the option anymore we
1167     // can remove all of the code that this section
1168     // depends upon.
1169     if (useDarwinGDBCompat())
1170       emitDebugInlineInfo();
1171   } else {
1172     // TODO: Fill this in for separated debug sections and separate
1173     // out information into new sections.
1174
1175     // Emit the debug info section and compile units.
1176     emitDebugInfo();
1177     emitDebugInfoDWO();
1178
1179     // Corresponding abbreviations into a abbrev section.
1180     emitAbbreviations();
1181     emitDebugAbbrevDWO();
1182
1183     // Emit info into a debug loc section.
1184     emitDebugLoc();
1185
1186     // Emit info into a debug aranges section.
1187     emitDebugARanges();
1188
1189     // Emit info into a debug ranges section.
1190     emitDebugRanges();
1191
1192     // Emit info into a debug macinfo section.
1193     emitDebugMacInfo();
1194
1195     // Emit DWO addresses.
1196     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
1197
1198     // Emit inline info.
1199     // TODO: When we don't need the option anymore we
1200     // can remove all of the code that this section
1201     // depends upon.
1202     if (useDarwinGDBCompat())
1203       emitDebugInlineInfo();
1204   }
1205
1206   // Emit info into the dwarf accelerator table sections.
1207   if (useDwarfAccelTables()) {
1208     emitAccelNames();
1209     emitAccelObjC();
1210     emitAccelNamespaces();
1211     emitAccelTypes();
1212   }
1213
1214   // Emit info into a debug pubnames section, if requested.
1215   if (GenerateDwarfPubNamesSection)
1216     emitDebugPubnames();
1217
1218   // Emit info into a debug pubtypes section.
1219   // TODO: When we don't need the option anymore we can
1220   // remove all of the code that adds to the table.
1221   if (useDarwinGDBCompat())
1222     emitDebugPubTypes();
1223
1224   // Finally emit string information into a string table.
1225   emitDebugStr();
1226   if (useSplitDwarf())
1227     emitDebugStrDWO();
1228
1229   // clean up.
1230   SPMap.clear();
1231   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1232          E = CUMap.end(); I != E; ++I)
1233     delete I->second;
1234
1235   for (SmallVectorImpl<CompileUnit *>::iterator I = SkeletonCUs.begin(),
1236          E = SkeletonCUs.end(); I != E; ++I)
1237     delete *I;
1238
1239   // Reset these for the next Module if we have one.
1240   FirstCU = NULL;
1241 }
1242
1243 // Find abstract variable, if any, associated with Var.
1244 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1245                                               DebugLoc ScopeLoc) {
1246   LLVMContext &Ctx = DV->getContext();
1247   // More then one inlined variable corresponds to one abstract variable.
1248   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1249   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1250   if (AbsDbgVariable)
1251     return AbsDbgVariable;
1252
1253   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1254   if (!Scope)
1255     return NULL;
1256
1257   AbsDbgVariable = new DbgVariable(Var, NULL);
1258   addScopeVariable(Scope, AbsDbgVariable);
1259   AbstractVariables[Var] = AbsDbgVariable;
1260   return AbsDbgVariable;
1261 }
1262
1263 // If Var is a current function argument then add it to CurrentFnArguments list.
1264 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1265                                       DbgVariable *Var, LexicalScope *Scope) {
1266   if (!LScopes.isCurrentFunctionScope(Scope))
1267     return false;
1268   DIVariable DV = Var->getVariable();
1269   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1270     return false;
1271   unsigned ArgNo = DV.getArgNumber();
1272   if (ArgNo == 0)
1273     return false;
1274
1275   size_t Size = CurrentFnArguments.size();
1276   if (Size == 0)
1277     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1278   // llvm::Function argument size is not good indicator of how many
1279   // arguments does the function have at source level.
1280   if (ArgNo > Size)
1281     CurrentFnArguments.resize(ArgNo * 2);
1282   CurrentFnArguments[ArgNo - 1] = Var;
1283   return true;
1284 }
1285
1286 // Collect variable information from side table maintained by MMI.
1287 void
1288 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1289                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1290   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1291   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1292          VE = VMap.end(); VI != VE; ++VI) {
1293     const MDNode *Var = VI->first;
1294     if (!Var) continue;
1295     Processed.insert(Var);
1296     DIVariable DV(Var);
1297     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1298
1299     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1300
1301     // If variable scope is not found then skip this variable.
1302     if (Scope == 0)
1303       continue;
1304
1305     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1306     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1307     RegVar->setFrameIndex(VP.first);
1308     if (!addCurrentFnArgument(MF, RegVar, Scope))
1309       addScopeVariable(Scope, RegVar);
1310     if (AbsDbgVariable)
1311       AbsDbgVariable->setFrameIndex(VP.first);
1312   }
1313 }
1314
1315 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1316 // defined reg.
1317 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1318   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1319   return MI->getNumOperands() == 3 &&
1320          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1321          (MI->getOperand(1).isImm() ||
1322           (MI->getOperand(1).isReg() && MI->getOperand(1).getReg() == 0U));
1323 }
1324
1325 // Get .debug_loc entry for the instruction range starting at MI.
1326 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1327                                          const MCSymbol *FLabel,
1328                                          const MCSymbol *SLabel,
1329                                          const MachineInstr *MI) {
1330   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1331
1332   assert(MI->getNumOperands() == 3);
1333   if (MI->getOperand(0).isReg()) {
1334     MachineLocation MLoc;
1335     // If the second operand is an immediate, this is a
1336     // register-indirect address.
1337     if (!MI->getOperand(1).isImm())
1338       MLoc.set(MI->getOperand(0).getReg());
1339     else
1340       MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1341     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1342   }
1343   if (MI->getOperand(0).isImm())
1344     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1345   if (MI->getOperand(0).isFPImm())
1346     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1347   if (MI->getOperand(0).isCImm())
1348     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1349
1350   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1351 }
1352
1353 // Find variables for each lexical scope.
1354 void
1355 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1356                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1357
1358   // Grab the variable info that was squirreled away in the MMI side-table.
1359   collectVariableInfoFromMMITable(MF, Processed);
1360
1361   for (SmallVectorImpl<const MDNode*>::const_iterator
1362          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1363          ++UVI) {
1364     const MDNode *Var = *UVI;
1365     if (Processed.count(Var))
1366       continue;
1367
1368     // History contains relevant DBG_VALUE instructions for Var and instructions
1369     // clobbering it.
1370     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1371     if (History.empty())
1372       continue;
1373     const MachineInstr *MInsn = History.front();
1374
1375     DIVariable DV(Var);
1376     LexicalScope *Scope = NULL;
1377     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1378         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1379       Scope = LScopes.getCurrentFunctionScope();
1380     else if (MDNode *IA = DV.getInlinedAt())
1381       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1382     else
1383       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1384     // If variable scope is not found then skip this variable.
1385     if (!Scope)
1386       continue;
1387
1388     Processed.insert(DV);
1389     assert(MInsn->isDebugValue() && "History must begin with debug value");
1390     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1391     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1392     if (!addCurrentFnArgument(MF, RegVar, Scope))
1393       addScopeVariable(Scope, RegVar);
1394     if (AbsVar)
1395       AbsVar->setMInsn(MInsn);
1396
1397     // Simplify ranges that are fully coalesced.
1398     if (History.size() <= 1 || (History.size() == 2 &&
1399                                 MInsn->isIdenticalTo(History.back()))) {
1400       RegVar->setMInsn(MInsn);
1401       continue;
1402     }
1403
1404     // Handle multiple DBG_VALUE instructions describing one variable.
1405     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1406
1407     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1408            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1409       const MachineInstr *Begin = *HI;
1410       assert(Begin->isDebugValue() && "Invalid History entry");
1411
1412       // Check if DBG_VALUE is truncating a range.
1413       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1414           && !Begin->getOperand(0).getReg())
1415         continue;
1416
1417       // Compute the range for a register location.
1418       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1419       const MCSymbol *SLabel = 0;
1420
1421       if (HI + 1 == HE)
1422         // If Begin is the last instruction in History then its value is valid
1423         // until the end of the function.
1424         SLabel = FunctionEndSym;
1425       else {
1426         const MachineInstr *End = HI[1];
1427         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1428               << "\t" << *Begin << "\t" << *End << "\n");
1429         if (End->isDebugValue())
1430           SLabel = getLabelBeforeInsn(End);
1431         else {
1432           // End is a normal instruction clobbering the range.
1433           SLabel = getLabelAfterInsn(End);
1434           assert(SLabel && "Forgot label after clobber instruction");
1435           ++HI;
1436         }
1437       }
1438
1439       // The value is valid until the next DBG_VALUE or clobber.
1440       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1441                                                     Begin));
1442     }
1443     DotDebugLocEntries.push_back(DotDebugLocEntry());
1444   }
1445
1446   // Collect info for variables that were optimized out.
1447   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1448   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1449   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1450     DIVariable DV(Variables.getElement(i));
1451     if (!DV || !DV.isVariable() || !Processed.insert(DV))
1452       continue;
1453     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1454       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1455   }
1456 }
1457
1458 // Return Label preceding the instruction.
1459 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1460   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1461   assert(Label && "Didn't insert label before instruction");
1462   return Label;
1463 }
1464
1465 // Return Label immediately following the instruction.
1466 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1467   return LabelsAfterInsn.lookup(MI);
1468 }
1469
1470 // Process beginning of an instruction.
1471 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1472   // Check if source location changes, but ignore DBG_VALUE locations.
1473   if (!MI->isDebugValue()) {
1474     DebugLoc DL = MI->getDebugLoc();
1475     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1476       unsigned Flags = 0;
1477       PrevInstLoc = DL;
1478       if (DL == PrologEndLoc) {
1479         Flags |= DWARF2_FLAG_PROLOGUE_END;
1480         PrologEndLoc = DebugLoc();
1481       }
1482       if (PrologEndLoc.isUnknown())
1483         Flags |= DWARF2_FLAG_IS_STMT;
1484
1485       if (!DL.isUnknown()) {
1486         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1487         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1488       } else
1489         recordSourceLine(0, 0, 0, 0);
1490     }
1491   }
1492
1493   // Insert labels where requested.
1494   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1495     LabelsBeforeInsn.find(MI);
1496
1497   // No label needed.
1498   if (I == LabelsBeforeInsn.end())
1499     return;
1500
1501   // Label already assigned.
1502   if (I->second)
1503     return;
1504
1505   if (!PrevLabel) {
1506     PrevLabel = MMI->getContext().CreateTempSymbol();
1507     Asm->OutStreamer.EmitLabel(PrevLabel);
1508   }
1509   I->second = PrevLabel;
1510 }
1511
1512 // Process end of an instruction.
1513 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1514   // Don't create a new label after DBG_VALUE instructions.
1515   // They don't generate code.
1516   if (!MI->isDebugValue())
1517     PrevLabel = 0;
1518
1519   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1520     LabelsAfterInsn.find(MI);
1521
1522   // No label needed.
1523   if (I == LabelsAfterInsn.end())
1524     return;
1525
1526   // Label already assigned.
1527   if (I->second)
1528     return;
1529
1530   // We need a label after this instruction.
1531   if (!PrevLabel) {
1532     PrevLabel = MMI->getContext().CreateTempSymbol();
1533     Asm->OutStreamer.EmitLabel(PrevLabel);
1534   }
1535   I->second = PrevLabel;
1536 }
1537
1538 // Each LexicalScope has first instruction and last instruction to mark
1539 // beginning and end of a scope respectively. Create an inverse map that list
1540 // scopes starts (and ends) with an instruction. One instruction may start (or
1541 // end) multiple scopes. Ignore scopes that are not reachable.
1542 void DwarfDebug::identifyScopeMarkers() {
1543   SmallVector<LexicalScope *, 4> WorkList;
1544   WorkList.push_back(LScopes.getCurrentFunctionScope());
1545   while (!WorkList.empty()) {
1546     LexicalScope *S = WorkList.pop_back_val();
1547
1548     const SmallVectorImpl<LexicalScope *> &Children = S->getChildren();
1549     if (!Children.empty())
1550       for (SmallVectorImpl<LexicalScope *>::const_iterator SI = Children.begin(),
1551              SE = Children.end(); SI != SE; ++SI)
1552         WorkList.push_back(*SI);
1553
1554     if (S->isAbstractScope())
1555       continue;
1556
1557     const SmallVectorImpl<InsnRange> &Ranges = S->getRanges();
1558     if (Ranges.empty())
1559       continue;
1560     for (SmallVectorImpl<InsnRange>::const_iterator RI = Ranges.begin(),
1561            RE = Ranges.end(); RI != RE; ++RI) {
1562       assert(RI->first && "InsnRange does not have first instruction!");
1563       assert(RI->second && "InsnRange does not have second instruction!");
1564       requestLabelBeforeInsn(RI->first);
1565       requestLabelAfterInsn(RI->second);
1566     }
1567   }
1568 }
1569
1570 // Get MDNode for DebugLoc's scope.
1571 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1572   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1573     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1574   return DL.getScope(Ctx);
1575 }
1576
1577 // Walk up the scope chain of given debug loc and find line number info
1578 // for the function.
1579 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1580   const MDNode *Scope = getScopeNode(DL, Ctx);
1581   DISubprogram SP = getDISubprogram(Scope);
1582   if (SP.isSubprogram()) {
1583     // Check for number of operands since the compatibility is
1584     // cheap here.
1585     if (SP->getNumOperands() > 19)
1586       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1587     else
1588       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1589   }
1590
1591   return DebugLoc();
1592 }
1593
1594 // Gather pre-function debug information.  Assumes being called immediately
1595 // after the function entry point has been emitted.
1596 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1597   if (!MMI->hasDebugInfo()) return;
1598   LScopes.initialize(*MF);
1599   if (LScopes.empty()) return;
1600   identifyScopeMarkers();
1601
1602   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1603   // belongs to.
1604   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1605   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1606   assert(TheCU && "Unable to find compile unit!");
1607   if (Asm->TM.hasMCUseLoc() &&
1608       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
1609     // Use a single line table if we are using .loc and generating assembly.
1610     Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1611   else
1612     Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1613
1614   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1615                                         Asm->getFunctionNumber());
1616   // Assumes in correct section after the entry point.
1617   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1618
1619   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1620
1621   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1622   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1623   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1624
1625   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1626        I != E; ++I) {
1627     bool AtBlockEntry = true;
1628     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1629          II != IE; ++II) {
1630       const MachineInstr *MI = II;
1631
1632       if (MI->isDebugValue()) {
1633         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1634
1635         // Keep track of user variables.
1636         const MDNode *Var =
1637           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1638
1639         // Variable is in a register, we need to check for clobbers.
1640         if (isDbgValueInDefinedReg(MI))
1641           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1642
1643         // Check the history of this variable.
1644         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1645         if (History.empty()) {
1646           UserVariables.push_back(Var);
1647           // The first mention of a function argument gets the FunctionBeginSym
1648           // label, so arguments are visible when breaking at function entry.
1649           DIVariable DV(Var);
1650           if (DV.isVariable() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1651               DISubprogram(getDISubprogram(DV.getContext()))
1652                 .describes(MF->getFunction()))
1653             LabelsBeforeInsn[MI] = FunctionBeginSym;
1654         } else {
1655           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1656           const MachineInstr *Prev = History.back();
1657           if (Prev->isDebugValue()) {
1658             // Coalesce identical entries at the end of History.
1659             if (History.size() >= 2 &&
1660                 Prev->isIdenticalTo(History[History.size() - 2])) {
1661               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1662                     << "\t" << *Prev
1663                     << "\t" << *History[History.size() - 2] << "\n");
1664               History.pop_back();
1665             }
1666
1667             // Terminate old register assignments that don't reach MI;
1668             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1669             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1670                 isDbgValueInDefinedReg(Prev)) {
1671               // Previous register assignment needs to terminate at the end of
1672               // its basic block.
1673               MachineBasicBlock::const_iterator LastMI =
1674                 PrevMBB->getLastNonDebugInstr();
1675               if (LastMI == PrevMBB->end()) {
1676                 // Drop DBG_VALUE for empty range.
1677                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1678                       << "\t" << *Prev << "\n");
1679                 History.pop_back();
1680               } else if (llvm::next(PrevMBB) != PrevMBB->getParent()->end())
1681                 // Terminate after LastMI.
1682                 History.push_back(LastMI);
1683             }
1684           }
1685         }
1686         History.push_back(MI);
1687       } else {
1688         // Not a DBG_VALUE instruction.
1689         if (!MI->isLabel())
1690           AtBlockEntry = false;
1691
1692         // First known non-DBG_VALUE and non-frame setup location marks
1693         // the beginning of the function body.
1694         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1695             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1696           PrologEndLoc = MI->getDebugLoc();
1697
1698         // Check if the instruction clobbers any registers with debug vars.
1699         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1700                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1701           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1702             continue;
1703           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1704                AI.isValid(); ++AI) {
1705             unsigned Reg = *AI;
1706             const MDNode *Var = LiveUserVar[Reg];
1707             if (!Var)
1708               continue;
1709             // Reg is now clobbered.
1710             LiveUserVar[Reg] = 0;
1711
1712             // Was MD last defined by a DBG_VALUE referring to Reg?
1713             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1714             if (HistI == DbgValues.end())
1715               continue;
1716             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1717             if (History.empty())
1718               continue;
1719             const MachineInstr *Prev = History.back();
1720             // Sanity-check: Register assignments are terminated at the end of
1721             // their block.
1722             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1723               continue;
1724             // Is the variable still in Reg?
1725             if (!isDbgValueInDefinedReg(Prev) ||
1726                 Prev->getOperand(0).getReg() != Reg)
1727               continue;
1728             // Var is clobbered. Make sure the next instruction gets a label.
1729             History.push_back(MI);
1730           }
1731         }
1732       }
1733     }
1734   }
1735
1736   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1737        I != E; ++I) {
1738     SmallVectorImpl<const MachineInstr*> &History = I->second;
1739     if (History.empty())
1740       continue;
1741
1742     // Make sure the final register assignments are terminated.
1743     const MachineInstr *Prev = History.back();
1744     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1745       const MachineBasicBlock *PrevMBB = Prev->getParent();
1746       MachineBasicBlock::const_iterator LastMI =
1747         PrevMBB->getLastNonDebugInstr();
1748       if (LastMI == PrevMBB->end())
1749         // Drop DBG_VALUE for empty range.
1750         History.pop_back();
1751       else if (PrevMBB != &PrevMBB->getParent()->back()) {
1752         // Terminate after LastMI.
1753         History.push_back(LastMI);
1754       }
1755     }
1756     // Request labels for the full history.
1757     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1758       const MachineInstr *MI = History[i];
1759       if (MI->isDebugValue())
1760         requestLabelBeforeInsn(MI);
1761       else
1762         requestLabelAfterInsn(MI);
1763     }
1764   }
1765
1766   PrevInstLoc = DebugLoc();
1767   PrevLabel = FunctionBeginSym;
1768
1769   // Record beginning of function.
1770   if (!PrologEndLoc.isUnknown()) {
1771     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1772                                        MF->getFunction()->getContext());
1773     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1774                      FnStartDL.getScope(MF->getFunction()->getContext()),
1775     // We'd like to list the prologue as "not statements" but GDB behaves
1776     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1777                      DWARF2_FLAG_IS_STMT);
1778   }
1779 }
1780
1781 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1782   SmallVectorImpl<DbgVariable *> &Vars = ScopeVariables[LS];
1783   DIVariable DV = Var->getVariable();
1784   // Variables with positive arg numbers are parameters.
1785   if (unsigned ArgNum = DV.getArgNumber()) {
1786     // Keep all parameters in order at the start of the variable list to ensure
1787     // function types are correct (no out-of-order parameters)
1788     //
1789     // This could be improved by only doing it for optimized builds (unoptimized
1790     // builds have the right order to begin with), searching from the back (this
1791     // would catch the unoptimized case quickly), or doing a binary search
1792     // rather than linear search.
1793     SmallVectorImpl<DbgVariable *>::iterator I = Vars.begin();
1794     while (I != Vars.end()) {
1795       unsigned CurNum = (*I)->getVariable().getArgNumber();
1796       // A local (non-parameter) variable has been found, insert immediately
1797       // before it.
1798       if (CurNum == 0)
1799         break;
1800       // A later indexed parameter has been found, insert immediately before it.
1801       if (CurNum > ArgNum)
1802         break;
1803       ++I;
1804     }
1805     Vars.insert(I, Var);
1806     return;
1807   }
1808
1809   Vars.push_back(Var);
1810 }
1811
1812 // Gather and emit post-function debug information.
1813 void DwarfDebug::endFunction(const MachineFunction *MF) {
1814   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1815
1816   // Define end label for subprogram.
1817   FunctionEndSym = Asm->GetTempSymbol("func_end",
1818                                       Asm->getFunctionNumber());
1819   // Assumes in correct section after the entry point.
1820   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1821   // Set DwarfCompileUnitID in MCContext to default value.
1822   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1823
1824   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1825   collectVariableInfo(MF, ProcessedVars);
1826
1827   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1828   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1829   assert(TheCU && "Unable to find compile unit!");
1830
1831   // Construct abstract scopes.
1832   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1833   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1834     LexicalScope *AScope = AList[i];
1835     DISubprogram SP(AScope->getScopeNode());
1836     if (SP.isSubprogram()) {
1837       // Collect info for variables that were optimized out.
1838       DIArray Variables = SP.getVariables();
1839       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1840         DIVariable DV(Variables.getElement(i));
1841         if (!DV || !DV.isVariable() || !ProcessedVars.insert(DV))
1842           continue;
1843         // Check that DbgVariable for DV wasn't created earlier, when
1844         // findAbstractVariable() was called for inlined instance of DV.
1845         LLVMContext &Ctx = DV->getContext();
1846         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1847         if (AbstractVariables.lookup(CleanDV))
1848           continue;
1849         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1850           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1851       }
1852     }
1853     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1854       constructScopeDIE(TheCU, AScope);
1855   }
1856
1857   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1858
1859   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1860     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1861
1862   // Clear debug info
1863   for (ScopeVariablesMap::iterator
1864          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1865     DeleteContainerPointers(I->second);
1866   ScopeVariables.clear();
1867   DeleteContainerPointers(CurrentFnArguments);
1868   UserVariables.clear();
1869   DbgValues.clear();
1870   AbstractVariables.clear();
1871   LabelsBeforeInsn.clear();
1872   LabelsAfterInsn.clear();
1873   PrevLabel = NULL;
1874 }
1875
1876 // Register a source line with debug info. Returns the  unique label that was
1877 // emitted and which provides correspondence to the source line list.
1878 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1879                                   unsigned Flags) {
1880   StringRef Fn;
1881   StringRef Dir;
1882   unsigned Src = 1;
1883   if (S) {
1884     DIDescriptor Scope(S);
1885
1886     if (Scope.isCompileUnit()) {
1887       DICompileUnit CU(S);
1888       Fn = CU.getFilename();
1889       Dir = CU.getDirectory();
1890     } else if (Scope.isFile()) {
1891       DIFile F(S);
1892       Fn = F.getFilename();
1893       Dir = F.getDirectory();
1894     } else if (Scope.isSubprogram()) {
1895       DISubprogram SP(S);
1896       Fn = SP.getFilename();
1897       Dir = SP.getDirectory();
1898     } else if (Scope.isLexicalBlockFile()) {
1899       DILexicalBlockFile DBF(S);
1900       Fn = DBF.getFilename();
1901       Dir = DBF.getDirectory();
1902     } else if (Scope.isLexicalBlock()) {
1903       DILexicalBlock DB(S);
1904       Fn = DB.getFilename();
1905       Dir = DB.getDirectory();
1906     } else
1907       llvm_unreachable("Unexpected scope info");
1908
1909     Src = getOrCreateSourceID(Fn, Dir,
1910             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1911   }
1912   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1913 }
1914
1915 //===----------------------------------------------------------------------===//
1916 // Emit Methods
1917 //===----------------------------------------------------------------------===//
1918
1919 // Compute the size and offset of a DIE.
1920 unsigned
1921 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1922   // Get the children.
1923   const std::vector<DIE *> &Children = Die->getChildren();
1924
1925   // Record the abbreviation.
1926   assignAbbrevNumber(Die->getAbbrev());
1927
1928   // Get the abbreviation for this DIE.
1929   unsigned AbbrevNumber = Die->getAbbrevNumber();
1930   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1931
1932   // Set DIE offset
1933   Die->setOffset(Offset);
1934
1935   // Start the size with the size of abbreviation code.
1936   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1937
1938   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1939   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1940
1941   // Size the DIE attribute values.
1942   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1943     // Size attribute value.
1944     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1945
1946   // Size the DIE children if any.
1947   if (!Children.empty()) {
1948     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1949            "Children flag not set");
1950
1951     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1952       Offset = computeSizeAndOffset(Children[j], Offset);
1953
1954     // End of children marker.
1955     Offset += sizeof(int8_t);
1956   }
1957
1958   Die->setSize(Offset - Die->getOffset());
1959   return Offset;
1960 }
1961
1962 // Compute the size and offset of all the DIEs.
1963 void DwarfUnits::computeSizeAndOffsets() {
1964   // Offset from the beginning of debug info section.
1965   unsigned SecOffset = 0;
1966   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1967          E = CUs.end(); I != E; ++I) {
1968     (*I)->setDebugInfoOffset(SecOffset);
1969     unsigned Offset =
1970       sizeof(int32_t) + // Length of Compilation Unit Info
1971       sizeof(int16_t) + // DWARF version number
1972       sizeof(int32_t) + // Offset Into Abbrev. Section
1973       sizeof(int8_t);   // Pointer Size (in bytes)
1974
1975     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1976     SecOffset += EndOffset;
1977   }
1978 }
1979
1980 // Emit initial Dwarf sections with a label at the start of each one.
1981 void DwarfDebug::emitSectionLabels() {
1982   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1983
1984   // Dwarf sections base addresses.
1985   DwarfInfoSectionSym =
1986     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1987   DwarfAbbrevSectionSym =
1988     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1989   if (useSplitDwarf())
1990     DwarfAbbrevDWOSectionSym =
1991       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1992                      "section_abbrev_dwo");
1993   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1994
1995   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1996     emitSectionSym(Asm, MacroInfo);
1997
1998   DwarfLineSectionSym =
1999     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
2000   emitSectionSym(Asm, TLOF.getDwarfLocSection());
2001   if (GenerateDwarfPubNamesSection)
2002     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
2003   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
2004   DwarfStrSectionSym =
2005     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
2006   if (useSplitDwarf()) {
2007     DwarfStrDWOSectionSym =
2008       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
2009     DwarfAddrSectionSym =
2010       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
2011   }
2012   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
2013                                              "debug_range");
2014
2015   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
2016                                            "section_debug_loc");
2017
2018   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
2019   emitSectionSym(Asm, TLOF.getDataSection());
2020 }
2021
2022 // Recursively emits a debug information entry.
2023 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
2024   // Get the abbreviation for this DIE.
2025   unsigned AbbrevNumber = Die->getAbbrevNumber();
2026   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
2027
2028   // Emit the code (index) for the abbreviation.
2029   if (Asm->isVerbose())
2030     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
2031                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
2032                                 Twine::utohexstr(Die->getSize()) + " " +
2033                                 dwarf::TagString(Abbrev->getTag()));
2034   Asm->EmitULEB128(AbbrevNumber);
2035
2036   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
2037   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
2038
2039   // Emit the DIE attribute values.
2040   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
2041     unsigned Attr = AbbrevData[i].getAttribute();
2042     unsigned Form = AbbrevData[i].getForm();
2043     assert(Form && "Too many attributes for DIE (check abbreviation)");
2044
2045     if (Asm->isVerbose())
2046       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
2047
2048     switch (Attr) {
2049     case dwarf::DW_AT_abstract_origin: {
2050       DIEEntry *E = cast<DIEEntry>(Values[i]);
2051       DIE *Origin = E->getEntry();
2052       unsigned Addr = Origin->getOffset();
2053       if (Form == dwarf::DW_FORM_ref_addr) {
2054         // For DW_FORM_ref_addr, output the offset from beginning of debug info
2055         // section. Origin->getOffset() returns the offset from start of the
2056         // compile unit.
2057         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2058         Addr += Holder.getCUOffset(Origin->getCompileUnit());
2059       }
2060       Asm->OutStreamer.EmitIntValue(Addr,
2061           Form == dwarf::DW_FORM_ref_addr ? DIEEntry::getRefAddrSize(Asm) : 4);
2062       break;
2063     }
2064     case dwarf::DW_AT_ranges: {
2065       // DW_AT_range Value encodes offset in debug_range section.
2066       DIEInteger *V = cast<DIEInteger>(Values[i]);
2067
2068       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
2069         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
2070                                  V->getValue(),
2071                                  4);
2072       } else {
2073         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
2074                                        V->getValue(),
2075                                        DwarfDebugRangeSectionSym,
2076                                        4);
2077       }
2078       break;
2079     }
2080     case dwarf::DW_AT_location: {
2081       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
2082         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2083           Asm->EmitLabelReference(L->getValue(), 4);
2084         else
2085           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
2086       } else {
2087         Values[i]->EmitValue(Asm, Form);
2088       }
2089       break;
2090     }
2091     case dwarf::DW_AT_accessibility: {
2092       if (Asm->isVerbose()) {
2093         DIEInteger *V = cast<DIEInteger>(Values[i]);
2094         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
2095       }
2096       Values[i]->EmitValue(Asm, Form);
2097       break;
2098     }
2099     default:
2100       // Emit an attribute using the defined form.
2101       Values[i]->EmitValue(Asm, Form);
2102       break;
2103     }
2104   }
2105
2106   // Emit the DIE children if any.
2107   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
2108     const std::vector<DIE *> &Children = Die->getChildren();
2109
2110     for (unsigned j = 0, M = Children.size(); j < M; ++j)
2111       emitDIE(Children[j], Abbrevs);
2112
2113     if (Asm->isVerbose())
2114       Asm->OutStreamer.AddComment("End Of Children Mark");
2115     Asm->EmitInt8(0);
2116   }
2117 }
2118
2119 // Emit the various dwarf units to the unit section USection with
2120 // the abbreviations going into ASection.
2121 void DwarfUnits::emitUnits(DwarfDebug *DD,
2122                            const MCSection *USection,
2123                            const MCSection *ASection,
2124                            const MCSymbol *ASectionSym) {
2125   Asm->OutStreamer.SwitchSection(USection);
2126   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2127          E = CUs.end(); I != E; ++I) {
2128     CompileUnit *TheCU = *I;
2129     DIE *Die = TheCU->getCUDie();
2130
2131     // Emit the compile units header.
2132     Asm->OutStreamer
2133       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
2134                                     TheCU->getUniqueID()));
2135
2136     // Emit size of content not including length itself
2137     unsigned ContentSize = Die->getSize() +
2138       sizeof(int16_t) + // DWARF version number
2139       sizeof(int32_t) + // Offset Into Abbrev. Section
2140       sizeof(int8_t);   // Pointer Size (in bytes)
2141
2142     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
2143     Asm->EmitInt32(ContentSize);
2144     Asm->OutStreamer.AddComment("DWARF version number");
2145     Asm->EmitInt16(DD->getDwarfVersion());
2146     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
2147     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
2148                            ASectionSym);
2149     Asm->OutStreamer.AddComment("Address Size (in bytes)");
2150     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2151
2152     DD->emitDIE(Die, Abbreviations);
2153     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
2154                                                   TheCU->getUniqueID()));
2155   }
2156 }
2157
2158 /// For a given compile unit DIE, returns offset from beginning of debug info.
2159 unsigned DwarfUnits::getCUOffset(DIE *Die) {
2160   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
2161          "Input DIE should be compile unit in getCUOffset.");
2162   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
2163        E = CUs.end(); I != E; ++I) {
2164     CompileUnit *TheCU = *I;
2165     if (TheCU->getCUDie() == Die)
2166       return TheCU->getDebugInfoOffset();
2167   }
2168   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
2169 }
2170
2171 // Emit the debug info section.
2172 void DwarfDebug::emitDebugInfo() {
2173   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2174
2175   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
2176                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
2177                    DwarfAbbrevSectionSym);
2178 }
2179
2180 // Emit the abbreviation section.
2181 void DwarfDebug::emitAbbreviations() {
2182   if (!useSplitDwarf())
2183     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
2184                 &Abbreviations);
2185   else
2186     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
2187 }
2188
2189 void DwarfDebug::emitAbbrevs(const MCSection *Section,
2190                              std::vector<DIEAbbrev *> *Abbrevs) {
2191   // Check to see if it is worth the effort.
2192   if (!Abbrevs->empty()) {
2193     // Start the debug abbrev section.
2194     Asm->OutStreamer.SwitchSection(Section);
2195
2196     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
2197     Asm->OutStreamer.EmitLabel(Begin);
2198
2199     // For each abbrevation.
2200     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
2201       // Get abbreviation data
2202       const DIEAbbrev *Abbrev = Abbrevs->at(i);
2203
2204       // Emit the abbrevations code (base 1 index.)
2205       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
2206
2207       // Emit the abbreviations data.
2208       Abbrev->Emit(Asm);
2209     }
2210
2211     // Mark end of abbreviations.
2212     Asm->EmitULEB128(0, "EOM(3)");
2213
2214     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
2215     Asm->OutStreamer.EmitLabel(End);
2216   }
2217 }
2218
2219 // Emit the last address of the section and the end of the line matrix.
2220 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
2221   // Define last address of section.
2222   Asm->OutStreamer.AddComment("Extended Op");
2223   Asm->EmitInt8(0);
2224
2225   Asm->OutStreamer.AddComment("Op size");
2226   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
2227   Asm->OutStreamer.AddComment("DW_LNE_set_address");
2228   Asm->EmitInt8(dwarf::DW_LNE_set_address);
2229
2230   Asm->OutStreamer.AddComment("Section end label");
2231
2232   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
2233                                    Asm->getDataLayout().getPointerSize());
2234
2235   // Mark end of matrix.
2236   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
2237   Asm->EmitInt8(0);
2238   Asm->EmitInt8(1);
2239   Asm->EmitInt8(1);
2240 }
2241
2242 // Emit visible names into a hashed accelerator table section.
2243 void DwarfDebug::emitAccelNames() {
2244   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2245                                            dwarf::DW_FORM_data4));
2246   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2247          E = CUMap.end(); I != E; ++I) {
2248     CompileUnit *TheCU = I->second;
2249     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
2250     for (StringMap<std::vector<DIE*> >::const_iterator
2251            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2252       StringRef Name = GI->getKey();
2253       const std::vector<DIE *> &Entities = GI->second;
2254       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2255              DE = Entities.end(); DI != DE; ++DI)
2256         AT.AddName(Name, (*DI));
2257     }
2258   }
2259
2260   AT.FinalizeTable(Asm, "Names");
2261   Asm->OutStreamer.SwitchSection(
2262     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2263   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2264   Asm->OutStreamer.EmitLabel(SectionBegin);
2265
2266   // Emit the full data.
2267   AT.Emit(Asm, SectionBegin, &InfoHolder);
2268 }
2269
2270 // Emit objective C classes and categories into a hashed accelerator table
2271 // section.
2272 void DwarfDebug::emitAccelObjC() {
2273   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2274                                            dwarf::DW_FORM_data4));
2275   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2276          E = CUMap.end(); I != E; ++I) {
2277     CompileUnit *TheCU = I->second;
2278     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2279     for (StringMap<std::vector<DIE*> >::const_iterator
2280            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2281       StringRef Name = GI->getKey();
2282       const std::vector<DIE *> &Entities = GI->second;
2283       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2284              DE = Entities.end(); DI != DE; ++DI)
2285         AT.AddName(Name, (*DI));
2286     }
2287   }
2288
2289   AT.FinalizeTable(Asm, "ObjC");
2290   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2291                                  .getDwarfAccelObjCSection());
2292   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2293   Asm->OutStreamer.EmitLabel(SectionBegin);
2294
2295   // Emit the full data.
2296   AT.Emit(Asm, SectionBegin, &InfoHolder);
2297 }
2298
2299 // Emit namespace dies into a hashed accelerator table.
2300 void DwarfDebug::emitAccelNamespaces() {
2301   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2302                                            dwarf::DW_FORM_data4));
2303   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2304          E = CUMap.end(); I != E; ++I) {
2305     CompileUnit *TheCU = I->second;
2306     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2307     for (StringMap<std::vector<DIE*> >::const_iterator
2308            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2309       StringRef Name = GI->getKey();
2310       const std::vector<DIE *> &Entities = GI->second;
2311       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2312              DE = Entities.end(); DI != DE; ++DI)
2313         AT.AddName(Name, (*DI));
2314     }
2315   }
2316
2317   AT.FinalizeTable(Asm, "namespac");
2318   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2319                                  .getDwarfAccelNamespaceSection());
2320   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2321   Asm->OutStreamer.EmitLabel(SectionBegin);
2322
2323   // Emit the full data.
2324   AT.Emit(Asm, SectionBegin, &InfoHolder);
2325 }
2326
2327 // Emit type dies into a hashed accelerator table.
2328 void DwarfDebug::emitAccelTypes() {
2329   std::vector<DwarfAccelTable::Atom> Atoms;
2330   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2331                                         dwarf::DW_FORM_data4));
2332   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2333                                         dwarf::DW_FORM_data2));
2334   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2335                                         dwarf::DW_FORM_data1));
2336   DwarfAccelTable AT(Atoms);
2337   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2338          E = CUMap.end(); I != E; ++I) {
2339     CompileUnit *TheCU = I->second;
2340     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2341       = TheCU->getAccelTypes();
2342     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2343            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2344       StringRef Name = GI->getKey();
2345       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2346       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2347              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2348         AT.AddName(Name, (*DI).first, (*DI).second);
2349     }
2350   }
2351
2352   AT.FinalizeTable(Asm, "types");
2353   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2354                                  .getDwarfAccelTypesSection());
2355   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2356   Asm->OutStreamer.EmitLabel(SectionBegin);
2357
2358   // Emit the full data.
2359   AT.Emit(Asm, SectionBegin, &InfoHolder);
2360 }
2361
2362 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2363 ///
2364 void DwarfDebug::emitDebugPubnames() {
2365   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2366
2367   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2368   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2369     CompileUnit *TheCU = I->second;
2370     unsigned ID = TheCU->getUniqueID();
2371
2372     if (TheCU->getGlobalNames().empty())
2373       continue;
2374
2375     // Start the dwarf pubnames section.
2376     Asm->OutStreamer.SwitchSection(
2377       Asm->getObjFileLowering().getDwarfPubNamesSection());
2378
2379     Asm->OutStreamer.AddComment("Length of Public Names Info");
2380     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2381                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2382
2383     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2384
2385     Asm->OutStreamer.AddComment("DWARF Version");
2386     Asm->EmitInt16(DwarfVersion);
2387
2388     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2389     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2390                            DwarfInfoSectionSym);
2391
2392     Asm->OutStreamer.AddComment("Compilation Unit Length");
2393     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2394                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2395                              4);
2396
2397     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2398     for (StringMap<DIE*>::const_iterator
2399            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2400       const char *Name = GI->getKeyData();
2401       const DIE *Entity = GI->second;
2402
2403       Asm->OutStreamer.AddComment("DIE offset");
2404       Asm->EmitInt32(Entity->getOffset());
2405
2406       if (Asm->isVerbose())
2407         Asm->OutStreamer.AddComment("External Name");
2408       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2409     }
2410
2411     Asm->OutStreamer.AddComment("End Mark");
2412     Asm->EmitInt32(0);
2413     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2414   }
2415 }
2416
2417 void DwarfDebug::emitDebugPubTypes() {
2418   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2419          E = CUMap.end(); I != E; ++I) {
2420     CompileUnit *TheCU = I->second;
2421     // Start the dwarf pubtypes section.
2422     Asm->OutStreamer.SwitchSection(
2423       Asm->getObjFileLowering().getDwarfPubTypesSection());
2424     Asm->OutStreamer.AddComment("Length of Public Types Info");
2425     Asm->EmitLabelDifference(
2426       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2427       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2428
2429     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2430                                                   TheCU->getUniqueID()));
2431
2432     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2433     Asm->EmitInt16(DwarfVersion);
2434
2435     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2436     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2437     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2438                                               TheCU->getUniqueID()),
2439                            DwarfInfoSectionSym);
2440
2441     Asm->OutStreamer.AddComment("Compilation Unit Length");
2442     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2443                                                 TheCU->getUniqueID()),
2444                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2445                                                 TheCU->getUniqueID()),
2446                              4);
2447
2448     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2449     for (StringMap<DIE*>::const_iterator
2450            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2451       const char *Name = GI->getKeyData();
2452       DIE *Entity = GI->second;
2453
2454       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2455       Asm->EmitInt32(Entity->getOffset());
2456
2457       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2458       // Emit the name with a terminating null byte.
2459       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2460     }
2461
2462     Asm->OutStreamer.AddComment("End Mark");
2463     Asm->EmitInt32(0);
2464     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2465                                                   TheCU->getUniqueID()));
2466   }
2467 }
2468
2469 // Emit strings into a string section.
2470 void DwarfUnits::emitStrings(const MCSection *StrSection,
2471                              const MCSection *OffsetSection = NULL,
2472                              const MCSymbol *StrSecSym = NULL) {
2473
2474   if (StringPool.empty()) return;
2475
2476   // Start the dwarf str section.
2477   Asm->OutStreamer.SwitchSection(StrSection);
2478
2479   // Get all of the string pool entries and put them in an array by their ID so
2480   // we can sort them.
2481   SmallVector<std::pair<unsigned,
2482                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2483
2484   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2485          I = StringPool.begin(), E = StringPool.end();
2486        I != E; ++I)
2487     Entries.push_back(std::make_pair(I->second.second, &*I));
2488
2489   array_pod_sort(Entries.begin(), Entries.end());
2490
2491   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2492     // Emit a label for reference from debug information entries.
2493     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2494
2495     // Emit the string itself with a terminating null byte.
2496     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2497                                          Entries[i].second->getKeyLength()+1));
2498   }
2499
2500   // If we've got an offset section go ahead and emit that now as well.
2501   if (OffsetSection) {
2502     Asm->OutStreamer.SwitchSection(OffsetSection);
2503     unsigned offset = 0;
2504     unsigned size = 4; // FIXME: DWARF64 is 8.
2505     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2506       Asm->OutStreamer.EmitIntValue(offset, size);
2507       offset += Entries[i].second->getKeyLength() + 1;
2508     }
2509   }
2510 }
2511
2512 // Emit strings into a string section.
2513 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2514
2515   if (AddressPool.empty()) return;
2516
2517   // Start the dwarf addr section.
2518   Asm->OutStreamer.SwitchSection(AddrSection);
2519
2520   // Order the address pool entries by ID
2521   SmallVector<const MCExpr *, 64> Entries(AddressPool.size());
2522
2523   for (DenseMap<const MCExpr *, unsigned>::iterator I = AddressPool.begin(),
2524                                                     E = AddressPool.end();
2525        I != E; ++I)
2526     Entries[I->second] = I->first;
2527
2528   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2529     // Emit an expression for reference from debug information entries.
2530     if (const MCExpr *Expr = Entries[i])
2531       Asm->OutStreamer.EmitValue(Expr, Asm->getDataLayout().getPointerSize());
2532     else
2533       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2534   }
2535
2536 }
2537
2538 // Emit visible names into a debug str section.
2539 void DwarfDebug::emitDebugStr() {
2540   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2541   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2542 }
2543
2544 // Emit locations into the debug loc section.
2545 void DwarfDebug::emitDebugLoc() {
2546   if (DotDebugLocEntries.empty())
2547     return;
2548
2549   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2550          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2551        I != E; ++I) {
2552     DotDebugLocEntry &Entry = *I;
2553     if (I + 1 != DotDebugLocEntries.end())
2554       Entry.Merge(I+1);
2555   }
2556
2557   // Start the dwarf loc section.
2558   Asm->OutStreamer.SwitchSection(
2559     Asm->getObjFileLowering().getDwarfLocSection());
2560   unsigned char Size = Asm->getDataLayout().getPointerSize();
2561   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2562   unsigned index = 1;
2563   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2564          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2565        I != E; ++I, ++index) {
2566     DotDebugLocEntry &Entry = *I;
2567     if (Entry.isMerged()) continue;
2568     if (Entry.isEmpty()) {
2569       Asm->OutStreamer.EmitIntValue(0, Size);
2570       Asm->OutStreamer.EmitIntValue(0, Size);
2571       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2572     } else {
2573       Asm->OutStreamer.EmitSymbolValue(Entry.getBeginSym(), Size);
2574       Asm->OutStreamer.EmitSymbolValue(Entry.getEndSym(), Size);
2575       DIVariable DV(Entry.getVariable());
2576       Asm->OutStreamer.AddComment("Loc expr size");
2577       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2578       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2579       Asm->EmitLabelDifference(end, begin, 2);
2580       Asm->OutStreamer.EmitLabel(begin);
2581       if (Entry.isInt()) {
2582         DIBasicType BTy(DV.getType());
2583         if (BTy.Verify() &&
2584             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2585              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2586           Asm->OutStreamer.AddComment("DW_OP_consts");
2587           Asm->EmitInt8(dwarf::DW_OP_consts);
2588           Asm->EmitSLEB128(Entry.getInt());
2589         } else {
2590           Asm->OutStreamer.AddComment("DW_OP_constu");
2591           Asm->EmitInt8(dwarf::DW_OP_constu);
2592           Asm->EmitULEB128(Entry.getInt());
2593         }
2594       } else if (Entry.isLocation()) {
2595         MachineLocation Loc = Entry.getLoc();
2596         if (!DV.hasComplexAddress())
2597           // Regular entry.
2598           Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2599         else {
2600           // Complex address entry.
2601           unsigned N = DV.getNumAddrElements();
2602           unsigned i = 0;
2603           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2604             if (Loc.getOffset()) {
2605               i = 2;
2606               Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2607               Asm->OutStreamer.AddComment("DW_OP_deref");
2608               Asm->EmitInt8(dwarf::DW_OP_deref);
2609               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2610               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2611               Asm->EmitSLEB128(DV.getAddrElement(1));
2612             } else {
2613               // If first address element is OpPlus then emit
2614               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2615               MachineLocation TLoc(Loc.getReg(), DV.getAddrElement(1));
2616               Asm->EmitDwarfRegOp(TLoc, DV.isIndirect());
2617               i = 2;
2618             }
2619           } else {
2620             Asm->EmitDwarfRegOp(Loc, DV.isIndirect());
2621           }
2622
2623           // Emit remaining complex address elements.
2624           for (; i < N; ++i) {
2625             uint64_t Element = DV.getAddrElement(i);
2626             if (Element == DIBuilder::OpPlus) {
2627               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2628               Asm->EmitULEB128(DV.getAddrElement(++i));
2629             } else if (Element == DIBuilder::OpDeref) {
2630               if (!Loc.isReg())
2631                 Asm->EmitInt8(dwarf::DW_OP_deref);
2632             } else
2633               llvm_unreachable("unknown Opcode found in complex address");
2634           }
2635         }
2636       }
2637       // else ... ignore constant fp. There is not any good way to
2638       // to represent them here in dwarf.
2639       Asm->OutStreamer.EmitLabel(end);
2640     }
2641   }
2642 }
2643
2644 // Emit visible names into a debug aranges section.
2645 void DwarfDebug::emitDebugARanges() {
2646   // Start the dwarf aranges section.
2647   Asm->OutStreamer.SwitchSection(
2648                           Asm->getObjFileLowering().getDwarfARangesSection());
2649 }
2650
2651 // Emit visible names into a debug ranges section.
2652 void DwarfDebug::emitDebugRanges() {
2653   // Start the dwarf ranges section.
2654   Asm->OutStreamer.SwitchSection(
2655     Asm->getObjFileLowering().getDwarfRangesSection());
2656   unsigned char Size = Asm->getDataLayout().getPointerSize();
2657   for (SmallVectorImpl<const MCSymbol *>::iterator
2658          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2659        I != E; ++I) {
2660     if (*I)
2661       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2662     else
2663       Asm->OutStreamer.EmitIntValue(0, Size);
2664   }
2665 }
2666
2667 // Emit visible names into a debug macinfo section.
2668 void DwarfDebug::emitDebugMacInfo() {
2669   if (const MCSection *LineInfo =
2670       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2671     // Start the dwarf macinfo section.
2672     Asm->OutStreamer.SwitchSection(LineInfo);
2673   }
2674 }
2675
2676 // Emit inline info using following format.
2677 // Section Header:
2678 // 1. length of section
2679 // 2. Dwarf version number
2680 // 3. address size.
2681 //
2682 // Entries (one "entry" for each function that was inlined):
2683 //
2684 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2685 //   otherwise offset into __debug_str for regular function name.
2686 // 2. offset into __debug_str section for regular function name.
2687 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2688 // instances for the function.
2689 //
2690 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2691 // inlined instance; the die_offset points to the inlined_subroutine die in the
2692 // __debug_info section, and the low_pc is the starting address for the
2693 // inlining instance.
2694 void DwarfDebug::emitDebugInlineInfo() {
2695   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2696     return;
2697
2698   if (!FirstCU)
2699     return;
2700
2701   Asm->OutStreamer.SwitchSection(
2702                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2703
2704   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2705   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2706                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2707
2708   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2709
2710   Asm->OutStreamer.AddComment("Dwarf Version");
2711   Asm->EmitInt16(DwarfVersion);
2712   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2713   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2714
2715   for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2716          E = InlinedSPNodes.end(); I != E; ++I) {
2717
2718     const MDNode *Node = *I;
2719     InlineInfoMap::iterator II = InlineInfo.find(Node);
2720     SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2721     DISubprogram SP(Node);
2722     StringRef LName = SP.getLinkageName();
2723     StringRef Name = SP.getName();
2724
2725     Asm->OutStreamer.AddComment("MIPS linkage name");
2726     if (LName.empty())
2727       Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2728                              DwarfStrSectionSym);
2729     else
2730       Asm->EmitSectionOffset(
2731           InfoHolder.getStringPoolEntry(Function::getRealLinkageName(LName)),
2732           DwarfStrSectionSym);
2733
2734     Asm->OutStreamer.AddComment("Function name");
2735     Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2736                            DwarfStrSectionSym);
2737     Asm->EmitULEB128(Labels.size(), "Inline count");
2738
2739     for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2740            LE = Labels.end(); LI != LE; ++LI) {
2741       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2742       Asm->EmitInt32(LI->second->getOffset());
2743
2744       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2745       Asm->OutStreamer.EmitSymbolValue(LI->first,
2746                                        Asm->getDataLayout().getPointerSize());
2747     }
2748   }
2749
2750   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2751 }
2752
2753 // DWARF5 Experimental Separate Dwarf emitters.
2754
2755 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2756 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2757 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2758 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2759 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2760   DICompileUnit DIUnit(N);
2761   CompilationDir = DIUnit.getDirectory();
2762
2763   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2764   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2765                                        DIUnit.getLanguage(), Die, N, Asm,
2766                                        this, &SkeletonHolder);
2767
2768   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2769                         DIUnit.getSplitDebugFilename());
2770
2771   // This should be a unique identifier when we want to build .dwp files.
2772   NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2773
2774   // Relocate to the beginning of the addr_base section, else 0 for the
2775   // beginning of the one for this compile unit.
2776   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2777     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2778                     DwarfAddrSectionSym);
2779   else
2780     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base,
2781                    dwarf::DW_FORM_sec_offset, 0);
2782
2783   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2784   // into an entity. We're using 0, or a NULL label for this.
2785   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2786
2787   // DW_AT_stmt_list is a offset of line number information for this
2788   // compile unit in debug_line section.
2789   // FIXME: Should handle multiple compile units.
2790   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2791     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2792                     DwarfLineSectionSym);
2793   else
2794     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2795
2796   if (!CompilationDir.empty())
2797     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2798
2799   SkeletonHolder.addUnit(NewCU);
2800   SkeletonCUs.push_back(NewCU);
2801
2802   return NewCU;
2803 }
2804
2805 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2806   assert(useSplitDwarf() && "No split dwarf debug info?");
2807   emitAbbrevs(Section, &SkeletonAbbrevs);
2808 }
2809
2810 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2811 // compile units that would normally be in debug_info.
2812 void DwarfDebug::emitDebugInfoDWO() {
2813   assert(useSplitDwarf() && "No split dwarf debug info?");
2814   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2815                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2816                        DwarfAbbrevDWOSectionSym);
2817 }
2818
2819 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2820 // abbreviations for the .debug_info.dwo section.
2821 void DwarfDebug::emitDebugAbbrevDWO() {
2822   assert(useSplitDwarf() && "No split dwarf?");
2823   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2824               &Abbreviations);
2825 }
2826
2827 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2828 // string section and is identical in format to traditional .debug_str
2829 // sections.
2830 void DwarfDebug::emitDebugStrDWO() {
2831   assert(useSplitDwarf() && "No split dwarf?");
2832   const MCSection *OffSec = Asm->getObjFileLowering()
2833                             .getDwarfStrOffDWOSection();
2834   const MCSymbol *StrSym = DwarfStrSectionSym;
2835   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2836                          OffSec, StrSym);
2837 }