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