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