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