lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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