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