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