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 CompileUnit *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   return NewCU;
 511 }
 512
 513 /// constructGlobalVariableDIE - Construct global variable DIE.
 514 void DwarfDebug::constructGlobalVariableDIE(CompileUnit *TheCU,
 515                                             const MDNode *N) {
 516   DIGlobalVariable GV(N);
 517
 518   // If debug information is malformed then ignore it.
 519   if (GV.Verify() == false)
 520     return;
 521
 522   TheCU->createGlobalVariableDIE(N);
 523   return;
 524 }
 525
 526 /// construct SubprogramDIE - Construct subprogram DIE.
 527 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
 528                                         const MDNode *N) {
 529   DISubprogram SP(N);
 530   if (!SP.isDefinition())
 531     // This is a method declaration which will be handled while constructing
 532     // class type.
 533     return;
 534
 535   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
 536
 537   // Add to map.
 538   TheCU->insertDIE(N, SubprogramDie);
 539
 540   // Add to context owner.
 541   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
 542
 543   // Expose as global.
 544   TheCU->addGlobal(SP.getName(), SubprogramDie);
 545
 546   SPMap[N] = TheCU;
 547   return;
 548 }
 549
 550 /// collectInfoFromNamedMDNodes - Collect debug info from named mdnodes such
 551 /// as llvm.dbg.enum and llvm.dbg.ty
 552 void DwarfDebug::collectInfoFromNamedMDNodes(Module *M) {
 553   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.sp"))
 554     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 555       const MDNode *N = NMD->getOperand(i);
 556       if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
 557         constructSubprogramDIE(CU, N);
 558     }
 559
 560   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.gv"))
 561     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 562       const MDNode *N = NMD->getOperand(i);
 563       if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
 564         constructGlobalVariableDIE(CU, N);
 565     }
 566
 567   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.enum"))
 568     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 569       DIType Ty(NMD->getOperand(i));
 570       if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
 571         CU->getOrCreateTypeDIE(Ty);
 572     }
 573
 574   if (NamedMDNode *NMD = M->getNamedMetadata("llvm.dbg.ty"))
 575     for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
 576       DIType Ty(NMD->getOperand(i));
 577       if (CompileUnit *CU = CUMap.lookup(Ty.getCompileUnit()))
 578         CU->getOrCreateTypeDIE(Ty);
 579     }
 580 }
 581
 582 /// collectLegacyDebugInfo - Collect debug info using DebugInfoFinder.
 583 /// FIXME - Remove this when dragon-egg and llvm-gcc switch to DIBuilder.
 584 bool DwarfDebug::collectLegacyDebugInfo(Module *M) {
 585   DebugInfoFinder DbgFinder;
 586   DbgFinder.processModule(*M);
 587
 588   bool HasDebugInfo = false;
 589   // Scan all the compile-units to see if there are any marked as the main
 590   // unit. If not, we do not generate debug info.
 591   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
 592          E = DbgFinder.compile_unit_end(); I != E; ++I) {
 593     if (DICompileUnit(*I).isMain()) {
 594       HasDebugInfo = true;
 595       break;
 596     }
 597   }
 598   if (!HasDebugInfo) return false;
 599
 600   // Create all the compile unit DIEs.
 601   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
 602          E = DbgFinder.compile_unit_end(); I != E; ++I)
 603     constructCompileUnit(*I);
 604
 605   // Create DIEs for each global variable.
 606   for (DebugInfoFinder::iterator I = DbgFinder.global_variable_begin(),
 607          E = DbgFinder.global_variable_end(); I != E; ++I) {
 608     const MDNode *N = *I;
 609     if (CompileUnit *CU = CUMap.lookup(DIGlobalVariable(N).getCompileUnit()))
 610       constructGlobalVariableDIE(CU, N);
 611   }
 612
 613   // Create DIEs for each subprogram.
 614   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
 615          E = DbgFinder.subprogram_end(); I != E; ++I) {
 616     const MDNode *N = *I;
 617     if (CompileUnit *CU = CUMap.lookup(DISubprogram(N).getCompileUnit()))
 618       constructSubprogramDIE(CU, N);
 619   }
 620
 621   return HasDebugInfo;
 622 }
 623
 624 /// beginModule - Emit all Dwarf sections that should come prior to the
 625 /// content. Create global DIEs and emit initial debug info sections.
 626 /// This is invoked by the target AsmPrinter.
 627 void DwarfDebug::beginModule(Module *M) {
 628   if (DisableDebugInfoPrinting)
 629     return;
 630
 631   // If module has named metadata anchors then use them, otherwise scan the
 632   // module using debug info finder to collect debug info.
 633   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 634   if (CU_Nodes) {
 635     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 636       DICompileUnit CUNode(CU_Nodes->getOperand(i));
 637       CompileUnit *CU = constructCompileUnit(CUNode);
 638       DIArray GVs = CUNode.getGlobalVariables();
 639       for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 640         constructGlobalVariableDIE(CU, GVs.getElement(i));
 641       DIArray SPs = CUNode.getSubprograms();
 642       for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 643         constructSubprogramDIE(CU, SPs.getElement(i));
 644       DIArray EnumTypes = CUNode.getEnumTypes();
 645       for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 646         CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 647       DIArray RetainedTypes = CUNode.getRetainedTypes();
 648       for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 649         CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 650     }
 651   } else if (!collectLegacyDebugInfo(M))
 652     return;
 653
 654   collectInfoFromNamedMDNodes(M);
 655
 656   // Tell MMI that we have debug info.
 657   MMI->setDebugInfoAvailability(true);
 658
 659   // Emit initial sections.
 660   EmitSectionLabels();
 661
 662   // Prime section data.
 663   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
 664 }
 665
 666 /// endModule - Emit all Dwarf sections that should come after the content.
 667 ///
 668 void DwarfDebug::endModule() {
 669   if (!FirstCU) return;
 670   const Module *M = MMI->getModule();
 671   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 672
 673   // Collect info for variables that were optimized out.
 674   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 675     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 676       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 677       DIArray Subprograms = TheCU.getSubprograms();
 678       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 679         DISubprogram SP(Subprograms.getElement(i));
 680         if (ProcessedSPNodes.count(SP) != 0) continue;
 681         if (!SP.Verify()) continue;
 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 =
 691           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 692         DeadFnScopeMap[SP] = Scope;
 693
 694         // Construct subprogram DIE and add variables DIEs.
 695         SmallVector<DbgVariable, 8> Variables;
 696         for (unsigned I = 0; I != E; ++I) {
 697           DIVariable DV(NMD->getOperand(I));
 698           if (!DV.Verify()) continue;
 699           Variables.push_back(DbgVariable(DV, NULL));
 700         }
 701         CompileUnit *SPCU = CUMap.lookup(TheCU);
 702         assert (SPCU && "Unable to find Compile Unit!");
 703         constructSubprogramDIE(SPCU, SP);
 704         DIE *ScopeDIE = SPCU->getDIE(SP);
 705         for (unsigned i = 0, N = Variables.size(); i < N; ++i) {
 706           if (DIE *VariableDIE =
 707               SPCU->constructVariableDIE(&Variables[i], Scope->isAbstractScope()))
 708             ScopeDIE->addChild(VariableDIE);
 709         }
 710       }
 711     }
 712   }
 713
 714   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 715   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 716          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 717     DIE *ISP = *AI;
 718     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 719   }
 720
 721   // Emit DW_AT_containing_type attribute to connect types with their
 722   // vtable holding type.
 723   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
 724          CUE = CUMap.end(); CUI != CUE; ++CUI) {
 725     CompileUnit *TheCU = CUI->second;
 726     TheCU->constructContainingTypeDIEs();
 727   }
 728
 729   // Standard sections final addresses.
 730   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
 731   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
 732   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
 733   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
 734
 735   // End text sections.
 736   for (unsigned i = 1, N = SectionMap.size(); i <= N; ++i) {
 737     Asm->OutStreamer.SwitchSection(SectionMap[i]);
 738     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", i));
 739   }
 740
 741   // Compute DIE offsets and sizes.
 742   computeSizeAndOffsets();
 743
 744   // Emit all the DIEs into a debug info section
 745   emitDebugInfo();
 746
 747   // Corresponding abbreviations into a abbrev section.
 748   emitAbbreviations();
 749
 750   // Emit info into a debug pubnames section.
 751   emitDebugPubNames();
 752
 753   // Emit info into a debug pubtypes section.
 754   emitDebugPubTypes();
 755
 756   // Emit info into a debug loc section.
 757   emitDebugLoc();
 758
 759   // Emit info into a debug aranges section.
 760   EmitDebugARanges();
 761
 762   // Emit info into a debug ranges section.
 763   emitDebugRanges();
 764
 765   // Emit info into a debug macinfo section.
 766   emitDebugMacInfo();
 767
 768   // Emit inline info.
 769   emitDebugInlineInfo();
 770
 771   // Emit info into a debug str section.
 772   emitDebugStr();
 773
 774   // clean up.
 775   DeleteContainerSeconds(DeadFnScopeMap);
 776   SPMap.clear();
 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 = SPMap.lookup(FnScope->getScopeNode());
1327   assert (TheCU && "Unable to find compile unit!");
1328
1329   // Construct abstract scopes.
1330   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1331   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1332     LexicalScope *AScope = AList[i];
1333     DISubprogram SP(AScope->getScopeNode());
1334     if (SP.Verify()) {
1335       // Collect info for variables that were optimized out.
1336       StringRef FName = SP.getLinkageName();
1337       if (FName.empty())
1338         FName = SP.getName();
1339       if (NamedMDNode *NMD =
1340           getFnSpecificMDNode(*(MF->getFunction()->getParent()), FName)) {
1341         for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1342           DIVariable DV(cast<MDNode>(NMD->getOperand(i)));
1343           if (!DV || !ProcessedVars.insert(DV))
1344             continue;
1345           if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1346             addScopeVariable(Scope, new DbgVariable(DV, NULL));
1347         }
1348       }
1349     }
1350     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1351       constructScopeDIE(TheCU, AScope);
1352   }
1353
1354   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1355
1356   if (!DisableFramePointerElim(*MF))
1357     TheCU->addUInt(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr,
1358                    dwarf::DW_FORM_flag, 1);
1359
1360   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1361                                                MMI->getFrameMoves()));
1362
1363   // Clear debug info
1364   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1365          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1366     DeleteContainerPointers(I->second);
1367   ScopeVariables.clear();
1368   DeleteContainerPointers(CurrentFnArguments);
1369   UserVariables.clear();
1370   DbgValues.clear();
1371   AbstractVariables.clear();
1372   LabelsBeforeInsn.clear();
1373   LabelsAfterInsn.clear();
1374   PrevLabel = NULL;
1375 }
1376
1377 /// recordSourceLine - Register a source line with debug info. Returns the
1378 /// unique label that was emitted and which provides correspondence to
1379 /// the source line list.
1380 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1381                                   unsigned Flags) {
1382   StringRef Fn;
1383   StringRef Dir;
1384   unsigned Src = 1;
1385   if (S) {
1386     DIDescriptor Scope(S);
1387
1388     if (Scope.isCompileUnit()) {
1389       DICompileUnit CU(S);
1390       Fn = CU.getFilename();
1391       Dir = CU.getDirectory();
1392     } else if (Scope.isFile()) {
1393       DIFile F(S);
1394       Fn = F.getFilename();
1395       Dir = F.getDirectory();
1396     } else if (Scope.isSubprogram()) {
1397       DISubprogram SP(S);
1398       Fn = SP.getFilename();
1399       Dir = SP.getDirectory();
1400     } else if (Scope.isLexicalBlock()) {
1401       DILexicalBlock DB(S);
1402       Fn = DB.getFilename();
1403       Dir = DB.getDirectory();
1404     } else
1405       assert(0 && "Unexpected scope info");
1406
1407     Src = GetOrCreateSourceID(Fn, Dir);
1408   }
1409   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1410 }
1411
1412 //===----------------------------------------------------------------------===//
1413 // Emit Methods
1414 //===----------------------------------------------------------------------===//
1415
1416 /// computeSizeAndOffset - Compute the size and offset of a DIE.
1417 ///
1418 unsigned
1419 DwarfDebug::computeSizeAndOffset(DIE *Die, unsigned Offset, bool Last) {
1420   // Get the children.
1421   const std::vector<DIE *> &Children = Die->getChildren();
1422
1423   // If not last sibling and has children then add sibling offset attribute.
1424   if (!Last && !Children.empty())
1425     Die->addSiblingOffset(DIEValueAllocator);
1426
1427   // Record the abbreviation.
1428   assignAbbrevNumber(Die->getAbbrev());
1429
1430   // Get the abbreviation for this DIE.
1431   unsigned AbbrevNumber = Die->getAbbrevNumber();
1432   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1433
1434   // Set DIE offset
1435   Die->setOffset(Offset);
1436
1437   // Start the size with the size of abbreviation code.
1438   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1439
1440   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1441   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1442
1443   // Size the DIE attribute values.
1444   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1445     // Size attribute value.
1446     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1447
1448   // Size the DIE children if any.
1449   if (!Children.empty()) {
1450     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1451            "Children flag not set");
1452
1453     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1454       Offset = computeSizeAndOffset(Children[j], Offset, (j + 1) == M);
1455
1456     // End of children marker.
1457     Offset += sizeof(int8_t);
1458   }
1459
1460   Die->setSize(Offset - Die->getOffset());
1461   return Offset;
1462 }
1463
1464 /// computeSizeAndOffsets - Compute the size and offset of all the DIEs.
1465 ///
1466 void DwarfDebug::computeSizeAndOffsets() {
1467   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1468          E = CUMap.end(); I != E; ++I) {
1469     // Compute size of compile unit header.
1470     unsigned Offset =
1471       sizeof(int32_t) + // Length of Compilation Unit Info
1472       sizeof(int16_t) + // DWARF version number
1473       sizeof(int32_t) + // Offset Into Abbrev. Section
1474       sizeof(int8_t);   // Pointer Size (in bytes)
1475     computeSizeAndOffset(I->second->getCUDie(), Offset, true);
1476   }
1477 }
1478
1479 /// EmitSectionSym - Switch to the specified MCSection and emit an assembler
1480 /// temporary label to it if SymbolStem is specified.
1481 static MCSymbol *EmitSectionSym(AsmPrinter *Asm, const MCSection *Section,
1482                                 const char *SymbolStem = 0) {
1483   Asm->OutStreamer.SwitchSection(Section);
1484   if (!SymbolStem) return 0;
1485
1486   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
1487   Asm->OutStreamer.EmitLabel(TmpSym);
1488   return TmpSym;
1489 }
1490
1491 /// EmitSectionLabels - Emit initial Dwarf sections with a label at
1492 /// the start of each one.
1493 void DwarfDebug::EmitSectionLabels() {
1494   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1495
1496   // Dwarf sections base addresses.
1497   DwarfInfoSectionSym =
1498     EmitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1499   DwarfAbbrevSectionSym =
1500     EmitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1501   EmitSectionSym(Asm, TLOF.getDwarfARangesSection());
1502
1503   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1504     EmitSectionSym(Asm, MacroInfo);
1505
1506   EmitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1507   EmitSectionSym(Asm, TLOF.getDwarfLocSection());
1508   EmitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1509   EmitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1510   DwarfStrSectionSym =
1511     EmitSectionSym(Asm, TLOF.getDwarfStrSection(), "section_str");
1512   DwarfDebugRangeSectionSym = EmitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1513                                              "debug_range");
1514
1515   DwarfDebugLocSectionSym = EmitSectionSym(Asm, TLOF.getDwarfLocSection(),
1516                                            "section_debug_loc");
1517
1518   TextSectionSym = EmitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1519   EmitSectionSym(Asm, TLOF.getDataSection());
1520 }
1521
1522 /// emitDIE - Recursively emits a debug information entry.
1523 ///
1524 void DwarfDebug::emitDIE(DIE *Die) {
1525   // Get the abbreviation for this DIE.
1526   unsigned AbbrevNumber = Die->getAbbrevNumber();
1527   const DIEAbbrev *Abbrev = Abbreviations[AbbrevNumber - 1];
1528
1529   // Emit the code (index) for the abbreviation.
1530   if (Asm->isVerbose())
1531     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1532                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1533                                 Twine::utohexstr(Die->getSize()) + " " +
1534                                 dwarf::TagString(Abbrev->getTag()));
1535   Asm->EmitULEB128(AbbrevNumber);
1536
1537   const SmallVector<DIEValue*, 32> &Values = Die->getValues();
1538   const SmallVector<DIEAbbrevData, 8> &AbbrevData = Abbrev->getData();
1539
1540   // Emit the DIE attribute values.
1541   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1542     unsigned Attr = AbbrevData[i].getAttribute();
1543     unsigned Form = AbbrevData[i].getForm();
1544     assert(Form && "Too many attributes for DIE (check abbreviation)");
1545
1546     if (Asm->isVerbose())
1547       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1548
1549     switch (Attr) {
1550     case dwarf::DW_AT_sibling:
1551       Asm->EmitInt32(Die->getSiblingOffset());
1552       break;
1553     case dwarf::DW_AT_abstract_origin: {
1554       DIEEntry *E = cast<DIEEntry>(Values[i]);
1555       DIE *Origin = E->getEntry();
1556       unsigned Addr = Origin->getOffset();
1557       Asm->EmitInt32(Addr);
1558       break;
1559     }
1560     case dwarf::DW_AT_ranges: {
1561       // DW_AT_range Value encodes offset in debug_range section.
1562       DIEInteger *V = cast<DIEInteger>(Values[i]);
1563
1564       if (Asm->MAI->doesDwarfUsesLabelOffsetForRanges()) {
1565         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1566                                  V->getValue(),
1567                                  4);
1568       } else {
1569         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1570                                        V->getValue(),
1571                                        DwarfDebugRangeSectionSym,
1572                                        4);
1573       }
1574       break;
1575     }
1576     case dwarf::DW_AT_location: {
1577       if (DIELabel *L = dyn_cast<DIELabel>(Values[i]))
1578         Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1579       else
1580         Values[i]->EmitValue(Asm, Form);
1581       break;
1582     }
1583     case dwarf::DW_AT_accessibility: {
1584       if (Asm->isVerbose()) {
1585         DIEInteger *V = cast<DIEInteger>(Values[i]);
1586         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1587       }
1588       Values[i]->EmitValue(Asm, Form);
1589       break;
1590     }
1591     default:
1592       // Emit an attribute using the defined form.
1593       Values[i]->EmitValue(Asm, Form);
1594       break;
1595     }
1596   }
1597
1598   // Emit the DIE children if any.
1599   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1600     const std::vector<DIE *> &Children = Die->getChildren();
1601
1602     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1603       emitDIE(Children[j]);
1604
1605     if (Asm->isVerbose())
1606       Asm->OutStreamer.AddComment("End Of Children Mark");
1607     Asm->EmitInt8(0);
1608   }
1609 }
1610
1611 /// emitDebugInfo - Emit the debug info section.
1612 ///
1613 void DwarfDebug::emitDebugInfo() {
1614   // Start debug info section.
1615   Asm->OutStreamer.SwitchSection(
1616                             Asm->getObjFileLowering().getDwarfInfoSection());
1617   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1618          E = CUMap.end(); I != E; ++I) {
1619     CompileUnit *TheCU = I->second;
1620     DIE *Die = TheCU->getCUDie();
1621
1622     // Emit the compile units header.
1623     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_begin",
1624                                                   TheCU->getID()));
1625
1626     // Emit size of content not including length itself
1627     unsigned ContentSize = Die->getSize() +
1628       sizeof(int16_t) + // DWARF version number
1629       sizeof(int32_t) + // Offset Into Abbrev. Section
1630       sizeof(int8_t);   // Pointer Size (in bytes)
1631
1632     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1633     Asm->EmitInt32(ContentSize);
1634     Asm->OutStreamer.AddComment("DWARF version number");
1635     Asm->EmitInt16(dwarf::DWARF_VERSION);
1636     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1637     Asm->EmitSectionOffset(Asm->GetTempSymbol("abbrev_begin"),
1638                            DwarfAbbrevSectionSym);
1639     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1640     Asm->EmitInt8(Asm->getTargetData().getPointerSize());
1641
1642     emitDIE(Die);
1643     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("info_end", TheCU->getID()));
1644   }
1645 }
1646
1647 /// emitAbbreviations - Emit the abbreviation section.
1648 ///
1649 void DwarfDebug::emitAbbreviations() const {
1650   // Check to see if it is worth the effort.
1651   if (!Abbreviations.empty()) {
1652     // Start the debug abbrev section.
1653     Asm->OutStreamer.SwitchSection(
1654                             Asm->getObjFileLowering().getDwarfAbbrevSection());
1655
1656     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_begin"));
1657
1658     // For each abbrevation.
1659     for (unsigned i = 0, N = Abbreviations.size(); i < N; ++i) {
1660       // Get abbreviation data
1661       const DIEAbbrev *Abbrev = Abbreviations[i];
1662
1663       // Emit the abbrevations code (base 1 index.)
1664       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1665
1666       // Emit the abbreviations data.
1667       Abbrev->Emit(Asm);
1668     }
1669
1670     // Mark end of abbreviations.
1671     Asm->EmitULEB128(0, "EOM(3)");
1672
1673     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("abbrev_end"));
1674   }
1675 }
1676
1677 /// emitEndOfLineMatrix - Emit the last address of the section and the end of
1678 /// the line matrix.
1679 ///
1680 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1681   // Define last address of section.
1682   Asm->OutStreamer.AddComment("Extended Op");
1683   Asm->EmitInt8(0);
1684
1685   Asm->OutStreamer.AddComment("Op size");
1686   Asm->EmitInt8(Asm->getTargetData().getPointerSize() + 1);
1687   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1688   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1689
1690   Asm->OutStreamer.AddComment("Section end label");
1691
1692   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1693                                    Asm->getTargetData().getPointerSize(),
1694                                    0/*AddrSpace*/);
1695
1696   // Mark end of matrix.
1697   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1698   Asm->EmitInt8(0);
1699   Asm->EmitInt8(1);
1700   Asm->EmitInt8(1);
1701 }
1702
1703 /// emitDebugPubNames - Emit visible names into a debug pubnames section.
1704 ///
1705 void DwarfDebug::emitDebugPubNames() {
1706   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1707          E = CUMap.end(); I != E; ++I) {
1708     CompileUnit *TheCU = I->second;
1709     // Start the dwarf pubnames section.
1710     Asm->OutStreamer.SwitchSection(
1711       Asm->getObjFileLowering().getDwarfPubNamesSection());
1712
1713     Asm->OutStreamer.AddComment("Length of Public Names Info");
1714     Asm->EmitLabelDifference(
1715       Asm->GetTempSymbol("pubnames_end", TheCU->getID()),
1716       Asm->GetTempSymbol("pubnames_begin", TheCU->getID()), 4);
1717
1718     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin",
1719                                                   TheCU->getID()));
1720
1721     Asm->OutStreamer.AddComment("DWARF Version");
1722     Asm->EmitInt16(dwarf::DWARF_VERSION);
1723
1724     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1725     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1726                            DwarfInfoSectionSym);
1727
1728     Asm->OutStreamer.AddComment("Compilation Unit Length");
1729     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1730                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
1731                              4);
1732
1733     const StringMap<DIE*> &Globals = TheCU->getGlobals();
1734     for (StringMap<DIE*>::const_iterator
1735            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1736       const char *Name = GI->getKeyData();
1737       DIE *Entity = GI->second;
1738
1739       Asm->OutStreamer.AddComment("DIE offset");
1740       Asm->EmitInt32(Entity->getOffset());
1741
1742       if (Asm->isVerbose())
1743         Asm->OutStreamer.AddComment("External Name");
1744       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
1745     }
1746
1747     Asm->OutStreamer.AddComment("End Mark");
1748     Asm->EmitInt32(0);
1749     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end",
1750                                                   TheCU->getID()));
1751   }
1752 }
1753
1754 void DwarfDebug::emitDebugPubTypes() {
1755   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1756          E = CUMap.end(); I != E; ++I) {
1757     CompileUnit *TheCU = I->second;
1758     // Start the dwarf pubnames section.
1759     Asm->OutStreamer.SwitchSection(
1760       Asm->getObjFileLowering().getDwarfPubTypesSection());
1761     Asm->OutStreamer.AddComment("Length of Public Types Info");
1762     Asm->EmitLabelDifference(
1763       Asm->GetTempSymbol("pubtypes_end", TheCU->getID()),
1764       Asm->GetTempSymbol("pubtypes_begin", TheCU->getID()), 4);
1765
1766     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
1767                                                   TheCU->getID()));
1768
1769     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
1770     Asm->EmitInt16(dwarf::DWARF_VERSION);
1771
1772     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
1773     Asm->EmitSectionOffset(Asm->GetTempSymbol("info_begin", TheCU->getID()),
1774                            DwarfInfoSectionSym);
1775
1776     Asm->OutStreamer.AddComment("Compilation Unit Length");
1777     Asm->EmitLabelDifference(Asm->GetTempSymbol("info_end", TheCU->getID()),
1778                              Asm->GetTempSymbol("info_begin", TheCU->getID()),
1779                              4);
1780
1781     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
1782     for (StringMap<DIE*>::const_iterator
1783            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
1784       const char *Name = GI->getKeyData();
1785       DIE *Entity = GI->second;
1786
1787       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
1788       Asm->EmitInt32(Entity->getOffset());
1789
1790       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
1791       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1), 0);
1792     }
1793
1794     Asm->OutStreamer.AddComment("End Mark");
1795     Asm->EmitInt32(0);
1796     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
1797                                                   TheCU->getID()));
1798   }
1799 }
1800
1801 /// emitDebugStr - Emit visible names into a debug str section.
1802 ///
1803 void DwarfDebug::emitDebugStr() {
1804   // Check to see if it is worth the effort.
1805   if (StringPool.empty()) return;
1806
1807   // Start the dwarf str section.
1808   Asm->OutStreamer.SwitchSection(
1809                                 Asm->getObjFileLowering().getDwarfStrSection());
1810
1811   // Get all of the string pool entries and put them in an array by their ID so
1812   // we can sort them.
1813   SmallVector<std::pair<unsigned,
1814       StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
1815
1816   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
1817        I = StringPool.begin(), E = StringPool.end(); I != E; ++I)
1818     Entries.push_back(std::make_pair(I->second.second, &*I));
1819
1820   array_pod_sort(Entries.begin(), Entries.end());
1821
1822   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
1823     // Emit a label for reference from debug information entries.
1824     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
1825
1826     // Emit the string itself.
1827     Asm->OutStreamer.EmitBytes(Entries[i].second->getKey(), 0/*addrspace*/);
1828   }
1829 }
1830
1831 /// emitDebugLoc - Emit visible names into a debug loc section.
1832 ///
1833 void DwarfDebug::emitDebugLoc() {
1834   if (DotDebugLocEntries.empty())
1835     return;
1836
1837   for (SmallVector<DotDebugLocEntry, 4>::iterator
1838          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1839        I != E; ++I) {
1840     DotDebugLocEntry &Entry = *I;
1841     if (I + 1 != DotDebugLocEntries.end())
1842       Entry.Merge(I+1);
1843   }
1844
1845   // Start the dwarf loc section.
1846   Asm->OutStreamer.SwitchSection(
1847     Asm->getObjFileLowering().getDwarfLocSection());
1848   unsigned char Size = Asm->getTargetData().getPointerSize();
1849   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
1850   unsigned index = 1;
1851   for (SmallVector<DotDebugLocEntry, 4>::iterator
1852          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
1853        I != E; ++I, ++index) {
1854     DotDebugLocEntry &Entry = *I;
1855     if (Entry.isMerged()) continue;
1856     if (Entry.isEmpty()) {
1857       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1858       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1859       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
1860     } else {
1861       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size, 0);
1862       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size, 0);
1863       DIVariable DV(Entry.Variable);
1864       Asm->OutStreamer.AddComment("Loc expr size");
1865       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
1866       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
1867       Asm->EmitLabelDifference(end, begin, 2);
1868       Asm->OutStreamer.EmitLabel(begin);
1869       if (Entry.isInt()) {
1870         DIBasicType BTy(DV.getType());
1871         if (BTy.Verify() &&
1872             (BTy.getEncoding()  == dwarf::DW_ATE_signed
1873              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
1874           Asm->OutStreamer.AddComment("DW_OP_consts");
1875           Asm->EmitInt8(dwarf::DW_OP_consts);
1876           Asm->EmitSLEB128(Entry.getInt());
1877         } else {
1878           Asm->OutStreamer.AddComment("DW_OP_constu");
1879           Asm->EmitInt8(dwarf::DW_OP_constu);
1880           Asm->EmitULEB128(Entry.getInt());
1881         }
1882       } else if (Entry.isLocation()) {
1883         if (!DV.hasComplexAddress())
1884           // Regular entry.
1885           Asm->EmitDwarfRegOp(Entry.Loc);
1886         else {
1887           // Complex address entry.
1888           unsigned N = DV.getNumAddrElements();
1889           unsigned i = 0;
1890           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
1891             if (Entry.Loc.getOffset()) {
1892               i = 2;
1893               Asm->EmitDwarfRegOp(Entry.Loc);
1894               Asm->OutStreamer.AddComment("DW_OP_deref");
1895               Asm->EmitInt8(dwarf::DW_OP_deref);
1896               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
1897               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1898               Asm->EmitSLEB128(DV.getAddrElement(1));
1899             } else {
1900               // If first address element is OpPlus then emit
1901               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
1902               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
1903               Asm->EmitDwarfRegOp(Loc);
1904               i = 2;
1905             }
1906           } else {
1907             Asm->EmitDwarfRegOp(Entry.Loc);
1908           }
1909
1910           // Emit remaining complex address elements.
1911           for (; i < N; ++i) {
1912             uint64_t Element = DV.getAddrElement(i);
1913             if (Element == DIBuilder::OpPlus) {
1914               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
1915               Asm->EmitULEB128(DV.getAddrElement(++i));
1916             } else if (Element == DIBuilder::OpDeref)
1917               Asm->EmitInt8(dwarf::DW_OP_deref);
1918             else llvm_unreachable("unknown Opcode found in complex address");
1919           }
1920         }
1921       }
1922       // else ... ignore constant fp. There is not any good way to
1923       // to represent them here in dwarf.
1924       Asm->OutStreamer.EmitLabel(end);
1925     }
1926   }
1927 }
1928
1929 /// EmitDebugARanges - Emit visible names into a debug aranges section.
1930 ///
1931 void DwarfDebug::EmitDebugARanges() {
1932   // Start the dwarf aranges section.
1933   Asm->OutStreamer.SwitchSection(
1934                           Asm->getObjFileLowering().getDwarfARangesSection());
1935 }
1936
1937 /// emitDebugRanges - Emit visible names into a debug ranges section.
1938 ///
1939 void DwarfDebug::emitDebugRanges() {
1940   // Start the dwarf ranges section.
1941   Asm->OutStreamer.SwitchSection(
1942     Asm->getObjFileLowering().getDwarfRangesSection());
1943   unsigned char Size = Asm->getTargetData().getPointerSize();
1944   for (SmallVector<const MCSymbol *, 8>::iterator
1945          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
1946        I != E; ++I) {
1947     if (*I)
1948       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size, 0);
1949     else
1950       Asm->OutStreamer.EmitIntValue(0, Size, /*addrspace*/0);
1951   }
1952 }
1953
1954 /// emitDebugMacInfo - Emit visible names into a debug macinfo section.
1955 ///
1956 void DwarfDebug::emitDebugMacInfo() {
1957   if (const MCSection *LineInfo =
1958       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
1959     // Start the dwarf macinfo section.
1960     Asm->OutStreamer.SwitchSection(LineInfo);
1961   }
1962 }
1963
1964 /// emitDebugInlineInfo - Emit inline info using following format.
1965 /// Section Header:
1966 /// 1. length of section
1967 /// 2. Dwarf version number
1968 /// 3. address size.
1969 ///
1970 /// Entries (one "entry" for each function that was inlined):
1971 ///
1972 /// 1. offset into __debug_str section for MIPS linkage name, if exists;
1973 ///   otherwise offset into __debug_str for regular function name.
1974 /// 2. offset into __debug_str section for regular function name.
1975 /// 3. an unsigned LEB128 number indicating the number of distinct inlining
1976 /// instances for the function.
1977 ///
1978 /// The rest of the entry consists of a {die_offset, low_pc} pair for each
1979 /// inlined instance; the die_offset points to the inlined_subroutine die in the
1980 /// __debug_info section, and the low_pc is the starting address for the
1981 /// inlining instance.
1982 void DwarfDebug::emitDebugInlineInfo() {
1983   if (!Asm->MAI->doesDwarfUsesInlineInfoSection())
1984     return;
1985
1986   if (!FirstCU)
1987     return;
1988
1989   Asm->OutStreamer.SwitchSection(
1990                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
1991
1992   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
1993   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
1994                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
1995
1996   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
1997
1998   Asm->OutStreamer.AddComment("Dwarf Version");
1999   Asm->EmitInt16(dwarf::DWARF_VERSION);
2000   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2001   Asm->EmitInt8(Asm->getTargetData().getPointerSize());
2002
2003   for (SmallVector<const MDNode *, 4>::iterator I = InlinedSPNodes.begin(),
2004          E = InlinedSPNodes.end(); I != E; ++I) {
2005
2006     const MDNode *Node = *I;
2007     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2008       = InlineInfo.find(Node);
2009     SmallVector<InlineInfoLabels, 4> &Labels = II->second;
2010     DISubprogram SP(Node);
2011     StringRef LName = SP.getLinkageName();
2012     StringRef Name = SP.getName();
2013
2014     Asm->OutStreamer.AddComment("MIPS linkage name");
2015     if (LName.empty()) {
2016       Asm->OutStreamer.EmitBytes(Name, 0);
2017       Asm->OutStreamer.EmitIntValue(0, 1, 0); // nul terminator.
2018     } else
2019       Asm->EmitSectionOffset(getStringPoolEntry(getRealLinkageName(LName)),
2020                              DwarfStrSectionSym);
2021
2022     Asm->OutStreamer.AddComment("Function name");
2023     Asm->EmitSectionOffset(getStringPoolEntry(Name), DwarfStrSectionSym);
2024     Asm->EmitULEB128(Labels.size(), "Inline count");
2025
2026     for (SmallVector<InlineInfoLabels, 4>::iterator LI = Labels.begin(),
2027            LE = Labels.end(); LI != LE; ++LI) {
2028       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2029       Asm->EmitInt32(LI->second->getOffset());
2030
2031       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2032       Asm->OutStreamer.EmitSymbolValue(LI->first,
2033                                        Asm->getTargetData().getPointerSize(),0);
2034     }
2035   }
2036
2037   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2038 }