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 "DwarfAccelTable.h"
  18 #include "DwarfCompileUnit.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/Statistic.h"
  21 #include "llvm/ADT/StringExtras.h"
  22 #include "llvm/ADT/Triple.h"
  23 #include "llvm/CodeGen/MachineFunction.h"
  24 #include "llvm/CodeGen/MachineModuleInfo.h"
  25 #include "llvm/DIBuilder.h"
  26 #include "llvm/DebugInfo.h"
  27 #include "llvm/IR/Constants.h"
  28 #include "llvm/IR/DataLayout.h"
  29 #include "llvm/IR/Instructions.h"
  30 #include "llvm/IR/Module.h"
  31 #include "llvm/MC/MCAsmInfo.h"
  32 #include "llvm/MC/MCSection.h"
  33 #include "llvm/MC/MCStreamer.h"
  34 #include "llvm/MC/MCSymbol.h"
  35 #include "llvm/Support/CommandLine.h"
  36 #include "llvm/Support/Debug.h"
  37 #include "llvm/Support/ErrorHandling.h"
  38 #include "llvm/Support/FormattedStream.h"
  39 #include "llvm/Support/Path.h"
  40 #include "llvm/Support/Timer.h"
  41 #include "llvm/Support/ValueHandle.h"
  42 #include "llvm/Target/TargetFrameLowering.h"
  43 #include "llvm/Target/TargetLoweringObjectFile.h"
  44 #include "llvm/Target/TargetMachine.h"
  45 #include "llvm/Target/TargetOptions.h"
  46 #include "llvm/Target/TargetRegisterInfo.h"
  47 using namespace llvm;
  48
  49 static cl::opt<bool> DisableDebugInfoPrinting("disable-debug-info-print",
  50                                               cl::Hidden,
  51      cl::desc("Disable debug info printing"));
  52
  53 static cl::opt<bool> UnknownLocations("use-unknown-locations", cl::Hidden,
  54      cl::desc("Make an absence of debug location information explicit."),
  55      cl::init(false));
  56
  57 static cl::opt<bool> GenerateDwarfPubNamesSection("generate-dwarf-pubnames",
  58      cl::Hidden, cl::init(false),
  59      cl::desc("Generate DWARF pubnames section"));
  60
  61 namespace {
  62   enum DefaultOnOff {
  63     Default, Enable, Disable
  64   };
  65 }
  66
  67 static cl::opt<DefaultOnOff> DwarfAccelTables("dwarf-accel-tables", cl::Hidden,
  68      cl::desc("Output prototype dwarf accelerator tables."),
  69      cl::values(
  70                 clEnumVal(Default, "Default for platform"),
  71                 clEnumVal(Enable, "Enabled"),
  72                 clEnumVal(Disable, "Disabled"),
  73                 clEnumValEnd),
  74      cl::init(Default));
  75
  76 static cl::opt<DefaultOnOff> DarwinGDBCompat("darwin-gdb-compat", cl::Hidden,
  77      cl::desc("Compatibility with Darwin gdb."),
  78      cl::values(
  79                 clEnumVal(Default, "Default for platform"),
  80                 clEnumVal(Enable, "Enabled"),
  81                 clEnumVal(Disable, "Disabled"),
  82                 clEnumValEnd),
  83      cl::init(Default));
  84
  85 static cl::opt<DefaultOnOff> SplitDwarf("split-dwarf", cl::Hidden,
  86      cl::desc("Output prototype dwarf split debug info."),
  87      cl::values(
  88                 clEnumVal(Default, "Default for platform"),
  89                 clEnumVal(Enable, "Enabled"),
  90                 clEnumVal(Disable, "Disabled"),
  91                 clEnumValEnd),
  92      cl::init(Default));
  93
  94 namespace {
  95   const char *DWARFGroupName = "DWARF Emission";
  96   const char *DbgTimerName = "DWARF Debug Writer";
  97 } // end anonymous namespace
  98
  99 //===----------------------------------------------------------------------===//
 100
 101 // Configuration values for initial hash set sizes (log2).
 102 //
 103 static const unsigned InitAbbreviationsSetSize = 9; // log2(512)
 104
 105 namespace llvm {
 106
 107 DIType DbgVariable::getType() const {
 108   DIType Ty = Var.getType();
 109   // FIXME: isBlockByrefVariable should be reformulated in terms of complex
 110   // addresses instead.
 111   if (Var.isBlockByrefVariable()) {
 112     /* Byref variables, in Blocks, are declared by the programmer as
 113        "SomeType VarName;", but the compiler creates a
 114        __Block_byref_x_VarName struct, and gives the variable VarName
 115        either the struct, or a pointer to the struct, as its type.  This
 116        is necessary for various behind-the-scenes things the compiler
 117        needs to do with by-reference variables in blocks.
 118
 119        However, as far as the original *programmer* is concerned, the
 120        variable should still have type 'SomeType', as originally declared.
 121
 122        The following function dives into the __Block_byref_x_VarName
 123        struct to find the original type of the variable.  This will be
 124        passed back to the code generating the type for the Debug
 125        Information Entry for the variable 'VarName'.  'VarName' will then
 126        have the original type 'SomeType' in its debug information.
 127
 128        The original type 'SomeType' will be the type of the field named
 129        'VarName' inside the __Block_byref_x_VarName struct.
 130
 131        NOTE: In order for this to not completely fail on the debugger
 132        side, the Debug Information Entry for the variable VarName needs to
 133        have a DW_AT_location that tells the debugger how to unwind through
 134        the pointers and __Block_byref_x_VarName struct to find the actual
 135        value of the variable.  The function addBlockByrefType does this.  */
 136     DIType subType = Ty;
 137     unsigned tag = Ty.getTag();
 138
 139     if (tag == dwarf::DW_TAG_pointer_type) {
 140       DIDerivedType DTy = DIDerivedType(Ty);
 141       subType = DTy.getTypeDerivedFrom();
 142     }
 143
 144     DICompositeType blockStruct = DICompositeType(subType);
 145     DIArray Elements = blockStruct.getTypeArray();
 146
 147     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 148       DIDescriptor Element = Elements.getElement(i);
 149       DIDerivedType DT = DIDerivedType(Element);
 150       if (getName() == DT.getName())
 151         return (DT.getTypeDerivedFrom());
 152     }
 153   }
 154   return Ty;
 155 }
 156
 157 } // end llvm namespace
 158
 159 DwarfDebug::DwarfDebug(AsmPrinter *A, Module *M)
 160   : Asm(A), MMI(Asm->MMI), FirstCU(0),
 161     AbbreviationsSet(InitAbbreviationsSetSize),
 162     SourceIdMap(DIEValueAllocator),
 163     PrevLabel(NULL), GlobalCUIndexCount(0),
 164     InfoHolder(A, &AbbreviationsSet, &Abbreviations, "info_string",
 165                DIEValueAllocator),
 166     SkeletonAbbrevSet(InitAbbreviationsSetSize),
 167     SkeletonHolder(A, &SkeletonAbbrevSet, &SkeletonAbbrevs, "skel_string",
 168                    DIEValueAllocator) {
 169
 170   DwarfInfoSectionSym = DwarfAbbrevSectionSym = 0;
 171   DwarfStrSectionSym = TextSectionSym = 0;
 172   DwarfDebugRangeSectionSym = DwarfDebugLocSectionSym = DwarfLineSectionSym = 0;
 173   DwarfAddrSectionSym = 0;
 174   DwarfAbbrevDWOSectionSym = DwarfStrDWOSectionSym = 0;
 175   FunctionBeginSym = FunctionEndSym = 0;
 176
 177   // Turn on accelerator tables and older gdb compatibility
 178   // for Darwin.
 179   bool IsDarwin = Triple(M->getTargetTriple()).isOSDarwin();
 180   if (DarwinGDBCompat == Default) {
 181     if (IsDarwin)
 182       IsDarwinGDBCompat = true;
 183     else
 184       IsDarwinGDBCompat = false;
 185   } else
 186     IsDarwinGDBCompat = DarwinGDBCompat == Enable ? true : false;
 187
 188   if (DwarfAccelTables == Default) {
 189     if (IsDarwin)
 190       HasDwarfAccelTables = true;
 191     else
 192       HasDwarfAccelTables = false;
 193   } else
 194     HasDwarfAccelTables = DwarfAccelTables == Enable ? true : false;
 195
 196   if (SplitDwarf == Default)
 197     HasSplitDwarf = false;
 198   else
 199     HasSplitDwarf = SplitDwarf == Enable ? true : false;
 200
 201   {
 202     NamedRegionTimer T(DbgTimerName, DWARFGroupName, TimePassesIsEnabled);
 203     beginModule();
 204   }
 205 }
 206 DwarfDebug::~DwarfDebug() {
 207 }
 208
 209 // Switch to the specified MCSection and emit an assembler
 210 // temporary label to it if SymbolStem is specified.
 211 static MCSymbol *emitSectionSym(AsmPrinter *Asm, const MCSection *Section,
 212                                 const char *SymbolStem = 0) {
 213   Asm->OutStreamer.SwitchSection(Section);
 214   if (!SymbolStem) return 0;
 215
 216   MCSymbol *TmpSym = Asm->GetTempSymbol(SymbolStem);
 217   Asm->OutStreamer.EmitLabel(TmpSym);
 218   return TmpSym;
 219 }
 220
 221 MCSymbol *DwarfUnits::getStringPoolSym() {
 222   return Asm->GetTempSymbol(StringPref);
 223 }
 224
 225 MCSymbol *DwarfUnits::getStringPoolEntry(StringRef Str) {
 226   std::pair<MCSymbol*, unsigned> &Entry =
 227     StringPool.GetOrCreateValue(Str).getValue();
 228   if (Entry.first) return Entry.first;
 229
 230   Entry.second = NextStringPoolNumber++;
 231   return Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
 232 }
 233
 234 unsigned DwarfUnits::getStringPoolIndex(StringRef Str) {
 235   std::pair<MCSymbol*, unsigned> &Entry =
 236     StringPool.GetOrCreateValue(Str).getValue();
 237   if (Entry.first) return Entry.second;
 238
 239   Entry.second = NextStringPoolNumber++;
 240   Entry.first = Asm->GetTempSymbol(StringPref, Entry.second);
 241   return Entry.second;
 242 }
 243
 244 unsigned DwarfUnits::getAddrPoolIndex(MCSymbol *Sym) {
 245   std::pair<MCSymbol*, unsigned> &Entry = AddressPool[Sym];
 246   if (Entry.first) return Entry.second;
 247
 248   Entry.second = NextAddrPoolNumber++;
 249   Entry.first = Sym;
 250   return Entry.second;
 251 }
 252
 253 // Define a unique number for the abbreviation.
 254 //
 255 void DwarfUnits::assignAbbrevNumber(DIEAbbrev &Abbrev) {
 256   // Profile the node so that we can make it unique.
 257   FoldingSetNodeID ID;
 258   Abbrev.Profile(ID);
 259
 260   // Check the set for priors.
 261   DIEAbbrev *InSet = AbbreviationsSet->GetOrInsertNode(&Abbrev);
 262
 263   // If it's newly added.
 264   if (InSet == &Abbrev) {
 265     // Add to abbreviation list.
 266     Abbreviations->push_back(&Abbrev);
 267
 268     // Assign the vector position + 1 as its number.
 269     Abbrev.setNumber(Abbreviations->size());
 270   } else {
 271     // Assign existing abbreviation number.
 272     Abbrev.setNumber(InSet->getNumber());
 273   }
 274 }
 275
 276 // If special LLVM prefix that is used to inform the asm
 277 // printer to not emit usual symbol prefix before the symbol name is used then
 278 // return linkage name after skipping this special LLVM prefix.
 279 static StringRef getRealLinkageName(StringRef LinkageName) {
 280   char One = '\1';
 281   if (LinkageName.startswith(StringRef(&One, 1)))
 282     return LinkageName.substr(1);
 283   return LinkageName;
 284 }
 285
 286 static bool isObjCClass(StringRef Name) {
 287   return Name.startswith("+") || Name.startswith("-");
 288 }
 289
 290 static bool hasObjCCategory(StringRef Name) {
 291   if (!isObjCClass(Name)) return false;
 292
 293   size_t pos = Name.find(')');
 294   if (pos != std::string::npos) {
 295     if (Name[pos+1] != ' ') return false;
 296     return true;
 297   }
 298   return false;
 299 }
 300
 301 static void getObjCClassCategory(StringRef In, StringRef &Class,
 302                                  StringRef &Category) {
 303   if (!hasObjCCategory(In)) {
 304     Class = In.slice(In.find('[') + 1, In.find(' '));
 305     Category = "";
 306     return;
 307   }
 308
 309   Class = In.slice(In.find('[') + 1, In.find('('));
 310   Category = In.slice(In.find('[') + 1, In.find(' '));
 311   return;
 312 }
 313
 314 static StringRef getObjCMethodName(StringRef In) {
 315   return In.slice(In.find(' ') + 1, In.find(']'));
 316 }
 317
 318 // Add the various names to the Dwarf accelerator table names.
 319 static void addSubprogramNames(CompileUnit *TheCU, DISubprogram SP,
 320                                DIE* Die) {
 321   if (!SP.isDefinition()) return;
 322
 323   TheCU->addAccelName(SP.getName(), Die);
 324
 325   // If the linkage name is different than the name, go ahead and output
 326   // that as well into the name table.
 327   if (SP.getLinkageName() != "" && SP.getName() != SP.getLinkageName())
 328     TheCU->addAccelName(SP.getLinkageName(), Die);
 329
 330   // If this is an Objective-C selector name add it to the ObjC accelerator
 331   // too.
 332   if (isObjCClass(SP.getName())) {
 333     StringRef Class, Category;
 334     getObjCClassCategory(SP.getName(), Class, Category);
 335     TheCU->addAccelObjC(Class, Die);
 336     if (Category != "")
 337       TheCU->addAccelObjC(Category, Die);
 338     // Also add the base method name to the name table.
 339     TheCU->addAccelName(getObjCMethodName(SP.getName()), Die);
 340   }
 341 }
 342
 343 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 344 // and DW_AT_high_pc attributes. If there are global variables in this
 345 // scope then create and insert DIEs for these variables.
 346 DIE *DwarfDebug::updateSubprogramScopeDIE(CompileUnit *SPCU,
 347                                           const MDNode *SPNode) {
 348   DIE *SPDie = SPCU->getDIE(SPNode);
 349
 350   assert(SPDie && "Unable to find subprogram DIE!");
 351   DISubprogram SP(SPNode);
 352
 353   // If we're updating an abstract DIE, then we will be adding the children and
 354   // object pointer later on. But what we don't want to do is process the
 355   // concrete DIE twice.
 356   DIE *AbsSPDIE = AbstractSPDies.lookup(SPNode);
 357   if (AbsSPDIE) {
 358     bool InSameCU = (AbsSPDIE->getCompileUnit() == SPCU->getCUDie());
 359     // Pick up abstract subprogram DIE.
 360     SPDie = new DIE(dwarf::DW_TAG_subprogram);
 361     // If AbsSPDIE belongs to a different CU, use DW_FORM_ref_addr instead of
 362     // DW_FORM_ref4.
 363     SPCU->addDIEEntry(SPDie, dwarf::DW_AT_abstract_origin,
 364                       InSameCU ? dwarf::DW_FORM_ref4 : dwarf::DW_FORM_ref_addr,
 365                       AbsSPDIE);
 366     SPCU->addDie(SPDie);
 367   } else {
 368     DISubprogram SPDecl = SP.getFunctionDeclaration();
 369     if (!SPDecl.isSubprogram()) {
 370       // There is not any need to generate specification DIE for a function
 371       // defined at compile unit level. If a function is defined inside another
 372       // function then gdb prefers the definition at top level and but does not
 373       // expect specification DIE in parent function. So avoid creating
 374       // specification DIE for a function defined inside a function.
 375       if (SP.isDefinition() && !SP.getContext().isCompileUnit() &&
 376           !SP.getContext().isFile() &&
 377           !isSubprogramContext(SP.getContext())) {
 378         SPCU->addFlag(SPDie, dwarf::DW_AT_declaration);
 379
 380         // Add arguments.
 381         DICompositeType SPTy = SP.getType();
 382         DIArray Args = SPTy.getTypeArray();
 383         unsigned SPTag = SPTy.getTag();
 384         if (SPTag == dwarf::DW_TAG_subroutine_type)
 385           for (unsigned i = 1, N = Args.getNumElements(); i < N; ++i) {
 386             DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 387             DIType ATy = DIType(Args.getElement(i));
 388             SPCU->addType(Arg, ATy);
 389             if (ATy.isArtificial())
 390               SPCU->addFlag(Arg, dwarf::DW_AT_artificial);
 391             if (ATy.isObjectPointer())
 392               SPCU->addDIEEntry(SPDie, dwarf::DW_AT_object_pointer,
 393                                 dwarf::DW_FORM_ref4, Arg);
 394             SPDie->addChild(Arg);
 395           }
 396         DIE *SPDeclDie = SPDie;
 397         SPDie = new DIE(dwarf::DW_TAG_subprogram);
 398         SPCU->addDIEEntry(SPDie, dwarf::DW_AT_specification,
 399                           dwarf::DW_FORM_ref4, SPDeclDie);
 400         SPCU->addDie(SPDie);
 401       }
 402     }
 403   }
 404
 405   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_low_pc,
 406                         Asm->GetTempSymbol("func_begin",
 407                                            Asm->getFunctionNumber()));
 408   SPCU->addLabelAddress(SPDie, dwarf::DW_AT_high_pc,
 409                         Asm->GetTempSymbol("func_end",
 410                                            Asm->getFunctionNumber()));
 411   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 412   MachineLocation Location(RI->getFrameRegister(*Asm->MF));
 413   SPCU->addAddress(SPDie, dwarf::DW_AT_frame_base, Location);
 414
 415   // Add name to the name table, we do this here because we're guaranteed
 416   // to have concrete versions of our DW_TAG_subprogram nodes.
 417   addSubprogramNames(SPCU, SP, SPDie);
 418
 419   return SPDie;
 420 }
 421
 422 // Construct new DW_TAG_lexical_block for this scope and attach
 423 // DW_AT_low_pc/DW_AT_high_pc labels.
 424 DIE *DwarfDebug::constructLexicalScopeDIE(CompileUnit *TheCU,
 425                                           LexicalScope *Scope) {
 426   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_lexical_block);
 427   if (Scope->isAbstractScope())
 428     return ScopeDIE;
 429
 430   const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
 431   if (Ranges.empty())
 432     return 0;
 433
 434   SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
 435   if (Ranges.size() > 1) {
 436     // .debug_range section has not been laid out yet. Emit offset in
 437     // .debug_range as a uint, size 4, for now. emitDIE will handle
 438     // DW_AT_ranges appropriately.
 439     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 440                    DebugRangeSymbols.size()
 441                    * Asm->getDataLayout().getPointerSize());
 442     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
 443          RE = Ranges.end(); RI != RE; ++RI) {
 444       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 445       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 446     }
 447     DebugRangeSymbols.push_back(NULL);
 448     DebugRangeSymbols.push_back(NULL);
 449     return ScopeDIE;
 450   }
 451
 452   MCSymbol *Start = getLabelBeforeInsn(RI->first);
 453   MCSymbol *End = getLabelAfterInsn(RI->second);
 454
 455   if (End == 0) return 0;
 456
 457   assert(Start->isDefined() && "Invalid starting label for an inlined scope!");
 458   assert(End->isDefined() && "Invalid end label for an inlined scope!");
 459
 460   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, Start);
 461   TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, End);
 462
 463   return ScopeDIE;
 464 }
 465
 466 // This scope represents inlined body of a function. Construct DIE to
 467 // represent this concrete inlined copy of the function.
 468 DIE *DwarfDebug::constructInlinedScopeDIE(CompileUnit *TheCU,
 469                                           LexicalScope *Scope) {
 470   const SmallVector<InsnRange, 4> &Ranges = Scope->getRanges();
 471   assert(Ranges.empty() == false &&
 472          "LexicalScope does not have instruction markers!");
 473
 474   if (!Scope->getScopeNode())
 475     return NULL;
 476   DIScope DS(Scope->getScopeNode());
 477   DISubprogram InlinedSP = getDISubprogram(DS);
 478   DIE *OriginDIE = TheCU->getDIE(InlinedSP);
 479   if (!OriginDIE) {
 480     DEBUG(dbgs() << "Unable to find original DIE for an inlined subprogram.");
 481     return NULL;
 482   }
 483
 484   SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin();
 485   MCSymbol *StartLabel = getLabelBeforeInsn(RI->first);
 486   MCSymbol *EndLabel = getLabelAfterInsn(RI->second);
 487
 488   if (StartLabel == 0 || EndLabel == 0) {
 489     llvm_unreachable("Unexpected Start and End labels for an inlined scope!");
 490   }
 491   assert(StartLabel->isDefined() &&
 492          "Invalid starting label for an inlined scope!");
 493   assert(EndLabel->isDefined() &&
 494          "Invalid end label for an inlined scope!");
 495
 496   DIE *ScopeDIE = new DIE(dwarf::DW_TAG_inlined_subroutine);
 497   TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_abstract_origin,
 498                      dwarf::DW_FORM_ref4, OriginDIE);
 499
 500   if (Ranges.size() > 1) {
 501     // .debug_range section has not been laid out yet. Emit offset in
 502     // .debug_range as a uint, size 4, for now. emitDIE will handle
 503     // DW_AT_ranges appropriately.
 504     TheCU->addUInt(ScopeDIE, dwarf::DW_AT_ranges, dwarf::DW_FORM_data4,
 505                    DebugRangeSymbols.size()
 506                    * Asm->getDataLayout().getPointerSize());
 507     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
 508          RE = Ranges.end(); RI != RE; ++RI) {
 509       DebugRangeSymbols.push_back(getLabelBeforeInsn(RI->first));
 510       DebugRangeSymbols.push_back(getLabelAfterInsn(RI->second));
 511     }
 512     DebugRangeSymbols.push_back(NULL);
 513     DebugRangeSymbols.push_back(NULL);
 514   } else {
 515     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_low_pc, StartLabel);
 516     TheCU->addLabelAddress(ScopeDIE, dwarf::DW_AT_high_pc, EndLabel);
 517   }
 518
 519   InlinedSubprogramDIEs.insert(OriginDIE);
 520
 521   // Track the start label for this inlined function.
 522   //.debug_inlined section specification does not clearly state how
 523   // to emit inlined scope that is split into multiple instruction ranges.
 524   // For now, use first instruction range and emit low_pc/high_pc pair and
 525   // corresponding .debug_inlined section entry for this pair.
 526   DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator
 527     I = InlineInfo.find(InlinedSP);
 528
 529   if (I == InlineInfo.end()) {
 530     InlineInfo[InlinedSP].push_back(std::make_pair(StartLabel, ScopeDIE));
 531     InlinedSPNodes.push_back(InlinedSP);
 532   } else
 533     I->second.push_back(std::make_pair(StartLabel, ScopeDIE));
 534
 535   DILocation DL(Scope->getInlinedAt());
 536   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_file, 0,
 537                  getOrCreateSourceID(DL.getFilename(), DL.getDirectory(),
 538                                      TheCU->getUniqueID()));
 539   TheCU->addUInt(ScopeDIE, dwarf::DW_AT_call_line, 0, DL.getLineNumber());
 540
 541   // Add name to the name table, we do this here because we're guaranteed
 542   // to have concrete versions of our DW_TAG_inlined_subprogram nodes.
 543   addSubprogramNames(TheCU, InlinedSP, ScopeDIE);
 544
 545   return ScopeDIE;
 546 }
 547
 548 // Construct a DIE for this scope.
 549 DIE *DwarfDebug::constructScopeDIE(CompileUnit *TheCU, LexicalScope *Scope) {
 550   if (!Scope || !Scope->getScopeNode())
 551     return NULL;
 552
 553   DIScope DS(Scope->getScopeNode());
 554   // Early return to avoid creating dangling variable|scope DIEs.
 555   if (!Scope->getInlinedAt() && DS.isSubprogram() && Scope->isAbstractScope() &&
 556       !TheCU->getDIE(DS))
 557     return NULL;
 558
 559   SmallVector<DIE *, 8> Children;
 560   DIE *ObjectPointer = NULL;
 561
 562   // Collect arguments for current function.
 563   if (LScopes.isCurrentFunctionScope(Scope))
 564     for (unsigned i = 0, N = CurrentFnArguments.size(); i < N; ++i)
 565       if (DbgVariable *ArgDV = CurrentFnArguments[i])
 566         if (DIE *Arg =
 567             TheCU->constructVariableDIE(ArgDV, Scope->isAbstractScope())) {
 568           Children.push_back(Arg);
 569           if (ArgDV->isObjectPointer()) ObjectPointer = Arg;
 570         }
 571
 572   // Collect lexical scope children first.
 573   const SmallVector<DbgVariable *, 8> &Variables = ScopeVariables.lookup(Scope);
 574   for (unsigned i = 0, N = Variables.size(); i < N; ++i)
 575     if (DIE *Variable =
 576         TheCU->constructVariableDIE(Variables[i], Scope->isAbstractScope())) {
 577       Children.push_back(Variable);
 578       if (Variables[i]->isObjectPointer()) ObjectPointer = Variable;
 579     }
 580   const SmallVector<LexicalScope *, 4> &Scopes = Scope->getChildren();
 581   for (unsigned j = 0, M = Scopes.size(); j < M; ++j)
 582     if (DIE *Nested = constructScopeDIE(TheCU, Scopes[j]))
 583       Children.push_back(Nested);
 584   DIE *ScopeDIE = NULL;
 585   if (Scope->getInlinedAt())
 586     ScopeDIE = constructInlinedScopeDIE(TheCU, Scope);
 587   else if (DS.isSubprogram()) {
 588     ProcessedSPNodes.insert(DS);
 589     if (Scope->isAbstractScope()) {
 590       ScopeDIE = TheCU->getDIE(DS);
 591       // Note down abstract DIE.
 592       if (ScopeDIE)
 593         AbstractSPDies.insert(std::make_pair(DS, ScopeDIE));
 594     }
 595     else
 596       ScopeDIE = updateSubprogramScopeDIE(TheCU, DS);
 597   }
 598   else {
 599     // There is no need to emit empty lexical block DIE.
 600     if (Children.empty())
 601       return NULL;
 602     ScopeDIE = constructLexicalScopeDIE(TheCU, Scope);
 603   }
 604
 605   if (!ScopeDIE) return NULL;
 606
 607   // Add children
 608   for (SmallVector<DIE *, 8>::iterator I = Children.begin(),
 609          E = Children.end(); I != E; ++I)
 610     ScopeDIE->addChild(*I);
 611
 612   if (DS.isSubprogram() && ObjectPointer != NULL)
 613     TheCU->addDIEEntry(ScopeDIE, dwarf::DW_AT_object_pointer,
 614                        dwarf::DW_FORM_ref4, ObjectPointer);
 615
 616   if (DS.isSubprogram())
 617     TheCU->addPubTypes(DISubprogram(DS));
 618
 619   return ScopeDIE;
 620 }
 621
 622 // Look up the source id with the given directory and source file names.
 623 // If none currently exists, create a new id and insert it in the
 624 // SourceIds map. This can update DirectoryNames and SourceFileNames maps
 625 // as well.
 626 unsigned DwarfDebug::getOrCreateSourceID(StringRef FileName,
 627                                          StringRef DirName, unsigned CUID) {
 628   // If we use .loc in assembly, we can't separate .file entries according to
 629   // compile units. Thus all files will belong to the default compile unit.
 630   if (Asm->TM.hasMCUseLoc() &&
 631       Asm->OutStreamer.getKind() == MCStreamer::SK_AsmStreamer)
 632     CUID = 0;
 633
 634   // If FE did not provide a file name, then assume stdin.
 635   if (FileName.empty())
 636     return getOrCreateSourceID("<stdin>", StringRef(), CUID);
 637
 638   // TODO: this might not belong here. See if we can factor this better.
 639   if (DirName == CompilationDir)
 640     DirName = "";
 641
 642   // FileIDCUMap stores the current ID for the given compile unit.
 643   unsigned SrcId = FileIDCUMap[CUID] + 1;
 644
 645   // We look up the CUID/file/dir by concatenating them with a zero byte.
 646   SmallString<128> NamePair;
 647   NamePair += utostr(CUID);
 648   NamePair += '\0';
 649   NamePair += DirName;
 650   NamePair += '\0'; // Zero bytes are not allowed in paths.
 651   NamePair += FileName;
 652
 653   StringMapEntry<unsigned> &Ent = SourceIdMap.GetOrCreateValue(NamePair, SrcId);
 654   if (Ent.getValue() != SrcId)
 655     return Ent.getValue();
 656
 657   FileIDCUMap[CUID] = SrcId;
 658   // Print out a .file directive to specify files for .loc directives.
 659   Asm->OutStreamer.EmitDwarfFileDirective(SrcId, DirName, FileName, CUID);
 660
 661   return SrcId;
 662 }
 663
 664 // Create new CompileUnit for the given metadata node with tag
 665 // DW_TAG_compile_unit.
 666 CompileUnit *DwarfDebug::constructCompileUnit(const MDNode *N) {
 667   DICompileUnit DIUnit(N);
 668   StringRef FN = DIUnit.getFilename();
 669   CompilationDir = DIUnit.getDirectory();
 670
 671   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
 672   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
 673                                        DIUnit.getLanguage(), Die, Asm,
 674                                        this, &InfoHolder);
 675
 676   FileIDCUMap[NewCU->getUniqueID()] = 0;
 677   // Call this to emit a .file directive if it wasn't emitted for the source
 678   // file this CU comes from yet.
 679   getOrCreateSourceID(FN, CompilationDir, NewCU->getUniqueID());
 680
 681   NewCU->addString(Die, dwarf::DW_AT_producer, DIUnit.getProducer());
 682   NewCU->addUInt(Die, dwarf::DW_AT_language, dwarf::DW_FORM_data2,
 683                  DIUnit.getLanguage());
 684   NewCU->addString(Die, dwarf::DW_AT_name, FN);
 685   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
 686   // into an entity. We're using 0 (or a NULL label) for this.
 687   NewCU->addLabelAddress(Die, dwarf::DW_AT_low_pc, NULL);
 688
 689   // Define start line table label for each Compile Unit.
 690   MCSymbol *LineTableStartSym = Asm->GetTempSymbol("line_table_start",
 691                                                    NewCU->getUniqueID());
 692   Asm->OutStreamer.getContext().setMCLineTableSymbol(LineTableStartSym,
 693                                                      NewCU->getUniqueID());
 694
 695   // DW_AT_stmt_list is a offset of line number information for this
 696   // compile unit in debug_line section.
 697   // The line table entries are not always emitted in assembly, so it
 698   // is not okay to use line_table_start here.
 699   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
 700     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
 701                     NewCU->getUniqueID() == 0 ?
 702                     Asm->GetTempSymbol("section_line") : LineTableStartSym);
 703   else if (NewCU->getUniqueID() == 0)
 704     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4, 0);
 705   else
 706     NewCU->addDelta(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_data4,
 707                     LineTableStartSym, DwarfLineSectionSym);
 708
 709   if (!CompilationDir.empty())
 710     NewCU->addString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
 711   if (DIUnit.isOptimized())
 712     NewCU->addFlag(Die, dwarf::DW_AT_APPLE_optimized);
 713
 714   StringRef Flags = DIUnit.getFlags();
 715   if (!Flags.empty())
 716     NewCU->addString(Die, dwarf::DW_AT_APPLE_flags, Flags);
 717
 718   if (unsigned RVer = DIUnit.getRunTimeVersion())
 719     NewCU->addUInt(Die, dwarf::DW_AT_APPLE_major_runtime_vers,
 720             dwarf::DW_FORM_data1, RVer);
 721
 722   if (!FirstCU)
 723     FirstCU = NewCU;
 724
 725   InfoHolder.addUnit(NewCU);
 726
 727   CUMap.insert(std::make_pair(N, NewCU));
 728   return NewCU;
 729 }
 730
 731 // Construct subprogram DIE.
 732 void DwarfDebug::constructSubprogramDIE(CompileUnit *TheCU,
 733                                         const MDNode *N) {
 734   CompileUnit *&CURef = SPMap[N];
 735   if (CURef)
 736     return;
 737   CURef = TheCU;
 738
 739   DISubprogram SP(N);
 740   if (!SP.isDefinition())
 741     // This is a method declaration which will be handled while constructing
 742     // class type.
 743     return;
 744
 745   DIE *SubprogramDie = TheCU->getOrCreateSubprogramDIE(SP);
 746
 747   // Add to map.
 748   TheCU->insertDIE(N, SubprogramDie);
 749
 750   // Add to context owner.
 751   TheCU->addToContextOwner(SubprogramDie, SP.getContext());
 752
 753   // Expose as global, if requested.
 754   if (GenerateDwarfPubNamesSection)
 755     TheCU->addGlobalName(SP.getName(), SubprogramDie);
 756 }
 757
 758 // Emit all Dwarf sections that should come prior to the content. Create
 759 // global DIEs and emit initial debug info sections. This is invoked by
 760 // the target AsmPrinter.
 761 void DwarfDebug::beginModule() {
 762   if (DisableDebugInfoPrinting)
 763     return;
 764
 765   const Module *M = MMI->getModule();
 766
 767   // If module has named metadata anchors then use them, otherwise scan the
 768   // module using debug info finder to collect debug info.
 769   NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu");
 770   if (!CU_Nodes)
 771     return;
 772
 773   // Emit initial sections so we can reference labels later.
 774   emitSectionLabels();
 775
 776   for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 777     DICompileUnit CUNode(CU_Nodes->getOperand(i));
 778     CompileUnit *CU = constructCompileUnit(CUNode);
 779     DIArray GVs = CUNode.getGlobalVariables();
 780     for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i)
 781       CU->createGlobalVariableDIE(GVs.getElement(i));
 782     DIArray SPs = CUNode.getSubprograms();
 783     for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
 784       constructSubprogramDIE(CU, SPs.getElement(i));
 785     DIArray EnumTypes = CUNode.getEnumTypes();
 786     for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
 787       CU->getOrCreateTypeDIE(EnumTypes.getElement(i));
 788     DIArray RetainedTypes = CUNode.getRetainedTypes();
 789     for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
 790       CU->getOrCreateTypeDIE(RetainedTypes.getElement(i));
 791     // If we're splitting the dwarf out now that we've got the entire
 792     // CU then construct a skeleton CU based upon it.
 793     if (useSplitDwarf()) {
 794     // This should be a unique identifier when we want to build .dwp files.
 795       CU->addUInt(CU->getCUDie(), dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
 796       // Now construct the skeleton CU associated.
 797       constructSkeletonCU(CUNode);
 798     }
 799   }
 800
 801   // Tell MMI that we have debug info.
 802   MMI->setDebugInfoAvailability(true);
 803
 804   // Prime section data.
 805   SectionMap.insert(Asm->getObjFileLowering().getTextSection());
 806 }
 807
 808 // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 809 void DwarfDebug::computeInlinedDIEs() {
 810   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 811   for (SmallPtrSet<DIE *, 4>::iterator AI = InlinedSubprogramDIEs.begin(),
 812          AE = InlinedSubprogramDIEs.end(); AI != AE; ++AI) {
 813     DIE *ISP = *AI;
 814     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 815   }
 816   for (DenseMap<const MDNode *, DIE *>::iterator AI = AbstractSPDies.begin(),
 817          AE = AbstractSPDies.end(); AI != AE; ++AI) {
 818     DIE *ISP = AI->second;
 819     if (InlinedSubprogramDIEs.count(ISP))
 820       continue;
 821     FirstCU->addUInt(ISP, dwarf::DW_AT_inline, 0, dwarf::DW_INL_inlined);
 822   }
 823 }
 824
 825 // Collect info for variables that were optimized out.
 826 void DwarfDebug::collectDeadVariables() {
 827   const Module *M = MMI->getModule();
 828   DenseMap<const MDNode *, LexicalScope *> DeadFnScopeMap;
 829
 830   if (NamedMDNode *CU_Nodes = M->getNamedMetadata("llvm.dbg.cu")) {
 831     for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
 832       DICompileUnit TheCU(CU_Nodes->getOperand(i));
 833       DIArray Subprograms = TheCU.getSubprograms();
 834       for (unsigned i = 0, e = Subprograms.getNumElements(); i != e; ++i) {
 835         DISubprogram SP(Subprograms.getElement(i));
 836         if (ProcessedSPNodes.count(SP) != 0) continue;
 837         if (!SP.Verify()) continue;
 838         if (!SP.isDefinition()) continue;
 839         DIArray Variables = SP.getVariables();
 840         if (Variables.getNumElements() == 0) continue;
 841
 842         LexicalScope *Scope =
 843           new LexicalScope(NULL, DIDescriptor(SP), NULL, false);
 844         DeadFnScopeMap[SP] = Scope;
 845
 846         // Construct subprogram DIE and add variables DIEs.
 847         CompileUnit *SPCU = CUMap.lookup(TheCU);
 848         assert(SPCU && "Unable to find Compile Unit!");
 849         constructSubprogramDIE(SPCU, SP);
 850         DIE *ScopeDIE = SPCU->getDIE(SP);
 851         for (unsigned vi = 0, ve = Variables.getNumElements(); vi != ve; ++vi) {
 852           DIVariable DV(Variables.getElement(vi));
 853           if (!DV.Verify()) continue;
 854           DbgVariable *NewVar = new DbgVariable(DV, NULL);
 855           if (DIE *VariableDIE =
 856               SPCU->constructVariableDIE(NewVar, Scope->isAbstractScope()))
 857             ScopeDIE->addChild(VariableDIE);
 858         }
 859       }
 860     }
 861   }
 862   DeleteContainerSeconds(DeadFnScopeMap);
 863 }
 864
 865 void DwarfDebug::finalizeModuleInfo() {
 866   // Collect info for variables that were optimized out.
 867   collectDeadVariables();
 868
 869   // Attach DW_AT_inline attribute with inlined subprogram DIEs.
 870   computeInlinedDIEs();
 871
 872   // Emit DW_AT_containing_type attribute to connect types with their
 873   // vtable holding type.
 874   for (DenseMap<const MDNode *, CompileUnit *>::iterator CUI = CUMap.begin(),
 875          CUE = CUMap.end(); CUI != CUE; ++CUI) {
 876     CompileUnit *TheCU = CUI->second;
 877     TheCU->constructContainingTypeDIEs();
 878   }
 879
 880    // Compute DIE offsets and sizes.
 881   InfoHolder.computeSizeAndOffsets();
 882   if (useSplitDwarf())
 883     SkeletonHolder.computeSizeAndOffsets();
 884 }
 885
 886 void DwarfDebug::endSections() {
 887   // Standard sections final addresses.
 888   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getTextSection());
 889   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("text_end"));
 890   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering().getDataSection());
 891   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("data_end"));
 892
 893   // End text sections.
 894   for (unsigned I = 0, E = SectionMap.size(); I != E; ++I) {
 895     Asm->OutStreamer.SwitchSection(SectionMap[I]);
 896     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("section_end", I+1));
 897   }
 898 }
 899
 900 // Emit all Dwarf sections that should come after the content.
 901 void DwarfDebug::endModule() {
 902
 903   if (!FirstCU) return;
 904
 905   // End any existing sections.
 906   // TODO: Does this need to happen?
 907   endSections();
 908
 909   // Finalize the debug info for the module.
 910   finalizeModuleInfo();
 911
 912   if (!useSplitDwarf()) {
 913     // Emit all the DIEs into a debug info section.
 914     emitDebugInfo();
 915
 916     // Corresponding abbreviations into a abbrev section.
 917     emitAbbreviations();
 918
 919     // Emit info into a debug loc section.
 920     emitDebugLoc();
 921
 922     // Emit info into a debug aranges section.
 923     emitDebugARanges();
 924
 925     // Emit info into a debug ranges section.
 926     emitDebugRanges();
 927
 928     // Emit info into a debug macinfo section.
 929     emitDebugMacInfo();
 930
 931     // Emit inline info.
 932     // TODO: When we don't need the option anymore we
 933     // can remove all of the code that this section
 934     // depends upon.
 935     if (useDarwinGDBCompat())
 936       emitDebugInlineInfo();
 937   } else {
 938     // TODO: Fill this in for separated debug sections and separate
 939     // out information into new sections.
 940
 941     // Emit the debug info section and compile units.
 942     emitDebugInfo();
 943     emitDebugInfoDWO();
 944
 945     // Corresponding abbreviations into a abbrev section.
 946     emitAbbreviations();
 947     emitDebugAbbrevDWO();
 948
 949     // Emit info into a debug loc section.
 950     emitDebugLoc();
 951
 952     // Emit info into a debug aranges section.
 953     emitDebugARanges();
 954
 955     // Emit info into a debug ranges section.
 956     emitDebugRanges();
 957
 958     // Emit info into a debug macinfo section.
 959     emitDebugMacInfo();
 960
 961     // Emit DWO addresses.
 962     InfoHolder.emitAddresses(Asm->getObjFileLowering().getDwarfAddrSection());
 963
 964     // Emit inline info.
 965     // TODO: When we don't need the option anymore we
 966     // can remove all of the code that this section
 967     // depends upon.
 968     if (useDarwinGDBCompat())
 969       emitDebugInlineInfo();
 970   }
 971
 972   // Emit info into the dwarf accelerator table sections.
 973   if (useDwarfAccelTables()) {
 974     emitAccelNames();
 975     emitAccelObjC();
 976     emitAccelNamespaces();
 977     emitAccelTypes();
 978   }
 979
 980   // Emit info into a debug pubnames section, if requested.
 981   if (GenerateDwarfPubNamesSection)
 982     emitDebugPubnames();
 983
 984   // Emit info into a debug pubtypes section.
 985   // TODO: When we don't need the option anymore we can
 986   // remove all of the code that adds to the table.
 987   if (useDarwinGDBCompat())
 988     emitDebugPubTypes();
 989
 990   // Finally emit string information into a string table.
 991   emitDebugStr();
 992   if (useSplitDwarf())
 993     emitDebugStrDWO();
 994
 995   // clean up.
 996   SPMap.clear();
 997   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
 998          E = CUMap.end(); I != E; ++I)
 999     delete I->second;
1000
1001   for (SmallVector<CompileUnit *, 1>::iterator I = SkeletonCUs.begin(),
1002          E = SkeletonCUs.end(); I != E; ++I)
1003     delete *I;
1004
1005   // Reset these for the next Module if we have one.
1006   FirstCU = NULL;
1007 }
1008
1009 // Find abstract variable, if any, associated with Var.
1010 DbgVariable *DwarfDebug::findAbstractVariable(DIVariable &DV,
1011                                               DebugLoc ScopeLoc) {
1012   LLVMContext &Ctx = DV->getContext();
1013   // More then one inlined variable corresponds to one abstract variable.
1014   DIVariable Var = cleanseInlinedVariable(DV, Ctx);
1015   DbgVariable *AbsDbgVariable = AbstractVariables.lookup(Var);
1016   if (AbsDbgVariable)
1017     return AbsDbgVariable;
1018
1019   LexicalScope *Scope = LScopes.findAbstractScope(ScopeLoc.getScope(Ctx));
1020   if (!Scope)
1021     return NULL;
1022
1023   AbsDbgVariable = new DbgVariable(Var, NULL);
1024   addScopeVariable(Scope, AbsDbgVariable);
1025   AbstractVariables[Var] = AbsDbgVariable;
1026   return AbsDbgVariable;
1027 }
1028
1029 // If Var is a current function argument then add it to CurrentFnArguments list.
1030 bool DwarfDebug::addCurrentFnArgument(const MachineFunction *MF,
1031                                       DbgVariable *Var, LexicalScope *Scope) {
1032   if (!LScopes.isCurrentFunctionScope(Scope))
1033     return false;
1034   DIVariable DV = Var->getVariable();
1035   if (DV.getTag() != dwarf::DW_TAG_arg_variable)
1036     return false;
1037   unsigned ArgNo = DV.getArgNumber();
1038   if (ArgNo == 0)
1039     return false;
1040
1041   size_t Size = CurrentFnArguments.size();
1042   if (Size == 0)
1043     CurrentFnArguments.resize(MF->getFunction()->arg_size());
1044   // llvm::Function argument size is not good indicator of how many
1045   // arguments does the function have at source level.
1046   if (ArgNo > Size)
1047     CurrentFnArguments.resize(ArgNo * 2);
1048   CurrentFnArguments[ArgNo - 1] = Var;
1049   return true;
1050 }
1051
1052 // Collect variable information from side table maintained by MMI.
1053 void
1054 DwarfDebug::collectVariableInfoFromMMITable(const MachineFunction *MF,
1055                                    SmallPtrSet<const MDNode *, 16> &Processed) {
1056   MachineModuleInfo::VariableDbgInfoMapTy &VMap = MMI->getVariableDbgInfo();
1057   for (MachineModuleInfo::VariableDbgInfoMapTy::iterator VI = VMap.begin(),
1058          VE = VMap.end(); VI != VE; ++VI) {
1059     const MDNode *Var = VI->first;
1060     if (!Var) continue;
1061     Processed.insert(Var);
1062     DIVariable DV(Var);
1063     const std::pair<unsigned, DebugLoc> &VP = VI->second;
1064
1065     LexicalScope *Scope = LScopes.findLexicalScope(VP.second);
1066
1067     // If variable scope is not found then skip this variable.
1068     if (Scope == 0)
1069       continue;
1070
1071     DbgVariable *AbsDbgVariable = findAbstractVariable(DV, VP.second);
1072     DbgVariable *RegVar = new DbgVariable(DV, AbsDbgVariable);
1073     RegVar->setFrameIndex(VP.first);
1074     if (!addCurrentFnArgument(MF, RegVar, Scope))
1075       addScopeVariable(Scope, RegVar);
1076     if (AbsDbgVariable)
1077       AbsDbgVariable->setFrameIndex(VP.first);
1078   }
1079 }
1080
1081 // Return true if debug value, encoded by DBG_VALUE instruction, is in a
1082 // defined reg.
1083 static bool isDbgValueInDefinedReg(const MachineInstr *MI) {
1084   assert(MI->isDebugValue() && "Invalid DBG_VALUE machine instruction!");
1085   return MI->getNumOperands() == 3 &&
1086          MI->getOperand(0).isReg() && MI->getOperand(0).getReg() &&
1087          MI->getOperand(1).isImm() && MI->getOperand(1).getImm() == 0;
1088 }
1089
1090 // Get .debug_loc entry for the instruction range starting at MI.
1091 static DotDebugLocEntry getDebugLocEntry(AsmPrinter *Asm,
1092                                          const MCSymbol *FLabel,
1093                                          const MCSymbol *SLabel,
1094                                          const MachineInstr *MI) {
1095   const MDNode *Var =  MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1096
1097   if (MI->getNumOperands() != 3) {
1098     MachineLocation MLoc = Asm->getDebugValueLocation(MI);
1099     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1100   }
1101   if (MI->getOperand(0).isReg() && MI->getOperand(1).isImm()) {
1102     MachineLocation MLoc;
1103     MLoc.set(MI->getOperand(0).getReg(), MI->getOperand(1).getImm());
1104     return DotDebugLocEntry(FLabel, SLabel, MLoc, Var);
1105   }
1106   if (MI->getOperand(0).isImm())
1107     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getImm());
1108   if (MI->getOperand(0).isFPImm())
1109     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getFPImm());
1110   if (MI->getOperand(0).isCImm())
1111     return DotDebugLocEntry(FLabel, SLabel, MI->getOperand(0).getCImm());
1112
1113   llvm_unreachable("Unexpected 3 operand DBG_VALUE instruction!");
1114 }
1115
1116 // Find variables for each lexical scope.
1117 void
1118 DwarfDebug::collectVariableInfo(const MachineFunction *MF,
1119                                 SmallPtrSet<const MDNode *, 16> &Processed) {
1120
1121   // collection info from MMI table.
1122   collectVariableInfoFromMMITable(MF, Processed);
1123
1124   for (SmallVectorImpl<const MDNode*>::const_iterator
1125          UVI = UserVariables.begin(), UVE = UserVariables.end(); UVI != UVE;
1126          ++UVI) {
1127     const MDNode *Var = *UVI;
1128     if (Processed.count(Var))
1129       continue;
1130
1131     // History contains relevant DBG_VALUE instructions for Var and instructions
1132     // clobbering it.
1133     SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1134     if (History.empty())
1135       continue;
1136     const MachineInstr *MInsn = History.front();
1137
1138     DIVariable DV(Var);
1139     LexicalScope *Scope = NULL;
1140     if (DV.getTag() == dwarf::DW_TAG_arg_variable &&
1141         DISubprogram(DV.getContext()).describes(MF->getFunction()))
1142       Scope = LScopes.getCurrentFunctionScope();
1143     else if (MDNode *IA = DV.getInlinedAt())
1144       Scope = LScopes.findInlinedScope(DebugLoc::getFromDILocation(IA));
1145     else
1146       Scope = LScopes.findLexicalScope(cast<MDNode>(DV->getOperand(1)));
1147     // If variable scope is not found then skip this variable.
1148     if (!Scope)
1149       continue;
1150
1151     Processed.insert(DV);
1152     assert(MInsn->isDebugValue() && "History must begin with debug value");
1153     DbgVariable *AbsVar = findAbstractVariable(DV, MInsn->getDebugLoc());
1154     DbgVariable *RegVar = new DbgVariable(DV, AbsVar);
1155     if (!addCurrentFnArgument(MF, RegVar, Scope))
1156       addScopeVariable(Scope, RegVar);
1157     if (AbsVar)
1158       AbsVar->setMInsn(MInsn);
1159
1160     // Simplify ranges that are fully coalesced.
1161     if (History.size() <= 1 || (History.size() == 2 &&
1162                                 MInsn->isIdenticalTo(History.back()))) {
1163       RegVar->setMInsn(MInsn);
1164       continue;
1165     }
1166
1167     // Handle multiple DBG_VALUE instructions describing one variable.
1168     RegVar->setDotDebugLocOffset(DotDebugLocEntries.size());
1169
1170     for (SmallVectorImpl<const MachineInstr*>::const_iterator
1171            HI = History.begin(), HE = History.end(); HI != HE; ++HI) {
1172       const MachineInstr *Begin = *HI;
1173       assert(Begin->isDebugValue() && "Invalid History entry");
1174
1175       // Check if DBG_VALUE is truncating a range.
1176       if (Begin->getNumOperands() > 1 && Begin->getOperand(0).isReg()
1177           && !Begin->getOperand(0).getReg())
1178         continue;
1179
1180       // Compute the range for a register location.
1181       const MCSymbol *FLabel = getLabelBeforeInsn(Begin);
1182       const MCSymbol *SLabel = 0;
1183
1184       if (HI + 1 == HE)
1185         // If Begin is the last instruction in History then its value is valid
1186         // until the end of the function.
1187         SLabel = FunctionEndSym;
1188       else {
1189         const MachineInstr *End = HI[1];
1190         DEBUG(dbgs() << "DotDebugLoc Pair:\n"
1191               << "\t" << *Begin << "\t" << *End << "\n");
1192         if (End->isDebugValue())
1193           SLabel = getLabelBeforeInsn(End);
1194         else {
1195           // End is a normal instruction clobbering the range.
1196           SLabel = getLabelAfterInsn(End);
1197           assert(SLabel && "Forgot label after clobber instruction");
1198           ++HI;
1199         }
1200       }
1201
1202       // The value is valid until the next DBG_VALUE or clobber.
1203       DotDebugLocEntries.push_back(getDebugLocEntry(Asm, FLabel, SLabel,
1204                                                     Begin));
1205     }
1206     DotDebugLocEntries.push_back(DotDebugLocEntry());
1207   }
1208
1209   // Collect info for variables that were optimized out.
1210   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1211   DIArray Variables = DISubprogram(FnScope->getScopeNode()).getVariables();
1212   for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1213     DIVariable DV(Variables.getElement(i));
1214     if (!DV || !DV.Verify() || !Processed.insert(DV))
1215       continue;
1216     if (LexicalScope *Scope = LScopes.findLexicalScope(DV.getContext()))
1217       addScopeVariable(Scope, new DbgVariable(DV, NULL));
1218   }
1219 }
1220
1221 // Return Label preceding the instruction.
1222 MCSymbol *DwarfDebug::getLabelBeforeInsn(const MachineInstr *MI) {
1223   MCSymbol *Label = LabelsBeforeInsn.lookup(MI);
1224   assert(Label && "Didn't insert label before instruction");
1225   return Label;
1226 }
1227
1228 // Return Label immediately following the instruction.
1229 MCSymbol *DwarfDebug::getLabelAfterInsn(const MachineInstr *MI) {
1230   return LabelsAfterInsn.lookup(MI);
1231 }
1232
1233 // Process beginning of an instruction.
1234 void DwarfDebug::beginInstruction(const MachineInstr *MI) {
1235   // Check if source location changes, but ignore DBG_VALUE locations.
1236   if (!MI->isDebugValue()) {
1237     DebugLoc DL = MI->getDebugLoc();
1238     if (DL != PrevInstLoc && (!DL.isUnknown() || UnknownLocations)) {
1239       unsigned Flags = 0;
1240       PrevInstLoc = DL;
1241       if (DL == PrologEndLoc) {
1242         Flags |= DWARF2_FLAG_PROLOGUE_END;
1243         PrologEndLoc = DebugLoc();
1244       }
1245       if (PrologEndLoc.isUnknown())
1246         Flags |= DWARF2_FLAG_IS_STMT;
1247
1248       if (!DL.isUnknown()) {
1249         const MDNode *Scope = DL.getScope(Asm->MF->getFunction()->getContext());
1250         recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
1251       } else
1252         recordSourceLine(0, 0, 0, 0);
1253     }
1254   }
1255
1256   // Insert labels where requested.
1257   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1258     LabelsBeforeInsn.find(MI);
1259
1260   // No label needed.
1261   if (I == LabelsBeforeInsn.end())
1262     return;
1263
1264   // Label already assigned.
1265   if (I->second)
1266     return;
1267
1268   if (!PrevLabel) {
1269     PrevLabel = MMI->getContext().CreateTempSymbol();
1270     Asm->OutStreamer.EmitLabel(PrevLabel);
1271   }
1272   I->second = PrevLabel;
1273 }
1274
1275 // Process end of an instruction.
1276 void DwarfDebug::endInstruction(const MachineInstr *MI) {
1277   // Don't create a new label after DBG_VALUE instructions.
1278   // They don't generate code.
1279   if (!MI->isDebugValue())
1280     PrevLabel = 0;
1281
1282   DenseMap<const MachineInstr*, MCSymbol*>::iterator I =
1283     LabelsAfterInsn.find(MI);
1284
1285   // No label needed.
1286   if (I == LabelsAfterInsn.end())
1287     return;
1288
1289   // Label already assigned.
1290   if (I->second)
1291     return;
1292
1293   // We need a label after this instruction.
1294   if (!PrevLabel) {
1295     PrevLabel = MMI->getContext().CreateTempSymbol();
1296     Asm->OutStreamer.EmitLabel(PrevLabel);
1297   }
1298   I->second = PrevLabel;
1299 }
1300
1301 // Each LexicalScope has first instruction and last instruction to mark
1302 // beginning and end of a scope respectively. Create an inverse map that list
1303 // scopes starts (and ends) with an instruction. One instruction may start (or
1304 // end) multiple scopes. Ignore scopes that are not reachable.
1305 void DwarfDebug::identifyScopeMarkers() {
1306   SmallVector<LexicalScope *, 4> WorkList;
1307   WorkList.push_back(LScopes.getCurrentFunctionScope());
1308   while (!WorkList.empty()) {
1309     LexicalScope *S = WorkList.pop_back_val();
1310
1311     const SmallVector<LexicalScope *, 4> &Children = S->getChildren();
1312     if (!Children.empty())
1313       for (SmallVector<LexicalScope *, 4>::const_iterator SI = Children.begin(),
1314              SE = Children.end(); SI != SE; ++SI)
1315         WorkList.push_back(*SI);
1316
1317     if (S->isAbstractScope())
1318       continue;
1319
1320     const SmallVector<InsnRange, 4> &Ranges = S->getRanges();
1321     if (Ranges.empty())
1322       continue;
1323     for (SmallVector<InsnRange, 4>::const_iterator RI = Ranges.begin(),
1324            RE = Ranges.end(); RI != RE; ++RI) {
1325       assert(RI->first && "InsnRange does not have first instruction!");
1326       assert(RI->second && "InsnRange does not have second instruction!");
1327       requestLabelBeforeInsn(RI->first);
1328       requestLabelAfterInsn(RI->second);
1329     }
1330   }
1331 }
1332
1333 // Get MDNode for DebugLoc's scope.
1334 static MDNode *getScopeNode(DebugLoc DL, const LLVMContext &Ctx) {
1335   if (MDNode *InlinedAt = DL.getInlinedAt(Ctx))
1336     return getScopeNode(DebugLoc::getFromDILocation(InlinedAt), Ctx);
1337   return DL.getScope(Ctx);
1338 }
1339
1340 // Walk up the scope chain of given debug loc and find line number info
1341 // for the function.
1342 static DebugLoc getFnDebugLoc(DebugLoc DL, const LLVMContext &Ctx) {
1343   const MDNode *Scope = getScopeNode(DL, Ctx);
1344   DISubprogram SP = getDISubprogram(Scope);
1345   if (SP.Verify()) {
1346     // Check for number of operands since the compatibility is
1347     // cheap here.
1348     if (SP->getNumOperands() > 19)
1349       return DebugLoc::get(SP.getScopeLineNumber(), 0, SP);
1350     else
1351       return DebugLoc::get(SP.getLineNumber(), 0, SP);
1352   }
1353
1354   return DebugLoc();
1355 }
1356
1357 // Gather pre-function debug information.  Assumes being called immediately
1358 // after the function entry point has been emitted.
1359 void DwarfDebug::beginFunction(const MachineFunction *MF) {
1360   if (!MMI->hasDebugInfo()) return;
1361   LScopes.initialize(*MF);
1362   if (LScopes.empty()) return;
1363   identifyScopeMarkers();
1364
1365   // Set DwarfCompileUnitID in MCContext to the Compile Unit this function
1366   // belongs to.
1367   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1368   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1369   assert(TheCU && "Unable to find compile unit!");
1370   Asm->OutStreamer.getContext().setDwarfCompileUnitID(TheCU->getUniqueID());
1371
1372   FunctionBeginSym = Asm->GetTempSymbol("func_begin",
1373                                         Asm->getFunctionNumber());
1374   // Assumes in correct section after the entry point.
1375   Asm->OutStreamer.EmitLabel(FunctionBeginSym);
1376
1377   assert(UserVariables.empty() && DbgValues.empty() && "Maps weren't cleaned");
1378
1379   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1380   // LiveUserVar - Map physreg numbers to the MDNode they contain.
1381   std::vector<const MDNode*> LiveUserVar(TRI->getNumRegs());
1382
1383   for (MachineFunction::const_iterator I = MF->begin(), E = MF->end();
1384        I != E; ++I) {
1385     bool AtBlockEntry = true;
1386     for (MachineBasicBlock::const_iterator II = I->begin(), IE = I->end();
1387          II != IE; ++II) {
1388       const MachineInstr *MI = II;
1389
1390       if (MI->isDebugValue()) {
1391         assert(MI->getNumOperands() > 1 && "Invalid machine instruction!");
1392
1393         // Keep track of user variables.
1394         const MDNode *Var =
1395           MI->getOperand(MI->getNumOperands() - 1).getMetadata();
1396
1397         // Variable is in a register, we need to check for clobbers.
1398         if (isDbgValueInDefinedReg(MI))
1399           LiveUserVar[MI->getOperand(0).getReg()] = Var;
1400
1401         // Check the history of this variable.
1402         SmallVectorImpl<const MachineInstr*> &History = DbgValues[Var];
1403         if (History.empty()) {
1404           UserVariables.push_back(Var);
1405           // The first mention of a function argument gets the FunctionBeginSym
1406           // label, so arguments are visible when breaking at function entry.
1407           DIVariable DV(Var);
1408           if (DV.Verify() && DV.getTag() == dwarf::DW_TAG_arg_variable &&
1409               DISubprogram(getDISubprogram(DV.getContext()))
1410                 .describes(MF->getFunction()))
1411             LabelsBeforeInsn[MI] = FunctionBeginSym;
1412         } else {
1413           // We have seen this variable before. Try to coalesce DBG_VALUEs.
1414           const MachineInstr *Prev = History.back();
1415           if (Prev->isDebugValue()) {
1416             // Coalesce identical entries at the end of History.
1417             if (History.size() >= 2 &&
1418                 Prev->isIdenticalTo(History[History.size() - 2])) {
1419               DEBUG(dbgs() << "Coalescing identical DBG_VALUE entries:\n"
1420                     << "\t" << *Prev
1421                     << "\t" << *History[History.size() - 2] << "\n");
1422               History.pop_back();
1423             }
1424
1425             // Terminate old register assignments that don't reach MI;
1426             MachineFunction::const_iterator PrevMBB = Prev->getParent();
1427             if (PrevMBB != I && (!AtBlockEntry || llvm::next(PrevMBB) != I) &&
1428                 isDbgValueInDefinedReg(Prev)) {
1429               // Previous register assignment needs to terminate at the end of
1430               // its basic block.
1431               MachineBasicBlock::const_iterator LastMI =
1432                 PrevMBB->getLastNonDebugInstr();
1433               if (LastMI == PrevMBB->end()) {
1434                 // Drop DBG_VALUE for empty range.
1435                 DEBUG(dbgs() << "Dropping DBG_VALUE for empty range:\n"
1436                       << "\t" << *Prev << "\n");
1437                 History.pop_back();
1438               }
1439               else {
1440                 // Terminate after LastMI.
1441                 History.push_back(LastMI);
1442               }
1443             }
1444           }
1445         }
1446         History.push_back(MI);
1447       } else {
1448         // Not a DBG_VALUE instruction.
1449         if (!MI->isLabel())
1450           AtBlockEntry = false;
1451
1452         // First known non-DBG_VALUE and non-frame setup location marks
1453         // the beginning of the function body.
1454         if (!MI->getFlag(MachineInstr::FrameSetup) &&
1455             (PrologEndLoc.isUnknown() && !MI->getDebugLoc().isUnknown()))
1456           PrologEndLoc = MI->getDebugLoc();
1457
1458         // Check if the instruction clobbers any registers with debug vars.
1459         for (MachineInstr::const_mop_iterator MOI = MI->operands_begin(),
1460                MOE = MI->operands_end(); MOI != MOE; ++MOI) {
1461           if (!MOI->isReg() || !MOI->isDef() || !MOI->getReg())
1462             continue;
1463           for (MCRegAliasIterator AI(MOI->getReg(), TRI, true);
1464                AI.isValid(); ++AI) {
1465             unsigned Reg = *AI;
1466             const MDNode *Var = LiveUserVar[Reg];
1467             if (!Var)
1468               continue;
1469             // Reg is now clobbered.
1470             LiveUserVar[Reg] = 0;
1471
1472             // Was MD last defined by a DBG_VALUE referring to Reg?
1473             DbgValueHistoryMap::iterator HistI = DbgValues.find(Var);
1474             if (HistI == DbgValues.end())
1475               continue;
1476             SmallVectorImpl<const MachineInstr*> &History = HistI->second;
1477             if (History.empty())
1478               continue;
1479             const MachineInstr *Prev = History.back();
1480             // Sanity-check: Register assignments are terminated at the end of
1481             // their block.
1482             if (!Prev->isDebugValue() || Prev->getParent() != MI->getParent())
1483               continue;
1484             // Is the variable still in Reg?
1485             if (!isDbgValueInDefinedReg(Prev) ||
1486                 Prev->getOperand(0).getReg() != Reg)
1487               continue;
1488             // Var is clobbered. Make sure the next instruction gets a label.
1489             History.push_back(MI);
1490           }
1491         }
1492       }
1493     }
1494   }
1495
1496   for (DbgValueHistoryMap::iterator I = DbgValues.begin(), E = DbgValues.end();
1497        I != E; ++I) {
1498     SmallVectorImpl<const MachineInstr*> &History = I->second;
1499     if (History.empty())
1500       continue;
1501
1502     // Make sure the final register assignments are terminated.
1503     const MachineInstr *Prev = History.back();
1504     if (Prev->isDebugValue() && isDbgValueInDefinedReg(Prev)) {
1505       const MachineBasicBlock *PrevMBB = Prev->getParent();
1506       MachineBasicBlock::const_iterator LastMI =
1507         PrevMBB->getLastNonDebugInstr();
1508       if (LastMI == PrevMBB->end())
1509         // Drop DBG_VALUE for empty range.
1510         History.pop_back();
1511       else {
1512         // Terminate after LastMI.
1513         History.push_back(LastMI);
1514       }
1515     }
1516     // Request labels for the full history.
1517     for (unsigned i = 0, e = History.size(); i != e; ++i) {
1518       const MachineInstr *MI = History[i];
1519       if (MI->isDebugValue())
1520         requestLabelBeforeInsn(MI);
1521       else
1522         requestLabelAfterInsn(MI);
1523     }
1524   }
1525
1526   PrevInstLoc = DebugLoc();
1527   PrevLabel = FunctionBeginSym;
1528
1529   // Record beginning of function.
1530   if (!PrologEndLoc.isUnknown()) {
1531     DebugLoc FnStartDL = getFnDebugLoc(PrologEndLoc,
1532                                        MF->getFunction()->getContext());
1533     recordSourceLine(FnStartDL.getLine(), FnStartDL.getCol(),
1534                      FnStartDL.getScope(MF->getFunction()->getContext()),
1535     // We'd like to list the prologue as "not statements" but GDB behaves
1536     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
1537                      DWARF2_FLAG_IS_STMT);
1538   }
1539 }
1540
1541 void DwarfDebug::addScopeVariable(LexicalScope *LS, DbgVariable *Var) {
1542 //  SmallVector<DbgVariable *, 8> &Vars = ScopeVariables.lookup(LS);
1543   ScopeVariables[LS].push_back(Var);
1544 //  Vars.push_back(Var);
1545 }
1546
1547 // Gather and emit post-function debug information.
1548 void DwarfDebug::endFunction(const MachineFunction *MF) {
1549   if (!MMI->hasDebugInfo() || LScopes.empty()) return;
1550
1551   // Define end label for subprogram.
1552   FunctionEndSym = Asm->GetTempSymbol("func_end",
1553                                       Asm->getFunctionNumber());
1554   // Assumes in correct section after the entry point.
1555   Asm->OutStreamer.EmitLabel(FunctionEndSym);
1556   // Set DwarfCompileUnitID in MCContext to default value.
1557   Asm->OutStreamer.getContext().setDwarfCompileUnitID(0);
1558
1559   SmallPtrSet<const MDNode *, 16> ProcessedVars;
1560   collectVariableInfo(MF, ProcessedVars);
1561
1562   LexicalScope *FnScope = LScopes.getCurrentFunctionScope();
1563   CompileUnit *TheCU = SPMap.lookup(FnScope->getScopeNode());
1564   assert(TheCU && "Unable to find compile unit!");
1565
1566   // Construct abstract scopes.
1567   ArrayRef<LexicalScope *> AList = LScopes.getAbstractScopesList();
1568   for (unsigned i = 0, e = AList.size(); i != e; ++i) {
1569     LexicalScope *AScope = AList[i];
1570     DISubprogram SP(AScope->getScopeNode());
1571     if (SP.Verify()) {
1572       // Collect info for variables that were optimized out.
1573       DIArray Variables = SP.getVariables();
1574       for (unsigned i = 0, e = Variables.getNumElements(); i != e; ++i) {
1575         DIVariable DV(Variables.getElement(i));
1576         if (!DV || !DV.Verify() || !ProcessedVars.insert(DV))
1577           continue;
1578         // Check that DbgVariable for DV wasn't created earlier, when
1579         // findAbstractVariable() was called for inlined instance of DV.
1580         LLVMContext &Ctx = DV->getContext();
1581         DIVariable CleanDV = cleanseInlinedVariable(DV, Ctx);
1582         if (AbstractVariables.lookup(CleanDV))
1583           continue;
1584         if (LexicalScope *Scope = LScopes.findAbstractScope(DV.getContext()))
1585           addScopeVariable(Scope, new DbgVariable(DV, NULL));
1586       }
1587     }
1588     if (ProcessedSPNodes.count(AScope->getScopeNode()) == 0)
1589       constructScopeDIE(TheCU, AScope);
1590   }
1591
1592   DIE *CurFnDIE = constructScopeDIE(TheCU, FnScope);
1593
1594   if (!MF->getTarget().Options.DisableFramePointerElim(*MF))
1595     TheCU->addFlag(CurFnDIE, dwarf::DW_AT_APPLE_omit_frame_ptr);
1596
1597   DebugFrames.push_back(FunctionDebugFrameInfo(Asm->getFunctionNumber(),
1598                                                MMI->getFrameMoves()));
1599
1600   // Clear debug info
1601   for (DenseMap<LexicalScope *, SmallVector<DbgVariable *, 8> >::iterator
1602          I = ScopeVariables.begin(), E = ScopeVariables.end(); I != E; ++I)
1603     DeleteContainerPointers(I->second);
1604   ScopeVariables.clear();
1605   DeleteContainerPointers(CurrentFnArguments);
1606   UserVariables.clear();
1607   DbgValues.clear();
1608   AbstractVariables.clear();
1609   LabelsBeforeInsn.clear();
1610   LabelsAfterInsn.clear();
1611   PrevLabel = NULL;
1612 }
1613
1614 // Register a source line with debug info. Returns the  unique label that was
1615 // emitted and which provides correspondence to the source line list.
1616 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
1617                                   unsigned Flags) {
1618   StringRef Fn;
1619   StringRef Dir;
1620   unsigned Src = 1;
1621   if (S) {
1622     DIDescriptor Scope(S);
1623
1624     if (Scope.isCompileUnit()) {
1625       DICompileUnit CU(S);
1626       Fn = CU.getFilename();
1627       Dir = CU.getDirectory();
1628     } else if (Scope.isFile()) {
1629       DIFile F(S);
1630       Fn = F.getFilename();
1631       Dir = F.getDirectory();
1632     } else if (Scope.isSubprogram()) {
1633       DISubprogram SP(S);
1634       Fn = SP.getFilename();
1635       Dir = SP.getDirectory();
1636     } else if (Scope.isLexicalBlockFile()) {
1637       DILexicalBlockFile DBF(S);
1638       Fn = DBF.getFilename();
1639       Dir = DBF.getDirectory();
1640     } else if (Scope.isLexicalBlock()) {
1641       DILexicalBlock DB(S);
1642       Fn = DB.getFilename();
1643       Dir = DB.getDirectory();
1644     } else
1645       llvm_unreachable("Unexpected scope info");
1646
1647     Src = getOrCreateSourceID(Fn, Dir,
1648             Asm->OutStreamer.getContext().getDwarfCompileUnitID());
1649   }
1650   Asm->OutStreamer.EmitDwarfLocDirective(Src, Line, Col, Flags, 0, 0, Fn);
1651 }
1652
1653 //===----------------------------------------------------------------------===//
1654 // Emit Methods
1655 //===----------------------------------------------------------------------===//
1656
1657 // Compute the size and offset of a DIE.
1658 unsigned
1659 DwarfUnits::computeSizeAndOffset(DIE *Die, unsigned Offset) {
1660   // Get the children.
1661   const std::vector<DIE *> &Children = Die->getChildren();
1662
1663   // Record the abbreviation.
1664   assignAbbrevNumber(Die->getAbbrev());
1665
1666   // Get the abbreviation for this DIE.
1667   unsigned AbbrevNumber = Die->getAbbrevNumber();
1668   const DIEAbbrev *Abbrev = Abbreviations->at(AbbrevNumber - 1);
1669
1670   // Set DIE offset
1671   Die->setOffset(Offset);
1672
1673   // Start the size with the size of abbreviation code.
1674   Offset += MCAsmInfo::getULEB128Size(AbbrevNumber);
1675
1676   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1677   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1678
1679   // Size the DIE attribute values.
1680   for (unsigned i = 0, N = Values.size(); i < N; ++i)
1681     // Size attribute value.
1682     Offset += Values[i]->SizeOf(Asm, AbbrevData[i].getForm());
1683
1684   // Size the DIE children if any.
1685   if (!Children.empty()) {
1686     assert(Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes &&
1687            "Children flag not set");
1688
1689     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1690       Offset = computeSizeAndOffset(Children[j], Offset);
1691
1692     // End of children marker.
1693     Offset += sizeof(int8_t);
1694   }
1695
1696   Die->setSize(Offset - Die->getOffset());
1697   return Offset;
1698 }
1699
1700 // Compute the size and offset of all the DIEs.
1701 void DwarfUnits::computeSizeAndOffsets() {
1702   // Offset from the beginning of debug info section.
1703   unsigned AccuOffset = 0;
1704   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1705          E = CUs.end(); I != E; ++I) {
1706     (*I)->setDebugInfoOffset(AccuOffset);
1707     unsigned Offset =
1708       sizeof(int32_t) + // Length of Compilation Unit Info
1709       sizeof(int16_t) + // DWARF version number
1710       sizeof(int32_t) + // Offset Into Abbrev. Section
1711       sizeof(int8_t);   // Pointer Size (in bytes)
1712
1713     unsigned EndOffset = computeSizeAndOffset((*I)->getCUDie(), Offset);
1714     AccuOffset += EndOffset;
1715   }
1716 }
1717
1718 // Emit initial Dwarf sections with a label at the start of each one.
1719 void DwarfDebug::emitSectionLabels() {
1720   const TargetLoweringObjectFile &TLOF = Asm->getObjFileLowering();
1721
1722   // Dwarf sections base addresses.
1723   DwarfInfoSectionSym =
1724     emitSectionSym(Asm, TLOF.getDwarfInfoSection(), "section_info");
1725   DwarfAbbrevSectionSym =
1726     emitSectionSym(Asm, TLOF.getDwarfAbbrevSection(), "section_abbrev");
1727   if (useSplitDwarf())
1728     DwarfAbbrevDWOSectionSym =
1729       emitSectionSym(Asm, TLOF.getDwarfAbbrevDWOSection(),
1730                      "section_abbrev_dwo");
1731   emitSectionSym(Asm, TLOF.getDwarfARangesSection());
1732
1733   if (const MCSection *MacroInfo = TLOF.getDwarfMacroInfoSection())
1734     emitSectionSym(Asm, MacroInfo);
1735
1736   DwarfLineSectionSym =
1737     emitSectionSym(Asm, TLOF.getDwarfLineSection(), "section_line");
1738   emitSectionSym(Asm, TLOF.getDwarfLocSection());
1739   if (GenerateDwarfPubNamesSection)
1740     emitSectionSym(Asm, TLOF.getDwarfPubNamesSection());
1741   emitSectionSym(Asm, TLOF.getDwarfPubTypesSection());
1742   DwarfStrSectionSym =
1743     emitSectionSym(Asm, TLOF.getDwarfStrSection(), "info_string");
1744   if (useSplitDwarf()) {
1745     DwarfStrDWOSectionSym =
1746       emitSectionSym(Asm, TLOF.getDwarfStrDWOSection(), "skel_string");
1747     DwarfAddrSectionSym =
1748       emitSectionSym(Asm, TLOF.getDwarfAddrSection(), "addr_sec");
1749   }
1750   DwarfDebugRangeSectionSym = emitSectionSym(Asm, TLOF.getDwarfRangesSection(),
1751                                              "debug_range");
1752
1753   DwarfDebugLocSectionSym = emitSectionSym(Asm, TLOF.getDwarfLocSection(),
1754                                            "section_debug_loc");
1755
1756   TextSectionSym = emitSectionSym(Asm, TLOF.getTextSection(), "text_begin");
1757   emitSectionSym(Asm, TLOF.getDataSection());
1758 }
1759
1760 // Recursively emits a debug information entry.
1761 void DwarfDebug::emitDIE(DIE *Die, std::vector<DIEAbbrev *> *Abbrevs) {
1762   // Get the abbreviation for this DIE.
1763   unsigned AbbrevNumber = Die->getAbbrevNumber();
1764   const DIEAbbrev *Abbrev = Abbrevs->at(AbbrevNumber - 1);
1765
1766   // Emit the code (index) for the abbreviation.
1767   if (Asm->isVerbose())
1768     Asm->OutStreamer.AddComment("Abbrev [" + Twine(AbbrevNumber) + "] 0x" +
1769                                 Twine::utohexstr(Die->getOffset()) + ":0x" +
1770                                 Twine::utohexstr(Die->getSize()) + " " +
1771                                 dwarf::TagString(Abbrev->getTag()));
1772   Asm->EmitULEB128(AbbrevNumber);
1773
1774   const SmallVectorImpl<DIEValue*> &Values = Die->getValues();
1775   const SmallVectorImpl<DIEAbbrevData> &AbbrevData = Abbrev->getData();
1776
1777   // Emit the DIE attribute values.
1778   for (unsigned i = 0, N = Values.size(); i < N; ++i) {
1779     unsigned Attr = AbbrevData[i].getAttribute();
1780     unsigned Form = AbbrevData[i].getForm();
1781     assert(Form && "Too many attributes for DIE (check abbreviation)");
1782
1783     if (Asm->isVerbose())
1784       Asm->OutStreamer.AddComment(dwarf::AttributeString(Attr));
1785
1786     switch (Attr) {
1787     case dwarf::DW_AT_abstract_origin: {
1788       DIEEntry *E = cast<DIEEntry>(Values[i]);
1789       DIE *Origin = E->getEntry();
1790       unsigned Addr = Origin->getOffset();
1791       if (Form == dwarf::DW_FORM_ref_addr) {
1792         // For DW_FORM_ref_addr, output the offset from beginning of debug info
1793         // section. Origin->getOffset() returns the offset from start of the
1794         // compile unit.
1795         DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1796         Addr += Holder.getCUOffset(Origin->getCompileUnit());
1797       }
1798       Asm->EmitInt32(Addr);
1799       break;
1800     }
1801     case dwarf::DW_AT_ranges: {
1802       // DW_AT_range Value encodes offset in debug_range section.
1803       DIEInteger *V = cast<DIEInteger>(Values[i]);
1804
1805       if (Asm->MAI->doesDwarfUseRelocationsAcrossSections()) {
1806         Asm->EmitLabelPlusOffset(DwarfDebugRangeSectionSym,
1807                                  V->getValue(),
1808                                  4);
1809       } else {
1810         Asm->EmitLabelOffsetDifference(DwarfDebugRangeSectionSym,
1811                                        V->getValue(),
1812                                        DwarfDebugRangeSectionSym,
1813                                        4);
1814       }
1815       break;
1816     }
1817     case dwarf::DW_AT_location: {
1818       if (DIELabel *L = dyn_cast<DIELabel>(Values[i])) {
1819         if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
1820           Asm->EmitLabelReference(L->getValue(), 4);
1821         else
1822           Asm->EmitLabelDifference(L->getValue(), DwarfDebugLocSectionSym, 4);
1823       } else {
1824         Values[i]->EmitValue(Asm, Form);
1825       }
1826       break;
1827     }
1828     case dwarf::DW_AT_accessibility: {
1829       if (Asm->isVerbose()) {
1830         DIEInteger *V = cast<DIEInteger>(Values[i]);
1831         Asm->OutStreamer.AddComment(dwarf::AccessibilityString(V->getValue()));
1832       }
1833       Values[i]->EmitValue(Asm, Form);
1834       break;
1835     }
1836     default:
1837       // Emit an attribute using the defined form.
1838       Values[i]->EmitValue(Asm, Form);
1839       break;
1840     }
1841   }
1842
1843   // Emit the DIE children if any.
1844   if (Abbrev->getChildrenFlag() == dwarf::DW_CHILDREN_yes) {
1845     const std::vector<DIE *> &Children = Die->getChildren();
1846
1847     for (unsigned j = 0, M = Children.size(); j < M; ++j)
1848       emitDIE(Children[j], Abbrevs);
1849
1850     if (Asm->isVerbose())
1851       Asm->OutStreamer.AddComment("End Of Children Mark");
1852     Asm->EmitInt8(0);
1853   }
1854 }
1855
1856 // Emit the various dwarf units to the unit section USection with
1857 // the abbreviations going into ASection.
1858 void DwarfUnits::emitUnits(DwarfDebug *DD,
1859                            const MCSection *USection,
1860                            const MCSection *ASection,
1861                            const MCSymbol *ASectionSym) {
1862   Asm->OutStreamer.SwitchSection(USection);
1863   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1864          E = CUs.end(); I != E; ++I) {
1865     CompileUnit *TheCU = *I;
1866     DIE *Die = TheCU->getCUDie();
1867
1868     // Emit the compile units header.
1869     Asm->OutStreamer
1870       .EmitLabel(Asm->GetTempSymbol(USection->getLabelBeginName(),
1871                                     TheCU->getUniqueID()));
1872
1873     // Emit size of content not including length itself
1874     unsigned ContentSize = Die->getSize() +
1875       sizeof(int16_t) + // DWARF version number
1876       sizeof(int32_t) + // Offset Into Abbrev. Section
1877       sizeof(int8_t);   // Pointer Size (in bytes)
1878
1879     Asm->OutStreamer.AddComment("Length of Compilation Unit Info");
1880     Asm->EmitInt32(ContentSize);
1881     Asm->OutStreamer.AddComment("DWARF version number");
1882     Asm->EmitInt16(dwarf::DWARF_VERSION);
1883     Asm->OutStreamer.AddComment("Offset Into Abbrev. Section");
1884     Asm->EmitSectionOffset(Asm->GetTempSymbol(ASection->getLabelBeginName()),
1885                            ASectionSym);
1886     Asm->OutStreamer.AddComment("Address Size (in bytes)");
1887     Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
1888
1889     DD->emitDIE(Die, Abbreviations);
1890     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol(USection->getLabelEndName(),
1891                                                   TheCU->getUniqueID()));
1892   }
1893 }
1894
1895 /// For a given compile unit DIE, returns offset from beginning of debug info.
1896 unsigned DwarfUnits::getCUOffset(DIE *Die) {
1897   assert(Die->getTag() == dwarf::DW_TAG_compile_unit  &&
1898          "Input DIE should be compile unit in getCUOffset.");
1899   for (SmallVectorImpl<CompileUnit *>::iterator I = CUs.begin(),
1900        E = CUs.end(); I != E; ++I) {
1901     CompileUnit *TheCU = *I;
1902     if (TheCU->getCUDie() == Die)
1903       return TheCU->getDebugInfoOffset();
1904   }
1905   llvm_unreachable("The compile unit DIE should belong to CUs in DwarfUnits.");
1906 }
1907
1908 // Emit the debug info section.
1909 void DwarfDebug::emitDebugInfo() {
1910   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
1911
1912   Holder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoSection(),
1913                    Asm->getObjFileLowering().getDwarfAbbrevSection(),
1914                    DwarfAbbrevSectionSym);
1915 }
1916
1917 // Emit the abbreviation section.
1918 void DwarfDebug::emitAbbreviations() {
1919   if (!useSplitDwarf())
1920     emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection(),
1921                 &Abbreviations);
1922   else
1923     emitSkeletonAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevSection());
1924 }
1925
1926 void DwarfDebug::emitAbbrevs(const MCSection *Section,
1927                              std::vector<DIEAbbrev *> *Abbrevs) {
1928   // Check to see if it is worth the effort.
1929   if (!Abbrevs->empty()) {
1930     // Start the debug abbrev section.
1931     Asm->OutStreamer.SwitchSection(Section);
1932
1933     MCSymbol *Begin = Asm->GetTempSymbol(Section->getLabelBeginName());
1934     Asm->OutStreamer.EmitLabel(Begin);
1935
1936     // For each abbrevation.
1937     for (unsigned i = 0, N = Abbrevs->size(); i < N; ++i) {
1938       // Get abbreviation data
1939       const DIEAbbrev *Abbrev = Abbrevs->at(i);
1940
1941       // Emit the abbrevations code (base 1 index.)
1942       Asm->EmitULEB128(Abbrev->getNumber(), "Abbreviation Code");
1943
1944       // Emit the abbreviations data.
1945       Abbrev->Emit(Asm);
1946     }
1947
1948     // Mark end of abbreviations.
1949     Asm->EmitULEB128(0, "EOM(3)");
1950
1951     MCSymbol *End = Asm->GetTempSymbol(Section->getLabelEndName());
1952     Asm->OutStreamer.EmitLabel(End);
1953   }
1954 }
1955
1956 // Emit the last address of the section and the end of the line matrix.
1957 void DwarfDebug::emitEndOfLineMatrix(unsigned SectionEnd) {
1958   // Define last address of section.
1959   Asm->OutStreamer.AddComment("Extended Op");
1960   Asm->EmitInt8(0);
1961
1962   Asm->OutStreamer.AddComment("Op size");
1963   Asm->EmitInt8(Asm->getDataLayout().getPointerSize() + 1);
1964   Asm->OutStreamer.AddComment("DW_LNE_set_address");
1965   Asm->EmitInt8(dwarf::DW_LNE_set_address);
1966
1967   Asm->OutStreamer.AddComment("Section end label");
1968
1969   Asm->OutStreamer.EmitSymbolValue(Asm->GetTempSymbol("section_end",SectionEnd),
1970                                    Asm->getDataLayout().getPointerSize());
1971
1972   // Mark end of matrix.
1973   Asm->OutStreamer.AddComment("DW_LNE_end_sequence");
1974   Asm->EmitInt8(0);
1975   Asm->EmitInt8(1);
1976   Asm->EmitInt8(1);
1977 }
1978
1979 // Emit visible names into a hashed accelerator table section.
1980 void DwarfDebug::emitAccelNames() {
1981   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
1982                                            dwarf::DW_FORM_data4));
1983   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
1984          E = CUMap.end(); I != E; ++I) {
1985     CompileUnit *TheCU = I->second;
1986     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNames();
1987     for (StringMap<std::vector<DIE*> >::const_iterator
1988            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
1989       const char *Name = GI->getKeyData();
1990       const std::vector<DIE *> &Entities = GI->second;
1991       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
1992              DE = Entities.end(); DI != DE; ++DI)
1993         AT.AddName(Name, (*DI));
1994     }
1995   }
1996
1997   AT.FinalizeTable(Asm, "Names");
1998   Asm->OutStreamer.SwitchSection(
1999     Asm->getObjFileLowering().getDwarfAccelNamesSection());
2000   MCSymbol *SectionBegin = Asm->GetTempSymbol("names_begin");
2001   Asm->OutStreamer.EmitLabel(SectionBegin);
2002
2003   // Emit the full data.
2004   AT.Emit(Asm, SectionBegin, &InfoHolder);
2005 }
2006
2007 // Emit objective C classes and categories into a hashed accelerator table
2008 // section.
2009 void DwarfDebug::emitAccelObjC() {
2010   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2011                                            dwarf::DW_FORM_data4));
2012   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2013          E = CUMap.end(); I != E; ++I) {
2014     CompileUnit *TheCU = I->second;
2015     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelObjC();
2016     for (StringMap<std::vector<DIE*> >::const_iterator
2017            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2018       const char *Name = GI->getKeyData();
2019       const std::vector<DIE *> &Entities = GI->second;
2020       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2021              DE = Entities.end(); DI != DE; ++DI)
2022         AT.AddName(Name, (*DI));
2023     }
2024   }
2025
2026   AT.FinalizeTable(Asm, "ObjC");
2027   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2028                                  .getDwarfAccelObjCSection());
2029   MCSymbol *SectionBegin = Asm->GetTempSymbol("objc_begin");
2030   Asm->OutStreamer.EmitLabel(SectionBegin);
2031
2032   // Emit the full data.
2033   AT.Emit(Asm, SectionBegin, &InfoHolder);
2034 }
2035
2036 // Emit namespace dies into a hashed accelerator table.
2037 void DwarfDebug::emitAccelNamespaces() {
2038   DwarfAccelTable AT(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2039                                            dwarf::DW_FORM_data4));
2040   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2041          E = CUMap.end(); I != E; ++I) {
2042     CompileUnit *TheCU = I->second;
2043     const StringMap<std::vector<DIE*> > &Names = TheCU->getAccelNamespace();
2044     for (StringMap<std::vector<DIE*> >::const_iterator
2045            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2046       const char *Name = GI->getKeyData();
2047       const std::vector<DIE *> &Entities = GI->second;
2048       for (std::vector<DIE *>::const_iterator DI = Entities.begin(),
2049              DE = Entities.end(); DI != DE; ++DI)
2050         AT.AddName(Name, (*DI));
2051     }
2052   }
2053
2054   AT.FinalizeTable(Asm, "namespac");
2055   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2056                                  .getDwarfAccelNamespaceSection());
2057   MCSymbol *SectionBegin = Asm->GetTempSymbol("namespac_begin");
2058   Asm->OutStreamer.EmitLabel(SectionBegin);
2059
2060   // Emit the full data.
2061   AT.Emit(Asm, SectionBegin, &InfoHolder);
2062 }
2063
2064 // Emit type dies into a hashed accelerator table.
2065 void DwarfDebug::emitAccelTypes() {
2066   std::vector<DwarfAccelTable::Atom> Atoms;
2067   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeDIEOffset,
2068                                         dwarf::DW_FORM_data4));
2069   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTag,
2070                                         dwarf::DW_FORM_data2));
2071   Atoms.push_back(DwarfAccelTable::Atom(DwarfAccelTable::eAtomTypeTypeFlags,
2072                                         dwarf::DW_FORM_data1));
2073   DwarfAccelTable AT(Atoms);
2074   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2075          E = CUMap.end(); I != E; ++I) {
2076     CompileUnit *TheCU = I->second;
2077     const StringMap<std::vector<std::pair<DIE*, unsigned > > > &Names
2078       = TheCU->getAccelTypes();
2079     for (StringMap<std::vector<std::pair<DIE*, unsigned> > >::const_iterator
2080            GI = Names.begin(), GE = Names.end(); GI != GE; ++GI) {
2081       const char *Name = GI->getKeyData();
2082       const std::vector<std::pair<DIE *, unsigned> > &Entities = GI->second;
2083       for (std::vector<std::pair<DIE *, unsigned> >::const_iterator DI
2084              = Entities.begin(), DE = Entities.end(); DI !=DE; ++DI)
2085         AT.AddName(Name, (*DI).first, (*DI).second);
2086     }
2087   }
2088
2089   AT.FinalizeTable(Asm, "types");
2090   Asm->OutStreamer.SwitchSection(Asm->getObjFileLowering()
2091                                  .getDwarfAccelTypesSection());
2092   MCSymbol *SectionBegin = Asm->GetTempSymbol("types_begin");
2093   Asm->OutStreamer.EmitLabel(SectionBegin);
2094
2095   // Emit the full data.
2096   AT.Emit(Asm, SectionBegin, &InfoHolder);
2097 }
2098
2099 /// emitDebugPubnames - Emit visible names into a debug pubnames section.
2100 ///
2101 void DwarfDebug::emitDebugPubnames() {
2102   const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2103
2104   typedef DenseMap<const MDNode*, CompileUnit*> CUMapType;
2105   for (CUMapType::iterator I = CUMap.begin(), E = CUMap.end(); I != E; ++I) {
2106     CompileUnit *TheCU = I->second;
2107     unsigned ID = TheCU->getUniqueID();
2108
2109     if (TheCU->getGlobalNames().empty())
2110       continue;
2111
2112     // Start the dwarf pubnames section.
2113     Asm->OutStreamer.SwitchSection(
2114       Asm->getObjFileLowering().getDwarfPubNamesSection());
2115
2116     Asm->OutStreamer.AddComment("Length of Public Names Info");
2117     Asm->EmitLabelDifference(Asm->GetTempSymbol("pubnames_end", ID),
2118                              Asm->GetTempSymbol("pubnames_begin", ID), 4);
2119
2120     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_begin", ID));
2121
2122     Asm->OutStreamer.AddComment("DWARF Version");
2123     Asm->EmitInt16(dwarf::DWARF_VERSION);
2124
2125     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2126     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2127                            DwarfInfoSectionSym);
2128
2129     Asm->OutStreamer.AddComment("Compilation Unit Length");
2130     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(), ID),
2131                              Asm->GetTempSymbol(ISec->getLabelBeginName(), ID),
2132                              4);
2133
2134     const StringMap<DIE*> &Globals = TheCU->getGlobalNames();
2135     for (StringMap<DIE*>::const_iterator
2136            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2137       const char *Name = GI->getKeyData();
2138       const DIE *Entity = GI->second;
2139
2140       Asm->OutStreamer.AddComment("DIE offset");
2141       Asm->EmitInt32(Entity->getOffset());
2142
2143       if (Asm->isVerbose())
2144         Asm->OutStreamer.AddComment("External Name");
2145       Asm->OutStreamer.EmitBytes(StringRef(Name, strlen(Name)+1), 0);
2146     }
2147
2148     Asm->OutStreamer.AddComment("End Mark");
2149     Asm->EmitInt32(0);
2150     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubnames_end", ID));
2151   }
2152 }
2153
2154 void DwarfDebug::emitDebugPubTypes() {
2155   for (DenseMap<const MDNode *, CompileUnit *>::iterator I = CUMap.begin(),
2156          E = CUMap.end(); I != E; ++I) {
2157     CompileUnit *TheCU = I->second;
2158     // Start the dwarf pubtypes section.
2159     Asm->OutStreamer.SwitchSection(
2160       Asm->getObjFileLowering().getDwarfPubTypesSection());
2161     Asm->OutStreamer.AddComment("Length of Public Types Info");
2162     Asm->EmitLabelDifference(
2163       Asm->GetTempSymbol("pubtypes_end", TheCU->getUniqueID()),
2164       Asm->GetTempSymbol("pubtypes_begin", TheCU->getUniqueID()), 4);
2165
2166     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_begin",
2167                                                   TheCU->getUniqueID()));
2168
2169     if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DWARF Version");
2170     Asm->EmitInt16(dwarf::DWARF_VERSION);
2171
2172     Asm->OutStreamer.AddComment("Offset of Compilation Unit Info");
2173     const MCSection *ISec = Asm->getObjFileLowering().getDwarfInfoSection();
2174     Asm->EmitSectionOffset(Asm->GetTempSymbol(ISec->getLabelBeginName(),
2175                                               TheCU->getUniqueID()),
2176                            DwarfInfoSectionSym);
2177
2178     Asm->OutStreamer.AddComment("Compilation Unit Length");
2179     Asm->EmitLabelDifference(Asm->GetTempSymbol(ISec->getLabelEndName(),
2180                                                 TheCU->getUniqueID()),
2181                              Asm->GetTempSymbol(ISec->getLabelBeginName(),
2182                                                 TheCU->getUniqueID()),
2183                              4);
2184
2185     const StringMap<DIE*> &Globals = TheCU->getGlobalTypes();
2186     for (StringMap<DIE*>::const_iterator
2187            GI = Globals.begin(), GE = Globals.end(); GI != GE; ++GI) {
2188       const char *Name = GI->getKeyData();
2189       DIE *Entity = GI->second;
2190
2191       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2192       Asm->EmitInt32(Entity->getOffset());
2193
2194       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("External Name");
2195       // Emit the name with a terminating null byte.
2196       Asm->OutStreamer.EmitBytes(StringRef(Name, GI->getKeyLength()+1));
2197     }
2198
2199     Asm->OutStreamer.AddComment("End Mark");
2200     Asm->EmitInt32(0);
2201     Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("pubtypes_end",
2202                                                   TheCU->getUniqueID()));
2203   }
2204 }
2205
2206 // Emit strings into a string section.
2207 void DwarfUnits::emitStrings(const MCSection *StrSection,
2208                              const MCSection *OffsetSection = NULL,
2209                              const MCSymbol *StrSecSym = NULL) {
2210
2211   if (StringPool.empty()) return;
2212
2213   // Start the dwarf str section.
2214   Asm->OutStreamer.SwitchSection(StrSection);
2215
2216   // Get all of the string pool entries and put them in an array by their ID so
2217   // we can sort them.
2218   SmallVector<std::pair<unsigned,
2219                  StringMapEntry<std::pair<MCSymbol*, unsigned> >*>, 64> Entries;
2220
2221   for (StringMap<std::pair<MCSymbol*, unsigned> >::iterator
2222          I = StringPool.begin(), E = StringPool.end();
2223        I != E; ++I)
2224     Entries.push_back(std::make_pair(I->second.second, &*I));
2225
2226   array_pod_sort(Entries.begin(), Entries.end());
2227
2228   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2229     // Emit a label for reference from debug information entries.
2230     Asm->OutStreamer.EmitLabel(Entries[i].second->getValue().first);
2231
2232     // Emit the string itself with a terminating null byte.
2233     Asm->OutStreamer.EmitBytes(StringRef(Entries[i].second->getKeyData(),
2234                                          Entries[i].second->getKeyLength()+1));
2235   }
2236
2237   // If we've got an offset section go ahead and emit that now as well.
2238   if (OffsetSection) {
2239     Asm->OutStreamer.SwitchSection(OffsetSection);
2240     unsigned offset = 0;
2241     unsigned size = 4; // FIXME: DWARF64 is 8.
2242     for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2243       Asm->OutStreamer.EmitIntValue(offset, size);
2244       offset += Entries[i].second->getKeyLength() + 1;
2245     }
2246   }
2247 }
2248
2249 // Emit strings into a string section.
2250 void DwarfUnits::emitAddresses(const MCSection *AddrSection) {
2251
2252   if (AddressPool.empty()) return;
2253
2254   // Start the dwarf addr section.
2255   Asm->OutStreamer.SwitchSection(AddrSection);
2256
2257   // Get all of the string pool entries and put them in an array by their ID so
2258   // we can sort them.
2259   SmallVector<std::pair<unsigned,
2260                         std::pair<MCSymbol*, unsigned>* >, 64> Entries;
2261
2262   for (DenseMap<MCSymbol*, std::pair<MCSymbol*, unsigned> >::iterator
2263          I = AddressPool.begin(), E = AddressPool.end();
2264        I != E; ++I)
2265     Entries.push_back(std::make_pair(I->second.second, &(I->second)));
2266
2267   array_pod_sort(Entries.begin(), Entries.end());
2268
2269   for (unsigned i = 0, e = Entries.size(); i != e; ++i) {
2270     // Emit a label for reference from debug information entries.
2271     MCSymbol *Sym = Entries[i].second->first;
2272     if (Sym)
2273       Asm->EmitLabelReference(Entries[i].second->first,
2274                               Asm->getDataLayout().getPointerSize());
2275     else
2276       Asm->OutStreamer.EmitIntValue(0, Asm->getDataLayout().getPointerSize());
2277   }
2278
2279 }
2280
2281 // Emit visible names into a debug str section.
2282 void DwarfDebug::emitDebugStr() {
2283   DwarfUnits &Holder = useSplitDwarf() ? SkeletonHolder : InfoHolder;
2284   Holder.emitStrings(Asm->getObjFileLowering().getDwarfStrSection());
2285 }
2286
2287 // Emit visible names into a debug loc section.
2288 void DwarfDebug::emitDebugLoc() {
2289   if (DotDebugLocEntries.empty())
2290     return;
2291
2292   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2293          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2294        I != E; ++I) {
2295     DotDebugLocEntry &Entry = *I;
2296     if (I + 1 != DotDebugLocEntries.end())
2297       Entry.Merge(I+1);
2298   }
2299
2300   // Start the dwarf loc section.
2301   Asm->OutStreamer.SwitchSection(
2302     Asm->getObjFileLowering().getDwarfLocSection());
2303   unsigned char Size = Asm->getDataLayout().getPointerSize();
2304   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", 0));
2305   unsigned index = 1;
2306   for (SmallVectorImpl<DotDebugLocEntry>::iterator
2307          I = DotDebugLocEntries.begin(), E = DotDebugLocEntries.end();
2308        I != E; ++I, ++index) {
2309     DotDebugLocEntry &Entry = *I;
2310     if (Entry.isMerged()) continue;
2311     if (Entry.isEmpty()) {
2312       Asm->OutStreamer.EmitIntValue(0, Size);
2313       Asm->OutStreamer.EmitIntValue(0, Size);
2314       Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_loc", index));
2315     } else {
2316       Asm->OutStreamer.EmitSymbolValue(Entry.Begin, Size);
2317       Asm->OutStreamer.EmitSymbolValue(Entry.End, Size);
2318       DIVariable DV(Entry.Variable);
2319       Asm->OutStreamer.AddComment("Loc expr size");
2320       MCSymbol *begin = Asm->OutStreamer.getContext().CreateTempSymbol();
2321       MCSymbol *end = Asm->OutStreamer.getContext().CreateTempSymbol();
2322       Asm->EmitLabelDifference(end, begin, 2);
2323       Asm->OutStreamer.EmitLabel(begin);
2324       if (Entry.isInt()) {
2325         DIBasicType BTy(DV.getType());
2326         if (BTy.Verify() &&
2327             (BTy.getEncoding()  == dwarf::DW_ATE_signed
2328              || BTy.getEncoding() == dwarf::DW_ATE_signed_char)) {
2329           Asm->OutStreamer.AddComment("DW_OP_consts");
2330           Asm->EmitInt8(dwarf::DW_OP_consts);
2331           Asm->EmitSLEB128(Entry.getInt());
2332         } else {
2333           Asm->OutStreamer.AddComment("DW_OP_constu");
2334           Asm->EmitInt8(dwarf::DW_OP_constu);
2335           Asm->EmitULEB128(Entry.getInt());
2336         }
2337       } else if (Entry.isLocation()) {
2338         if (!DV.hasComplexAddress())
2339           // Regular entry.
2340           Asm->EmitDwarfRegOp(Entry.Loc);
2341         else {
2342           // Complex address entry.
2343           unsigned N = DV.getNumAddrElements();
2344           unsigned i = 0;
2345           if (N >= 2 && DV.getAddrElement(0) == DIBuilder::OpPlus) {
2346             if (Entry.Loc.getOffset()) {
2347               i = 2;
2348               Asm->EmitDwarfRegOp(Entry.Loc);
2349               Asm->OutStreamer.AddComment("DW_OP_deref");
2350               Asm->EmitInt8(dwarf::DW_OP_deref);
2351               Asm->OutStreamer.AddComment("DW_OP_plus_uconst");
2352               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2353               Asm->EmitSLEB128(DV.getAddrElement(1));
2354             } else {
2355               // If first address element is OpPlus then emit
2356               // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
2357               MachineLocation Loc(Entry.Loc.getReg(), DV.getAddrElement(1));
2358               Asm->EmitDwarfRegOp(Loc);
2359               i = 2;
2360             }
2361           } else {
2362             Asm->EmitDwarfRegOp(Entry.Loc);
2363           }
2364
2365           // Emit remaining complex address elements.
2366           for (; i < N; ++i) {
2367             uint64_t Element = DV.getAddrElement(i);
2368             if (Element == DIBuilder::OpPlus) {
2369               Asm->EmitInt8(dwarf::DW_OP_plus_uconst);
2370               Asm->EmitULEB128(DV.getAddrElement(++i));
2371             } else if (Element == DIBuilder::OpDeref) {
2372               if (!Entry.Loc.isReg())
2373                 Asm->EmitInt8(dwarf::DW_OP_deref);
2374             } else
2375               llvm_unreachable("unknown Opcode found in complex address");
2376           }
2377         }
2378       }
2379       // else ... ignore constant fp. There is not any good way to
2380       // to represent them here in dwarf.
2381       Asm->OutStreamer.EmitLabel(end);
2382     }
2383   }
2384 }
2385
2386 // Emit visible names into a debug aranges section.
2387 void DwarfDebug::emitDebugARanges() {
2388   // Start the dwarf aranges section.
2389   Asm->OutStreamer.SwitchSection(
2390                           Asm->getObjFileLowering().getDwarfARangesSection());
2391 }
2392
2393 // Emit visible names into a debug ranges section.
2394 void DwarfDebug::emitDebugRanges() {
2395   // Start the dwarf ranges section.
2396   Asm->OutStreamer.SwitchSection(
2397     Asm->getObjFileLowering().getDwarfRangesSection());
2398   unsigned char Size = Asm->getDataLayout().getPointerSize();
2399   for (SmallVectorImpl<const MCSymbol *>::iterator
2400          I = DebugRangeSymbols.begin(), E = DebugRangeSymbols.end();
2401        I != E; ++I) {
2402     if (*I)
2403       Asm->OutStreamer.EmitSymbolValue(const_cast<MCSymbol*>(*I), Size);
2404     else
2405       Asm->OutStreamer.EmitIntValue(0, Size);
2406   }
2407 }
2408
2409 // Emit visible names into a debug macinfo section.
2410 void DwarfDebug::emitDebugMacInfo() {
2411   if (const MCSection *LineInfo =
2412       Asm->getObjFileLowering().getDwarfMacroInfoSection()) {
2413     // Start the dwarf macinfo section.
2414     Asm->OutStreamer.SwitchSection(LineInfo);
2415   }
2416 }
2417
2418 // Emit inline info using following format.
2419 // Section Header:
2420 // 1. length of section
2421 // 2. Dwarf version number
2422 // 3. address size.
2423 //
2424 // Entries (one "entry" for each function that was inlined):
2425 //
2426 // 1. offset into __debug_str section for MIPS linkage name, if exists;
2427 //   otherwise offset into __debug_str for regular function name.
2428 // 2. offset into __debug_str section for regular function name.
2429 // 3. an unsigned LEB128 number indicating the number of distinct inlining
2430 // instances for the function.
2431 //
2432 // The rest of the entry consists of a {die_offset, low_pc} pair for each
2433 // inlined instance; the die_offset points to the inlined_subroutine die in the
2434 // __debug_info section, and the low_pc is the starting address for the
2435 // inlining instance.
2436 void DwarfDebug::emitDebugInlineInfo() {
2437   if (!Asm->MAI->doesDwarfUseInlineInfoSection())
2438     return;
2439
2440   if (!FirstCU)
2441     return;
2442
2443   Asm->OutStreamer.SwitchSection(
2444                         Asm->getObjFileLowering().getDwarfDebugInlineSection());
2445
2446   Asm->OutStreamer.AddComment("Length of Debug Inlined Information Entry");
2447   Asm->EmitLabelDifference(Asm->GetTempSymbol("debug_inlined_end", 1),
2448                            Asm->GetTempSymbol("debug_inlined_begin", 1), 4);
2449
2450   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_begin", 1));
2451
2452   Asm->OutStreamer.AddComment("Dwarf Version");
2453   Asm->EmitInt16(dwarf::DWARF_VERSION);
2454   Asm->OutStreamer.AddComment("Address Size (in bytes)");
2455   Asm->EmitInt8(Asm->getDataLayout().getPointerSize());
2456
2457   for (SmallVectorImpl<const MDNode *>::iterator I = InlinedSPNodes.begin(),
2458          E = InlinedSPNodes.end(); I != E; ++I) {
2459
2460     const MDNode *Node = *I;
2461     DenseMap<const MDNode *, SmallVector<InlineInfoLabels, 4> >::iterator II
2462       = InlineInfo.find(Node);
2463     SmallVectorImpl<InlineInfoLabels> &Labels = II->second;
2464     DISubprogram SP(Node);
2465     StringRef LName = SP.getLinkageName();
2466     StringRef Name = SP.getName();
2467
2468     Asm->OutStreamer.AddComment("MIPS linkage name");
2469     if (LName.empty())
2470       Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2471                              DwarfStrSectionSym);
2472     else
2473       Asm->EmitSectionOffset(InfoHolder
2474                              .getStringPoolEntry(getRealLinkageName(LName)),
2475                              DwarfStrSectionSym);
2476
2477     Asm->OutStreamer.AddComment("Function name");
2478     Asm->EmitSectionOffset(InfoHolder.getStringPoolEntry(Name),
2479                            DwarfStrSectionSym);
2480     Asm->EmitULEB128(Labels.size(), "Inline count");
2481
2482     for (SmallVectorImpl<InlineInfoLabels>::iterator LI = Labels.begin(),
2483            LE = Labels.end(); LI != LE; ++LI) {
2484       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("DIE offset");
2485       Asm->EmitInt32(LI->second->getOffset());
2486
2487       if (Asm->isVerbose()) Asm->OutStreamer.AddComment("low_pc");
2488       Asm->OutStreamer.EmitSymbolValue(LI->first,
2489                                        Asm->getDataLayout().getPointerSize());
2490     }
2491   }
2492
2493   Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("debug_inlined_end", 1));
2494 }
2495
2496 // DWARF5 Experimental Separate Dwarf emitters.
2497
2498 // This DIE has the following attributes: DW_AT_comp_dir, DW_AT_stmt_list,
2499 // DW_AT_low_pc, DW_AT_high_pc, DW_AT_ranges, DW_AT_dwo_name, DW_AT_dwo_id,
2500 // DW_AT_ranges_base, DW_AT_addr_base. If DW_AT_ranges is present,
2501 // DW_AT_low_pc and DW_AT_high_pc are not used, and vice versa.
2502 CompileUnit *DwarfDebug::constructSkeletonCU(const MDNode *N) {
2503   DICompileUnit DIUnit(N);
2504   CompilationDir = DIUnit.getDirectory();
2505
2506   DIE *Die = new DIE(dwarf::DW_TAG_compile_unit);
2507   CompileUnit *NewCU = new CompileUnit(GlobalCUIndexCount++,
2508                                        DIUnit.getLanguage(), Die, Asm,
2509                                        this, &SkeletonHolder);
2510
2511   NewCU->addLocalString(Die, dwarf::DW_AT_GNU_dwo_name,
2512                         DIUnit.getSplitDebugFilename());
2513
2514   // This should be a unique identifier when we want to build .dwp files.
2515   NewCU->addUInt(Die, dwarf::DW_AT_GNU_dwo_id, dwarf::DW_FORM_data8, 0);
2516
2517   // Relocate to the beginning of the addr_base section, else 0 for the beginning
2518   // of the one for this compile unit.
2519   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2520     NewCU->addLabel(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset,
2521                     DwarfAddrSectionSym);
2522   else
2523     NewCU->addUInt(Die, dwarf::DW_AT_GNU_addr_base, dwarf::DW_FORM_sec_offset, 0);
2524
2525   // 2.17.1 requires that we use DW_AT_low_pc for a single entry point
2526   // into an entity. We're using 0, or a NULL label for this.
2527   NewCU->addUInt(Die, dwarf::DW_AT_low_pc, dwarf::DW_FORM_addr, 0);
2528
2529   // DW_AT_stmt_list is a offset of line number information for this
2530   // compile unit in debug_line section.
2531   // FIXME: Should handle multiple compile units.
2532   if (Asm->MAI->doesDwarfUseRelocationsAcrossSections())
2533     NewCU->addLabel(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset,
2534                     DwarfLineSectionSym);
2535   else
2536     NewCU->addUInt(Die, dwarf::DW_AT_stmt_list, dwarf::DW_FORM_sec_offset, 0);
2537
2538   if (!CompilationDir.empty())
2539     NewCU->addLocalString(Die, dwarf::DW_AT_comp_dir, CompilationDir);
2540
2541   SkeletonHolder.addUnit(NewCU);
2542   SkeletonCUs.push_back(NewCU);
2543
2544   return NewCU;
2545 }
2546
2547 void DwarfDebug::emitSkeletonAbbrevs(const MCSection *Section) {
2548   assert(useSplitDwarf() && "No split dwarf debug info?");
2549   emitAbbrevs(Section, &SkeletonAbbrevs);
2550 }
2551
2552 // Emit the .debug_info.dwo section for separated dwarf. This contains the
2553 // compile units that would normally be in debug_info.
2554 void DwarfDebug::emitDebugInfoDWO() {
2555   assert(useSplitDwarf() && "No split dwarf debug info?");
2556   InfoHolder.emitUnits(this, Asm->getObjFileLowering().getDwarfInfoDWOSection(),
2557                        Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2558                        DwarfAbbrevDWOSectionSym);
2559 }
2560
2561 // Emit the .debug_abbrev.dwo section for separated dwarf. This contains the
2562 // abbreviations for the .debug_info.dwo section.
2563 void DwarfDebug::emitDebugAbbrevDWO() {
2564   assert(useSplitDwarf() && "No split dwarf?");
2565   emitAbbrevs(Asm->getObjFileLowering().getDwarfAbbrevDWOSection(),
2566               &Abbreviations);
2567 }
2568
2569 // Emit the .debug_str.dwo section for separated dwarf. This contains the
2570 // string section and is identical in format to traditional .debug_str
2571 // sections.
2572 void DwarfDebug::emitDebugStrDWO() {
2573   assert(useSplitDwarf() && "No split dwarf?");
2574   const MCSection *OffSec = Asm->getObjFileLowering()
2575                             .getDwarfStrOffDWOSection();
2576   const MCSymbol *StrSym = DwarfStrSectionSym;
2577   InfoHolder.emitStrings(Asm->getObjFileLowering().getDwarfStrDWOSection(),
2578                          OffSec, StrSym);
2579 }