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