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