lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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