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