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