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 = 0;
1097       PrevInstLoc = DL;
1098       if (DL == PrologEndLoc) {
1099         Flags |= DWARF2_FLAG_PROLOGUE_END;
1100         PrologEndLoc = DebugLoc();
1101       }
1102       if (PrologEndLoc.isUnknown())
1103         Flags |= DWARF2_FLAG_IS_STMT;
1104
1105       if (!DL.isUnknown()) {
1106         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1107         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1108       } else
1109         recordSourceLine(0, 0, 0, 0);
1110     }
1111   }
1112
1113   // Insert labels where requested.
1114   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1115     LabelsBeforeInsn.find(MI);
1116
1117   // No label needed.
1118   if (I == LabelsBeforeInsn.end())
1119     return;
1120
1121   // Label already assigned.
1122   if (I->second)
1123     return;
1124
1125   if (!PrevLabel) {
1126     PrevLabel = MMI->getContext().CreateTempSymbol();
1127     Asm->OutStreamer.EmitLabel(PrevLabel);
1128   }
1129   I->second = PrevLabel;
1130 }
1131
1132 /// endInstruction - Process end of an instruction.
1133 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1134   // Don't create a new label after DBG_VALUE instructions.
1135   // They don't generate code.
1136   if (!MI->isDebugValue())
1137     PrevLabel = 0;
1138
1139   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1140     LabelsAfterInsn.find(MI);
1141
1142   // No label needed.
1143   if (I == LabelsAfterInsn.end())
1144     return;
1145
1146   // Label already assigned.
1147   if (I->second)
1148     return;
1149
1150   // We need a label after this instruction.
1151   if (!PrevLabel) {
1152     PrevLabel = MMI->getContext().CreateTempSymbol();
1153     Asm->OutStreamer.EmitLabel(PrevLabel);
1154   }
1155   I->second = PrevLabel;
1156 }
1157
1158 /// identifyScopeMarkers() -
1159 /// Each LexicalScope has first instruction and last instruction to mark
1160 /// beginning and end of a scope respectively. Create an inverse map that list
1161 /// scopes starts (and ends) with an instruction. One instruction may start (or
1162 /// end) multiple scopes. Ignore scopes that are not reachable.
1163 void DwarfDebug::identifyScopeMarkers() {
1164   SmallVector<LexicalScope *, 4> WorkList;
1165   WorkList.push_back(LScopes.getCurrentFunctionScope());
1166   while (!WorkList.empty()) {
1167     LexicalScope *S = WorkList.pop_back_val();
1168
1169     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1170     if (!Children.empty())
1171       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1172              SE = Children.end(); SI != SE; ++SI)
1173         WorkList.push_back(*SI);
1174
1175     if (S->isAbstractScope())
1176       continue;
1177
1178     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1179     if (Ranges.empty())
1180       continue;
1181     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1182            RE = Ranges.end(); RI != RE; ++RI) {
1183       assert(RI->first && "InsnRange does not have first instruction!");
1184       assert(RI->second && "InsnRange does not have second instruction!");
1185       requestLabelBeforeInsn(RI->first);
1186       requestLabelAfterInsn(RI->second);
1187     }
1188   }
1189 }
1190
1191 /// getScopeNode - Get MDNode for DebugLoc's scope.
1192 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1193   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1194     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1195   return DL.getScope(Ctx);
1196 }
1197
1198 /// getFnDebugLoc - Walk up the scope chain of given debug loc and find
1199 /// line number info for the function.
1200 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1201   const MDNode *Scope = getScopeNode(DL, Ctx);
1202   DISubprogram SP = getDISubprogram(Scope);
1203   if (SP.Verify()) {
1204     // Check for number of operands since the compatibility is
1205     // cheap here.
1206     if (SP->getNumOperands() > 19)
1207       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1208     else
1209       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1210   }
1211
1212   return DebugLoc();
1213 }
1214
1215 /// beginFunction - Gather pre-function debug information.  Assumes being
1216 /// emitted immediately after the function entry point.
1217 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1218   if (!MMI->hasDebugInfo()) return;
1219   LScopes.initialize(*MF);
1220   if (LScopes.empty()) return;
1221   identifyScopeMarkers();
1222
1223   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1224                                         Asm->getFunctionNumber());
1225   // Assumes in correct section after the entry point.
1226   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1227
1228   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1229
1230   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1231   /// LiveUserVar - Map physreg numbers to the MDNode they contain.
1232   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1233
1234   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1235        I != E; ++I) {
1236     bool AtBlockEntry = true;
1237     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1238          II != IE; ++II) {
1239       const MachineInstr *MI = II;
1240
1241       if (MI->isDebugValue()) {
1242         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1243
1244         // Keep track of user variables.
1245         const MDNode *Var =
1246           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1247
1248         // Variable is in a register, we need to check for clobbers.
1249         if (isDbgValueInDefinedReg(MI))
1250           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1251
1252         // Check the history of this variable.
1253         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1254         if (History.empty()) {
1255           UserVariables.push_back(Var);
1256           // The first mention of a function argument gets the FunctionBeginSym
1257           // label, so arguments are visible when breaking at function entry.
1258           DIVariable DV(Var);
1259           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1260               DISubprogram(getDISubprogram(DV.getContext()))
1261                 .describes(MF->getFunction()))
1262             LabelsBeforeInsn[MI] = FunctionBeginSym;
1263         } else {
1264           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1265           const MachineInstr *Prev = History.back();
1266           if (Prev->isDebugValue()) {
1267             // Coalesce identical entries at the end of History.
1268             if (History.size() >= 2 &&
1269                 Prev->isIdenticalTo(History[History.size() - 2])) {
1270               DEBUG(dbgs() << "Coalesce identical DBG_VALUE entries:\n"
1271                     << "\t" << *Prev
1272                     << "\t" << *History[History.size() - 2] << "\n");
1273               History.pop_back();
1274             }
1275
1276             // Terminate old register assignments that don't reach MI;
1277             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1278             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1279                 isDbgValueInDefinedReg(Prev)) {
1280               // Previous register assignment needs to terminate at the end of
1281               // its basic block.
1282               MachineBasicBlock::const_iterator LastMI =
1283                 PrevMBB->getLastNonDebugInstr();
1284               if (LastMI == PrevMBB->end()) {
1285                 // Drop DBG_VALUE for empty range.
1286                 DEBUG(dbgs() << "Drop DBG_VALUE for empty range:\n"
1287                       << "\t" << *Prev << "\n");
1288                 History.pop_back();
1289               }
1290               else {
1291                 // Terminate after LastMI.
1292                 History.push_back(LastMI);
1293               }
1294             }
1295           }
1296         }
1297         History.push_back(MI);
1298       } else {
1299         // Not a DBG_VALUE instruction.
1300         if (!MI->isLabel())
1301           AtBlockEntry = false;
1302
1303         // First known non DBG_VALUE location marks beginning of function
1304         // body.
1305         if (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown())
1306           PrologEndLoc = MI->getDebugLoc();
1307
1308         // Check if the instruction clobbers any registers with debug vars.
1309         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1310                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1311           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1312             continue;
1313           for (const uint16_t *AI = TRI->getOverlaps(MOI->getReg());
1314                unsigned Reg = *AI; ++AI) {
1315             const MDNode *Var = LiveUserVar[Reg];
1316             if (!Var)
1317               continue;
1318             // Reg is now clobbered.
1319             LiveUserVar[Reg] = 0;
1320
1321             // Was MD last defined by a DBG_VALUE referring to Reg?
1322             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1323             if (HistI == DbgValues.end())
1324               continue;
1325             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1326             if (History.empty())
1327               continue;
1328             const MachineInstr *Prev = History.back();
1329             // Sanity-check: Register assignments are terminated at the end of
1330             // their block.
1331             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1332               continue;
1333             // Is the variable still in Reg?
1334             if (!isDbgValueInDefinedReg(Prev) ||
1335                 Prev->getOperand(0).getReg() != Reg)
1336               continue;
1337             // Var is clobbered. Make sure the next instruction gets a label.
1338             History.push_back(MI);
1339           }
1340         }
1341       }
1342     }
1343   }
1344
1345   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1346        I != E; ++I) {
1347     SmallVectorImpl<const MachineInstr*> &History = I->second;
1348     if (History.empty())
1349       continue;
1350
1351     // Make sure the final register assignments are terminated.
1352     const MachineInstr *Prev = History.back();
1353     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1354       const MachineBasicBlock *PrevMBB = Prev->getParent();
1355       MachineBasicBlock::const_iterator LastMI =
1356         PrevMBB->getLastNonDebugInstr();
1357       if (LastMI == PrevMBB->end())
1358         // Drop DBG_VALUE for empty range.
1359         History.pop_back();
1360       else {
1361         // Terminate after LastMI.
1362         History.push_back(LastMI);
1363       }
1364     }
1365     // Request labels for the full history.
1366     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1367       const MachineInstr *MI = History[i];
1368       if (MI->isDebugValue())
1369         requestLabelBeforeInsn(MI);
1370       else
1371         requestLabelAfterInsn(MI);
1372     }
1373   }
1374
1375   PrevInstLoc = DebugLoc();
1376   PrevLabel = FunctionBeginSym;
1377
1378   // Record beginning of function.
1379   if (!PrologEndLoc.isUnknown()) {
1380     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1381                                        MF->getFunction()->getContext());
1382     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1383                      FnStartDL.getScope(MF->getFunction()->getContext()),
1384                      0);
1385   }
1386 }
1387
1388 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1389 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1390   ScopeVariables[LS].push_back(Var);
1391 //  Vars.push_back(Var);
1392 }
1393
1394 /// endFunction - Gather and emit post-function debug information.
1395 ///
1396 void DwarfDebug::endFunction(const MachineFunction *MF) {
1397   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1398
1399   // Define end label for subprogram.
1400   FunctionEndSym = Asm->GetTempSymbol("func_end",
1401                                       Asm->getFunctionNumber());
1402   // Assumes in correct section after the entry point.
1403   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1404
1405   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1406   collectVariableInfo(MF, ProcessedVars);
1407
1408   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1409   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1410   assert(TheCU && "Unable to find compile unit!");
1411
1412   // Construct abstract scopes.
1413   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1414   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1415     LexicalScope *AScope = AList[i];
1416     DISubprogram SP(AScope->getScopeNode());
1417     if (SP.Verify()) {
1418       // Collect info for variables that were optimized out.
1419       DIArray Variables = SP.getVariables();
1420       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1421         DIVariable DV(Variables.getElement(i));
1422         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1423           continue;
1424         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1425           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1426       }
1427     }
1428     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1429       constructScopeDIE(TheCU, AScope);
1430   }
1431
1432   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1433
1434   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1435     TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1436                    dwarf::DW_FORM_flag, 1);
1437
1438   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1439                                                MMI->getFrameMoves()));
1440
1441   // Clear debug info
1442   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1443          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1444     DeleteContainerPointers(I->second);
1445   ScopeVariables.clear();
1446   DeleteContainerPointers(CurrentFnArguments);
1447   UserVariables.clear();
1448   DbgValues.clear();
1449   AbstractVariables.clear();
1450   LabelsBeforeInsn.clear();
1451   LabelsAfterInsn.clear();
1452   PrevLabel = NULL;
1453 }
1454
1455 /// recordSourceLine - Register a source line with debug info. Returns the
1456 /// unique label that was emitted and which provides correspondence to
1457 /// the source line list.
1458 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1459                                   unsigned Flags) {
1460   StringRef Fn;
1461   StringRef Dir;
1462   unsigned Src = 1;
1463   if (S) {
1464     DIDescriptor Scope(S);
1465
1466     if (Scope.isCompileUnit()) {
1467       DICompileUnit CU(S);
1468       Fn = CU.getFilename();
1469       Dir = CU.getDirectory();
1470     } else if (Scope.isFile()) {
1471       DIFile F(S);
1472       Fn = F.getFilename();
1473       Dir = F.getDirectory();
1474     } else if (Scope.isSubprogram()) {
1475       DISubprogram SP(S);
1476       Fn = SP.getFilename();
1477       Dir = SP.getDirectory();
1478     } else if (Scope.isLexicalBlockFile()) {
1479       DILexicalBlockFile DBF(S);
1480       Fn = DBF.getFilename();
1481       Dir = DBF.getDirectory();
1482     } else if (Scope.isLexicalBlock()) {
1483       DILexicalBlock DB(S);
1484       Fn = DB.getFilename();
1485       Dir = DB.getDirectory();
1486     } else
1487       llvm_unreachable("Unexpected scope info");
1488
1489     Src = GetOrCreateSourceID(Fn, Dir);
1490   }
1491   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1492 }
1493
1494 //===----------------------------------------------------------------------===//
1495 // Emit Methods
1496 //===----------------------------------------------------------------------===//
1497
1498 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1499 ///
1500 unsigned
1501 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1502   // Get the children.
1503   const std::vector<DIE *> &Children = Die->getChildren();
1504
1505   // Record the abbreviation.
1506   assignAbbrevNumber(Die->getAbbrev());
1507
1508   // Get the abbreviation for this DIE.
1509   unsigned AbbrevNumber = Die->getAbbrevNumber();
1510   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1511
1512   // Set DIE offset
1513   Die->setOffset(Offset);
1514
1515   // Start the size with the size of abbreviation code.
1516   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1517
1518   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1519   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1520
1521   // Size the DIE attribute values.
1522   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1523     // Size attribute value.
1524     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1525
1526   // Size the DIE children if any.
1527   if (!Children.empty()) {
1528     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1529            "Children flag not set");
1530
1531     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1532       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1533
1534     // End of children marker.
1535     Offset += sizeof(int8_t);
1536   }
1537
1538   Die->setSize(Offset - Die->getOffset());
1539   return Offset;
1540 }
1541
1542 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1543 ///
1544 void DwarfDebug::computeSizeAndOffsets() {
1545   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1546          E = CUMap.end(); I != E; ++I) {
1547     // Compute size of compile unit header.
1548     unsigned Offset =
1549       sizeof(int32_t) + // Length of Compilation Unit Info
1550       sizeof(int16_t) + // DWARF version number
1551       sizeof(int32_t) + // Offset Into Abbrev. Section
1552       sizeof(int8_t);   // Pointer Size (in bytes)
1553     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1554   }
1555 }
1556
1557 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1558 /// the start of each one.
1559 void DwarfDebug::EmitSectionLabels() {
1560   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1561
1562   // Dwarf sections base addresses.
1563   DwarfInfoSectionSym =
1564     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1565   DwarfAbbrevSectionSym =
1566     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1567   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1568
1569   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1570     EmitSectionSym(Asm, MacroInfo);
1571
1572   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1573   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1574   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1575   DwarfStrSectionSym =
1576     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1577   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1578                                              "debug_range");
1579
1580   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1581                                            "section_debug_loc");
1582
1583   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1584   EmitSectionSym(Asm, TLOF.getDataSection());
1585 }
1586
1587 /// emitDIE - Recursively emits a debug information entry.
1588 ///
1589 void DwarfDebug::emitDIE(DIE *Die) {
1590   // Get the abbreviation for this DIE.
1591   unsigned AbbrevNumber = Die->getAbbrevNumber();
1592   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1593
1594   // Emit the code (index) for the abbreviation.
1595   if (Asm->isVerbose())
1596     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1597                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1598                                 Twine::utohexstr(Die->getSize()) + " " +
1599                                 dwarf::TagString(Abbrev->getTag()));
1600   Asm->EmitULEB128(AbbrevNumber);
1601
1602   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1603   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1604
1605   // Emit the DIE attribute values.
1606   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1607     unsigned Attr = AbbrevData[i].getAttribute();
1608     unsigned Form = AbbrevData[i].getForm();
1609     assert(Form && "Too many attributes for DIE (check abbreviation)");
1610
1611     if (Asm->isVerbose())
1612       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1613
1614     switch (Attr) {
1615     case dwarf::DW_AT_abstract_origin: {
1616       DIEEntry *E = cast<DIEEntry>(Values[i]);
1617       DIE *Origin = E->getEntry();
1618       unsigned Addr = Origin->getOffset();
1619       Asm->EmitInt32(Addr);
1620       break;
1621     }
1622     case dwarf::DW_AT_ranges: {
1623       // DW_AT_range Value encodes offset in debug_range section.
1624       DIEInteger *V = cast<DIEInteger>(Values[i]);
1625
1626       if (Asm->MAI->doesDwarfUseLabelOffsetForRanges()) {
1627         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1628                                  V->getValue(),
1629                                  4);
1630       } else {
1631         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1632                                        V->getValue(),
1633                                        DwarfDebugRangeSectionSym,
1634                                        4);
1635       }
1636       break;
1637     }
1638     case dwarf::DW_AT_location: {
1639       if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1640         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1641       else
1642         Values[i]->EmitValue(Asm, Form);
1643       break;
1644     }
1645     case dwarf::DW_AT_accessibility: {
1646       if (Asm->isVerbose()) {
1647         DIEInteger *V = cast<DIEInteger>(Values[i]);
1648         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1649       }
1650       Values[i]->EmitValue(Asm, Form);
1651       break;
1652     }
1653     default:
1654       // Emit an attribute using the defined form.
1655       Values[i]->EmitValue(Asm, Form);
1656       break;
1657     }
1658   }
1659
1660   // Emit the DIE children if any.
1661   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1662     const std::vector<DIE *> &Children = Die->getChildren();
1663
1664     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1665       emitDIE(Children[j]);
1666
1667     if (Asm->isVerbose())
1668       Asm->OutStreamer.AddComment("End Of Children Mark");
1669     Asm->EmitInt8(0);
1670   }
1671 }
1672
1673 /// emitDebugInfo - Emit the debug info section.
1674 ///
1675 void DwarfDebug::emitDebugInfo() {
1676   // Start debug info section.
1677   Asm->OutStreamer.SwitchSection(
1678                             Asm->getObjFileLowering().getDwarfInfoSection());
1679   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1680          E = CUMap.end(); I != E; ++I) {
1681     CompileUnit *TheCU = I->second;
1682     DIE *Die = TheCU->getCUDie();
1683
1684     // Emit the compile units header.
1685     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1686                                                   TheCU->getID()));
1687
1688     // Emit size of content not including length itself
1689     unsigned ContentSize = Die->getSize() +
1690       sizeof(int16_t) + // DWARF version number
1691       sizeof(int32_t) + // Offset Into Abbrev. Section
1692       sizeof(int8_t);   // Pointer Size (in bytes)
1693
1694     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1695     Asm->EmitInt32(ContentSize);
1696     Asm->OutStreamer.AddComment("DWARF version number");
1697     Asm->EmitInt16(dwarf::DWARF_VERSION);
1698     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1699     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1700                            DwarfAbbrevSectionSym);
1701     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1702     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1703
1704     emitDIE(Die);
1705     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1706   }
1707 }
1708
1709 /// emitAbbreviations - Emit the abbreviation section.
1710 ///
1711 void DwarfDebug::emitAbbreviations() const {
1712   // Check to see if it is worth the effort.
1713   if (!Abbreviations.empty()) {
1714     // Start the debug abbrev section.
1715     Asm->OutStreamer.SwitchSection(
1716                             Asm->getObjFileLowering().getDwarfAbbrevSection());
1717
1718     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1719
1720     // For each abbrevation.
1721     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1722       // Get abbreviation data
1723       const DIEAbbrev *Abbrev = Abbreviations[i];
1724
1725       // Emit the abbrevations code (base 1 index.)
1726       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1727
1728       // Emit the abbreviations data.
1729       Abbrev->Emit(Asm);
1730     }
1731
1732     // Mark end of abbreviations.
1733     Asm->EmitULEB128(0, "EOM(3)");
1734
1735     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1736   }
1737 }
1738
1739 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1740 /// the line matrix.
1741 ///
1742 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1743   // Define last address of section.
1744   Asm->OutStreamer.AddComment("Extended Op");
1745   Asm->EmitInt8(0);
1746
1747   Asm->OutStreamer.AddComment("Op size");
1748   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1749   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1750   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1751
1752   Asm->OutStreamer.AddComment("Section end label");
1753
1754   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1755                                    Asm->getTargetData().getPointerSize(),
1756                                    0/*AddrSpace*/);
1757
1758   // Mark end of matrix.
1759   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1760   Asm->EmitInt8(0);
1761   Asm->EmitInt8(1);
1762   Asm->EmitInt8(1);
1763 }
1764
1765 /// emitAccelNames - Emit visible names into a hashed accelerator table
1766 /// section.
1767 void DwarfDebug::emitAccelNames() {
1768   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1769                                            dwarf::DW_FORM_data4));
1770   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1771          E = CUMap.end(); I != E; ++I) {
1772     CompileUnit *TheCU = I->second;
1773     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1774     for (StringMap<std::vector<DIE*> >::const_iterator
1775            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1776       const char *Name = GI->getKeyData();
1777       const std::vector<DIE *> &Entities = GI->second;
1778       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1779              DE = Entities.end(); DI != DE; ++DI)
1780         AT.AddName(Name, (*DI));
1781     }
1782   }
1783
1784   AT.FinalizeTable(Asm, "Names");
1785   Asm->OutStreamer.SwitchSection(
1786     Asm->getObjFileLowering().getDwarfAccelNamesSection());
1787   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
1788   Asm->OutStreamer.EmitLabel(SectionBegin);
1789
1790   // Emit the full data.
1791   AT.Emit(Asm, SectionBegin, this);
1792 }
1793
1794 /// emitAccelObjC - Emit objective C classes and categories into a hashed
1795 /// accelerator table section.
1796 void DwarfDebug::emitAccelObjC() {
1797   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1798                                            dwarf::DW_FORM_data4));
1799   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1800          E = CUMap.end(); I != E; ++I) {
1801     CompileUnit *TheCU = I->second;
1802     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
1803     for (StringMap<std::vector<DIE*> >::const_iterator
1804            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1805       const char *Name = GI->getKeyData();
1806       const std::vector<DIE *> &Entities = GI->second;
1807       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1808              DE = Entities.end(); DI != DE; ++DI)
1809         AT.AddName(Name, (*DI));
1810     }
1811   }
1812
1813   AT.FinalizeTable(Asm, "ObjC");
1814   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1815                                  .getDwarfAccelObjCSection());
1816   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
1817   Asm->OutStreamer.EmitLabel(SectionBegin);
1818
1819   // Emit the full data.
1820   AT.Emit(Asm, SectionBegin, this);
1821 }
1822
1823 /// emitAccelNamespace - Emit namespace dies into a hashed accelerator
1824 /// table.
1825 void DwarfDebug::emitAccelNamespaces() {
1826   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1827                                            dwarf::DW_FORM_data4));
1828   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1829          E = CUMap.end(); I != E; ++I) {
1830     CompileUnit *TheCU = I->second;
1831     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
1832     for (StringMap<std::vector<DIE*> >::const_iterator
1833            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1834       const char *Name = GI->getKeyData();
1835       const std::vector<DIE *> &Entities = GI->second;
1836       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1837              DE = Entities.end(); DI != DE; ++DI)
1838         AT.AddName(Name, (*DI));
1839     }
1840   }
1841
1842   AT.FinalizeTable(Asm, "namespac");
1843   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1844                                  .getDwarfAccelNamespaceSection());
1845   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
1846   Asm->OutStreamer.EmitLabel(SectionBegin);
1847
1848   // Emit the full data.
1849   AT.Emit(Asm, SectionBegin, this);
1850 }
1851
1852 /// emitAccelTypes() - Emit type dies into a hashed accelerator table.
1853 void DwarfDebug::emitAccelTypes() {
1854   std::vector<DwarfAccelTable::Atom> Atoms;
1855   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1856                                         dwarf::DW_FORM_data4));
1857   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
1858                                         dwarf::DW_FORM_data2));
1859   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
1860                                         dwarf::DW_FORM_data1));
1861   DwarfAccelTable AT(Atoms);
1862   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1863          E = CUMap.end(); I != E; ++I) {
1864     CompileUnit *TheCU = I->second;
1865     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
1866       = TheCU->getAccelTypes();
1867     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
1868            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1869       const char *Name = GI->getKeyData();
1870       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
1871       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
1872              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
1873         AT.AddName(Name, (*DI).first, (*DI).second);
1874     }
1875   }
1876
1877   AT.FinalizeTable(Asm, "types");
1878   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
1879                                  .getDwarfAccelTypesSection());
1880   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
1881   Asm->OutStreamer.EmitLabel(SectionBegin);
1882
1883   // Emit the full data.
1884   AT.Emit(Asm, SectionBegin, this);
1885 }
1886
1887 void DwarfDebug::emitDebugPubTypes() {
1888   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1889          E = CUMap.end(); I != E; ++I) {
1890     CompileUnit *TheCU = I->second;
1891     // Start the dwarf pubtypes section.
1892     Asm->OutStreamer.SwitchSection(
1893       Asm->getObjFileLowering().getDwarfPubTypesSection());
1894     Asm->OutStreamer.AddComment("Length of Public Types Info");
1895     Asm->EmitLabelDifference(
1896       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1897       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1898
1899     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1900                                                   TheCU->getID()));
1901
1902     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1903     Asm->EmitInt16(dwarf::DWARF_VERSION);
1904
1905     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1906     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1907                            DwarfInfoSectionSym);
1908
1909     Asm->OutStreamer.AddComment("Compilation Unit Length");
1910     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1911                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
1912                              4);
1913
1914     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1915     for (StringMap<DIE*>::const_iterator
1916            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1917       const char *Name = GI->getKeyData();
1918       DIE *Entity = GI->second;
1919
1920       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1921       Asm->EmitInt32(Entity->getOffset());
1922
1923       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1924       // Emit the name with a terminating null byte.
1925       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1926     }
1927
1928     Asm->OutStreamer.AddComment("End Mark");
1929     Asm->EmitInt32(0);
1930     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1931                                                   TheCU->getID()));
1932   }
1933 }
1934
1935 /// emitDebugStr - Emit visible names into a debug str section.
1936 ///
1937 void DwarfDebug::emitDebugStr() {
1938   // Check to see if it is worth the effort.
1939   if (StringPool.empty()) return;
1940
1941   // Start the dwarf str section.
1942   Asm->OutStreamer.SwitchSection(
1943                                 Asm->getObjFileLowering().getDwarfStrSection());
1944
1945   // Get all of the string pool entries and put them in an array by their ID so
1946   // we can sort them.
1947   SmallVector<std::pair<unsigned,
1948       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1949
1950   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1951        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1952     Entries.push_back(std::make_pair(I->second.second, &*I));
1953
1954   array_pod_sort(Entries.begin(), Entries.end());
1955
1956   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1957     // Emit a label for reference from debug information entries.
1958     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1959
1960     // Emit the string itself with a terminating null byte.
1961     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
1962                                          Entries[i].second->getKeyLength()+1),
1963                                0/*addrspace*/);
1964   }
1965 }
1966
1967 /// emitDebugLoc - Emit visible names into a debug loc section.
1968 ///
1969 void DwarfDebug::emitDebugLoc() {
1970   if (DotDebugLocEntries.empty())
1971     return;
1972
1973   for (SmallVector<DotDebugLocEntry, 4>::iterator
1974          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1975        I != E; ++I) {
1976     DotDebugLocEntry &Entry = *I;
1977     if (I + 1 != DotDebugLocEntries.end())
1978       Entry.Merge(I+1);
1979   }
1980
1981   // Start the dwarf loc section.
1982   Asm->OutStreamer.SwitchSection(
1983     Asm->getObjFileLowering().getDwarfLocSection());
1984   unsigned char Size = Asm->getTargetData().getPointerSize();
1985   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1986   unsigned index = 1;
1987   for (SmallVector<DotDebugLocEntry, 4>::iterator
1988          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1989        I != E; ++I, ++index) {
1990     DotDebugLocEntry &Entry = *I;
1991     if (Entry.isMerged()) continue;
1992     if (Entry.isEmpty()) {
1993       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1994       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1995       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1996     } else {
1997       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1998       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1999       DIVariable DV(Entry.Variable);
2000       Asm->OutStreamer.AddComment("Loc expr size");
2001       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2002       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2003       Asm->EmitLabelDifference(end, begin, 2);
2004       Asm->OutStreamer.EmitLabel(begin);
2005       if (Entry.isInt()) {
2006         DIBasicType BTy(DV.getType());
2007         if (BTy.Verify() &&
2008             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2009              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2010           Asm->OutStreamer.AddComment("DW_OP_consts");
2011           Asm->EmitInt8(dwarf::DW_OP_consts);
2012           Asm->EmitSLEB128(Entry.getInt());
2013         } else {
2014           Asm->OutStreamer.AddComment("DW_OP_constu");
2015           Asm->EmitInt8(dwarf::DW_OP_constu);
2016           Asm->EmitULEB128(Entry.getInt());
2017         }
2018       } else if (Entry.isLocation()) {
2019         if (!DV.hasComplexAddress())
2020           // Regular entry.
2021           Asm->EmitDwarfRegOp(Entry.Loc);
2022         else {
2023           // Complex address entry.
2024           unsigned N = DV.getNumAddrElements();
2025           unsigned i = 0;
2026           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2027             if (Entry.Loc.getOffset()) {
2028               i = 2;
2029               Asm->EmitDwarfRegOp(Entry.Loc);
2030               Asm->OutStreamer.AddComment("DW_OP_deref");
2031               Asm->EmitInt8(dwarf::DW_OP_deref);
2032               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2033               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2034               Asm->EmitSLEB128(DV.getAddrElement(1));
2035             } else {
2036               // If first address element is OpPlus then emit
2037               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2038               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2039               Asm->EmitDwarfRegOp(Loc);
2040               i = 2;
2041             }
2042           } else {
2043             Asm->EmitDwarfRegOp(Entry.Loc);
2044           }
2045
2046           // Emit remaining complex address elements.
2047           for (; i < N; ++i) {
2048             uint64_t Element = DV.getAddrElement(i);
2049             if (Element == DIBuilder::OpPlus) {
2050               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2051               Asm->EmitULEB128(DV.getAddrElement(++i));
2052             } else if (Element == DIBuilder::OpDeref) {
2053               if (Entry.Loc.getOffset())
2054                 Asm->EmitInt8(dwarf::DW_OP_deref);
2055             } else
2056               llvm_unreachable("unknown Opcode found in complex address");
2057           }
2058         }
2059       }
2060       // else ... ignore constant fp. There is not any good way to
2061       // to represent them here in dwarf.
2062       Asm->OutStreamer.EmitLabel(end);
2063     }
2064   }
2065 }
2066
2067 /// EmitDebugARanges - Emit visible names into a debug aranges section.
2068 ///
2069 void DwarfDebug::EmitDebugARanges() {
2070   // Start the dwarf aranges section.
2071   Asm->OutStreamer.SwitchSection(
2072                           Asm->getObjFileLowering().getDwarfARangesSection());
2073 }
2074
2075 /// emitDebugRanges - Emit visible names into a debug ranges section.
2076 ///
2077 void DwarfDebug::emitDebugRanges() {
2078   // Start the dwarf ranges section.
2079   Asm->OutStreamer.SwitchSection(
2080     Asm->getObjFileLowering().getDwarfRangesSection());
2081   unsigned char Size = Asm->getTargetData().getPointerSize();
2082   for (SmallVector<const MCSymbol *, 8>::iterator
2083          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2084        I != E; ++I) {
2085     if (*I)
2086       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
2087     else
2088       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
2089   }
2090 }
2091
2092 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
2093 ///
2094 void DwarfDebug::emitDebugMacInfo() {
2095   if (const MCSection *LineInfo =
2096       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2097     // Start the dwarf macinfo section.
2098     Asm->OutStreamer.SwitchSection(LineInfo);
2099   }
2100 }
2101
2102 /// emitDebugInlineInfo - Emit inline info using following format.
2103 /// Section Header:
2104 /// 1. length of section
2105 /// 2. Dwarf version number
2106 /// 3. address size.
2107 ///
2108 /// Entries (one "entry" for each function that was inlined):
2109 ///
2110 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
2111 ///   otherwise offset into __debug_str for regular function name.
2112 /// 2. offset into __debug_str section for regular function name.
2113 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
2114 /// instances for the function.
2115 ///
2116 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
2117 /// inlined instance; the die_offset points to the inlined_subroutine die in the
2118 /// __debug_info section, and the low_pc is the starting address for the
2119 /// inlining instance.
2120 void DwarfDebug::emitDebugInlineInfo() {
2121   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2122     return;
2123
2124   if (!FirstCU)
2125     return;
2126
2127   Asm->OutStreamer.SwitchSection(
2128                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2129
2130   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2131   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2132                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2133
2134   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2135
2136   Asm->OutStreamer.AddComment("Dwarf Version");
2137   Asm->EmitInt16(dwarf::DWARF_VERSION);
2138   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2139   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2140
2141   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2142          E = InlinedSPNodes.end(); I != E; ++I) {
2143
2144     const MDNode *Node = *I;
2145     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2146       = InlineInfo.find(Node);
2147     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2148     DISubprogram SP(Node);
2149     StringRef LName = SP.getLinkageName();
2150     StringRef Name = SP.getName();
2151
2152     Asm->OutStreamer.AddComment("MIPS linkage name");
2153     if (LName.empty())
2154       Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2155     else
2156       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2157                              DwarfStrSectionSym);
2158
2159     Asm->OutStreamer.AddComment("Function name");
2160     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2161     Asm->EmitULEB128(Labels.size(), "Inline count");
2162
2163     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2164            LE = Labels.end(); LI != LE; ++LI) {
2165       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2166       Asm->EmitInt32(LI->second->getOffset());
2167
2168       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2169       Asm->OutStreamer.EmitSymbolValue(LI->first,
2170                                        Asm->getTargetData().getPointerSize(),0);
2171     }
2172   }
2173
2174   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2175 }