lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

   1 //===-- llvm/CodeGen/DwarfCompileUnit.cpp - Dwarf Compile Unit ------------===//
   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 compile unit.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #define DEBUG_TYPE "dwarfdebug"
  15
  16 #include "DwarfAccelTable.h"
  17 #include "DwarfCompileUnit.h"
  18 #include "DwarfDebug.h"
  19 #include "llvm/Constants.h"
  20 #include "llvm/GlobalVariable.h"
  21 #include "llvm/Instructions.h"
  22 #include "llvm/Analysis/DIBuilder.h"
  23 #include "llvm/Support/Debug.h"
  24 #include "llvm/Target/Mangler.h"
  25 #include "llvm/Target/TargetData.h"
  26 #include "llvm/Target/TargetFrameLowering.h"
  27 #include "llvm/Target/TargetMachine.h"
  28 #include "llvm/Target/TargetRegisterInfo.h"
  29 #include "llvm/ADT/APFloat.h"
  30 #include "llvm/Support/ErrorHandling.h"
  31
  32 using namespace llvm;
  33
  34 /// CompileUnit - Compile unit constructor.
  35 CompileUnit::CompileUnit(unsigned I, unsigned L, DIE *D, AsmPrinter *A,
  36                          DwarfDebug *DW)
  37   : ID(I), Language(L), CUDie(D), Asm(A), DD(DW), IndexTyDie(0) {
  38   DIEIntegerOne = new (DIEValueAllocator) DIEInteger(1);
  39 }
  40
  41 /// ~CompileUnit - Destructor for compile unit.
  42 CompileUnit::~CompileUnit() {
  43   for (unsigned j = 0, M = DIEBlocks.size(); j < M; ++j)
  44     DIEBlocks[j]->~DIEBlock();
  45 }
  46
  47 /// createDIEEntry - Creates a new DIEEntry to be a proxy for a debug
  48 /// information entry.
  49 DIEEntry *CompileUnit::createDIEEntry(DIE *Entry) {
  50   DIEEntry *Value = new (DIEValueAllocator) DIEEntry(Entry);
  51   return Value;
  52 }
  53
  54 /// addUInt - Add an unsigned integer attribute data and value.
  55 ///
  56 void CompileUnit::addUInt(DIE *Die, unsigned Attribute,
  57                           unsigned Form, uint64_t Integer) {
  58   if (!Form) Form = DIEInteger::BestForm(false, Integer);
  59   DIEValue *Value = Integer == 1 ?
  60     DIEIntegerOne : new (DIEValueAllocator) DIEInteger(Integer);
  61   Die->addValue(Attribute, Form, Value);
  62 }
  63
  64 /// addSInt - Add an signed integer attribute data and value.
  65 ///
  66 void CompileUnit::addSInt(DIE *Die, unsigned Attribute,
  67                           unsigned Form, int64_t Integer) {
  68   if (!Form) Form = DIEInteger::BestForm(true, Integer);
  69   DIEValue *Value = new (DIEValueAllocator) DIEInteger(Integer);
  70   Die->addValue(Attribute, Form, Value);
  71 }
  72
  73 /// addString - Add a string attribute data and value. We always emit a
  74 /// reference to the string pool instead of immediate strings so that DIEs have
  75 /// more predictable sizes.
  76 void CompileUnit::addString(DIE *Die, unsigned Attribute, StringRef String) {
  77   MCSymbol *Symb = DD->getStringPoolEntry(String);
  78   DIEValue *Value;
  79   if (Asm->needsRelocationsForDwarfStringPool())
  80     Value = new (DIEValueAllocator) DIELabel(Symb);
  81   else {
  82     MCSymbol *StringPool = DD->getStringPool();
  83     Value = new (DIEValueAllocator) DIEDelta(Symb, StringPool);
  84   }
  85   Die->addValue(Attribute, dwarf::DW_FORM_strp, Value);
  86 }
  87
  88 /// addLabel - Add a Dwarf label attribute data and value.
  89 ///
  90 void CompileUnit::addLabel(DIE *Die, unsigned Attribute, unsigned Form,
  91                            const MCSymbol *Label) {
  92   DIEValue *Value = new (DIEValueAllocator) DIELabel(Label);
  93   Die->addValue(Attribute, Form, Value);
  94 }
  95
  96 /// addDelta - Add a label delta attribute data and value.
  97 ///
  98 void CompileUnit::addDelta(DIE *Die, unsigned Attribute, unsigned Form,
  99                            const MCSymbol *Hi, const MCSymbol *Lo) {
 100   DIEValue *Value = new (DIEValueAllocator) DIEDelta(Hi, Lo);
 101   Die->addValue(Attribute, Form, Value);
 102 }
 103
 104 /// addDIEEntry - Add a DIE attribute data and value.
 105 ///
 106 void CompileUnit::addDIEEntry(DIE *Die, unsigned Attribute, unsigned Form,
 107                               DIE *Entry) {
 108   Die->addValue(Attribute, Form, createDIEEntry(Entry));
 109 }
 110
 111 /// addBlock - Add block data.
 112 ///
 113 void CompileUnit::addBlock(DIE *Die, unsigned Attribute, unsigned Form,
 114                            DIEBlock *Block) {
 115   Block->ComputeSize(Asm);
 116   DIEBlocks.push_back(Block); // Memoize so we can call the destructor later on.
 117   Die->addValue(Attribute, Block->BestForm(), Block);
 118 }
 119
 120 /// addSourceLine - Add location information to specified debug information
 121 /// entry.
 122 void CompileUnit::addSourceLine(DIE *Die, DIVariable V) {
 123   // Verify variable.
 124   if (!V.Verify())
 125     return;
 126
 127   unsigned Line = V.getLineNumber();
 128   if (Line == 0)
 129     return;
 130   unsigned FileID = DD->GetOrCreateSourceID(V.getContext().getFilename(),
 131                                             V.getContext().getDirectory());
 132   assert(FileID && "Invalid file id");
 133   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 134   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 135 }
 136
 137 /// addSourceLine - Add location information to specified debug information
 138 /// entry.
 139 void CompileUnit::addSourceLine(DIE *Die, DIGlobalVariable G) {
 140   // Verify global variable.
 141   if (!G.Verify())
 142     return;
 143
 144   unsigned Line = G.getLineNumber();
 145   if (Line == 0)
 146     return;
 147   unsigned FileID = DD->GetOrCreateSourceID(G.getFilename(), G.getDirectory());
 148   assert(FileID && "Invalid file id");
 149   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 150   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 151 }
 152
 153 /// addSourceLine - Add location information to specified debug information
 154 /// entry.
 155 void CompileUnit::addSourceLine(DIE *Die, DISubprogram SP) {
 156   // Verify subprogram.
 157   if (!SP.Verify())
 158     return;
 159
 160   // If the line number is 0, don't add it.
 161   unsigned Line = SP.getLineNumber();
 162   if (Line == 0)
 163     return;
 164
 165   unsigned FileID = DD->GetOrCreateSourceID(SP.getFilename(),
 166                                             SP.getDirectory());
 167   assert(FileID && "Invalid file id");
 168   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 169   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 170 }
 171
 172 /// addSourceLine - Add location information to specified debug information
 173 /// entry.
 174 void CompileUnit::addSourceLine(DIE *Die, DIType Ty) {
 175   // Verify type.
 176   if (!Ty.Verify())
 177     return;
 178
 179   unsigned Line = Ty.getLineNumber();
 180   if (Line == 0)
 181     return;
 182   unsigned FileID = DD->GetOrCreateSourceID(Ty.getFilename(),
 183                                             Ty.getDirectory());
 184   assert(FileID && "Invalid file id");
 185   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 186   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 187 }
 188
 189 /// addSourceLine - Add location information to specified debug information
 190 /// entry.
 191 void CompileUnit::addSourceLine(DIE *Die, DIObjCProperty Ty) {
 192   // Verify type.
 193   if (!Ty.Verify())
 194     return;
 195
 196   unsigned Line = Ty.getLineNumber();
 197   if (Line == 0)
 198     return;
 199   DIFile File = Ty.getFile();
 200   unsigned FileID = DD->GetOrCreateSourceID(File.getFilename(),
 201                                             File.getDirectory());
 202   assert(FileID && "Invalid file id");
 203   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 204   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 205 }
 206
 207 /// addSourceLine - Add location information to specified debug information
 208 /// entry.
 209 void CompileUnit::addSourceLine(DIE *Die, DINameSpace NS) {
 210   // Verify namespace.
 211   if (!NS.Verify())
 212     return;
 213
 214   unsigned Line = NS.getLineNumber();
 215   if (Line == 0)
 216     return;
 217   StringRef FN = NS.getFilename();
 218
 219   unsigned FileID = DD->GetOrCreateSourceID(FN, NS.getDirectory());
 220   assert(FileID && "Invalid file id");
 221   addUInt(Die, dwarf::DW_AT_decl_file, 0, FileID);
 222   addUInt(Die, dwarf::DW_AT_decl_line, 0, Line);
 223 }
 224
 225 /// addVariableAddress - Add DW_AT_location attribute for a
 226 /// DbgVariable based on provided MachineLocation.
 227 void CompileUnit::addVariableAddress(DbgVariable *&DV, DIE *Die,
 228                                      MachineLocation Location) {
 229   if (DV->variableHasComplexAddress())
 230     addComplexAddress(DV, Die, dwarf::DW_AT_location, Location);
 231   else if (DV->isBlockByrefVariable())
 232     addBlockByrefAddress(DV, Die, dwarf::DW_AT_location, Location);
 233   else
 234     addAddress(Die, dwarf::DW_AT_location, Location);
 235 }
 236
 237 /// addRegisterOp - Add register operand.
 238 void CompileUnit::addRegisterOp(DIE *TheDie, unsigned Reg) {
 239   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 240   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 241   if (DWReg < 32)
 242     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + DWReg);
 243   else {
 244     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 245     addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
 246   }
 247 }
 248
 249 /// addRegisterOffset - Add register offset.
 250 void CompileUnit::addRegisterOffset(DIE *TheDie, unsigned Reg,
 251                                     int64_t Offset) {
 252   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 253   unsigned DWReg = RI->getDwarfRegNum(Reg, false);
 254   const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
 255   if (Reg == TRI->getFrameRegister(*Asm->MF))
 256     // If variable offset is based in frame register then use fbreg.
 257     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_fbreg);
 258   else if (DWReg < 32)
 259     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + DWReg);
 260   else {
 261     addUInt(TheDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 262     addUInt(TheDie, 0, dwarf::DW_FORM_udata, DWReg);
 263   }
 264   addSInt(TheDie, 0, dwarf::DW_FORM_sdata, Offset);
 265 }
 266
 267 /// addAddress - Add an address attribute to a die based on the location
 268 /// provided.
 269 void CompileUnit::addAddress(DIE *Die, unsigned Attribute,
 270                              const MachineLocation &Location) {
 271   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 272
 273   if (Location.isReg())
 274     addRegisterOp(Block, Location.getReg());
 275   else
 276     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
 277
 278   // Now attach the location information to the DIE.
 279   addBlock(Die, Attribute, 0, Block);
 280 }
 281
 282 /// addComplexAddress - Start with the address based on the location provided,
 283 /// and generate the DWARF information necessary to find the actual variable
 284 /// given the extra address information encoded in the DIVariable, starting from
 285 /// the starting location.  Add the DWARF information to the die.
 286 ///
 287 void CompileUnit::addComplexAddress(DbgVariable *&DV, DIE *Die,
 288                                     unsigned Attribute,
 289                                     const MachineLocation &Location) {
 290   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 291   unsigned N = DV->getNumAddrElements();
 292   unsigned i = 0;
 293   if (Location.isReg()) {
 294     if (N >= 2 && DV->getAddrElement(0) == DIBuilder::OpPlus) {
 295       // If first address element is OpPlus then emit
 296       // DW_OP_breg + Offset instead of DW_OP_reg + Offset.
 297       addRegisterOffset(Block, Location.getReg(), DV->getAddrElement(1));
 298       i = 2;
 299     } else
 300       addRegisterOp(Block, Location.getReg());
 301   }
 302   else
 303     addRegisterOffset(Block, Location.getReg(), Location.getOffset());
 304
 305   for (;i < N; ++i) {
 306     uint64_t Element = DV->getAddrElement(i);
 307     if (Element == DIBuilder::OpPlus) {
 308       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 309       addUInt(Block, 0, dwarf::DW_FORM_udata, DV->getAddrElement(++i));
 310     } else if (Element == DIBuilder::OpDeref) {
 311       if (!Location.isReg())
 312         addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 313     } else llvm_unreachable("unknown DIBuilder Opcode");
 314   }
 315
 316   // Now attach the location information to the DIE.
 317   addBlock(Die, Attribute, 0, Block);
 318 }
 319
 320 /* Byref variables, in Blocks, are declared by the programmer as "SomeType
 321    VarName;", but the compiler creates a __Block_byref_x_VarName struct, and
 322    gives the variable VarName either the struct, or a pointer to the struct, as
 323    its type.  This is necessary for various behind-the-scenes things the
 324    compiler needs to do with by-reference variables in Blocks.
 325
 326    However, as far as the original *programmer* is concerned, the variable
 327    should still have type 'SomeType', as originally declared.
 328
 329    The function getBlockByrefType dives into the __Block_byref_x_VarName
 330    struct to find the original type of the variable, which is then assigned to
 331    the variable's Debug Information Entry as its real type.  So far, so good.
 332    However now the debugger will expect the variable VarName to have the type
 333    SomeType.  So we need the location attribute for the variable to be an
 334    expression that explains to the debugger how to navigate through the
 335    pointers and struct to find the actual variable of type SomeType.
 336
 337    The following function does just that.  We start by getting
 338    the "normal" location for the variable. This will be the location
 339    of either the struct __Block_byref_x_VarName or the pointer to the
 340    struct __Block_byref_x_VarName.
 341
 342    The struct will look something like:
 343
 344    struct __Block_byref_x_VarName {
 345      ... <various fields>
 346      struct __Block_byref_x_VarName *forwarding;
 347      ... <various other fields>
 348      SomeType VarName;
 349      ... <maybe more fields>
 350    };
 351
 352    If we are given the struct directly (as our starting point) we
 353    need to tell the debugger to:
 354
 355    1).  Add the offset of the forwarding field.
 356
 357    2).  Follow that pointer to get the real __Block_byref_x_VarName
 358    struct to use (the real one may have been copied onto the heap).
 359
 360    3).  Add the offset for the field VarName, to find the actual variable.
 361
 362    If we started with a pointer to the struct, then we need to
 363    dereference that pointer first, before the other steps.
 364    Translating this into DWARF ops, we will need to append the following
 365    to the current location description for the variable:
 366
 367    DW_OP_deref                    -- optional, if we start with a pointer
 368    DW_OP_plus_uconst <forward_fld_offset>
 369    DW_OP_deref
 370    DW_OP_plus_uconst <varName_fld_offset>
 371
 372    That is what this function does.  */
 373
 374 /// addBlockByrefAddress - Start with the address based on the location
 375 /// provided, and generate the DWARF information necessary to find the
 376 /// actual Block variable (navigating the Block struct) based on the
 377 /// starting location.  Add the DWARF information to the die.  For
 378 /// more information, read large comment just above here.
 379 ///
 380 void CompileUnit::addBlockByrefAddress(DbgVariable *&DV, DIE *Die,
 381                                        unsigned Attribute,
 382                                        const MachineLocation &Location) {
 383   DIType Ty = DV->getType();
 384   DIType TmpTy = Ty;
 385   unsigned Tag = Ty.getTag();
 386   bool isPointer = false;
 387
 388   StringRef varName = DV->getName();
 389
 390   if (Tag == dwarf::DW_TAG_pointer_type) {
 391     DIDerivedType DTy = DIDerivedType(Ty);
 392     TmpTy = DTy.getTypeDerivedFrom();
 393     isPointer = true;
 394   }
 395
 396   DICompositeType blockStruct = DICompositeType(TmpTy);
 397
 398   // Find the __forwarding field and the variable field in the __Block_byref
 399   // struct.
 400   DIArray Fields = blockStruct.getTypeArray();
 401   DIDescriptor varField = DIDescriptor();
 402   DIDescriptor forwardingField = DIDescriptor();
 403
 404   for (unsigned i = 0, N = Fields.getNumElements(); i < N; ++i) {
 405     DIDescriptor Element = Fields.getElement(i);
 406     DIDerivedType DT = DIDerivedType(Element);
 407     StringRef fieldName = DT.getName();
 408     if (fieldName == "__forwarding")
 409       forwardingField = Element;
 410     else if (fieldName == varName)
 411       varField = Element;
 412   }
 413
 414   // Get the offsets for the forwarding field and the variable field.
 415   unsigned forwardingFieldOffset =
 416     DIDerivedType(forwardingField).getOffsetInBits() >> 3;
 417   unsigned varFieldOffset =
 418     DIDerivedType(varField).getOffsetInBits() >> 3;
 419
 420   // Decode the original location, and use that as the start of the byref
 421   // variable's location.
 422   const TargetRegisterInfo *RI = Asm->TM.getRegisterInfo();
 423   unsigned Reg = RI->getDwarfRegNum(Location.getReg(), false);
 424   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 425
 426   if (Location.isReg()) {
 427     if (Reg < 32)
 428       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_reg0 + Reg);
 429     else {
 430       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_regx);
 431       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 432     }
 433   } else {
 434     if (Reg < 32)
 435       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_breg0 + Reg);
 436     else {
 437       addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_bregx);
 438       addUInt(Block, 0, dwarf::DW_FORM_udata, Reg);
 439     }
 440
 441     addUInt(Block, 0, dwarf::DW_FORM_sdata, Location.getOffset());
 442   }
 443
 444   // If we started with a pointer to the __Block_byref... struct, then
 445   // the first thing we need to do is dereference the pointer (DW_OP_deref).
 446   if (isPointer)
 447     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 448
 449   // Next add the offset for the '__forwarding' field:
 450   // DW_OP_plus_uconst ForwardingFieldOffset.  Note there's no point in
 451   // adding the offset if it's 0.
 452   if (forwardingFieldOffset > 0) {
 453     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 454     addUInt(Block, 0, dwarf::DW_FORM_udata, forwardingFieldOffset);
 455   }
 456
 457   // Now dereference the __forwarding field to get to the real __Block_byref
 458   // struct:  DW_OP_deref.
 459   addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
 460
 461   // Now that we've got the real __Block_byref... struct, add the offset
 462   // for the variable's field to get to the location of the actual variable:
 463   // DW_OP_plus_uconst varFieldOffset.  Again, don't add if it's 0.
 464   if (varFieldOffset > 0) {
 465     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
 466     addUInt(Block, 0, dwarf::DW_FORM_udata, varFieldOffset);
 467   }
 468
 469   // Now attach the location information to the DIE.
 470   addBlock(Die, Attribute, 0, Block);
 471 }
 472
 473 /// isTypeSigned - Return true if the type is signed.
 474 static bool isTypeSigned(DIType Ty, int *SizeInBits) {
 475   if (Ty.isDerivedType())
 476     return isTypeSigned(DIDerivedType(Ty).getTypeDerivedFrom(), SizeInBits);
 477   if (Ty.isBasicType())
 478     if (DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed
 479         || DIBasicType(Ty).getEncoding() == dwarf::DW_ATE_signed_char) {
 480       *SizeInBits = Ty.getSizeInBits();
 481       return true;
 482     }
 483   return false;
 484 }
 485
 486 /// addConstantValue - Add constant value entry in variable DIE.
 487 bool CompileUnit::addConstantValue(DIE *Die, const MachineOperand &MO,
 488                                    DIType Ty) {
 489   assert(MO.isImm() && "Invalid machine operand!");
 490   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 491   int SizeInBits = -1;
 492   bool SignedConstant = isTypeSigned(Ty, &SizeInBits);
 493   unsigned Form = SignedConstant ? dwarf::DW_FORM_sdata : dwarf::DW_FORM_udata;
 494   switch (SizeInBits) {
 495     case 8:  Form = dwarf::DW_FORM_data1; break;
 496     case 16: Form = dwarf::DW_FORM_data2; break;
 497     case 32: Form = dwarf::DW_FORM_data4; break;
 498     case 64: Form = dwarf::DW_FORM_data8; break;
 499     default: break;
 500   }
 501   SignedConstant ? addSInt(Block, 0, Form, MO.getImm())
 502     : addUInt(Block, 0, Form, MO.getImm());
 503
 504   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 505   return true;
 506 }
 507
 508 /// addConstantFPValue - Add constant value entry in variable DIE.
 509 bool CompileUnit::addConstantFPValue(DIE *Die, const MachineOperand &MO) {
 510   assert (MO.isFPImm() && "Invalid machine operand!");
 511   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 512   APFloat FPImm = MO.getFPImm()->getValueAPF();
 513
 514   // Get the raw data form of the floating point.
 515   const APInt FltVal = FPImm.bitcastToAPInt();
 516   const char *FltPtr = (const char*)FltVal.getRawData();
 517
 518   int NumBytes = FltVal.getBitWidth() / 8; // 8 bits per byte.
 519   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 520   int Incr = (LittleEndian ? 1 : -1);
 521   int Start = (LittleEndian ? 0 : NumBytes - 1);
 522   int Stop = (LittleEndian ? NumBytes : -1);
 523
 524   // Output the constant to DWARF one byte at a time.
 525   for (; Start != Stop; Start += Incr)
 526     addUInt(Block, 0, dwarf::DW_FORM_data1,
 527             (unsigned char)0xFF & FltPtr[Start]);
 528
 529   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 530   return true;
 531 }
 532
 533 /// addConstantValue - Add constant value entry in variable DIE.
 534 bool CompileUnit::addConstantValue(DIE *Die, const ConstantInt *CI,
 535                                    bool Unsigned) {
 536   unsigned CIBitWidth = CI->getBitWidth();
 537   if (CIBitWidth <= 64) {
 538     unsigned form = 0;
 539     switch (CIBitWidth) {
 540     case 8: form = dwarf::DW_FORM_data1; break;
 541     case 16: form = dwarf::DW_FORM_data2; break;
 542     case 32: form = dwarf::DW_FORM_data4; break;
 543     case 64: form = dwarf::DW_FORM_data8; break;
 544     default:
 545       form = Unsigned ? dwarf::DW_FORM_udata : dwarf::DW_FORM_sdata;
 546     }
 547     if (Unsigned)
 548       addUInt(Die, dwarf::DW_AT_const_value, form, CI->getZExtValue());
 549     else
 550       addSInt(Die, dwarf::DW_AT_const_value, form, CI->getSExtValue());
 551     return true;
 552   }
 553
 554   DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
 555
 556   // Get the raw data form of the large APInt.
 557   const APInt Val = CI->getValue();
 558   const uint64_t *Ptr64 = Val.getRawData();
 559
 560   int NumBytes = Val.getBitWidth() / 8; // 8 bits per byte.
 561   bool LittleEndian = Asm->getTargetData().isLittleEndian();
 562
 563   // Output the constant to DWARF one byte at a time.
 564   for (int i = 0; i < NumBytes; i++) {
 565     uint8_t c;
 566     if (LittleEndian)
 567       c = Ptr64[i / 8] >> (8 * (i & 7));
 568     else
 569       c = Ptr64[(NumBytes - 1 - i) / 8] >> (8 * ((NumBytes - 1 - i) & 7));
 570     addUInt(Block, 0, dwarf::DW_FORM_data1, c);
 571   }
 572
 573   addBlock(Die, dwarf::DW_AT_const_value, 0, Block);
 574   return true;
 575 }
 576
 577 /// addTemplateParams - Add template parameters in buffer.
 578 void CompileUnit::addTemplateParams(DIE &Buffer, DIArray TParams) {
 579   // Add template parameters.
 580   for (unsigned i = 0, e = TParams.getNumElements(); i != e; ++i) {
 581     DIDescriptor Element = TParams.getElement(i);
 582     if (Element.isTemplateTypeParameter())
 583       Buffer.addChild(getOrCreateTemplateTypeParameterDIE(
 584                         DITemplateTypeParameter(Element)));
 585     else if (Element.isTemplateValueParameter())
 586       Buffer.addChild(getOrCreateTemplateValueParameterDIE(
 587                         DITemplateValueParameter(Element)));
 588   }
 589 }
 590
 591 /// addToContextOwner - Add Die into the list of its context owner's children.
 592 void CompileUnit::addToContextOwner(DIE *Die, DIDescriptor Context) {
 593   if (Context.isType()) {
 594     DIE *ContextDIE = getOrCreateTypeDIE(DIType(Context));
 595     ContextDIE->addChild(Die);
 596   } else if (Context.isNameSpace()) {
 597     DIE *ContextDIE = getOrCreateNameSpace(DINameSpace(Context));
 598     ContextDIE->addChild(Die);
 599   } else if (Context.isSubprogram()) {
 600     DIE *ContextDIE = getOrCreateSubprogramDIE(DISubprogram(Context));
 601     ContextDIE->addChild(Die);
 602   } else if (DIE *ContextDIE = getDIE(Context))
 603     ContextDIE->addChild(Die);
 604   else
 605     addDie(Die);
 606 }
 607
 608 /// getOrCreateTypeDIE - Find existing DIE or create new DIE for the
 609 /// given DIType.
 610 DIE *CompileUnit::getOrCreateTypeDIE(const MDNode *TyNode) {
 611   DIType Ty(TyNode);
 612   if (!Ty.Verify())
 613     return NULL;
 614   DIE *TyDIE = getDIE(Ty);
 615   if (TyDIE)
 616     return TyDIE;
 617
 618   // Create new type.
 619   TyDIE = new DIE(dwarf::DW_TAG_base_type);
 620   insertDIE(Ty, TyDIE);
 621   if (Ty.isBasicType())
 622     constructTypeDIE(*TyDIE, DIBasicType(Ty));
 623   else if (Ty.isCompositeType())
 624     constructTypeDIE(*TyDIE, DICompositeType(Ty));
 625   else {
 626     assert(Ty.isDerivedType() && "Unknown kind of DIType");
 627     constructTypeDIE(*TyDIE, DIDerivedType(Ty));
 628   }
 629   // If this is a named finished type then include it in the list of types
 630   // for the accelerator tables.
 631   if (!Ty.getName().empty() && !Ty.isForwardDecl()) {
 632     bool IsImplementation = 0;
 633     if (Ty.isCompositeType()) {
 634       DICompositeType CT(Ty);
 635       // A runtime language of 0 actually means C/C++ and that any
 636       // non-negative value is some version of Objective-C/C++.
 637       IsImplementation = (CT.getRunTimeLang() == 0) ||
 638         CT.isObjcClassComplete();
 639     }
 640     unsigned Flags = IsImplementation ?
 641                      DwarfAccelTable::eTypeFlagClassIsImplementation : 0;
 642     addAccelType(Ty.getName(), std::make_pair(TyDIE, Flags));
 643   }
 644
 645   addToContextOwner(TyDIE, Ty.getContext());
 646   return TyDIE;
 647 }
 648
 649 /// addType - Add a new type attribute to the specified entity.
 650 void CompileUnit::addType(DIE *Entity, DIType Ty,
 651                           unsigned Attribute) {
 652   if (!Ty.Verify())
 653     return;
 654
 655   // Check for pre-existence.
 656   DIEEntry *Entry = getDIEEntry(Ty);
 657   // If it exists then use the existing value.
 658   if (Entry) {
 659     Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
 660     return;
 661   }
 662
 663   // Construct type.
 664   DIE *Buffer = getOrCreateTypeDIE(Ty);
 665
 666   // Set up proxy.
 667   Entry = createDIEEntry(Buffer);
 668   insertDIEEntry(Ty, Entry);
 669   Entity->addValue(Attribute, dwarf::DW_FORM_ref4, Entry);
 670
 671   // If this is a complete composite type then include it in the
 672   // list of global types.
 673   addGlobalType(Ty);
 674 }
 675
 676 /// addGlobalType - Add a new global type to the compile unit.
 677 ///
 678 void CompileUnit::addGlobalType(DIType Ty) {
 679   DIDescriptor Context = Ty.getContext();
 680   if (Ty.isCompositeType() && !Ty.getName().empty() && !Ty.isForwardDecl()
 681       && (!Context || Context.isCompileUnit() || Context.isFile()
 682           || Context.isNameSpace()))
 683     if (DIEEntry *Entry = getDIEEntry(Ty))
 684       GlobalTypes[Ty.getName()] = Entry->getEntry();
 685 }
 686
 687 /// addPubTypes - Add type for pubtypes section.
 688 void CompileUnit::addPubTypes(DISubprogram SP) {
 689   DICompositeType SPTy = SP.getType();
 690   unsigned SPTag = SPTy.getTag();
 691   if (SPTag != dwarf::DW_TAG_subroutine_type)
 692     return;
 693
 694   DIArray Args = SPTy.getTypeArray();
 695   for (unsigned i = 0, e = Args.getNumElements(); i != e; ++i) {
 696     DIType ATy(Args.getElement(i));
 697     if (!ATy.Verify())
 698       continue;
 699     addGlobalType(ATy);
 700   }
 701 }
 702
 703 /// constructTypeDIE - Construct basic type die from DIBasicType.
 704 void CompileUnit::constructTypeDIE(DIE &Buffer, DIBasicType BTy) {
 705   // Get core information.
 706   StringRef Name = BTy.getName();
 707   // Add name if not anonymous or intermediate type.
 708   if (!Name.empty())
 709     addString(&Buffer, dwarf::DW_AT_name, Name);
 710
 711   if (BTy.getTag() == dwarf::DW_TAG_unspecified_type) {
 712     Buffer.setTag(dwarf::DW_TAG_unspecified_type);
 713     // Unspecified types has only name, nothing else.
 714     return;
 715   }
 716
 717   Buffer.setTag(dwarf::DW_TAG_base_type);
 718   addUInt(&Buffer, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
 719           BTy.getEncoding());
 720
 721   uint64_t Size = BTy.getSizeInBits() >> 3;
 722   addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 723 }
 724
 725 /// constructTypeDIE - Construct derived type die from DIDerivedType.
 726 void CompileUnit::constructTypeDIE(DIE &Buffer, DIDerivedType DTy) {
 727   // Get core information.
 728   StringRef Name = DTy.getName();
 729   uint64_t Size = DTy.getSizeInBits() >> 3;
 730   unsigned Tag = DTy.getTag();
 731
 732   // FIXME - Workaround for templates.
 733   if (Tag == dwarf::DW_TAG_inheritance) Tag = dwarf::DW_TAG_reference_type;
 734
 735   Buffer.setTag(Tag);
 736
 737   // Map to main type, void will not have a type.
 738   DIType FromTy = DTy.getTypeDerivedFrom();
 739   addType(&Buffer, FromTy);
 740
 741   // Add name if not anonymous or intermediate type.
 742   if (!Name.empty())
 743     addString(&Buffer, dwarf::DW_AT_name, Name);
 744
 745   // Add size if non-zero (derived types might be zero-sized.)
 746   if (Size && Tag != dwarf::DW_TAG_pointer_type)
 747     addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 748
 749   // Add source line info if available and TyDesc is not a forward declaration.
 750   if (!DTy.isForwardDecl())
 751     addSourceLine(&Buffer, DTy);
 752 }
 753
 754 /// constructTypeDIE - Construct type DIE from DICompositeType.
 755 void CompileUnit::constructTypeDIE(DIE &Buffer, DICompositeType CTy) {
 756   // Get core information.
 757   StringRef Name = CTy.getName();
 758
 759   uint64_t Size = CTy.getSizeInBits() >> 3;
 760   unsigned Tag = CTy.getTag();
 761   Buffer.setTag(Tag);
 762
 763   switch (Tag) {
 764   case dwarf::DW_TAG_vector_type:
 765   case dwarf::DW_TAG_array_type:
 766     constructArrayTypeDIE(Buffer, &CTy);
 767     break;
 768   case dwarf::DW_TAG_enumeration_type: {
 769     DIArray Elements = CTy.getTypeArray();
 770
 771     // Add enumerators to enumeration type.
 772     for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
 773       DIE *ElemDie = NULL;
 774       DIDescriptor Enum(Elements.getElement(i));
 775       if (Enum.isEnumerator()) {
 776         ElemDie = constructEnumTypeDIE(DIEnumerator(Enum));
 777         Buffer.addChild(ElemDie);
 778       }
 779     }
 780   }
 781     break;
 782   case dwarf::DW_TAG_subroutine_type: {
 783     // Add return type.
 784     DIArray Elements = CTy.getTypeArray();
 785     DIDescriptor RTy = Elements.getElement(0);
 786     addType(&Buffer, DIType(RTy));
 787
 788     bool isPrototyped = true;
 789     // Add arguments.
 790     for (unsigned i = 1, N = Elements.getNumElements(); i < N; ++i) {
 791       DIDescriptor Ty = Elements.getElement(i);
 792       if (Ty.isUnspecifiedParameter()) {
 793         DIE *Arg = new DIE(dwarf::DW_TAG_unspecified_parameters);
 794         Buffer.addChild(Arg);
 795         isPrototyped = false;
 796       } else {
 797         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
 798         addType(Arg, DIType(Ty));
 799         Buffer.addChild(Arg);
 800       }
 801     }
 802     // Add prototype flag if we're dealing with a C language and the
 803     // function has been prototyped.
 804     if (isPrototyped &&
 805         (Language == dwarf::DW_LANG_C89 ||
 806          Language == dwarf::DW_LANG_C99 ||
 807          Language == dwarf::DW_LANG_ObjC))
 808       addUInt(&Buffer, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
 809   }
 810     break;
 811   case dwarf::DW_TAG_structure_type:
 812   case dwarf::DW_TAG_union_type:
 813   case dwarf::DW_TAG_class_type: {
 814     // Add elements to structure type.
 815     DIArray Elements = CTy.getTypeArray();
 816
 817     // A forward struct declared type may not have elements available.
 818     unsigned N = Elements.getNumElements();
 819     if (N == 0)
 820       break;
 821
 822     // Add elements to structure type.
 823     for (unsigned i = 0; i < N; ++i) {
 824       DIDescriptor Element = Elements.getElement(i);
 825       DIE *ElemDie = NULL;
 826       if (Element.isSubprogram()) {
 827         DISubprogram SP(Element);
 828         ElemDie = getOrCreateSubprogramDIE(DISubprogram(Element));
 829         if (SP.isProtected())
 830           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 831                   dwarf::DW_ACCESS_protected);
 832         else if (SP.isPrivate())
 833           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 834                   dwarf::DW_ACCESS_private);
 835         else
 836           addUInt(ElemDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
 837             dwarf::DW_ACCESS_public);
 838         if (SP.isExplicit())
 839           addUInt(ElemDie, dwarf::DW_AT_explicit, dwarf::DW_FORM_flag, 1);
 840       }
 841       else if (Element.isVariable()) {
 842         DIVariable DV(Element);
 843         ElemDie = new DIE(dwarf::DW_TAG_variable);
 844         addString(ElemDie, dwarf::DW_AT_name, DV.getName());
 845         addType(ElemDie, DV.getType());
 846         addUInt(ElemDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 847         addUInt(ElemDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
 848         addSourceLine(ElemDie, DV);
 849       } else if (Element.isDerivedType()) {
 850         DIDerivedType DDTy(Element);
 851         if (DDTy.getTag() == dwarf::DW_TAG_friend) {
 852           ElemDie = new DIE(dwarf::DW_TAG_friend);
 853           addType(ElemDie, DDTy.getTypeDerivedFrom(), dwarf::DW_AT_friend);
 854         } else
 855           ElemDie = createMemberDIE(DIDerivedType(Element));
 856       } else if (Element.isObjCProperty()) {
 857         DIObjCProperty Property(Element);
 858         ElemDie = new DIE(Property.getTag());
 859         StringRef PropertyName = Property.getObjCPropertyName();
 860         addString(ElemDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
 861         addType(ElemDie, Property.getType());
 862         addSourceLine(ElemDie, Property);
 863         StringRef GetterName = Property.getObjCPropertyGetterName();
 864         if (!GetterName.empty())
 865           addString(ElemDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
 866         StringRef SetterName = Property.getObjCPropertySetterName();
 867         if (!SetterName.empty())
 868           addString(ElemDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
 869         unsigned PropertyAttributes = 0;
 870         if (Property.isReadOnlyObjCProperty())
 871           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
 872         if (Property.isReadWriteObjCProperty())
 873           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
 874         if (Property.isAssignObjCProperty())
 875           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
 876         if (Property.isRetainObjCProperty())
 877           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
 878         if (Property.isCopyObjCProperty())
 879           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
 880         if (Property.isNonAtomicObjCProperty())
 881           PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
 882         if (PropertyAttributes)
 883           addUInt(ElemDie, dwarf::DW_AT_APPLE_property_attribute, 0,
 884                  PropertyAttributes);
 885
 886         DIEEntry *Entry = getDIEEntry(Element);
 887         if (!Entry) {
 888           Entry = createDIEEntry(ElemDie);
 889           insertDIEEntry(Element, Entry);
 890         }
 891       } else
 892         continue;
 893       Buffer.addChild(ElemDie);
 894     }
 895
 896     if (CTy.isAppleBlockExtension())
 897       addUInt(&Buffer, dwarf::DW_AT_APPLE_block, dwarf::DW_FORM_flag, 1);
 898
 899     DICompositeType ContainingType = CTy.getContainingType();
 900     if (DIDescriptor(ContainingType).isCompositeType())
 901       addDIEEntry(&Buffer, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4,
 902                   getOrCreateTypeDIE(DIType(ContainingType)));
 903     else {
 904       DIDescriptor Context = CTy.getContext();
 905       addToContextOwner(&Buffer, Context);
 906     }
 907
 908     if (CTy.isObjcClassComplete())
 909       addUInt(&Buffer, dwarf::DW_AT_APPLE_objc_complete_type,
 910               dwarf::DW_FORM_flag, 1);
 911
 912     // Add template parameters to a class, structure or union types.
 913     // FIXME: The support isn't in the metadata for this yet.
 914     if (Tag == dwarf::DW_TAG_class_type ||
 915         Tag == dwarf::DW_TAG_structure_type ||
 916         Tag == dwarf::DW_TAG_union_type)
 917       addTemplateParams(Buffer, CTy.getTemplateParams());
 918
 919     break;
 920   }
 921   default:
 922     break;
 923   }
 924
 925   // Add name if not anonymous or intermediate type.
 926   if (!Name.empty())
 927     addString(&Buffer, dwarf::DW_AT_name, Name);
 928
 929   if (Tag == dwarf::DW_TAG_enumeration_type || Tag == dwarf::DW_TAG_class_type
 930       || Tag == dwarf::DW_TAG_structure_type || Tag == dwarf::DW_TAG_union_type)
 931   {
 932     // Add size if non-zero (derived types might be zero-sized.)
 933     if (Size)
 934       addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, Size);
 935     else {
 936       // Add zero size if it is not a forward declaration.
 937       if (CTy.isForwardDecl())
 938         addUInt(&Buffer, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
 939       else
 940         addUInt(&Buffer, dwarf::DW_AT_byte_size, 0, 0);
 941     }
 942
 943     // Add source line info if available.
 944     if (!CTy.isForwardDecl())
 945       addSourceLine(&Buffer, CTy);
 946
 947     // No harm in adding the runtime language to the declaration.
 948     unsigned RLang = CTy.getRunTimeLang();
 949     if (RLang)
 950       addUInt(&Buffer, dwarf::DW_AT_APPLE_runtime_class,
 951               dwarf::DW_FORM_data1, RLang);
 952   }
 953 }
 954
 955 /// getOrCreateTemplateTypeParameterDIE - Find existing DIE or create new DIE
 956 /// for the given DITemplateTypeParameter.
 957 DIE *
 958 CompileUnit::getOrCreateTemplateTypeParameterDIE(DITemplateTypeParameter TP) {
 959   DIE *ParamDIE = getDIE(TP);
 960   if (ParamDIE)
 961     return ParamDIE;
 962
 963   ParamDIE = new DIE(dwarf::DW_TAG_template_type_parameter);
 964   addType(ParamDIE, TP.getType());
 965   addString(ParamDIE, dwarf::DW_AT_name, TP.getName());
 966   return ParamDIE;
 967 }
 968
 969 /// getOrCreateTemplateValueParameterDIE - Find existing DIE or create new DIE
 970 /// for the given DITemplateValueParameter.
 971 DIE *
 972 CompileUnit::getOrCreateTemplateValueParameterDIE(DITemplateValueParameter TPV) {
 973   DIE *ParamDIE = getDIE(TPV);
 974   if (ParamDIE)
 975     return ParamDIE;
 976
 977   ParamDIE = new DIE(dwarf::DW_TAG_template_value_parameter);
 978   addType(ParamDIE, TPV.getType());
 979   if (!TPV.getName().empty())
 980     addString(ParamDIE, dwarf::DW_AT_name, TPV.getName());
 981   addUInt(ParamDIE, dwarf::DW_AT_const_value, dwarf::DW_FORM_udata,
 982           TPV.getValue());
 983   return ParamDIE;
 984 }
 985
 986 /// getOrCreateNameSpace - Create a DIE for DINameSpace.
 987 DIE *CompileUnit::getOrCreateNameSpace(DINameSpace NS) {
 988   DIE *NDie = getDIE(NS);
 989   if (NDie)
 990     return NDie;
 991   NDie = new DIE(dwarf::DW_TAG_namespace);
 992   insertDIE(NS, NDie);
 993   if (!NS.getName().empty()) {
 994     addString(NDie, dwarf::DW_AT_name, NS.getName());
 995     addAccelNamespace(NS.getName(), NDie);
 996   } else
 997     addAccelNamespace("(anonymous namespace)", NDie);
 998   addSourceLine(NDie, NS);
 999   addToContextOwner(NDie, NS.getContext());
1000   return NDie;
1001 }
1002
1003 /// getRealLinkageName - If special LLVM prefix that is used to inform the asm
1004 /// printer to not emit usual symbol prefix before the symbol name is used then
1005 /// return linkage name after skipping this special LLVM prefix.
1006 static StringRef getRealLinkageName(StringRef LinkageName) {
1007   char One = '\1';
1008   if (LinkageName.startswith(StringRef(&One, 1)))
1009     return LinkageName.substr(1);
1010   return LinkageName;
1011 }
1012
1013 /// getOrCreateSubprogramDIE - Create new DIE using SP.
1014 DIE *CompileUnit::getOrCreateSubprogramDIE(DISubprogram SP) {
1015   DIE *SPDie = getDIE(SP);
1016   if (SPDie)
1017     return SPDie;
1018
1019   DISubprogram SPDecl = SP.getFunctionDeclaration();
1020   DIE *DeclDie = NULL;
1021   if (SPDecl.isSubprogram()) {
1022     DeclDie = getOrCreateSubprogramDIE(SPDecl);
1023   }
1024
1025   SPDie = new DIE(dwarf::DW_TAG_subprogram);
1026
1027   // DW_TAG_inlined_subroutine may refer to this DIE.
1028   insertDIE(SP, SPDie);
1029
1030   // Add to context owner.
1031   addToContextOwner(SPDie, SP.getContext());
1032
1033   // Add function template parameters.
1034   addTemplateParams(*SPDie, SP.getTemplateParams());
1035
1036   // Unfortunately this code needs to stay here instead of below the
1037   // AT_specification code in order to work around a bug in older
1038   // gdbs that requires the linkage name to resolve multiple template
1039   // functions.
1040   StringRef LinkageName = SP.getLinkageName();
1041   if (!LinkageName.empty())
1042     addString(SPDie, dwarf::DW_AT_MIPS_linkage_name,
1043               getRealLinkageName(LinkageName));
1044
1045   // If this DIE is going to refer declaration info using AT_specification
1046   // then there is no need to add other attributes.
1047   if (DeclDie) {
1048     // Refer function declaration directly.
1049     addDIEEntry(SPDie, dwarf::DW_AT_specification, dwarf::DW_FORM_ref4,
1050                 DeclDie);
1051
1052     return SPDie;
1053   }
1054
1055   // Constructors and operators for anonymous aggregates do not have names.
1056   if (!SP.getName().empty())
1057     addString(SPDie, dwarf::DW_AT_name, SP.getName());
1058
1059   addSourceLine(SPDie, SP);
1060
1061   // Add the prototype if we have a prototype and we have a C like
1062   // language.
1063   if (SP.isPrototyped() &&
1064       (Language == dwarf::DW_LANG_C89 ||
1065        Language == dwarf::DW_LANG_C99 ||
1066        Language == dwarf::DW_LANG_ObjC))
1067     addUInt(SPDie, dwarf::DW_AT_prototyped, dwarf::DW_FORM_flag, 1);
1068
1069   // Add Return Type.
1070   DICompositeType SPTy = SP.getType();
1071   DIArray Args = SPTy.getTypeArray();
1072   unsigned SPTag = SPTy.getTag();
1073
1074   if (Args.getNumElements() == 0 || SPTag != dwarf::DW_TAG_subroutine_type)
1075     addType(SPDie, SPTy);
1076   else
1077     addType(SPDie, DIType(Args.getElement(0)));
1078
1079   unsigned VK = SP.getVirtuality();
1080   if (VK) {
1081     addUInt(SPDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1, VK);
1082     DIEBlock *Block = getDIEBlock();
1083     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1084     addUInt(Block, 0, dwarf::DW_FORM_udata, SP.getVirtualIndex());
1085     addBlock(SPDie, dwarf::DW_AT_vtable_elem_location, 0, Block);
1086     ContainingTypeMap.insert(std::make_pair(SPDie,
1087                                             SP.getContainingType()));
1088   }
1089
1090   if (!SP.isDefinition()) {
1091     addUInt(SPDie, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag, 1);
1092
1093     // Add arguments. Do not add arguments for subprogram definition. They will
1094     // be handled while processing variables.
1095     DICompositeType SPTy = SP.getType();
1096     DIArray Args = SPTy.getTypeArray();
1097     unsigned SPTag = SPTy.getTag();
1098
1099     if (SPTag == dwarf::DW_TAG_subroutine_type)
1100       for (unsigned i = 1, N =  Args.getNumElements(); i < N; ++i) {
1101         DIE *Arg = new DIE(dwarf::DW_TAG_formal_parameter);
1102         DIType ATy = DIType(DIType(Args.getElement(i)));
1103         addType(Arg, ATy);
1104         if (ATy.isArtificial())
1105           addUInt(Arg, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1106         SPDie->addChild(Arg);
1107       }
1108   }
1109
1110   if (SP.isArtificial())
1111     addUInt(SPDie, dwarf::DW_AT_artificial, dwarf::DW_FORM_flag, 1);
1112
1113   if (!SP.isLocalToUnit())
1114     addUInt(SPDie, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1115
1116   if (SP.isOptimized())
1117     addUInt(SPDie, dwarf::DW_AT_APPLE_optimized, dwarf::DW_FORM_flag, 1);
1118
1119   if (unsigned isa = Asm->getISAEncoding()) {
1120     addUInt(SPDie, dwarf::DW_AT_APPLE_isa, dwarf::DW_FORM_flag, isa);
1121   }
1122
1123   return SPDie;
1124 }
1125
1126 // Return const expression if value is a GEP to access merged global
1127 // constant. e.g.
1128 // i8* getelementptr ({ i8, i8, i8, i8 }* @_MergedGlobals, i32 0, i32 0)
1129 static const ConstantExpr *getMergedGlobalExpr(const Value *V) {
1130   const ConstantExpr *CE = dyn_cast_or_null<ConstantExpr>(V);
1131   if (!CE || CE->getNumOperands() != 3 ||
1132       CE->getOpcode() != Instruction::GetElementPtr)
1133     return NULL;
1134
1135   // First operand points to a global struct.
1136   Value *Ptr = CE->getOperand(0);
1137   if (!isa<GlobalValue>(Ptr) ||
1138       !isa<StructType>(cast<PointerType>(Ptr->getType())->getElementType()))
1139     return NULL;
1140
1141   // Second operand is zero.
1142   const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(CE->getOperand(1));
1143   if (!CI || !CI->isZero())
1144     return NULL;
1145
1146   // Third operand is offset.
1147   if (!isa<ConstantInt>(CE->getOperand(2)))
1148     return NULL;
1149
1150   return CE;
1151 }
1152
1153 /// createGlobalVariableDIE - create global variable DIE.
1154 void CompileUnit::createGlobalVariableDIE(const MDNode *N) {
1155   // Check for pre-existence.
1156   if (getDIE(N))
1157     return;
1158
1159   DIGlobalVariable GV(N);
1160   if (!GV.Verify())
1161     return;
1162
1163   DIE *VariableDIE = new DIE(GV.getTag());
1164   // Add to map.
1165   insertDIE(N, VariableDIE);
1166
1167   // Add name.
1168   addString(VariableDIE, dwarf::DW_AT_name, GV.getDisplayName());
1169   StringRef LinkageName = GV.getLinkageName();
1170   bool isGlobalVariable = GV.getGlobal() != NULL;
1171   if (!LinkageName.empty() && isGlobalVariable)
1172     addString(VariableDIE, dwarf::DW_AT_MIPS_linkage_name,
1173               getRealLinkageName(LinkageName));
1174   // Add type.
1175   DIType GTy = GV.getType();
1176   addType(VariableDIE, GTy);
1177
1178   // Add scoping info.
1179   if (!GV.isLocalToUnit())
1180     addUInt(VariableDIE, dwarf::DW_AT_external, dwarf::DW_FORM_flag, 1);
1181
1182   // Add line number info.
1183   addSourceLine(VariableDIE, GV);
1184   // Add to context owner.
1185   DIDescriptor GVContext = GV.getContext();
1186   addToContextOwner(VariableDIE, GVContext);
1187   // Add location.
1188   bool addToAccelTable = false;
1189   DIE *VariableSpecDIE = NULL;
1190   if (isGlobalVariable) {
1191     addToAccelTable = true;
1192     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1193     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1194     addLabel(Block, 0, dwarf::DW_FORM_udata,
1195              Asm->Mang->getSymbol(GV.getGlobal()));
1196     // Do not create specification DIE if context is either compile unit
1197     // or a subprogram.
1198     if (GVContext && GV.isDefinition() && !GVContext.isCompileUnit() &&
1199         !GVContext.isFile() && !isSubprogramContext(GVContext)) {
1200       // Create specification DIE.
1201       VariableSpecDIE = new DIE(dwarf::DW_TAG_variable);
1202       addDIEEntry(VariableSpecDIE, dwarf::DW_AT_specification,
1203                   dwarf::DW_FORM_ref4, VariableDIE);
1204       addBlock(VariableSpecDIE, dwarf::DW_AT_location, 0, Block);
1205       addUInt(VariableDIE, dwarf::DW_AT_declaration, dwarf::DW_FORM_flag,
1206                      1);
1207       addDie(VariableSpecDIE);
1208     } else {
1209       addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1210     }
1211   } else if (const ConstantInt *CI =
1212              dyn_cast_or_null<ConstantInt>(GV.getConstant()))
1213     addConstantValue(VariableDIE, CI, GTy.isUnsignedDIType());
1214   else if (const ConstantExpr *CE = getMergedGlobalExpr(N->getOperand(11))) {
1215     addToAccelTable = true;
1216     // GV is a merged global.
1217     DIEBlock *Block = new (DIEValueAllocator) DIEBlock();
1218     Value *Ptr = CE->getOperand(0);
1219     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
1220     addLabel(Block, 0, dwarf::DW_FORM_udata,
1221                     Asm->Mang->getSymbol(cast<GlobalValue>(Ptr)));
1222     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1223     SmallVector<Value*, 3> Idx(CE->op_begin()+1, CE->op_end());
1224     addUInt(Block, 0, dwarf::DW_FORM_udata,
1225                    Asm->getTargetData().getIndexedOffset(Ptr->getType(), Idx));
1226     addUInt(Block, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1227     addBlock(VariableDIE, dwarf::DW_AT_location, 0, Block);
1228   }
1229
1230   if (addToAccelTable) {
1231     DIE *AddrDIE = VariableSpecDIE ? VariableSpecDIE : VariableDIE;
1232     addAccelName(GV.getName(), AddrDIE);
1233
1234     // If the linkage name is different than the name, go ahead and output
1235     // that as well into the name table.
1236     if (GV.getLinkageName() != "" && GV.getName() != GV.getLinkageName())
1237       addAccelName(GV.getLinkageName(), AddrDIE);
1238   }
1239
1240   return;
1241 }
1242
1243 /// constructSubrangeDIE - Construct subrange DIE from DISubrange.
1244 void CompileUnit::constructSubrangeDIE(DIE &Buffer, DISubrange SR, DIE *IndexTy){
1245   DIE *DW_Subrange = new DIE(dwarf::DW_TAG_subrange_type);
1246   addDIEEntry(DW_Subrange, dwarf::DW_AT_type, dwarf::DW_FORM_ref4, IndexTy);
1247   uint64_t L = SR.getLo();
1248   uint64_t H = SR.getHi();
1249
1250   // The L value defines the lower bounds which is typically zero for C/C++. The
1251   // H value is the upper bounds.  Values are 64 bit.  H - L + 1 is the size
1252   // of the array. If L > H then do not emit DW_AT_lower_bound and
1253   // DW_AT_upper_bound attributes. If L is zero and H is also zero then the
1254   // array has one element and in such case do not emit lower bound.
1255
1256   if (L > H) {
1257     Buffer.addChild(DW_Subrange);
1258     return;
1259   }
1260   if (L)
1261     addUInt(DW_Subrange, dwarf::DW_AT_lower_bound, 0, L);
1262   addUInt(DW_Subrange, dwarf::DW_AT_upper_bound, 0, H);
1263   Buffer.addChild(DW_Subrange);
1264 }
1265
1266 /// constructArrayTypeDIE - Construct array type DIE from DICompositeType.
1267 void CompileUnit::constructArrayTypeDIE(DIE &Buffer,
1268                                         DICompositeType *CTy) {
1269   Buffer.setTag(dwarf::DW_TAG_array_type);
1270   if (CTy->getTag() == dwarf::DW_TAG_vector_type)
1271     addUInt(&Buffer, dwarf::DW_AT_GNU_vector, dwarf::DW_FORM_flag, 1);
1272
1273   // Emit derived type.
1274   addType(&Buffer, CTy->getTypeDerivedFrom());
1275   DIArray Elements = CTy->getTypeArray();
1276
1277   // Get an anonymous type for index type.
1278   DIE *IdxTy = getIndexTyDie();
1279   if (!IdxTy) {
1280     // Construct an anonymous type for index type.
1281     IdxTy = new DIE(dwarf::DW_TAG_base_type);
1282     addUInt(IdxTy, dwarf::DW_AT_byte_size, 0, sizeof(int32_t));
1283     addUInt(IdxTy, dwarf::DW_AT_encoding, dwarf::DW_FORM_data1,
1284             dwarf::DW_ATE_signed);
1285     addDie(IdxTy);
1286     setIndexTyDie(IdxTy);
1287   }
1288
1289   // Add subranges to array type.
1290   for (unsigned i = 0, N = Elements.getNumElements(); i < N; ++i) {
1291     DIDescriptor Element = Elements.getElement(i);
1292     if (Element.getTag() == dwarf::DW_TAG_subrange_type)
1293       constructSubrangeDIE(Buffer, DISubrange(Element), IdxTy);
1294   }
1295 }
1296
1297 /// constructEnumTypeDIE - Construct enum type DIE from DIEnumerator.
1298 DIE *CompileUnit::constructEnumTypeDIE(DIEnumerator ETy) {
1299   DIE *Enumerator = new DIE(dwarf::DW_TAG_enumerator);
1300   StringRef Name = ETy.getName();
1301   addString(Enumerator, dwarf::DW_AT_name, Name);
1302   int64_t Value = ETy.getEnumValue();
1303   addSInt(Enumerator, dwarf::DW_AT_const_value, dwarf::DW_FORM_sdata, Value);
1304   return Enumerator;
1305 }
1306
1307 /// constructContainingTypeDIEs - Construct DIEs for types that contain
1308 /// vtables.
1309 void CompileUnit::constructContainingTypeDIEs() {
1310   for (DenseMap<DIE *, const MDNode *>::iterator CI = ContainingTypeMap.begin(),
1311          CE = ContainingTypeMap.end(); CI != CE; ++CI) {
1312     DIE *SPDie = CI->first;
1313     const MDNode *N = CI->second;
1314     if (!N) continue;
1315     DIE *NDie = getDIE(N);
1316     if (!NDie) continue;
1317     addDIEEntry(SPDie, dwarf::DW_AT_containing_type, dwarf::DW_FORM_ref4, NDie);
1318   }
1319 }
1320
1321 /// constructVariableDIE - Construct a DIE for the given DbgVariable.
1322 DIE *CompileUnit::constructVariableDIE(DbgVariable *DV, bool isScopeAbstract) {
1323   StringRef Name = DV->getName();
1324   if (Name.empty())
1325     return NULL;
1326
1327   // Translate tag to proper Dwarf tag.
1328   unsigned Tag = DV->getTag();
1329
1330   // Define variable debug information entry.
1331   DIE *VariableDie = new DIE(Tag);
1332   DbgVariable *AbsVar = DV->getAbstractVariable();
1333   DIE *AbsDIE = AbsVar ? AbsVar->getDIE() : NULL;
1334   if (AbsDIE)
1335     addDIEEntry(VariableDie, dwarf::DW_AT_abstract_origin,
1336                             dwarf::DW_FORM_ref4, AbsDIE);
1337   else {
1338     addString(VariableDie, dwarf::DW_AT_name, Name);
1339     addSourceLine(VariableDie, DV->getVariable());
1340     addType(VariableDie, DV->getType());
1341   }
1342
1343   if (DV->isArtificial())
1344     addUInt(VariableDie, dwarf::DW_AT_artificial,
1345                         dwarf::DW_FORM_flag, 1);
1346
1347   if (isScopeAbstract) {
1348     DV->setDIE(VariableDie);
1349     return VariableDie;
1350   }
1351
1352   // Add variable address.
1353
1354   unsigned Offset = DV->getDotDebugLocOffset();
1355   if (Offset != ~0U) {
1356     addLabel(VariableDie, dwarf::DW_AT_location,
1357                          dwarf::DW_FORM_data4,
1358                          Asm->GetTempSymbol("debug_loc", Offset));
1359     DV->setDIE(VariableDie);
1360     return VariableDie;
1361   }
1362
1363   // Check if variable is described by a DBG_VALUE instruction.
1364   if (const MachineInstr *DVInsn = DV->getMInsn()) {
1365     bool updated = false;
1366     if (DVInsn->getNumOperands() == 3) {
1367       if (DVInsn->getOperand(0).isReg()) {
1368         const MachineOperand RegOp = DVInsn->getOperand(0);
1369         const TargetRegisterInfo *TRI = Asm->TM.getRegisterInfo();
1370         if (DVInsn->getOperand(1).isImm() &&
1371             TRI->getFrameRegister(*Asm->MF) == RegOp.getReg()) {
1372           unsigned FrameReg = 0;
1373           const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1374           int Offset =
1375             TFI->getFrameIndexReference(*Asm->MF,
1376                                         DVInsn->getOperand(1).getImm(),
1377                                         FrameReg);
1378           MachineLocation Location(FrameReg, Offset);
1379           addVariableAddress(DV, VariableDie, Location);
1380
1381         } else if (RegOp.getReg())
1382           addVariableAddress(DV, VariableDie,
1383                                          MachineLocation(RegOp.getReg()));
1384         updated = true;
1385       }
1386       else if (DVInsn->getOperand(0).isImm())
1387         updated =
1388           addConstantValue(VariableDie, DVInsn->getOperand(0),
1389                                        DV->getType());
1390       else if (DVInsn->getOperand(0).isFPImm())
1391         updated =
1392           addConstantFPValue(VariableDie, DVInsn->getOperand(0));
1393       else if (DVInsn->getOperand(0).isCImm())
1394         updated =
1395           addConstantValue(VariableDie,
1396                                        DVInsn->getOperand(0).getCImm(),
1397                                        DV->getType().isUnsignedDIType());
1398     } else {
1399       addVariableAddress(DV, VariableDie,
1400                                      Asm->getDebugValueLocation(DVInsn));
1401       updated = true;
1402     }
1403     if (!updated) {
1404       // If variableDie is not updated then DBG_VALUE instruction does not
1405       // have valid variable info.
1406       delete VariableDie;
1407       return NULL;
1408     }
1409     DV->setDIE(VariableDie);
1410     return VariableDie;
1411   } else {
1412     // .. else use frame index.
1413     int FI = DV->getFrameIndex();
1414     if (FI != ~0) {
1415       unsigned FrameReg = 0;
1416       const TargetFrameLowering *TFI = Asm->TM.getFrameLowering();
1417       int Offset =
1418         TFI->getFrameIndexReference(*Asm->MF, FI, FrameReg);
1419       MachineLocation Location(FrameReg, Offset);
1420       addVariableAddress(DV, VariableDie, Location);
1421     }
1422   }
1423
1424   DV->setDIE(VariableDie);
1425   return VariableDie;
1426 }
1427
1428 /// createMemberDIE - Create new member DIE.
1429 DIE *CompileUnit::createMemberDIE(DIDerivedType DT) {
1430   DIE *MemberDie = new DIE(DT.getTag());
1431   StringRef Name = DT.getName();
1432   if (!Name.empty())
1433     addString(MemberDie, dwarf::DW_AT_name, Name);
1434
1435   addType(MemberDie, DT.getTypeDerivedFrom());
1436
1437   addSourceLine(MemberDie, DT);
1438
1439   DIEBlock *MemLocationDie = new (DIEValueAllocator) DIEBlock();
1440   addUInt(MemLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus_uconst);
1441
1442   uint64_t Size = DT.getSizeInBits();
1443   uint64_t FieldSize = DT.getOriginalTypeSize();
1444
1445   if (Size != FieldSize) {
1446     // Handle bitfield.
1447     addUInt(MemberDie, dwarf::DW_AT_byte_size, 0, DT.getOriginalTypeSize()>>3);
1448     addUInt(MemberDie, dwarf::DW_AT_bit_size, 0, DT.getSizeInBits());
1449
1450     uint64_t Offset = DT.getOffsetInBits();
1451     uint64_t AlignMask = ~(DT.getAlignInBits() - 1);
1452     uint64_t HiMark = (Offset + FieldSize) & AlignMask;
1453     uint64_t FieldOffset = (HiMark - FieldSize);
1454     Offset -= FieldOffset;
1455
1456     // Maybe we need to work from the other end.
1457     if (Asm->getTargetData().isLittleEndian())
1458       Offset = FieldSize - (Offset + Size);
1459     addUInt(MemberDie, dwarf::DW_AT_bit_offset, 0, Offset);
1460
1461     // Here WD_AT_data_member_location points to the anonymous
1462     // field that includes this bit field.
1463     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, FieldOffset >> 3);
1464
1465   } else
1466     // This is not a bitfield.
1467     addUInt(MemLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits() >> 3);
1468
1469   if (DT.getTag() == dwarf::DW_TAG_inheritance
1470       && DT.isVirtual()) {
1471
1472     // For C++, virtual base classes are not at fixed offset. Use following
1473     // expression to extract appropriate offset from vtable.
1474     // BaseAddr = ObAddr + *((*ObAddr) - Offset)
1475
1476     DIEBlock *VBaseLocationDie = new (DIEValueAllocator) DIEBlock();
1477     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_dup);
1478     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1479     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_constu);
1480     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_udata, DT.getOffsetInBits());
1481     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
1482     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
1483     addUInt(VBaseLocationDie, 0, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
1484
1485     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0,
1486              VBaseLocationDie);
1487   } else
1488     addBlock(MemberDie, dwarf::DW_AT_data_member_location, 0, MemLocationDie);
1489
1490   if (DT.isProtected())
1491     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1492             dwarf::DW_ACCESS_protected);
1493   else if (DT.isPrivate())
1494     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1495             dwarf::DW_ACCESS_private);
1496   // Otherwise C++ member and base classes are considered public.
1497   else
1498     addUInt(MemberDie, dwarf::DW_AT_accessibility, dwarf::DW_FORM_data1,
1499             dwarf::DW_ACCESS_public);
1500   if (DT.isVirtual())
1501     addUInt(MemberDie, dwarf::DW_AT_virtuality, dwarf::DW_FORM_data1,
1502             dwarf::DW_VIRTUALITY_virtual);
1503
1504   // Objective-C properties.
1505   if (MDNode *PNode = DT.getObjCProperty())
1506     if (DIEEntry *PropertyDie = getDIEEntry(PNode))
1507       MemberDie->addValue(dwarf::DW_AT_APPLE_property, dwarf::DW_FORM_ref4,
1508                           PropertyDie);
1509
1510   // This is only for backward compatibility.
1511   StringRef PropertyName = DT.getObjCPropertyName();
1512   if (!PropertyName.empty()) {
1513     addString(MemberDie, dwarf::DW_AT_APPLE_property_name, PropertyName);
1514     StringRef GetterName = DT.getObjCPropertyGetterName();
1515     if (!GetterName.empty())
1516       addString(MemberDie, dwarf::DW_AT_APPLE_property_getter, GetterName);
1517     StringRef SetterName = DT.getObjCPropertySetterName();
1518     if (!SetterName.empty())
1519       addString(MemberDie, dwarf::DW_AT_APPLE_property_setter, SetterName);
1520     unsigned PropertyAttributes = 0;
1521     if (DT.isReadOnlyObjCProperty())
1522       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readonly;
1523     if (DT.isReadWriteObjCProperty())
1524       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_readwrite;
1525     if (DT.isAssignObjCProperty())
1526       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_assign;
1527     if (DT.isRetainObjCProperty())
1528       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_retain;
1529     if (DT.isCopyObjCProperty())
1530       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_copy;
1531     if (DT.isNonAtomicObjCProperty())
1532       PropertyAttributes |= dwarf::DW_APPLE_PROPERTY_nonatomic;
1533     if (PropertyAttributes)
1534       addUInt(MemberDie, dwarf::DW_AT_APPLE_property_attribute, 0,
1535               PropertyAttributes);
1536   }
1537   return MemberDie;
1538 }