lib/CodeGen/AsmPrinter/DwarfDebug.cpp

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