lib/CodeGen/AsmPrinter/DwarfDebug.cpp

   1 //===-- llvm/CodeGen/DwarfDebug.cpp - Dwarf Debug Framework ---------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file contains support for writing dwarf debug info into asm files.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15 #include "DwarfDebug.h"
  16 #include "DIE.h"
  17 #include "DwarfAccelTable.h"
  18 #include "DwarfCompileUnit.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/Module.h"
  21 #include "llvm/Instructions.h"
  22 #include "llvm/CodeGen/MachineFunction.h"
  23 #include "llvm/CodeGen/MachineModuleInfo.h"
  24 #include "llvm/MC/MCAsmInfo.h"
  25 #include "llvm/MC/MCSection.h"
  26 #include "llvm/MC/MCStreamer.h"
  27 #include "llvm/MC/MCSymbol.h"
  28 #include "llvm/Target/TargetData.h"
  29 #include "llvm/Target/TargetFrameLowering.h"
  30 #include "llvm/Target/TargetLoweringObjectFile.h"
  31 #include "llvm/Target/TargetMachine.h"
  32 #include "llvm/Target/TargetRegisterInfo.h"
  33 #include "llvm/Target/TargetOptions.h"
  34 #include "llvm/Analysis/DebugInfo.h"
  35 #include "llvm/Analysis/DIBuilder.h"
  36 #include "llvm/ADT/Statistic.h"
  37 #include "llvm/ADT/STLExtras.h"
  38 #include "llvm/ADT/StringExtras.h"
  39 #include "llvm/Support/CommandLine.h"
  40 #include "llvm/Support/Debug.h"
  41 #include "llvm/Support/ErrorHandling.h"
  42 #include "llvm/Support/ValueHandle.h"
  43 #include "llvm/Support/FormattedStream.h"
  44 #include "llvm/Support/Timer.h"
  45 #include "llvm/Support/Path.h"
  46 using namespace llvm;
  47
  48 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
  49                                               cl::Hidden,
  50      cl::desc("Disable debug info printing"));
  51
  52 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
  53      cl::desc("Make an absence of debug location information explicit."),
  54      cl::init(false));
  55
  56 static cl::opt<bool> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
  57      cl::desc("Output prototype dwarf accelerator tables."),
  58      cl::init(false));
  59
  60 namespace {
  61   const char *DWARFGroupName = "DWARF Emission";
  62   const char *DbgTimerName = "DWARF Debug Writer";
  63 } // end anonymous namespace
  64
  65 //===----------------------------------------------------------------------===//
  66
  67 /// Configuration values for initial hash set sizes (log2).
  68 ///
  69 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
  70
  71 namespace llvm {
  72
  73 DIType DbgVariable::getType() const {
  74   DIType Ty = Var.getType();
  75   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
  76   // addresses instead.
  77   if (Var.isBlockByrefVariable()) {
  78     /* Byref variables, in Blocks, are declared by the programmer as
  79        "SomeType VarName;", but the compiler creates a
  80        __Block_byref_x_VarName struct, and gives the variable VarName
  81        either the struct, or a pointer to the struct, as its type.  This
  82        is necessary for various behind-the-scenes things the compiler
  83        needs to do with by-reference variables in blocks.
  84
  85        However, as far as the original *programmer* is concerned, the
  86        variable should still have type 'SomeType', as originally declared.
  87
  88        The following function dives into the __Block_byref_x_VarName
  89        struct to find the original type of the variable.  This will be
  90        passed back to the code generating the type for the Debug
  91        Information Entry for the variable 'VarName'.  'VarName' will then
  92        have the original type 'SomeType' in its debug information.
  93
  94        The original type 'SomeType' will be the type of the field named
  95        'VarName' inside the __Block_byref_x_VarName struct.
  96
  97        NOTE: In order for this to not completely fail on the debugger
  98        side, the Debug Information Entry for the variable VarName needs to
  99        have a DW_AT_location that tells the debugger how to unwind through
 100        the pointers and __Block_byref_x_VarName struct to find the actual
 101        value of the variable.  The function addBlockByrefType does this.  */
 102     DIType subType = Ty;
 103     unsigned tag = Ty.getTag();
 104
 105     if (tag == dwarf::DW_TAG_pointer_type) {
 106       DIDerivedType DTy = DIDerivedType(Ty);
 107       subType = DTy.getTypeDerivedFrom();
 108     }
 109
 110     DICompositeType blockStruct = DICompositeType(subType);
 111     DIArray Elements = blockStruct.getTypeArray();
 112
 113     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 114       DIDescriptor Element = Elements.getElement(i);
 115       DIDerivedType DT = DIDerivedType(Element);
 116       if (getName() == DT.getName())
 117         return (DT.getTypeDerivedFrom());
 118     }
 119     return Ty;
 120   }
 121   return Ty;
 122 }
 123
 124 } // end llvm namespace
 125
 126 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 127   : Asm(A), MMI(Asm->MMI), FirstCU(0),
 128     AbbreviationsSet(InitAbbreviationsSetSize),
 129     PrevLabel(NULL) {
 130   NextStringPoolNumber = 0;
 131
 132   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 133   DwarfStrSectionSym = TextSectionSym = 0;
 134   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = 0;
 135   FunctionBeginSym = FunctionEndSym = 0;
 136   {
 137     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
 138     beginModule(M);
 139   }
 140 }
 141 DwarfDebug::~DwarfDebug() {
 142 }
 143
 144 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
 145 /// temporary label to it if SymbolStem is specified.
 146 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
 147                                 const char *SymbolStem = 0) {
 148   Asm->OutStreamer.SwitchSection(Section);
 149   if (!SymbolStem) return 0;
 150
 151   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
 152   Asm->OutStreamer.EmitLabel(TmpSym);
 153   return TmpSym;
 154 }
 155
 156 MCSymbol *DwarfDebug::getStringPool() {
 157   return Asm->GetTempSymbol("section_str");
 158 }
 159
 160 MCSymbol *DwarfDebug::getStringPoolEntry(StringRef Str) {
 161   std::pair<MCSymbol*, unsigned> &Entry = StringPool[Str];
 162   if (Entry.first) return Entry.first;
 163
 164   Entry.second = NextStringPoolNumber++;
 165   return Entry.first = Asm->GetTempSymbol("string", Entry.second);
 166 }
 167
 168 /// assignAbbrevNumber - Define a unique number for the abbreviation.
 169 ///
 170 void DwarfDebug::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 171   // Profile the node so that we can make it unique.
 172   FoldingSetNodeID ID;
 173   Abbrev.Profile(ID);
 174
 175   // Check the set for priors.
 176   DIEAbbrev *InSet = AbbreviationsSet.GetOrInsertNode(&Abbrev);
 177
 178   // If it's newly added.
 179   if (InSet == &Abbrev) {
 180     // Add to abbreviation list.
 181     Abbreviations.push_back(&Abbrev);
 182
 183     // Assign the vector position + 1 as its number.
 184     Abbrev.setNumber(Abbreviations.size());
 185   } else {
 186     // Assign existing abbreviation number.
 187     Abbrev.setNumber(InSet->getNumber());
 188   }
 189 }
 190
 191 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
 192 /// printer to not emit usual symbol prefix before the symbol name is used then
 193 /// return linkage name after skipping this special LLVM prefix.
 194 static StringRef getRealLinkageName(StringRef LinkageName) {
 195   char One = '\1';
 196   if (LinkageName.startswith(StringRef(&One, 1)))
 197     return LinkageName.substr(1);
 198   return LinkageName;
 199 }
 200
 201 static bool isObjCClass(StringRef Name) {
 202   return Name.startswith("+") || Name.startswith("-");
 203 }
 204
 205 static bool hasObjCCategory(StringRef Name) {
 206   if (!isObjCClass(Name)) return false;
 207
 208   size_t pos = Name.find(')');
 209   if (pos != std::string::npos) {
 210     if (Name[pos+1] != ' ') return false;
 211     return true;
 212   }
 213   return false;
 214 }
 215
 216 static void getObjCClassCategory(StringRef In, StringRef &Class,
 217                                  StringRef &Category) {
 218   if (!hasObjCCategory(In)) {
 219     Class = In.slice(In.find('[') + 1, In.find(' '));
 220     Category = "";
 221     return;
 222   }
 223
 224   Class = In.slice(In.find('[') + 1, In.find('('));
 225   Category = In.slice(In.find('[') + 1, In.find(' '));
 226   return;
 227 }
 228
 229 static StringRef getObjCMethodName(StringRef In) {
 230   return In.slice(In.find(' ') + 1, In.find(']'));
 231 }
 232
 233 // Add the various names to the Dwarf accelerator table names.
 234 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
 235                                DIE* Die) {
 236   if (!SP.isDefinition()) return;
 237
 238   TheCU->addAccelName(SP.getName(), Die);
 239
 240   // If the linkage name is different than the name, go ahead and output
 241   // that as well into the name table.
 242   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
 243     TheCU->addAccelName(SP.getLinkageName(), Die);
 244
 245   // If this is an Objective-C selector name add it to the ObjC accelerator
 246   // too.
 247   if (isObjCClass(SP.getName())) {
 248     StringRef Class, Category;
 249     getObjCClassCategory(SP.getName(), Class, Category);
 250     TheCU->addAccelObjC(Class, Die);
 251     if (Category != "")
 252       TheCU->addAccelObjC(Category, Die);
 253     // Also add the base method name to the name table.
 254     TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
 255   }
 256 }
 257
 258 /// updateSubprogramScopeDIE - Find DIE for the given subprogram and
 259 /// attach appropriate DW_AT_low_pc and DW_AT_high_pc attributes.
 260 /// If there are global variables in this scope then create and insert
 261 /// DIEs for these variables.
 262 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
 263                                           const MDNode *SPNode) {
 264   DIE *SPDie = SPCU->getDIE(SPNode);
 265
 266   assert(SPDie && "Unable to find subprogram DIE!");
 267   DISubprogram SP(SPNode);
 268
 269   DISubprogram SPDecl = SP.getFunctionDeclaration();
 270   if (!SPDecl.isSubprogram()) {
 271     // There is not any need to generate specification DIE for a function
 272     // defined at compile unit level. If a function is defined inside another
 273     // function then gdb prefers the definition at top level and but does not
 274     // expect specification DIE in parent function. So avoid creating
 275     // specification DIE for a function defined inside a function.
 276     if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
 277         !SP.getContext().isFile() &&
 278         !isSubprogramContext(SP.getContext())) {
 279       SPCU->addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 280
 281       // Add arguments.
 282       DICompositeType SPTy = SP.getType();
 283       DIArray Args = SPTy.getTypeArray();
 284       unsigned SPTag = SPTy.getTag();
 285       if (SPTag == dwarf::DW_TAG_subroutine_type)
 286         for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
 287           DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 288           DIType ATy = DIType(DIType(Args.getElement(i)));
 289           SPCU->addType(Arg, ATy);
 290           if (ATy.isArtificial())
 291             SPCU->addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
 292           SPDie->addChild(Arg);
 293         }
 294       DIE *SPDeclDie = SPDie;
 295       SPDie = new DIE(dwarf::DW_TAG_subprogram);
 296       SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
 297                         SPDeclDie);
 298       SPCU->addDie(SPDie);
 299     }
 300   }
 301   // Pick up abstract subprogram DIE.
 302   if (DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode)) {
 303     SPDie = new DIE(dwarf::DW_TAG_subprogram);
 304     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
 305                       dwarf::DW_FORM_ref4, AbsSPDIE);
 306     SPCU->addDie(SPDie);
 307   }
 308
 309   SPCU->addLabel(SPDie, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
 310                  Asm->GetTempSymbol("func_begin", Asm->getFunctionNumber()));
 311   SPCU->addLabel(SPDie, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
 312                  Asm->GetTempSymbol("func_end", Asm->getFunctionNumber()));
 313   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 314   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
 315   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
 316
 317   // Add name to the name table, we do this here because we're guaranteed
 318   // to have concrete versions of our DW_TAG_subprogram nodes.
 319   addSubprogramNames(SPCU, SP, SPDie);
 320
 321   return SPDie;
 322 }
 323
 324 /// constructLexicalScope - Construct new DW_TAG_lexical_block
 325 /// for this scope and attach DW_AT_low_pc/DW_AT_high_pc labels.
 326 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
 327                                           LexicalScope *Scope) {
 328   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
 329   if (Scope->isAbstractScope())
 330     return ScopeDIE;
 331
 332   const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
 333   if (Ranges.empty())
 334     return 0;
 335
 336   SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
 337   if (Ranges.size() > 1) {
 338     // .debug_range section has not been laid out yet. Emit offset in
 339     // .debug_range as a uint, size 4, for now. emitDIE will handle
 340     // DW_AT_ranges appropriately.
 341     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 342                    DebugRangeSymbols.size()
 343                    * Asm->getTargetData().getPointerSize());
 344     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
 345          RE = Ranges.end(); RI != RE; ++RI) {
 346       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 347       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 348     }
 349     DebugRangeSymbols.push_back(NULL);
 350     DebugRangeSymbols.push_back(NULL);
 351     return ScopeDIE;
 352   }
 353
 354   const MCSymbol *Start = getLabelBeforeInsn(RI->first);
 355   const MCSymbol *End = getLabelAfterInsn(RI->second);
 356
 357   if (End == 0) return 0;
 358
 359   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
 360   assert(End->isDefined() && "Invalid end label for an inlined scope!");
 361
 362   TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, Start);
 363   TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr, End);
 364
 365   return ScopeDIE;
 366 }
 367
 368 /// constructInlinedScopeDIE - This scope represents inlined body of
 369 /// a function. Construct DIE to represent this concrete inlined copy
 370 /// of the function.
 371 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
 372                                           LexicalScope *Scope) {
 373   const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
 374   assert(Ranges.empty() == false &&
 375          "LexicalScope does not have instruction markers!");
 376
 377   if (!Scope->getScopeNode())
 378     return NULL;
 379   DIScope DS(Scope->getScopeNode());
 380   DISubprogram InlinedSP = getDISubprogram(DS);
 381   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
 382   if (!OriginDIE) {
 383     DEBUG(dbgs() << "Unable to find original DIE for inlined subprogram.");
 384     return NULL;
 385   }
 386
 387   SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
 388   const MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
 389   const MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
 390
 391   if (StartLabel == 0 || EndLabel == 0) {
 392     assert(0 && "Unexpected Start and End labels for a inlined scope!");
 393     return 0;
 394   }
 395   assert(StartLabel->isDefined() &&
 396          "Invalid starting label for an inlined scope!");
 397   assert(EndLabel->isDefined() &&
 398          "Invalid end label for an inlined scope!");
 399
 400   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
 401   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
 402                      dwarf::DW_FORM_ref4, OriginDIE);
 403
 404   if (Ranges.size() > 1) {
 405     // .debug_range section has not been laid out yet. Emit offset in
 406     // .debug_range as a uint, size 4, for now. emitDIE will handle
 407     // DW_AT_ranges appropriately.
 408     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 409                    DebugRangeSymbols.size()
 410                    * Asm->getTargetData().getPointerSize());
 411     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
 412          RE = Ranges.end(); RI != RE; ++RI) {
 413       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 414       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 415     }
 416     DebugRangeSymbols.push_back(NULL);
 417     DebugRangeSymbols.push_back(NULL);
 418   } else {
 419     TheCU->addLabel(ScopeDIE, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr,
 420                     StartLabel);
 421     TheCU->addLabel(ScopeDIE, dwarf::DW_AT_high_pc, dwarf::DW_FORM_addr,
 422                     EndLabel);
 423   }
 424
 425   InlinedSubprogramDIEs.insert(OriginDIE);
 426
 427   // Track the start label for this inlined function.
 428   //.debug_inlined section specification does not clearly state how
 429   // to emit inlined scope that is split into multiple instruction ranges.
 430   // For now, use first instruction range and emit low_pc/high_pc pair and
 431   // corresponding .debug_inlined section entry for this pair.
 432   DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
 433     I = InlineInfo.find(InlinedSP);
 434
 435   if (I == InlineInfo.end()) {
 436     InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
 437     InlinedSPNodes.push_back(InlinedSP);
 438   } else
 439     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
 440
 441   DILocation DL(Scope->getInlinedAt());
 442   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0, TheCU->getID());
 443   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
 444
 445   // Add name to the name table, we do this here because we're guaranteed
 446   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
 447   addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
 448
 449   return ScopeDIE;
 450 }
 451
 452 /// constructScopeDIE - Construct a DIE for this scope.
 453 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
 454   if (!Scope || !Scope->getScopeNode())
 455     return NULL;
 456
 457   SmallVector<DIE *, 8> Children;
 458
 459   // Collect arguments for current function.
 460   if (LScopes.isCurrentFunctionScope(Scope))
 461     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
 462       if (DbgVariable *ArgDV = CurrentFnArguments[i])
 463         if (DIE *Arg =
 464             TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope()))
 465           Children.push_back(Arg);
 466
 467   // Collect lexical scope children first.
 468   const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
 469   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
 470     if (DIE *Variable =
 471         TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope()))
 472       Children.push_back(Variable);
 473   const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
 474   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
 475     if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
 476       Children.push_back(Nested);
 477   DIScope DS(Scope->getScopeNode());
 478   DIE *ScopeDIE = NULL;
 479   if (Scope->getInlinedAt())
 480     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
 481   else if (DS.isSubprogram()) {
 482     ProcessedSPNodes.insert(DS);
 483     if (Scope->isAbstractScope()) {
 484       ScopeDIE = TheCU->getDIE(DS);
 485       // Note down abstract DIE.
 486       if (ScopeDIE)
 487         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
 488     }
 489     else
 490       ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
 491   }
 492   else {
 493     // There is no need to emit empty lexical block DIE.
 494     if (Children.empty())
 495       return NULL;
 496     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
 497   }
 498
 499   if (!ScopeDIE) return NULL;
 500
 501   // Add children
 502   for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
 503          E = Children.end(); I != E; ++I)
 504     ScopeDIE->addChild(*I);
 505
 506   if (DS.isSubprogram())
 507     TheCU->addPubTypes(DISubprogram(DS));
 508
 509   return ScopeDIE;
 510 }
 511
 512 /// GetOrCreateSourceID - Look up the source id with the given directory and
 513 /// source file names. If none currently exists, create a new id and insert it
 514 /// in the SourceIds map. This can update DirectoryNames and SourceFileNames
 515 /// maps as well.
 516 unsigned DwarfDebug::GetOrCreateSourceID(StringRef FileName,
 517                                          StringRef DirName) {
 518   // If FE did not provide a file name, then assume stdin.
 519   if (FileName.empty())
 520     return GetOrCreateSourceID("<stdin>", StringRef());
 521
 522   // TODO: this might not belong here. See if we can factor this better.
 523   if (DirName == CompilationDir)
 524     DirName = "";
 525
 526   unsigned SrcId = SourceIdMap.size()+1;
 527   std::pair<std::string, std::string> SourceName =
 528       std::make_pair(FileName, DirName);
 529   std::pair<std::pair<std::string, std::string>, unsigned> Entry =
 530       make_pair(SourceName, SrcId);
 531
 532   std::map<std::pair<std::string, std::string>, unsigned>::iterator I;
 533   bool NewlyInserted;
 534   tie(I, NewlyInserted) = SourceIdMap.insert(Entry);
 535   if (!NewlyInserted)
 536     return I->second;
 537
 538   // Print out a .file directive to specify files for .loc directives.
 539   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, Entry.first.second,
 540                                           Entry.first.first);
 541
 542   return SrcId;
 543 }
 544
 545 /// constructCompileUnit - Create new CompileUnit for the given
 546 /// metadata node with tag DW_TAG_compile_unit.
 547 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
 548   DICompileUnit DIUnit(N);
 549   StringRef FN = DIUnit.getFilename();
 550   CompilationDir = DIUnit.getDirectory();
 551   unsigned ID = GetOrCreateSourceID(FN, CompilationDir);
 552
 553   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
 554   CompileUnit *NewCU = new CompileUnit(ID, Die, Asm, this);
 555   NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
 556   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
 557                  DIUnit.getLanguage());
 558   NewCU->addString(Die, dwarf::DW_AT_name, FN);
 559   // Use DW_AT_entry_pc instead of DW_AT_low_pc/DW_AT_high_pc pair. This
 560   // simplifies debug range entries.
 561   NewCU->addUInt(Die, dwarf::DW_AT_entry_pc, dwarf::DW_FORM_addr, 0);
 562   // DW_AT_stmt_list is a offset of line number information for this
 563   // compile unit in debug_line section.
 564   if (Asm->MAI->doesDwarfRequireRelocationForSectionOffset())
 565     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
 566                     Asm->GetTempSymbol("section_line"));
 567   else
 568     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
 569
 570   if (!CompilationDir.empty())
 571     NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
 572   if (DIUnit.isOptimized())
 573     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
 574
 575   StringRef Flags = DIUnit.getFlags();
 576   if (!Flags.empty())
 577     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
 578
 579   if (unsigned RVer = DIUnit.getRunTimeVersion())
 580     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
 581             dwarf::DW_FORM_data1, RVer);
 582
 583   if (!FirstCU)
 584     FirstCU = NewCU;
 585   CUMap.insert(std::make_pair(N, NewCU));
 586   return NewCU;
 587 }
 588
 589 /// construct SubprogramDIE - Construct subprogram DIE.
 590 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
 591                                         const MDNode *N) {
 592   CompileUnit *&CURef = SPMap[N];
 593   if (CURef)
 594     return;
 595   CURef = TheCU;
 596
 597   DISubprogram SP(N);
 598   if (!SP.isDefinition())
 599     // This is a method declaration which will be handled while constructing
 600     // class type.
 601     return;
 602
 603   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
 604
 605   // Add to map.
 606   TheCU->insertDIE(N, SubprogramDie);
 607
 608   // Add to context owner.
 609   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
 610
 611   return;
 612 }
 613
 614 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
 615 /// as llvm.dbg.enum and llvm.dbg.ty
 616 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
 617   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
 618     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 619       const MDNode *N = NMD->getOperand(i);
 620       if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
 621         constructSubprogramDIE(CU, N);
 622     }
 623
 624   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
 625     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 626       const MDNode *N = NMD->getOperand(i);
 627       if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
 628         CU->createGlobalVariableDIE(N);
 629     }
 630
 631   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
 632     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 633       DIType Ty(NMD->getOperand(i));
 634       if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
 635         CU->getOrCreateTypeDIE(Ty);
 636     }
 637
 638   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
 639     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 640       DIType Ty(NMD->getOperand(i));
 641       if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
 642         CU->getOrCreateTypeDIE(Ty);
 643     }
 644 }
 645
 646 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
 647 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
 648 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
 649   DebugInfoFinder DbgFinder;
 650   DbgFinder.processModule(*M);
 651
 652   bool HasDebugInfo = false;
 653   // Scan all the compile-units to see if there are any marked as the main
 654   // unit. If not, we do not generate debug info.
 655   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
 656          E = DbgFinder.compile_unit_end(); I != E; ++I) {
 657     if (DICompileUnit(*I).isMain()) {
 658       HasDebugInfo = true;
 659       break;
 660     }
 661   }
 662   if (!HasDebugInfo) return false;
 663
 664   // Create all the compile unit DIEs.
 665   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
 666          E = DbgFinder.compile_unit_end(); I != E; ++I)
 667     constructCompileUnit(*I);
 668
 669   // Create DIEs for each global variable.
 670   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
 671          E = DbgFinder.global_variable_end(); I != E; ++I) {
 672     const MDNode *N = *I;
 673     if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
 674       CU->createGlobalVariableDIE(N);
 675   }
 676
 677   // Create DIEs for each subprogram.
 678   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
 679          E = DbgFinder.subprogram_end(); I != E; ++I) {
 680     const MDNode *N = *I;
 681     if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
 682       constructSubprogramDIE(CU, N);
 683   }
 684
 685   return HasDebugInfo;
 686 }
 687
 688 /// beginModule - Emit all Dwarf sections that should come prior to the
 689 /// content. Create global DIEs and emit initial debug info sections.
 690 /// This is invoked by the target AsmPrinter.
 691 void DwarfDebug::beginModule(Module *M) {
 692   if (DisableDebugInfoPrinting)
 693     return;
 694
 695   // If module has named metadata anchors then use them, otherwise scan the
 696   // module using debug info finder to collect debug info.
 697   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 698   if (CU_Nodes) {
 699     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 700       DICompileUnit CUNode(CU_Nodes->getOperand(i));
 701       CompileUnit *CU = constructCompileUnit(CUNode);
 702       DIArray GVs = CUNode.getGlobalVariables();
 703       for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 704         CU->createGlobalVariableDIE(GVs.getElement(i));
 705       DIArray SPs = CUNode.getSubprograms();
 706       for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 707         constructSubprogramDIE(CU, SPs.getElement(i));
 708       DIArray EnumTypes = CUNode.getEnumTypes();
 709       for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 710         CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 711       DIArray RetainedTypes = CUNode.getRetainedTypes();
 712       for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 713         CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 714     }
 715   } else if (!collectLegacyDebugInfo(M))
 716     return;
 717
 718   collectInfoFromNamedMDNodes(M);
 719
 720   // Tell MMI that we have debug info.
 721   MMI->setDebugInfoAvailability(true);
 722
 723   // Emit initial sections.
 724   EmitSectionLabels();
 725
 726   // Prime section data.
 727   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
 728 }
 729
 730 /// endModule - Emit all Dwarf sections that should come after the content.
 731 ///
 732 void DwarfDebug::endModule() {
 733   if (!FirstCU) return;
 734   const Module *M = MMI->getModule();
 735   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 736
 737   // Collect info for variables that were optimized out.
 738   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 739     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 740       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 741       DIArray Subprograms = TheCU.getSubprograms();
 742       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 743         DISubprogram SP(Subprograms.getElement(i));
 744         if (ProcessedSPNodes.count(SP) != 0) continue;
 745         if (!SP.Verify()) continue;
 746         if (!SP.isDefinition()) continue;
 747         DIArray Variables = SP.getVariables();
 748         if (Variables.getNumElements() == 0) continue;
 749
 750         LexicalScope *Scope =
 751           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 752         DeadFnScopeMap[SP] = Scope;
 753
 754         // Construct subprogram DIE and add variables DIEs.
 755         CompileUnit *SPCU = CUMap.lookup(TheCU);
 756         assert(SPCU && "Unable to find Compile Unit!");
 757         constructSubprogramDIE(SPCU, SP);
 758         DIE *ScopeDIE = SPCU->getDIE(SP);
 759         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 760           DIVariable DV(Variables.getElement(vi));
 761           if (!DV.Verify()) continue;
 762           DbgVariable *NewVar = new DbgVariable(DV, NULL);
 763           if (DIE *VariableDIE =
 764               SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
 765             ScopeDIE->addChild(VariableDIE);
 766         }
 767       }
 768     }
 769   }
 770
 771   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 772   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 773          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 774     DIE *ISP = *AI;
 775     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 776   }
 777   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 778          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 779     DIE *ISP = AI->second;
 780     if (InlinedSubprogramDIEs.count(ISP))
 781       continue;
 782     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 783   }
 784
 785   // Emit DW_AT_containing_type attribute to connect types with their
 786   // vtable holding type.
 787   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
 788          CUE = CUMap.end(); CUI != CUE; ++CUI) {
 789     CompileUnit *TheCU = CUI->second;
 790     TheCU->constructContainingTypeDIEs();
 791   }
 792
 793   // Standard sections final addresses.
 794   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
 795   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
 796   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
 797   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
 798
 799   // End text sections.
 800   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
 801     Asm->OutStreamer.SwitchSection(SectionMap[i]);
 802     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
 803   }
 804
 805   // Compute DIE offsets and sizes.
 806   computeSizeAndOffsets();
 807
 808   // Emit all the DIEs into a debug info section
 809   emitDebugInfo();
 810
 811   // Corresponding abbreviations into a abbrev section.
 812   emitAbbreviations();
 813
 814   // Emit info into a dwarf accelerator table sections.
 815   if (DwarfAccelTables) {
 816     emitAccelNames();
 817     emitAccelObjC();
 818     emitAccelNamespaces();
 819     emitAccelTypes();
 820   }
 821
 822   // Emit info into a debug pubtypes section.
 823   emitDebugPubTypes();
 824
 825   // Emit info into a debug loc section.
 826   emitDebugLoc();
 827
 828   // Emit info into a debug aranges section.
 829   EmitDebugARanges();
 830
 831   // Emit info into a debug ranges section.
 832   emitDebugRanges();
 833
 834   // Emit info into a debug macinfo section.
 835   emitDebugMacInfo();
 836
 837   // Emit inline info.
 838   emitDebugInlineInfo();
 839
 840   // Emit info into a debug str section.
 841   emitDebugStr();
 842
 843   // clean up.
 844   DeleteContainerSeconds(DeadFnScopeMap);
 845   SPMap.clear();
 846   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
 847          E = CUMap.end(); I != E; ++I)
 848     delete I->second;
 849   FirstCU = NULL;  // Reset for the next Module, if any.
 850 }
 851
 852 /// findAbstractVariable - Find abstract variable, if any, associated with Var.
 853 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
 854                                               DebugLoc ScopeLoc) {
 855   LLVMContext &Ctx = DV->getContext();
 856   // More then one inlined variable corresponds to one abstract variable.
 857   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
 858   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
 859   if (AbsDbgVariable)
 860     return AbsDbgVariable;
 861
 862   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
 863   if (!Scope)
 864     return NULL;
 865
 866   AbsDbgVariable = new DbgVariable(Var, NULL);
 867   addScopeVariable(Scope, AbsDbgVariable);
 868   AbstractVariables[Var] = AbsDbgVariable;
 869   return AbsDbgVariable;
 870 }
 871
 872 /// addCurrentFnArgument - If Var is a current function argument then add
 873 /// it to CurrentFnArguments list.
 874 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
 875                                       DbgVariable *Var, LexicalScope *Scope) {
 876   if (!LScopes.isCurrentFunctionScope(Scope))
 877     return false;
 878   DIVariable DV = Var->getVariable();
 879   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
 880     return false;
 881   unsigned ArgNo = DV.getArgNumber();
 882   if (ArgNo == 0)
 883     return false;
 884
 885   size_t Size = CurrentFnArguments.size();
 886   if (Size == 0)
 887     CurrentFnArguments.resize(MF->getFunction()->arg_size());
 888   // llvm::Function argument size is not good indicator of how many
 889   // arguments does the function have at source level.
 890   if (ArgNo > Size)
 891     CurrentFnArguments.resize(ArgNo * 2);
 892   CurrentFnArguments[ArgNo - 1] = Var;
 893   return true;
 894 }
 895
 896 /// collectVariableInfoFromMMITable - Collect variable information from
 897 /// side table maintained by MMI.
 898 void
 899 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
 900                                    SmallPtrSet<const MDNode *, 16> &Processed) {
 901   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
 902   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
 903          VE = VMap.end(); VI != VE; ++VI) {
 904     const MDNode *Var = VI->first;
 905     if (!Var) continue;
 906     Processed.insert(Var);
 907     DIVariable DV(Var);
 908     const std::pair<unsigned, DebugLoc> &VP = VI->second;
 909
 910     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
 911
 912     // If variable scope is not found then skip this variable.
 913     if (Scope == 0)
 914       continue;
 915
 916     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
 917     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
 918     RegVar->setFrameIndex(VP.first);
 919     if (!addCurrentFnArgument(MF, RegVar, Scope))
 920       addScopeVariable(Scope, RegVar);
 921     if (AbsDbgVariable)
 922       AbsDbgVariable->setFrameIndex(VP.first);
 923   }
 924 }
 925
 926 /// isDbgValueInDefinedReg - Return true if debug value, encoded by
 927 /// DBG_VALUE instruction, is in a defined reg.
 928 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
 929   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
 930   return MI->getNumOperands() == 3 &&
 931          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
 932          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
 933 }
 934
 935 /// getDebugLocEntry - Get .debug_loc entry for the instruction range starting
 936 /// at MI.
 937 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
 938                                          const MCSymbol *FLabel,
 939                                          const MCSymbol *SLabel,
 940                                          const MachineInstr *MI) {
 941   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
 942
 943   if (MI->getNumOperands() != 3) {
 944     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
 945     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
 946   }
 947   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
 948     MachineLocation MLoc;
 949     MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
 950     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
 951   }
 952   if (MI->getOperand(0).isImm())
 953     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
 954   if (MI->getOperand(0).isFPImm())
 955     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
 956   if (MI->getOperand(0).isCImm())
 957     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
 958
 959   assert(0 && "Unexpected 3 operand DBG_VALUE instruction!");
 960   return DotDebugLocEntry();
 961 }
 962
 963 /// collectVariableInfo - Find variables for each lexical scope.
 964 void
 965 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
 966                                 SmallPtrSet<const MDNode *, 16> &Processed) {
 967
 968   /// collection info from MMI table.
 969   collectVariableInfoFromMMITable(MF, Processed);
 970
 971   for (SmallVectorImpl<const MDNode*>::const_iterator
 972          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
 973          ++UVI) {
 974     const MDNode *Var = *UVI;
 975     if (Processed.count(Var))
 976       continue;
 977
 978     // History contains relevant DBG_VALUE instructions for Var and instructions
 979     // clobbering it.
 980     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
 981     if (History.empty())
 982       continue;
 983     const MachineInstr *MInsn = History.front();
 984
 985     DIVariable DV(Var);
 986     LexicalScope *Scope = NULL;
 987     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
 988         DISubprogram(DV.getContext()).describes(MF->getFunction()))
 989       Scope = LScopes.getCurrentFunctionScope();
 990     else {
 991       if (DV.getVersion() <= LLVMDebugVersion9)
 992         Scope = LScopes.findLexicalScope(MInsn->getDebugLoc());
 993       else {
 994         if (MDNode *IA = DV.getInlinedAt())
 995           Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
 996         else
 997           Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
 998       }
 999     }
1000     // If variable scope is not found then skip this variable.
1001     if (!Scope)
1002       continue;
1003
1004     Processed.insert(DV);
1005     assert(MInsn->isDebugValue() && "History must begin with debug value");
1006     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1007     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1008     if (!addCurrentFnArgument(MF, RegVar, Scope))
1009       addScopeVariable(Scope, RegVar);
1010     if (AbsVar)
1011       AbsVar->setMInsn(MInsn);
1012
1013     // Simple ranges that are fully coalesced.
1014     if (History.size() <= 1 || (History.size() == 2 &&
1015                                 MInsn->isIdenticalTo(History.back()))) {
1016       RegVar->setMInsn(MInsn);
1017       continue;
1018     }
1019
1020     // handle multiple DBG_VALUE instructions describing one variable.
1021     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1022
1023     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1024            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1025       const MachineInstr *Begin = *HI;
1026       assert(Begin->isDebugValue() && "Invalid History entry");
1027
1028       // Check if DBG_VALUE is truncating a range.
1029       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1030           && !Begin->getOperand(0).getReg())
1031         continue;
1032
1033       // Compute the range for a register location.
1034       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1035       const MCSymbol *SLabel = 0;
1036
1037       if (HI + 1 == HE)
1038         // If Begin is the last instruction in History then its value is valid
1039         // until the end of the function.
1040         SLabel = FunctionEndSym;
1041       else {
1042         const MachineInstr *End = HI[1];
1043         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1044               << "\t" << *Begin << "\t" << *End << "\n");
1045         if (End->isDebugValue())
1046           SLabel = getLabelBeforeInsn(End);
1047         else {
1048           // End is a normal instruction clobbering the range.
1049           SLabel = getLabelAfterInsn(End);
1050           assert(SLabel && "Forgot label after clobber instruction");
1051           ++HI;
1052         }
1053       }
1054
1055       // The value is valid until the next DBG_VALUE or clobber.
1056       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1057                                                     Begin));
1058     }
1059     DotDebugLocEntries.push_back(DotDebugLocEntry());
1060   }
1061
1062   // Collect info for variables that were optimized out.
1063   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1064   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1065   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1066     DIVariable DV(Variables.getElement(i));
1067     if (!DV || !DV.Verify() || !Processed.insert(DV))
1068       continue;
1069     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1070       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1071   }
1072 }
1073
1074 /// getLabelBeforeInsn - Return Label preceding the instruction.
1075 const MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1076   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1077   assert(Label && "Didn't insert label before instruction");
1078   return Label;
1079 }
1080
1081 /// getLabelAfterInsn - Return Label immediately following the instruction.
1082 const MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1083   return LabelsAfterInsn.lookup(MI);
1084 }
1085
1086 /// beginInstruction - Process beginning of an instruction.
1087 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1088   // Check if source location changes, but ignore DBG_VALUE locations.
1089   if (!MI->isDebugValue()) {
1090     DebugLoc DL = MI->getDebugLoc();
1091     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1092       unsigned Flags = DWARF2_FLAG_IS_STMT;
1093       PrevInstLoc = DL;
1094       if (DL == PrologEndLoc) {
1095         Flags |= DWARF2_FLAG_PROLOGUE_END;
1096         PrologEndLoc = DebugLoc();
1097       }
1098       if (!DL.isUnknown()) {
1099         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1100         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1101       } else
1102         recordSourceLine(0, 0, 0, 0);
1103     }
1104   }
1105
1106   // Insert labels where requested.
1107   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1108     LabelsBeforeInsn.find(MI);
1109
1110   // No label needed.
1111   if (I == LabelsBeforeInsn.end())
1112     return;
1113
1114   // Label already assigned.
1115   if (I->second)
1116     return;
1117
1118   if (!PrevLabel) {
1119     PrevLabel = MMI->getContext().CreateTempSymbol();
1120     Asm->OutStreamer.EmitLabel(PrevLabel);
1121   }
1122   I->second = PrevLabel;
1123 }
1124
1125 /// endInstruction - Process end of an instruction.
1126 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1127   // Don't create a new label after DBG_VALUE instructions.
1128   // They don't generate code.
1129   if (!MI->isDebugValue())
1130     PrevLabel = 0;
1131
1132   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1133     LabelsAfterInsn.find(MI);
1134
1135   // No label needed.
1136   if (I == LabelsAfterInsn.end())
1137     return;
1138
1139   // Label already assigned.
1140   if (I->second)
1141     return;
1142
1143   // We need a label after this instruction.
1144   if (!PrevLabel) {
1145     PrevLabel = MMI->getContext().CreateTempSymbol();
1146     Asm->OutStreamer.EmitLabel(PrevLabel);
1147   }
1148   I->second = PrevLabel;
1149 }
1150
1151 /// identifyScopeMarkers() -
1152 /// Each LexicalScope has first instruction and last instruction to mark
1153 /// beginning and end of a scope respectively. Create an inverse map that list
1154 /// scopes starts (and ends) with an instruction. One instruction may start (or
1155 /// end) multiple scopes. Ignore scopes that are not reachable.
1156 void DwarfDebug::identifyScopeMarkers() {
1157   SmallVector<LexicalScope *, 4> WorkList;
1158   WorkList.push_back(LScopes.getCurrentFunctionScope());
1159   while (!WorkList.empty()) {
1160     LexicalScope *S = WorkList.pop_back_val();
1161
1162     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1163     if (!Children.empty())
1164       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1165              SE = Children.end(); SI != SE; ++SI)
1166         WorkList.push_back(*SI);
1167
1168     if (S->isAbstractScope())
1169       continue;
1170
1171     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1172     if (Ranges.empty())
1173       continue;
1174     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1175            RE = Ranges.end(); RI != RE; ++RI) {
1176       assert(RI->first && "InsnRange does not have first instruction!");
1177       assert(RI->second && "InsnRange does not have second instruction!");
1178       requestLabelBeforeInsn(RI->first);
1179       requestLabelAfterInsn(RI->second);
1180     }
1181   }
1182 }
1183
1184 /// getScopeNode - Get MDNode for DebugLoc's scope.
1185 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1186   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1187     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1188   return DL.getScope(Ctx);
1189 }
1190
1191 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1192 /// line number  info for the function.
1193 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1194   const MDNode *Scope = getScopeNode(DL, Ctx);
1195   DISubprogram SP = getDISubprogram(Scope);
1196   if (SP.Verify())
1197     return DebugLoc::get(SP.getLineNumber(), 0, SP);
1198   return DebugLoc();
1199 }
1200
1201 /// beginFunction - Gather pre-function debug information.  Assumes being
1202 /// emitted immediately after the function entry point.
1203 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1204   if (!MMI->hasDebugInfo()) return;
1205   LScopes.initialize(*MF);
1206   if (LScopes.empty()) return;
1207   identifyScopeMarkers();
1208
1209   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1210                                         Asm->getFunctionNumber());
1211   // Assumes in correct section after the entry point.
1212   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1213
1214   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1215
1216   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1217   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1218   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1219
1220   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1221        I != E; ++I) {
1222     bool AtBlockEntry = true;
1223     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1224          II != IE; ++II) {
1225       const MachineInstr *MI = II;
1226
1227       if (MI->isDebugValue()) {
1228         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1229
1230         // Keep track of user variables.
1231         const MDNode *Var =
1232           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1233
1234         // Variable is in a register, we need to check for clobbers.
1235         if (isDbgValueInDefinedReg(MI))
1236           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1237
1238         // Check the history of this variable.
1239         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1240         if (History.empty()) {
1241           UserVariables.push_back(Var);
1242           // The first mention of a function argument gets the FunctionBeginSym
1243           // label, so arguments are visible when breaking at function entry.
1244           DIVariable DV(Var);
1245           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1246               DISubprogram(getDISubprogram(DV.getContext()))
1247                 .describes(MF->getFunction()))
1248             LabelsBeforeInsn[MI] = FunctionBeginSym;
1249         } else {
1250           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1251           const MachineInstr *Prev = History.back();
1252           if (Prev->isDebugValue()) {
1253             // Coalesce identical entries at the end of History.
1254             if (History.size() >= 2 &&
1255                 Prev->isIdenticalTo(History[History.size() - 2])) {
1256               DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1257                     << "\t" << *Prev
1258                     << "\t" << *History[History.size() - 2] << "\n");
1259               History.pop_back();
1260             }
1261
1262             // Terminate old register assignments that don't reach MI;
1263             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1264             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1265                 isDbgValueInDefinedReg(Prev)) {
1266               // Previous register assignment needs to terminate at the end of
1267               // its basic block.
1268               MachineBasicBlock::const_iterator LastMI =
1269                 PrevMBB->getLastNonDebugInstr();
1270               if (LastMI == PrevMBB->end()) {
1271                 // Drop DBG_VALUE for empty range.
1272                 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1273                       << "\t" << *Prev << "\n");
1274                 History.pop_back();
1275               }
1276               else {
1277                 // Terminate after LastMI.
1278                 History.push_back(LastMI);
1279               }
1280             }
1281           }
1282         }
1283         History.push_back(MI);
1284       } else {
1285         // Not a DBG_VALUE instruction.
1286         if (!MI->isLabel())
1287           AtBlockEntry = false;
1288
1289         // First known non DBG_VALUE location marks beginning of function
1290         // body.
1291         if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1292           PrologEndLoc = MI->getDebugLoc();
1293
1294         // Check if the instruction clobbers any registers with debug vars.
1295         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1296                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1297           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1298             continue;
1299           for (const unsigned *AI = TRI->getOverlaps(MOI->getReg());
1300                unsigned Reg = *AI; ++AI) {
1301             const MDNode *Var = LiveUserVar[Reg];
1302             if (!Var)
1303               continue;
1304             // Reg is now clobbered.
1305             LiveUserVar[Reg] = 0;
1306
1307             // Was MD last defined by a DBG_VALUE referring to Reg?
1308             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1309             if (HistI == DbgValues.end())
1310               continue;
1311             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1312             if (History.empty())
1313               continue;
1314             const MachineInstr *Prev = History.back();
1315             // Sanity-check: Register assignments are terminated at the end of
1316             // their block.
1317             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1318               continue;
1319             // Is the variable still in Reg?
1320             if (!isDbgValueInDefinedReg(Prev) ||
1321                 Prev->getOperand(0).getReg() != Reg)
1322               continue;
1323             // Var is clobbered. Make sure the next instruction gets a label.
1324             History.push_back(MI);
1325           }
1326         }
1327       }
1328     }
1329   }
1330
1331   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1332        I != E; ++I) {
1333     SmallVectorImpl<const MachineInstr*> &History = I->second;
1334     if (History.empty())
1335       continue;
1336
1337     // Make sure the final register assignments are terminated.
1338     const MachineInstr *Prev = History.back();
1339     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1340       const MachineBasicBlock *PrevMBB = Prev->getParent();
1341       MachineBasicBlock::const_iterator LastMI =
1342         PrevMBB->getLastNonDebugInstr();
1343       if (LastMI == PrevMBB->end())
1344         // Drop DBG_VALUE for empty range.
1345         History.pop_back();
1346       else {
1347         // Terminate after LastMI.
1348         History.push_back(LastMI);
1349       }
1350     }
1351     // Request labels for the full history.
1352     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1353       const MachineInstr *MI = History[i];
1354       if (MI->isDebugValue())
1355         requestLabelBeforeInsn(MI);
1356       else
1357         requestLabelAfterInsn(MI);
1358     }
1359   }
1360
1361   PrevInstLoc = DebugLoc();
1362   PrevLabel = FunctionBeginSym;
1363
1364   // Record beginning of function.
1365   if (!PrologEndLoc.isUnknown()) {
1366     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1367                                        MF->getFunction()->getContext());
1368     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1369                      FnStartDL.getScope(MF->getFunction()->getContext()),
1370                      DWARF2_FLAG_IS_STMT);
1371   }
1372 }
1373
1374 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1375 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1376   ScopeVariables[LS].push_back(Var);
1377 //  Vars.push_back(Var);
1378 }
1379
1380 /// endFunction - Gather and emit post-function debug information.
1381 ///
1382 void DwarfDebug::endFunction(const MachineFunction *MF) {
1383   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1384
1385   // Define end label for subprogram.
1386   FunctionEndSym = Asm->GetTempSymbol("func_end",
1387                                       Asm->getFunctionNumber());
1388   // Assumes in correct section after the entry point.
1389   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1390
1391   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1392   collectVariableInfo(MF, ProcessedVars);
1393
1394   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1395   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1396   assert(TheCU && "Unable to find compile unit!");
1397
1398   // Construct abstract scopes.
1399   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1400   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1401     LexicalScope *AScope = AList[i];
1402     DISubprogram SP(AScope->getScopeNode());
1403     if (SP.Verify()) {
1404       // Collect info for variables that were optimized out.
1405       DIArray Variables = SP.getVariables();
1406       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1407         DIVariable DV(Variables.getElement(i));
1408         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1409           continue;
1410         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1411           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1412       }
1413     }
1414     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1415       constructScopeDIE(TheCU, AScope);
1416   }
1417
1418   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1419
1420   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1421     TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1422                    dwarf::DW_FORM_flag, 1);
1423
1424   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1425                                                MMI->getFrameMoves()));
1426
1427   // Clear debug info
1428   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1429          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1430     DeleteContainerPointers(I->second);
1431   ScopeVariables.clear();
1432   DeleteContainerPointers(CurrentFnArguments);
1433   UserVariables.clear();
1434   DbgValues.clear();
1435   AbstractVariables.clear();
1436   LabelsBeforeInsn.clear();
1437   LabelsAfterInsn.clear();
1438   PrevLabel = NULL;
1439 }
1440
1441 /// recordSourceLine - Register a source line with debug info. Returns the
1442 /// unique label that was emitted and which provides correspondence to
1443 /// the source line list.
1444 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1445                                   unsigned Flags) {
1446   StringRef Fn;
1447   StringRef Dir;
1448   unsigned Src = 1;
1449   if (S) {
1450     DIDescriptor Scope(S);
1451
1452     if (Scope.isCompileUnit()) {
1453       DICompileUnit CU(S);
1454       Fn = CU.getFilename();
1455       Dir = CU.getDirectory();
1456     } else if (Scope.isFile()) {
1457       DIFile F(S);
1458       Fn = F.getFilename();
1459       Dir = F.getDirectory();
1460     } else if (Scope.isSubprogram()) {
1461       DISubprogram SP(S);
1462       Fn = SP.getFilename();
1463       Dir = SP.getDirectory();
1464     } else if (Scope.isLexicalBlockFile()) {
1465       DILexicalBlockFile DBF(S);
1466       Fn = DBF.getFilename();
1467       Dir = DBF.getDirectory();
1468     } else if (Scope.isLexicalBlock()) {
1469       DILexicalBlock DB(S);
1470       Fn = DB.getFilename();
1471       Dir = DB.getDirectory();
1472     } else
1473       assert(0 && "Unexpected scope info");
1474
1475     Src = GetOrCreateSourceID(Fn, Dir);
1476   }
1477   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1478 }
1479
1480 //===----------------------------------------------------------------------===//
1481 // Emit Methods
1482 //===----------------------------------------------------------------------===//
1483
1484 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1485 ///
1486 unsigned
1487 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1488   // Get the children.
1489   const std::vector<DIE *> &Children = Die->getChildren();
1490
1491   // If not last sibling and has children then add sibling offset attribute.
1492   if (!Last && !Children.empty())
1493     Die->addSiblingOffset(DIEValueAllocator);
1494
1495   // Record the abbreviation.
1496   assignAbbrevNumber(Die->getAbbrev());
1497
1498   // Get the abbreviation for this DIE.
1499   unsigned AbbrevNumber = Die->getAbbrevNumber();
1500   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1501
1502   // Set DIE offset
1503   Die->setOffset(Offset);
1504
1505   // Start the size with the size of abbreviation code.
1506   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1507
1508   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1509   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1510
1511   // Size the DIE attribute values.
1512   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1513     // Size attribute value.
1514     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1515
1516   // Size the DIE children if any.
1517   if (!Children.empty()) {
1518     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1519            "Children flag not set");
1520
1521     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1522       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1523
1524     // End of children marker.
1525     Offset += sizeof(int8_t);
1526   }
1527
1528   Die->setSize(Offset - Die->getOffset());
1529   return Offset;
1530 }
1531
1532 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1533 ///
1534 void DwarfDebug::computeSizeAndOffsets() {
1535   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1536          E = CUMap.end(); I != E; ++I) {
1537     // Compute size of compile unit header.
1538     unsigned Offset =
1539       sizeof(int32_t) + // Length of Compilation Unit Info
1540       sizeof(int16_t) + // DWARF version number
1541       sizeof(int32_t) + // Offset Into Abbrev. Section
1542       sizeof(int8_t);   // Pointer Size (in bytes)
1543     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1544   }
1545 }
1546
1547 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1548 /// the start of each one.
1549 void DwarfDebug::EmitSectionLabels() {
1550   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1551
1552   // Dwarf sections base addresses.
1553   DwarfInfoSectionSym =
1554     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1555   DwarfAbbrevSectionSym =
1556     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1557   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1558
1559   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1560     EmitSectionSym(Asm, MacroInfo);
1561
1562   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1563   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1564   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1565   DwarfStrSectionSym =
1566     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1567   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1568                                              "debug_range");
1569
1570   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1571                                            "section_debug_loc");
1572
1573   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1574   EmitSectionSym(Asm, TLOF.getDataSection());
1575 }
1576
1577 /// emitDIE - Recursively emits a debug information entry.
1578 ///
1579 void DwarfDebug::emitDIE(DIE *Die) {
1580   // Get the abbreviation for this DIE.
1581   unsigned AbbrevNumber = Die->getAbbrevNumber();
1582   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1583
1584   // Emit the code (index) for the abbreviation.
1585   if (Asm->isVerbose())
1586     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1587                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1588                                 Twine::utohexstr(Die->getSize()) + " " +
1589                                 dwarf::TagString(Abbrev->getTag()));
1590   Asm->EmitULEB128(AbbrevNumber);
1591
1592   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1593   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1594
1595   // Emit the DIE attribute values.
1596   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1597     unsigned Attr = AbbrevData[i].getAttribute();
1598     unsigned Form = AbbrevData[i].getForm();
1599     assert(Form && "Too many attributes for DIE (check abbreviation)");
1600
1601     if (Asm->isVerbose())
1602       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1603
1604     switch (Attr) {
1605     case dwarf::DW_AT_sibling:
1606       Asm->EmitInt32(Die->getSiblingOffset());
1607       break;
1608     case dwarf::DW_AT_abstract_origin: {
1609       DIEEntry *E = cast<DIEEntry>(Values[i]);
1610       DIE *Origin = E->getEntry();
1611       unsigned Addr = Origin->getOffset();
1612       Asm->EmitInt32(Addr);
1613       break;
1614     }
1615     case dwarf::DW_AT_ranges: {
1616       // DW_AT_range Value encodes offset in debug_range section.
1617       DIEInteger *V = cast<DIEInteger>(Values[i]);
1618
1619       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1620         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1621                                  V->getValue(),
1622                                  4);
1623       } else {
1624         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1625                                        V->getValue(),
1626                                        DwarfDebugRangeSectionSym,
1627                                        4);
1628       }
1629       break;
1630     }
1631     case dwarf::DW_AT_location: {
1632       if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1633         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1634       else
1635         Values[i]->EmitValue(Asm, Form);
1636       break;
1637     }
1638     case dwarf::DW_AT_accessibility: {
1639       if (Asm->isVerbose()) {
1640         DIEInteger *V = cast<DIEInteger>(Values[i]);
1641         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1642       }
1643       Values[i]->EmitValue(Asm, Form);
1644       break;
1645     }
1646     default:
1647       // Emit an attribute using the defined form.
1648       Values[i]->EmitValue(Asm, Form);
1649       break;
1650     }
1651   }
1652
1653   // Emit the DIE children if any.
1654   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1655     const std::vector<DIE *> &Children = Die->getChildren();
1656
1657     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1658       emitDIE(Children[j]);
1659
1660     if (Asm->isVerbose())
1661       Asm->OutStreamer.AddComment("End Of Children Mark");
1662     Asm->EmitInt8(0);
1663   }
1664 }
1665
1666 /// emitDebugInfo - Emit the debug info section.
1667 ///
1668 void DwarfDebug::emitDebugInfo() {
1669   // Start debug info section.
1670   Asm->OutStreamer.SwitchSection(
1671                             Asm->getObjFileLowering().getDwarfInfoSection());
1672   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1673          E = CUMap.end(); I != E; ++I) {
1674     CompileUnit *TheCU = I->second;
1675     DIE *Die = TheCU->getCUDie();
1676
1677     // Emit the compile units header.
1678     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1679                                                   TheCU->getID()));
1680
1681     // Emit size of content not including length itself
1682     unsigned ContentSize = Die->getSize() +
1683       sizeof(int16_t) + // DWARF version number
1684       sizeof(int32_t) + // Offset Into Abbrev. Section
1685       sizeof(int8_t);   // Pointer Size (in bytes)
1686
1687     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1688     Asm->EmitInt32(ContentSize);
1689     Asm->OutStreamer.AddComment("DWARF version number");
1690     Asm->EmitInt16(dwarf::DWARF_VERSION);
1691     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1692     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1693                            DwarfAbbrevSectionSym);
1694     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1695     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1696
1697     emitDIE(Die);
1698     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1699   }
1700 }
1701
1702 /// emitAbbreviations - Emit the abbreviation section.
1703 ///
1704 void DwarfDebug::emitAbbreviations() const {
1705   // Check to see if it is worth the effort.
1706   if (!Abbreviations.empty()) {
1707     // Start the debug abbrev section.
1708     Asm->OutStreamer.SwitchSection(
1709                             Asm->getObjFileLowering().getDwarfAbbrevSection());
1710
1711     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1712
1713     // For each abbrevation.
1714     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1715       // Get abbreviation data
1716       const DIEAbbrev *Abbrev = Abbreviations[i];
1717
1718       // Emit the abbrevations code (base 1 index.)
1719       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1720
1721       // Emit the abbreviations data.
1722       Abbrev->Emit(Asm);
1723     }
1724
1725     // Mark end of abbreviations.
1726     Asm->EmitULEB128(0, "EOM(3)");
1727
1728     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1729   }
1730 }
1731
1732 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1733 /// the line matrix.
1734 ///
1735 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1736   // Define last address of section.
1737   Asm->OutStreamer.AddComment("Extended Op");
1738   Asm->EmitInt8(0);
1739
1740   Asm->OutStreamer.AddComment("Op size");
1741   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1742   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1743   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1744
1745   Asm->OutStreamer.AddComment("Section end label");
1746
1747   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1748                                    Asm->getTargetData().getPointerSize(),
1749                                    0/*AddrSpace*/);
1750
1751   // Mark end of matrix.
1752   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1753   Asm->EmitInt8(0);
1754   Asm->EmitInt8(1);
1755   Asm->EmitInt8(1);
1756 }
1757
1758 /// emitAccelNames - Emit visible names into a hashed accelerator table
1759 /// section.
1760 void DwarfDebug::emitAccelNames() {
1761   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1762                                            dwarf::DW_FORM_data4));
1763   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1764          E = CUMap.end(); I != E; ++I) {
1765     CompileUnit *TheCU = I->second;
1766     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1767     for (StringMap<std::vector<DIE*> >::const_iterator
1768            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1769       const char *Name = GI->getKeyData();
1770       std::vector<DIE *> Entities = GI->second;
1771       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1772              DE = Entities.end(); DI != DE; ++DI)
1773         AT.AddName(Name, (*DI));
1774     }
1775   }
1776
1777   AT.FinalizeTable(Asm, "Names");
1778   Asm->OutStreamer.SwitchSection(
1779     Asm->getObjFileLowering().getDwarfAccelNamesSection());
1780   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1781   Asm->OutStreamer.EmitLabel(SectionBegin);
1782
1783   // Emit the full data.
1784   AT.Emit(Asm, SectionBegin, this);
1785 }
1786
1787 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1788 /// accelerator table section.
1789 void DwarfDebug::emitAccelObjC() {
1790   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1791                                            dwarf::DW_FORM_data4));
1792   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1793          E = CUMap.end(); I != E; ++I) {
1794     CompileUnit *TheCU = I->second;
1795     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1796     for (StringMap<std::vector<DIE*> >::const_iterator
1797            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1798       const char *Name = GI->getKeyData();
1799       std::vector<DIE *> Entities = GI->second;
1800       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1801              DE = Entities.end(); DI != DE; ++DI)
1802         AT.AddName(Name, (*DI));
1803     }
1804   }
1805
1806   AT.FinalizeTable(Asm, "ObjC");
1807   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1808                                  .getDwarfAccelObjCSection());
1809   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1810   Asm->OutStreamer.EmitLabel(SectionBegin);
1811
1812   // Emit the full data.
1813   AT.Emit(Asm, SectionBegin, this);
1814 }
1815
1816 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1817 /// table.
1818 void DwarfDebug::emitAccelNamespaces() {
1819   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1820                                            dwarf::DW_FORM_data4));
1821   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1822          E = CUMap.end(); I != E; ++I) {
1823     CompileUnit *TheCU = I->second;
1824     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1825     for (StringMap<std::vector<DIE*> >::const_iterator
1826            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1827       const char *Name = GI->getKeyData();
1828       std::vector<DIE *> Entities = GI->second;
1829       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1830              DE = Entities.end(); DI != DE; ++DI)
1831         AT.AddName(Name, (*DI));
1832     }
1833   }
1834
1835   AT.FinalizeTable(Asm, "namespac");
1836   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1837                                  .getDwarfAccelNamespaceSection());
1838   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1839   Asm->OutStreamer.EmitLabel(SectionBegin);
1840
1841   // Emit the full data.
1842   AT.Emit(Asm, SectionBegin, this);
1843 }
1844
1845 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1846 void DwarfDebug::emitAccelTypes() {
1847   std::vector<DwarfAccelTable::Atom> Atoms;
1848   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1849                                         dwarf::DW_FORM_data4));
1850   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1851                                         dwarf::DW_FORM_data2));
1852   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1853                                         dwarf::DW_FORM_data1));
1854   DwarfAccelTable AT(Atoms);
1855   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1856          E = CUMap.end(); I != E; ++I) {
1857     CompileUnit *TheCU = I->second;
1858     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1859       = TheCU->getAccelTypes();
1860     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1861            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1862       const char *Name = GI->getKeyData();
1863       std::vector<std::pair<DIE *, unsigned> > Entities = GI->second;
1864       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1865              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1866         AT.AddName(Name, (*DI).first, (*DI).second);
1867     }
1868   }
1869
1870   AT.FinalizeTable(Asm, "types");
1871   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1872                                  .getDwarfAccelTypesSection());
1873   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1874   Asm->OutStreamer.EmitLabel(SectionBegin);
1875
1876   // Emit the full data.
1877   AT.Emit(Asm, SectionBegin, this);
1878 }
1879
1880 void DwarfDebug::emitDebugPubTypes() {
1881   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1882          E = CUMap.end(); I != E; ++I) {
1883     CompileUnit *TheCU = I->second;
1884     // Start the dwarf pubtypes section.
1885     Asm->OutStreamer.SwitchSection(
1886       Asm->getObjFileLowering().getDwarfPubTypesSection());
1887     Asm->OutStreamer.AddComment("Length of Public Types Info");
1888     Asm->EmitLabelDifference(
1889       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1890       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1891
1892     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1893                                                   TheCU->getID()));
1894
1895     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1896     Asm->EmitInt16(dwarf::DWARF_VERSION);
1897
1898     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1899     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1900                            DwarfInfoSectionSym);
1901
1902     Asm->OutStreamer.AddComment("Compilation Unit Length");
1903     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1904                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
1905                              4);
1906
1907     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1908     for (StringMap<DIE*>::const_iterator
1909            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1910       const char *Name = GI->getKeyData();
1911       DIE *Entity = GI->second;
1912
1913       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1914       Asm->EmitInt32(Entity->getOffset());
1915
1916       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1917       // Emit the name with a terminating null byte.
1918       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1919     }
1920
1921     Asm->OutStreamer.AddComment("End Mark");
1922     Asm->EmitInt32(0);
1923     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1924                                                   TheCU->getID()));
1925   }
1926 }
1927
1928 /// emitDebugStr - Emit visible names into a debug str section.
1929 ///
1930 void DwarfDebug::emitDebugStr() {
1931   // Check to see if it is worth the effort.
1932   if (StringPool.empty()) return;
1933
1934   // Start the dwarf str section.
1935   Asm->OutStreamer.SwitchSection(
1936                                 Asm->getObjFileLowering().getDwarfStrSection());
1937
1938   // Get all of the string pool entries and put them in an array by their ID so
1939   // we can sort them.
1940   SmallVector<std::pair<unsigned,
1941       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1942
1943   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1944        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1945     Entries.push_back(std::make_pair(I->second.second, &*I));
1946
1947   array_pod_sort(Entries.begin(), Entries.end());
1948
1949   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1950     // Emit a label for reference from debug information entries.
1951     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1952
1953     // Emit the string itself with a terminating null byte.
1954     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1955                                          Entries[i].second->getKeyLength()+1),
1956                                0/*addrspace*/);
1957   }
1958 }
1959
1960 /// emitDebugLoc - Emit visible names into a debug loc section.
1961 ///
1962 void DwarfDebug::emitDebugLoc() {
1963   if (DotDebugLocEntries.empty())
1964     return;
1965
1966   for (SmallVector<DotDebugLocEntry, 4>::iterator
1967          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1968        I != E; ++I) {
1969     DotDebugLocEntry &Entry = *I;
1970     if (I + 1 != DotDebugLocEntries.end())
1971       Entry.Merge(I+1);
1972   }
1973
1974   // Start the dwarf loc section.
1975   Asm->OutStreamer.SwitchSection(
1976     Asm->getObjFileLowering().getDwarfLocSection());
1977   unsigned char Size = Asm->getTargetData().getPointerSize();
1978   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1979   unsigned index = 1;
1980   for (SmallVector<DotDebugLocEntry, 4>::iterator
1981          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1982        I != E; ++I, ++index) {
1983     DotDebugLocEntry &Entry = *I;
1984     if (Entry.isMerged()) continue;
1985     if (Entry.isEmpty()) {
1986       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1987       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1988       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1989     } else {
1990       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1991       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1992       DIVariable DV(Entry.Variable);
1993       Asm->OutStreamer.AddComment("Loc expr size");
1994       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1995       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1996       Asm->EmitLabelDifference(end, begin, 2);
1997       Asm->OutStreamer.EmitLabel(begin);
1998       if (Entry.isInt()) {
1999         DIBasicType BTy(DV.getType());
2000         if (BTy.Verify() &&
2001             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2002              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2003           Asm->OutStreamer.AddComment("DW_OP_consts");
2004           Asm->EmitInt8(dwarf::DW_OP_consts);
2005           Asm->EmitSLEB128(Entry.getInt());
2006         } else {
2007           Asm->OutStreamer.AddComment("DW_OP_constu");
2008           Asm->EmitInt8(dwarf::DW_OP_constu);
2009           Asm->EmitULEB128(Entry.getInt());
2010         }
2011       } else if (Entry.isLocation()) {
2012         if (!DV.hasComplexAddress())
2013           // Regular entry.
2014           Asm->EmitDwarfRegOp(Entry.Loc);
2015         else {
2016           // Complex address entry.
2017           unsigned N = DV.getNumAddrElements();
2018           unsigned i = 0;
2019           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2020             if (Entry.Loc.getOffset()) {
2021               i = 2;
2022               Asm->EmitDwarfRegOp(Entry.Loc);
2023               Asm->OutStreamer.AddComment("DW_OP_deref");
2024               Asm->EmitInt8(dwarf::DW_OP_deref);
2025               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2026               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2027               Asm->EmitSLEB128(DV.getAddrElement(1));
2028             } else {
2029               // If first address element is OpPlus then emit
2030               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2031               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2032               Asm->EmitDwarfRegOp(Loc);
2033               i = 2;
2034             }
2035           } else {
2036             Asm->EmitDwarfRegOp(Entry.Loc);
2037           }
2038
2039           // Emit remaining complex address elements.
2040           for (; i < N; ++i) {
2041             uint64_t Element = DV.getAddrElement(i);
2042             if (Element == DIBuilder::OpPlus) {
2043               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2044               Asm->EmitULEB128(DV.getAddrElement(++i));
2045             } else if (Element == DIBuilder::OpDeref)
2046               Asm->EmitInt8(dwarf::DW_OP_deref);
2047             else llvm_unreachable("unknown Opcode found in complex address");
2048           }
2049         }
2050       }
2051       // else ... ignore constant fp. There is not any good way to
2052       // to represent them here in dwarf.
2053       Asm->OutStreamer.EmitLabel(end);
2054     }
2055   }
2056 }
2057
2058 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2059 ///
2060 void DwarfDebug::EmitDebugARanges() {
2061   // Start the dwarf aranges section.
2062   Asm->OutStreamer.SwitchSection(
2063                           Asm->getObjFileLowering().getDwarfARangesSection());
2064 }
2065
2066 /// emitDebugRanges - Emit visible names into a debug ranges section.
2067 ///
2068 void DwarfDebug::emitDebugRanges() {
2069   // Start the dwarf ranges section.
2070   Asm->OutStreamer.SwitchSection(
2071     Asm->getObjFileLowering().getDwarfRangesSection());
2072   unsigned char Size = Asm->getTargetData().getPointerSize();
2073   for (SmallVector<const MCSymbol *, 8>::iterator
2074          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2075        I != E; ++I) {
2076     if (*I)
2077       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2078     else
2079       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2080   }
2081 }
2082
2083 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2084 ///
2085 void DwarfDebug::emitDebugMacInfo() {
2086   if (const MCSection *LineInfo =
2087       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2088     // Start the dwarf macinfo section.
2089     Asm->OutStreamer.SwitchSection(LineInfo);
2090   }
2091 }
2092
2093 /// emitDebugInlineInfo - Emit inline info using following format.
2094 /// Section Header:
2095 /// 1. length of section
2096 /// 2. Dwarf version number
2097 /// 3. address size.
2098 ///
2099 /// Entries (one "entry" for each function that was inlined):
2100 ///
2101 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2102 ///   otherwise offset into __debug_str for regular function name.
2103 /// 2. offset into __debug_str section for regular function name.
2104 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2105 /// instances for the function.
2106 ///
2107 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2108 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2109 /// __debug_info section, and the low_pc is the starting address for the
2110 /// inlining instance.
2111 void DwarfDebug::emitDebugInlineInfo() {
2112   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
2113     return;
2114
2115   if (!FirstCU)
2116     return;
2117
2118   Asm->OutStreamer.SwitchSection(
2119                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2120
2121   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2122   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2123                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2124
2125   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2126
2127   Asm->OutStreamer.AddComment("Dwarf Version");
2128   Asm->EmitInt16(dwarf::DWARF_VERSION);
2129   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2130   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2131
2132   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2133          E = InlinedSPNodes.end(); I != E; ++I) {
2134
2135     const MDNode *Node = *I;
2136     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2137       = InlineInfo.find(Node);
2138     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2139     DISubprogram SP(Node);
2140     StringRef LName = SP.getLinkageName();
2141     StringRef Name = SP.getName();
2142
2143     Asm->OutStreamer.AddComment("MIPS linkage name");
2144     if (LName.empty()) {
2145       Asm->OutStreamer.EmitBytes(Name, 0);
2146       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2147     } else
2148       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2149                              DwarfStrSectionSym);
2150
2151     Asm->OutStreamer.AddComment("Function name");
2152     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2153     Asm->EmitULEB128(Labels.size(), "Inline count");
2154
2155     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2156            LE = Labels.end(); LI != LE; ++LI) {
2157       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2158       Asm->EmitInt32(LI->second->getOffset());
2159
2160       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2161       Asm->OutStreamer.EmitSymbolValue(LI->first,
2162                                        Asm->getTargetData().getPointerSize(),0);
2163     }
2164   }
2165
2166   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2167 }