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