lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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