CGDebugInfo.cpp revision ffc52e78a27564d0512d42ed5c98a5588cf906b5 
1//===--- CGDebugInfo.cpp - Emit Debug Information for a Module ------------===//
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 coordinates the debug information generation while generating code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CGDebugInfo.h"
15#include "CodeGenFunction.h"
16#include "CodeGenModule.h"
17#include "clang/AST/ASTContext.h"
18#include "clang/AST/DeclObjC.h"
19#include "clang/AST/DeclTemplate.h"
20#include "clang/AST/Expr.h"
21#include "clang/AST/RecordLayout.h"
22#include "clang/Basic/SourceManager.h"
23#include "clang/Basic/FileManager.h"
24#include "clang/Basic/Version.h"
25#include "clang/Frontend/CodeGenOptions.h"
26#include "llvm/Constants.h"
27#include "llvm/DerivedTypes.h"
28#include "llvm/Instructions.h"
29#include "llvm/Intrinsics.h"
30#include "llvm/Module.h"
31#include "llvm/ADT/StringExtras.h"
32#include "llvm/ADT/SmallVector.h"
33#include "llvm/Support/Dwarf.h"
34#include "llvm/System/Path.h"
35#include "llvm/Target/TargetMachine.h"
36using namespace clang;
37using namespace clang::CodeGen;
38
39CGDebugInfo::CGDebugInfo(CodeGenModule &CGM)
40  : CGM(CGM), DebugFactory(CGM.getModule()),
41    BlockLiteralGenericSet(false) {
42  CreateCompileUnit();
43}
44
45CGDebugInfo::~CGDebugInfo() {
46  assert(RegionStack.empty() && "Region stack mismatch, stack not empty!");
47}
48
49void CGDebugInfo::setLocation(SourceLocation Loc) {
50  if (Loc.isValid())
51    CurLoc = CGM.getContext().getSourceManager().getInstantiationLoc(Loc);
52}
53
54/// getContextDescriptor - Get context info for the decl.
55llvm::DIDescriptor CGDebugInfo::getContextDescriptor(const Decl *Context,
56                                              llvm::DIDescriptor &CompileUnit) {
57  if (!Context)
58    return CompileUnit;
59
60  llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator
61    I = RegionMap.find(Context);
62  if (I != RegionMap.end())
63    return llvm::DIDescriptor(dyn_cast_or_null<llvm::MDNode>(I->second));
64
65  // Check namespace.
66  if (const NamespaceDecl *NSDecl = dyn_cast<NamespaceDecl>(Context))
67    return llvm::DIDescriptor(getOrCreateNameSpace(NSDecl, CompileUnit));
68
69  if (const RecordDecl *RDecl = dyn_cast<RecordDecl>(Context)) {
70    if (!RDecl->isDependentType()) {
71      llvm::DIType Ty = getOrCreateType(CGM.getContext().getTypeDeclType(RDecl),
72                                        llvm::DIFile(CompileUnit));
73      return llvm::DIDescriptor(Ty);
74    }
75  }
76  return CompileUnit;
77}
78
79/// getFunctionName - Get function name for the given FunctionDecl. If the
80/// name is constructred on demand (e.g. C++ destructor) then the name
81/// is stored on the side.
82llvm::StringRef CGDebugInfo::getFunctionName(const FunctionDecl *FD) {
83  assert (FD && "Invalid FunctionDecl!");
84  IdentifierInfo *FII = FD->getIdentifier();
85  if (FII)
86    return FII->getName();
87
88  // Otherwise construct human readable name for debug info.
89  std::string NS = FD->getNameAsString();
90
91  // Copy this name on the side and use its reference.
92  char *StrPtr = DebugInfoNames.Allocate<char>(NS.length());
93  memcpy(StrPtr, NS.data(), NS.length());
94  return llvm::StringRef(StrPtr, NS.length());
95}
96
97/// getClassName - Get class name including template argument list.
98llvm::StringRef
99CGDebugInfo::getClassName(RecordDecl *RD) {
100  ClassTemplateSpecializationDecl *Spec
101    = dyn_cast<ClassTemplateSpecializationDecl>(RD);
102  if (!Spec)
103    return RD->getName();
104
105  const TemplateArgument *Args;
106  unsigned NumArgs;
107  std::string Buffer;
108  if (TypeSourceInfo *TAW = Spec->getTypeAsWritten()) {
109    const TemplateSpecializationType *TST =
110      cast<TemplateSpecializationType>(TAW->getType());
111    Args = TST->getArgs();
112    NumArgs = TST->getNumArgs();
113  } else {
114    const TemplateArgumentList &TemplateArgs = Spec->getTemplateArgs();
115    Args = TemplateArgs.getFlatArgumentList();
116    NumArgs = TemplateArgs.flat_size();
117  }
118  Buffer = RD->getIdentifier()->getNameStart();
119  PrintingPolicy Policy(CGM.getLangOptions());
120  Buffer += TemplateSpecializationType::PrintTemplateArgumentList(Args,
121                                                                  NumArgs,
122                                                                  Policy);
123
124  // Copy this name on the side and use its reference.
125  char *StrPtr = DebugInfoNames.Allocate<char>(Buffer.length());
126  memcpy(StrPtr, Buffer.data(), Buffer.length());
127  return llvm::StringRef(StrPtr, Buffer.length());
128
129}
130
131/// getOrCreateFile - Get the file debug info descriptor for the input location.
132llvm::DIFile CGDebugInfo::getOrCreateFile(SourceLocation Loc) {
133  if (!Loc.isValid())
134    // If Location is not valid then use main input file.
135    return DebugFactory.CreateFile(TheCU.getFilename(), TheCU.getDirectory(),
136                                   TheCU);
137  SourceManager &SM = CGM.getContext().getSourceManager();
138  PresumedLoc PLoc = SM.getPresumedLoc(Loc);
139
140  // Cache the results.
141  const char *fname = PLoc.getFilename();
142  llvm::DenseMap<const char *, llvm::WeakVH>::iterator it =
143    DIFileCache.find(fname);
144
145  if (it != DIFileCache.end()) {
146    // Verify that the information still exists.
147    if (&*it->second)
148      return llvm::DIFile(cast<llvm::MDNode>(it->second));
149  }
150
151  llvm::DIFile F = DebugFactory.CreateFile(PLoc.getFilename(),
152                                           getCurrentDirname(), TheCU);
153
154  DIFileCache[fname] = F;
155  return F;
156
157}
158
159/// getLineNumber - Get line number for the location. If location is invalid
160/// then use current location.
161unsigned CGDebugInfo::getLineNumber(SourceLocation Loc) {
162  assert (CurLoc.isValid() && "Invalid current location!");
163  SourceManager &SM = CGM.getContext().getSourceManager();
164  PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
165  return PLoc.getLine();
166}
167
168/// getColumnNumber - Get column number for the location. If location is
169/// invalid then use current location.
170unsigned CGDebugInfo::getColumnNumber(SourceLocation Loc) {
171  assert (CurLoc.isValid() && "Invalid current location!");
172  SourceManager &SM = CGM.getContext().getSourceManager();
173  PresumedLoc PLoc = SM.getPresumedLoc(Loc.isValid() ? Loc : CurLoc);
174  return PLoc.getColumn();
175}
176
177llvm::StringRef CGDebugInfo::getCurrentDirname() {
178  if (!CWDName.empty())
179    return CWDName;
180  char *CompDirnamePtr = NULL;
181  llvm::sys::Path CWD = llvm::sys::Path::GetCurrentDirectory();
182  CompDirnamePtr = DebugInfoNames.Allocate<char>(CWD.size());
183  memcpy(CompDirnamePtr, CWD.c_str(), CWD.size());
184  return CWDName = llvm::StringRef(CompDirnamePtr, CWD.size());
185}
186
187/// CreateCompileUnit - Create new compile unit.
188void CGDebugInfo::CreateCompileUnit() {
189
190  // Get absolute path name.
191  SourceManager &SM = CGM.getContext().getSourceManager();
192  std::string MainFileName = CGM.getCodeGenOpts().MainFileName;
193  if (MainFileName.empty())
194    MainFileName = "<unknown>";
195
196  // The main file name provided via the "-main-file-name" option contains just
197  // the file name itself with no path information. This file name may have had
198  // a relative path, so we look into the actual file entry for the main
199  // file to determine the real absolute path for the file.
200  std::string MainFileDir;
201  if (const FileEntry *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
202    MainFileDir = MainFile->getDir()->getName();
203    if (MainFileDir != ".")
204      MainFileName = MainFileDir + "/" + MainFileName;
205  }
206
207  // Save filename string.
208  char *FilenamePtr = DebugInfoNames.Allocate<char>(MainFileName.length());
209  memcpy(FilenamePtr, MainFileName.c_str(), MainFileName.length());
210  llvm::StringRef Filename(FilenamePtr, MainFileName.length());
211
212  unsigned LangTag;
213  const LangOptions &LO = CGM.getLangOptions();
214  if (LO.CPlusPlus) {
215    if (LO.ObjC1)
216      LangTag = llvm::dwarf::DW_LANG_ObjC_plus_plus;
217    else
218      LangTag = llvm::dwarf::DW_LANG_C_plus_plus;
219  } else if (LO.ObjC1) {
220    LangTag = llvm::dwarf::DW_LANG_ObjC;
221  } else if (LO.C99) {
222    LangTag = llvm::dwarf::DW_LANG_C99;
223  } else {
224    LangTag = llvm::dwarf::DW_LANG_C89;
225  }
226
227  std::string Producer = getClangFullVersion();
228
229  // Figure out which version of the ObjC runtime we have.
230  unsigned RuntimeVers = 0;
231  if (LO.ObjC1)
232    RuntimeVers = LO.ObjCNonFragileABI ? 2 : 1;
233
234  // Create new compile unit.
235  TheCU = DebugFactory.CreateCompileUnit(
236    LangTag, Filename, getCurrentDirname(),
237    Producer, true,
238    LO.Optimize, CGM.getCodeGenOpts().DwarfDebugFlags, RuntimeVers);
239}
240
241/// CreateType - Get the Basic type from the cache or create a new
242/// one if necessary.
243llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT,
244                                     llvm::DIFile Unit) {
245  unsigned Encoding = 0;
246  const char *BTName = NULL;
247  switch (BT->getKind()) {
248  default:
249  case BuiltinType::Void:
250    return llvm::DIType();
251  case BuiltinType::ObjCClass:
252    return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_structure_type,
253                                            Unit, "objc_class", Unit, 0, 0, 0, 0,
254                                            llvm::DIType::FlagFwdDecl,
255                                            llvm::DIType(), llvm::DIArray());
256  case BuiltinType::ObjCId: {
257    // typedef struct objc_class *Class;
258    // typedef struct objc_object {
259    //  Class isa;
260    // } *id;
261
262    llvm::DIType OCTy =
263      DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_structure_type,
264                                       Unit, "objc_class", Unit, 0, 0, 0, 0,
265                                       llvm::DIType::FlagFwdDecl,
266                                       llvm::DIType(), llvm::DIArray());
267    unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
268
269    llvm::DIType ISATy =
270      DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type,
271                                     Unit, "", Unit,
272                                     0, Size, 0, 0, 0, OCTy);
273
274    llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
275
276    llvm::DIType FieldTy =
277      DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
278                                     "isa", Unit,
279                                     0,Size, 0, 0, 0, ISATy);
280    EltTys.push_back(FieldTy);
281    llvm::DIArray Elements =
282      DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
283
284    return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_structure_type,
285                                            Unit, "objc_object", Unit, 0, 0, 0, 0,
286                                            0,
287                                            llvm::DIType(), Elements);
288  }
289  case BuiltinType::UChar:
290  case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break;
291  case BuiltinType::Char_S:
292  case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break;
293  case BuiltinType::UShort:
294  case BuiltinType::UInt:
295  case BuiltinType::ULong:
296  case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break;
297  case BuiltinType::Short:
298  case BuiltinType::Int:
299  case BuiltinType::Long:
300  case BuiltinType::LongLong:  Encoding = llvm::dwarf::DW_ATE_signed; break;
301  case BuiltinType::Bool:      Encoding = llvm::dwarf::DW_ATE_boolean; break;
302  case BuiltinType::Float:
303  case BuiltinType::LongDouble:
304  case BuiltinType::Double:    Encoding = llvm::dwarf::DW_ATE_float; break;
305  }
306
307  switch (BT->getKind()) {
308  case BuiltinType::Long:      BTName = "long int"; break;
309  case BuiltinType::LongLong:  BTName = "long long int"; break;
310  case BuiltinType::ULong:     BTName = "long unsigned int"; break;
311  case BuiltinType::ULongLong: BTName = "long long unsigned int"; break;
312  default:
313    BTName = BT->getName(CGM.getContext().getLangOptions());
314    break;
315  }
316  // Bit size, align and offset of the type.
317  uint64_t Size = CGM.getContext().getTypeSize(BT);
318  uint64_t Align = CGM.getContext().getTypeAlign(BT);
319  uint64_t Offset = 0;
320
321  llvm::DIType DbgTy =
322    DebugFactory.CreateBasicType(Unit, BTName,
323                                 Unit, 0, Size, Align,
324                                 Offset, /*flags*/ 0, Encoding);
325  return DbgTy;
326}
327
328llvm::DIType CGDebugInfo::CreateType(const ComplexType *Ty,
329                                     llvm::DIFile Unit) {
330  // Bit size, align and offset of the type.
331  unsigned Encoding = llvm::dwarf::DW_ATE_complex_float;
332  if (Ty->isComplexIntegerType())
333    Encoding = llvm::dwarf::DW_ATE_lo_user;
334
335  uint64_t Size = CGM.getContext().getTypeSize(Ty);
336  uint64_t Align = CGM.getContext().getTypeAlign(Ty);
337  uint64_t Offset = 0;
338
339  llvm::DIType DbgTy =
340    DebugFactory.CreateBasicType(Unit, "complex",
341                                 Unit, 0, Size, Align,
342                                 Offset, /*flags*/ 0, Encoding);
343  return DbgTy;
344}
345
346/// CreateCVRType - Get the qualified type from the cache or create
347/// a new one if necessary.
348llvm::DIType CGDebugInfo::CreateQualifiedType(QualType Ty, llvm::DIFile Unit) {
349  QualifierCollector Qc;
350  const Type *T = Qc.strip(Ty);
351
352  // Ignore these qualifiers for now.
353  Qc.removeObjCGCAttr();
354  Qc.removeAddressSpace();
355
356  // We will create one Derived type for one qualifier and recurse to handle any
357  // additional ones.
358  unsigned Tag;
359  if (Qc.hasConst()) {
360    Tag = llvm::dwarf::DW_TAG_const_type;
361    Qc.removeConst();
362  } else if (Qc.hasVolatile()) {
363    Tag = llvm::dwarf::DW_TAG_volatile_type;
364    Qc.removeVolatile();
365  } else if (Qc.hasRestrict()) {
366    Tag = llvm::dwarf::DW_TAG_restrict_type;
367    Qc.removeRestrict();
368  } else {
369    assert(Qc.empty() && "Unknown type qualifier for debug info");
370    return getOrCreateType(QualType(T, 0), Unit);
371  }
372
373  llvm::DIType FromTy = getOrCreateType(Qc.apply(T), Unit);
374
375  // No need to fill in the Name, Line, Size, Alignment, Offset in case of
376  // CVR derived types.
377  llvm::DIType DbgTy =
378    DebugFactory.CreateDerivedType(Tag, Unit, "", Unit,
379                                   0, 0, 0, 0, 0, FromTy);
380  return DbgTy;
381}
382
383llvm::DIType CGDebugInfo::CreateType(const ObjCObjectPointerType *Ty,
384                                     llvm::DIFile Unit) {
385  llvm::DIType DbgTy =
386    CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
387                          Ty->getPointeeType(), Unit);
388  return DbgTy;
389}
390
391llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty,
392                                     llvm::DIFile Unit) {
393  return CreatePointerLikeType(llvm::dwarf::DW_TAG_pointer_type, Ty,
394                               Ty->getPointeeType(), Unit);
395}
396
397llvm::DIType CGDebugInfo::CreatePointerLikeType(unsigned Tag,
398                                                const Type *Ty,
399                                                QualType PointeeTy,
400                                                llvm::DIFile Unit) {
401  llvm::DIType EltTy = getOrCreateType(PointeeTy, Unit);
402
403  // Bit size, align and offset of the type.
404
405  // Size is always the size of a pointer. We can't use getTypeSize here
406  // because that does not return the correct value for references.
407  uint64_t Size =
408    CGM.getContext().Target.getPointerWidth(PointeeTy.getAddressSpace());
409  uint64_t Align = CGM.getContext().getTypeAlign(Ty);
410
411  return
412    DebugFactory.CreateDerivedType(Tag, Unit, "", Unit,
413                                   0, Size, Align, 0, 0, EltTy);
414
415}
416
417llvm::DIType CGDebugInfo::CreateType(const BlockPointerType *Ty,
418                                     llvm::DIFile Unit) {
419  if (BlockLiteralGenericSet)
420    return BlockLiteralGeneric;
421
422  unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
423
424  llvm::SmallVector<llvm::DIDescriptor, 5> EltTys;
425
426  llvm::DIType FieldTy;
427
428  QualType FType;
429  uint64_t FieldSize, FieldOffset;
430  unsigned FieldAlign;
431
432  llvm::DIArray Elements;
433  llvm::DIType EltTy, DescTy;
434
435  FieldOffset = 0;
436  FType = CGM.getContext().UnsignedLongTy;
437  EltTys.push_back(CreateMemberType(Unit, FType, "reserved", &FieldOffset));
438  EltTys.push_back(CreateMemberType(Unit, FType, "Size", &FieldOffset));
439
440  Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
441  EltTys.clear();
442
443  unsigned Flags = llvm::DIType::FlagAppleBlock;
444  unsigned LineNo = getLineNumber(CurLoc);
445
446  EltTy = DebugFactory.CreateCompositeType(Tag, Unit, "__block_descriptor",
447                                           Unit, LineNo, FieldOffset, 0, 0,
448                                           Flags, llvm::DIType(), Elements);
449
450  // Bit size, align and offset of the type.
451  uint64_t Size = CGM.getContext().getTypeSize(Ty);
452  uint64_t Align = CGM.getContext().getTypeAlign(Ty);
453
454  DescTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type,
455                                          Unit, "", Unit,
456                                          LineNo, Size, Align, 0, 0, EltTy);
457
458  FieldOffset = 0;
459  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
460  EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
461  FType = CGM.getContext().IntTy;
462  EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
463  EltTys.push_back(CreateMemberType(Unit, FType, "__reserved", &FieldOffset));
464  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
465  EltTys.push_back(CreateMemberType(Unit, FType, "__FuncPtr", &FieldOffset));
466
467  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
468  FieldTy = DescTy;
469  FieldSize = CGM.getContext().getTypeSize(Ty);
470  FieldAlign = CGM.getContext().getTypeAlign(Ty);
471  FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
472                                           "__descriptor", Unit,
473                                           LineNo, FieldSize, FieldAlign,
474                                           FieldOffset, 0, FieldTy);
475  EltTys.push_back(FieldTy);
476
477  FieldOffset += FieldSize;
478  Elements = DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
479
480  EltTy = DebugFactory.CreateCompositeType(Tag, Unit, "__block_literal_generic",
481                                           Unit, LineNo, FieldOffset, 0, 0,
482                                           Flags, llvm::DIType(), Elements);
483
484  BlockLiteralGenericSet = true;
485  BlockLiteralGeneric
486    = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, Unit,
487                                     "", Unit,
488                                     LineNo, Size, Align, 0, 0, EltTy);
489  return BlockLiteralGeneric;
490}
491
492llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty,
493                                     llvm::DIFile Unit) {
494  // Typedefs are derived from some other type.  If we have a typedef of a
495  // typedef, make sure to emit the whole chain.
496  llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
497
498  // We don't set size information, but do specify where the typedef was
499  // declared.
500  unsigned Line = getLineNumber(Ty->getDecl()->getLocation());
501
502  llvm::DIDescriptor TyContext
503    = getContextDescriptor(dyn_cast<Decl>(Ty->getDecl()->getDeclContext()),
504                           Unit);
505  llvm::DIType DbgTy =
506    DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_typedef,
507                                   TyContext,
508                                   Ty->getDecl()->getName(), Unit,
509                                   Line, 0, 0, 0, 0, Src);
510  return DbgTy;
511}
512
513llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
514                                     llvm::DIFile Unit) {
515  llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
516
517  // Add the result type at least.
518  EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit));
519
520  // Set up remainder of arguments if there is a prototype.
521  // FIXME: IF NOT, HOW IS THIS REPRESENTED?  llvm-gcc doesn't represent '...'!
522  if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
523    for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
524      EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
525  } else {
526    // FIXME: Handle () case in C.  llvm-gcc doesn't do it either.
527  }
528
529  llvm::DIArray EltTypeArray =
530    DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
531
532  llvm::DIType DbgTy =
533    DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type,
534                                     Unit, "", Unit,
535                                     0, 0, 0, 0, 0,
536                                     llvm::DIType(), EltTypeArray);
537  return DbgTy;
538}
539
540/// CollectRecordFields - A helper function to collect debug info for
541/// record fields. This is used while creating debug info entry for a Record.
542void CGDebugInfo::
543CollectRecordFields(const RecordDecl *RD, llvm::DIFile Unit,
544                    llvm::SmallVectorImpl<llvm::DIDescriptor> &EltTys) {
545  unsigned FieldNo = 0;
546  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
547  for (RecordDecl::field_iterator I = RD->field_begin(),
548                                  E = RD->field_end();
549       I != E; ++I, ++FieldNo) {
550    FieldDecl *Field = *I;
551    llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
552    llvm::StringRef FieldName = Field->getName();
553
554    // Ignore unnamed fields. Do not ignore unnamed records.
555    if (FieldName.empty() && !isa<RecordType>(Field->getType()))
556      continue;
557
558    // Get the location for the field.
559    llvm::DIFile FieldDefUnit = getOrCreateFile(Field->getLocation());
560    unsigned FieldLine = getLineNumber(Field->getLocation());
561    QualType FType = Field->getType();
562    uint64_t FieldSize = 0;
563    unsigned FieldAlign = 0;
564    if (!FType->isIncompleteArrayType()) {
565
566      // Bit size, align and offset of the type.
567      FieldSize = CGM.getContext().getTypeSize(FType);
568      Expr *BitWidth = Field->getBitWidth();
569      if (BitWidth)
570        FieldSize = BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
571      FieldAlign =  CGM.getContext().getTypeAlign(FType);
572    }
573
574    uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
575
576    unsigned Flags = 0;
577    AccessSpecifier Access = I->getAccess();
578    if (Access == clang::AS_private)
579      Flags |= llvm::DIType::FlagPrivate;
580    else if (Access == clang::AS_protected)
581      Flags |= llvm::DIType::FlagProtected;
582
583    // Create a DW_TAG_member node to remember the offset of this field in the
584    // struct.  FIXME: This is an absolutely insane way to capture this
585    // information.  When we gut debug info, this should be fixed.
586    FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
587                                             FieldName, FieldDefUnit,
588                                             FieldLine, FieldSize, FieldAlign,
589                                             FieldOffset, Flags, FieldTy);
590    EltTys.push_back(FieldTy);
591  }
592}
593
594/// getOrCreateMethodType - CXXMethodDecl's type is a FunctionType. This
595/// function type is not updated to include implicit "this" pointer. Use this
596/// routine to get a method type which includes "this" pointer.
597llvm::DIType
598CGDebugInfo::getOrCreateMethodType(const CXXMethodDecl *Method,
599                                   llvm::DIFile Unit) {
600  llvm::DIType FnTy
601    = getOrCreateType(QualType(Method->getType()->getAs<FunctionProtoType>(),
602                               0),
603                      Unit);
604
605  // Static methods do not need "this" pointer argument.
606  if (Method->isStatic())
607    return FnTy;
608
609  // Add "this" pointer.
610
611  llvm::DIArray Args = llvm::DICompositeType(FnTy).getTypeArray();
612  assert (Args.getNumElements() && "Invalid number of arguments!");
613
614  llvm::SmallVector<llvm::DIDescriptor, 16> Elts;
615
616  // First element is always return type. For 'void' functions it is NULL.
617  Elts.push_back(Args.getElement(0));
618
619  // "this" pointer is always first argument.
620  ASTContext &Context = CGM.getContext();
621  QualType ThisPtr =
622    Context.getPointerType(Context.getTagDeclType(Method->getParent()));
623  llvm::DIType ThisPtrType =
624    DebugFactory.CreateArtificialType(getOrCreateType(ThisPtr, Unit));
625
626  TypeCache[ThisPtr.getAsOpaquePtr()] = ThisPtrType;
627  Elts.push_back(ThisPtrType);
628
629  // Copy rest of the arguments.
630  for (unsigned i = 1, e = Args.getNumElements(); i != e; ++i)
631    Elts.push_back(Args.getElement(i));
632
633  llvm::DIArray EltTypeArray =
634    DebugFactory.GetOrCreateArray(Elts.data(), Elts.size());
635
636  return
637    DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type,
638                                     Unit, "", Unit,
639                                     0, 0, 0, 0, 0,
640                                     llvm::DIType(), EltTypeArray);
641}
642
643/// CreateCXXMemberFunction - A helper function to create a DISubprogram for
644/// a single member function GlobalDecl.
645llvm::DISubprogram
646CGDebugInfo::CreateCXXMemberFunction(const CXXMethodDecl *Method,
647                                     llvm::DIFile Unit,
648                                     llvm::DIType RecordTy) {
649  bool IsCtorOrDtor =
650    isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method);
651
652  llvm::StringRef MethodName = getFunctionName(Method);
653  llvm::DIType MethodTy = getOrCreateMethodType(Method, Unit);
654
655  // Since a single ctor/dtor corresponds to multiple functions, it doesn't
656  // make sense to give a single ctor/dtor a linkage name.
657  llvm::StringRef MethodLinkageName;
658  if (!IsCtorOrDtor)
659    MethodLinkageName = CGM.getMangledName(Method);
660
661  // Get the location for the method.
662  llvm::DIFile MethodDefUnit = getOrCreateFile(Method->getLocation());
663  unsigned MethodLine = getLineNumber(Method->getLocation());
664
665  // Collect virtual method info.
666  llvm::DIType ContainingType;
667  unsigned Virtuality = 0;
668  unsigned VIndex = 0;
669
670  if (Method->isVirtual()) {
671    if (Method->isPure())
672      Virtuality = llvm::dwarf::DW_VIRTUALITY_pure_virtual;
673    else
674      Virtuality = llvm::dwarf::DW_VIRTUALITY_virtual;
675
676    // It doesn't make sense to give a virtual destructor a vtable index,
677    // since a single destructor has two entries in the vtable.
678    if (!isa<CXXDestructorDecl>(Method))
679      VIndex = CGM.getVTables().getMethodVTableIndex(Method);
680    ContainingType = RecordTy;
681  }
682
683  llvm::DISubprogram SP =
684    DebugFactory.CreateSubprogram(RecordTy , MethodName, MethodName,
685                                  MethodLinkageName,
686                                  MethodDefUnit, MethodLine,
687                                  MethodTy, /*isLocalToUnit=*/false,
688                                  /* isDefintion=*/ false,
689                                  Virtuality, VIndex, ContainingType,
690                                  Method->isImplicit(),
691                                  CGM.getLangOptions().Optimize);
692
693  // Don't cache ctors or dtors since we have to emit multiple functions for
694  // a single ctor or dtor.
695  if (!IsCtorOrDtor && Method->isThisDeclarationADefinition())
696    SPCache[Method] = llvm::WeakVH(SP);
697
698  return SP;
699}
700
701/// CollectCXXMemberFunctions - A helper function to collect debug info for
702/// C++ member functions.This is used while creating debug info entry for
703/// a Record.
704void CGDebugInfo::
705CollectCXXMemberFunctions(const CXXRecordDecl *RD, llvm::DIFile Unit,
706                          llvm::SmallVectorImpl<llvm::DIDescriptor> &EltTys,
707                          llvm::DIType RecordTy) {
708  for(CXXRecordDecl::method_iterator I = RD->method_begin(),
709        E = RD->method_end(); I != E; ++I) {
710    const CXXMethodDecl *Method = *I;
711
712    if (Method->isImplicit() && !Method->isUsed())
713      continue;
714
715    EltTys.push_back(CreateCXXMemberFunction(Method, Unit, RecordTy));
716  }
717}
718
719/// CollectCXXBases - A helper function to collect debug info for
720/// C++ base classes. This is used while creating debug info entry for
721/// a Record.
722void CGDebugInfo::
723CollectCXXBases(const CXXRecordDecl *RD, llvm::DIFile Unit,
724                llvm::SmallVectorImpl<llvm::DIDescriptor> &EltTys,
725                llvm::DIType RecordTy) {
726
727  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
728  for (CXXRecordDecl::base_class_const_iterator BI = RD->bases_begin(),
729         BE = RD->bases_end(); BI != BE; ++BI) {
730    unsigned BFlags = 0;
731    uint64_t BaseOffset;
732
733    const CXXRecordDecl *Base =
734      cast<CXXRecordDecl>(BI->getType()->getAs<RecordType>()->getDecl());
735
736    if (BI->isVirtual()) {
737      // virtual base offset offset is -ve. The code generator emits dwarf
738      // expression where it expects +ve number.
739      BaseOffset = 0 - CGM.getVTables().getVirtualBaseOffsetOffset(RD, Base);
740      BFlags = llvm::DIType::FlagVirtual;
741    } else
742      BaseOffset = RL.getBaseClassOffset(Base);
743
744    AccessSpecifier Access = BI->getAccessSpecifier();
745    if (Access == clang::AS_private)
746      BFlags |= llvm::DIType::FlagPrivate;
747    else if (Access == clang::AS_protected)
748      BFlags |= llvm::DIType::FlagProtected;
749
750    llvm::DIType DTy =
751      DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_inheritance,
752                                     RecordTy, llvm::StringRef(),
753                                     Unit, 0, 0, 0,
754                                     BaseOffset, BFlags,
755                                     getOrCreateType(BI->getType(),
756                                                     Unit));
757    EltTys.push_back(DTy);
758  }
759}
760
761/// getOrCreateVTablePtrType - Return debug info descriptor for vtable.
762llvm::DIType CGDebugInfo::getOrCreateVTablePtrType(llvm::DIFile Unit) {
763  if (VTablePtrType.isValid())
764    return VTablePtrType;
765
766  ASTContext &Context = CGM.getContext();
767
768  /* Function type */
769  llvm::DIDescriptor STy = getOrCreateType(Context.IntTy, Unit);
770  llvm::DIArray SElements = DebugFactory.GetOrCreateArray(&STy, 1);
771  llvm::DIType SubTy =
772    DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type,
773                                     Unit, "", Unit,
774                                     0, 0, 0, 0, 0, llvm::DIType(), SElements);
775
776  unsigned Size = Context.getTypeSize(Context.VoidPtrTy);
777  llvm::DIType vtbl_ptr_type
778    = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type,
779                                     Unit, "__vtbl_ptr_type", Unit,
780                                     0, Size, 0, 0, 0, SubTy);
781
782  VTablePtrType =
783    DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type,
784                                   Unit, "", Unit,
785                                   0, Size, 0, 0, 0, vtbl_ptr_type);
786  return VTablePtrType;
787}
788
789/// getVTableName - Get vtable name for the given Class.
790llvm::StringRef CGDebugInfo::getVTableName(const CXXRecordDecl *RD) {
791  // Otherwise construct gdb compatible name name.
792  std::string Name = "_vptr$" + RD->getNameAsString();
793
794  // Copy this name on the side and use its reference.
795  char *StrPtr = DebugInfoNames.Allocate<char>(Name.length());
796  memcpy(StrPtr, Name.data(), Name.length());
797  return llvm::StringRef(StrPtr, Name.length());
798}
799
800
801/// CollectVTableInfo - If the C++ class has vtable info then insert appropriate
802/// debug info entry in EltTys vector.
803void CGDebugInfo::
804CollectVTableInfo(const CXXRecordDecl *RD, llvm::DIFile Unit,
805                  llvm::SmallVectorImpl<llvm::DIDescriptor> &EltTys) {
806  const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
807
808  // If there is a primary base then it will hold vtable info.
809  if (RL.getPrimaryBase())
810    return;
811
812  // If this class is not dynamic then there is not any vtable info to collect.
813  if (!RD->isDynamicClass())
814    return;
815
816  unsigned Size = CGM.getContext().getTypeSize(CGM.getContext().VoidPtrTy);
817  llvm::DIType VPTR
818    = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
819                                     getVTableName(RD), Unit,
820                                     0, Size, 0, 0, 0,
821                                     getOrCreateVTablePtrType(Unit));
822  EltTys.push_back(VPTR);
823}
824
825/// CreateType - get structure or union type.
826llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty,
827                                     llvm::DIFile Unit) {
828  RecordDecl *RD = Ty->getDecl();
829
830  unsigned Tag;
831  if (RD->isStruct())
832    Tag = llvm::dwarf::DW_TAG_structure_type;
833  else if (RD->isUnion())
834    Tag = llvm::dwarf::DW_TAG_union_type;
835  else {
836    assert(RD->isClass() && "Unknown RecordType!");
837    Tag = llvm::dwarf::DW_TAG_class_type;
838  }
839
840  // Get overall information about the record type for the debug info.
841  llvm::DIFile DefUnit = getOrCreateFile(RD->getLocation());
842  unsigned Line = getLineNumber(RD->getLocation());
843
844  // Records and classes and unions can all be recursive.  To handle them, we
845  // first generate a debug descriptor for the struct as a forward declaration.
846  // Then (if it is a definition) we go through and get debug info for all of
847  // its members.  Finally, we create a descriptor for the complete type (which
848  // may refer to the forward decl if the struct is recursive) and replace all
849  // uses of the forward declaration with the final definition.
850  llvm::DIDescriptor FDContext =
851    getContextDescriptor(dyn_cast<Decl>(RD->getDeclContext()), Unit);
852
853  // If this is just a forward declaration, construct an appropriately
854  // marked node and just return it.
855  if (!RD->getDefinition()) {
856    llvm::DICompositeType FwdDecl =
857      DebugFactory.CreateCompositeType(Tag, FDContext, RD->getName(),
858                                       DefUnit, Line, 0, 0, 0,
859                                       llvm::DIType::FlagFwdDecl,
860                                       llvm::DIType(), llvm::DIArray());
861
862      return FwdDecl;
863  }
864
865  llvm::DIType FwdDecl = DebugFactory.CreateTemporaryType();
866
867  llvm::MDNode *MN = FwdDecl;
868  llvm::TrackingVH<llvm::MDNode> FwdDeclNode = MN;
869  // Otherwise, insert it into the TypeCache so that recursive uses will find
870  // it.
871  TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
872  // Push the struct on region stack.
873  RegionStack.push_back(FwdDeclNode);
874  RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
875
876  // Convert all the elements.
877  llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
878
879  const CXXRecordDecl *CXXDecl = dyn_cast<CXXRecordDecl>(RD);
880  if (CXXDecl) {
881    CollectCXXBases(CXXDecl, Unit, EltTys, FwdDecl);
882    CollectVTableInfo(CXXDecl, Unit, EltTys);
883  }
884
885  // Collect static variables with initializers.
886  for (RecordDecl::decl_iterator I = RD->decls_begin(), E = RD->decls_end();
887       I != E; ++I)
888    if (const VarDecl *V = dyn_cast<VarDecl>(*I)) {
889      if (const Expr *Init = V->getInit()) {
890        Expr::EvalResult Result;
891        if (Init->Evaluate(Result, CGM.getContext()) && Result.Val.isInt()) {
892          llvm::ConstantInt *CI
893            = llvm::ConstantInt::get(CGM.getLLVMContext(), Result.Val.getInt());
894
895          // Create the descriptor for static variable.
896          llvm::DIFile VUnit = getOrCreateFile(V->getLocation());
897          llvm::StringRef VName = V->getName();
898          llvm::DIType VTy = getOrCreateType(V->getType(), VUnit);
899          // Do not use DIGlobalVariable for enums.
900          if (VTy.getTag() != llvm::dwarf::DW_TAG_enumeration_type) {
901            DebugFactory.CreateGlobalVariable(FwdDecl, VName, VName, VName, VUnit,
902                                              getLineNumber(V->getLocation()),
903                                              VTy, true, true, CI);
904          }
905        }
906      }
907    }
908
909  CollectRecordFields(RD, Unit, EltTys);
910  llvm::MDNode *ContainingType = NULL;
911  if (CXXDecl) {
912    CollectCXXMemberFunctions(CXXDecl, Unit, EltTys, FwdDecl);
913
914    // A class's primary base or the class itself contains the vtable.
915    const ASTRecordLayout &RL = CGM.getContext().getASTRecordLayout(RD);
916    if (const CXXRecordDecl *PBase = RL.getPrimaryBase())
917      ContainingType =
918        getOrCreateType(QualType(PBase->getTypeForDecl(), 0), Unit);
919    else if (CXXDecl->isDynamicClass())
920      ContainingType = FwdDecl;
921  }
922
923  llvm::DIArray Elements =
924    DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
925
926  // Bit size, align and offset of the type.
927  uint64_t Size = CGM.getContext().getTypeSize(Ty);
928  uint64_t Align = CGM.getContext().getTypeAlign(Ty);
929
930  RegionStack.pop_back();
931  llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator RI =
932    RegionMap.find(Ty->getDecl());
933  if (RI != RegionMap.end())
934    RegionMap.erase(RI);
935
936  llvm::DIDescriptor RDContext =
937    getContextDescriptor(dyn_cast<Decl>(RD->getDeclContext()), Unit);
938
939  llvm::StringRef RDName = RD->getName();
940  // If this is a class, include the template arguments also.
941  if (Tag == llvm::dwarf::DW_TAG_class_type)
942    RDName = getClassName(RD);
943
944  llvm::DICompositeType RealDecl =
945    DebugFactory.CreateCompositeType(Tag, RDContext,
946                                     RDName,
947                                     DefUnit, Line, Size, Align, 0, 0,
948                                     llvm::DIType(), Elements,
949                                     0, ContainingType);
950
951  // Now that we have a real decl for the struct, replace anything using the
952  // old decl with the new one.  This will recursively update the debug info.
953  llvm::DIType(FwdDeclNode).replaceAllUsesWith(RealDecl);
954  RegionMap[RD] = llvm::WeakVH(RealDecl);
955  return RealDecl;
956}
957
958/// CreateType - get objective-c object type.
959llvm::DIType CGDebugInfo::CreateType(const ObjCObjectType *Ty,
960                                     llvm::DIFile Unit) {
961  // Ignore protocols.
962  return getOrCreateType(Ty->getBaseType(), Unit);
963}
964
965/// CreateType - get objective-c interface type.
966llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
967                                     llvm::DIFile Unit) {
968  ObjCInterfaceDecl *ID = Ty->getDecl();
969  unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
970
971  // Get overall information about the record type for the debug info.
972  llvm::DIFile DefUnit = getOrCreateFile(ID->getLocation());
973  unsigned Line = getLineNumber(ID->getLocation());
974  unsigned RuntimeLang = TheCU.getLanguage();
975
976  // If this is just a forward declaration, return a special forward-declaration
977  // debug type.
978  if (ID->isForwardDecl()) {
979    llvm::DICompositeType FwdDecl =
980      DebugFactory.CreateCompositeType(Tag, Unit, ID->getName(),
981                                       DefUnit, Line, 0, 0, 0, 0,
982                                       llvm::DIType(), llvm::DIArray(),
983                                       RuntimeLang);
984    return FwdDecl;
985  }
986
987  // To handle recursive interface, we
988  // first generate a debug descriptor for the struct as a forward declaration.
989  // Then (if it is a definition) we go through and get debug info for all of
990  // its members.  Finally, we create a descriptor for the complete type (which
991  // may refer to the forward decl if the struct is recursive) and replace all
992  // uses of the forward declaration with the final definition.
993  llvm::DIType FwdDecl = DebugFactory.CreateTemporaryType();
994
995  llvm::MDNode *MN = FwdDecl;
996  llvm::TrackingVH<llvm::MDNode> FwdDeclNode = MN;
997  // Otherwise, insert it into the TypeCache so that recursive uses will find
998  // it.
999  TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
1000  // Push the struct on region stack.
1001  RegionStack.push_back(FwdDeclNode);
1002  RegionMap[Ty->getDecl()] = llvm::WeakVH(FwdDecl);
1003
1004  // Convert all the elements.
1005  llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
1006
1007  ObjCInterfaceDecl *SClass = ID->getSuperClass();
1008  if (SClass) {
1009    llvm::DIType SClassTy =
1010      getOrCreateType(CGM.getContext().getObjCInterfaceType(SClass), Unit);
1011    llvm::DIType InhTag =
1012      DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_inheritance,
1013                                     Unit, "", Unit, 0, 0, 0,
1014                                     0 /* offset */, 0, SClassTy);
1015    EltTys.push_back(InhTag);
1016  }
1017
1018  const ASTRecordLayout &RL = CGM.getContext().getASTObjCInterfaceLayout(ID);
1019
1020  unsigned FieldNo = 0;
1021  for (ObjCInterfaceDecl::ivar_iterator I = ID->ivar_begin(),
1022         E = ID->ivar_end();  I != E; ++I, ++FieldNo) {
1023    ObjCIvarDecl *Field = *I;
1024    llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
1025
1026    llvm::StringRef FieldName = Field->getName();
1027
1028    // Ignore unnamed fields.
1029    if (FieldName.empty())
1030      continue;
1031
1032    // Get the location for the field.
1033    llvm::DIFile FieldDefUnit = getOrCreateFile(Field->getLocation());
1034    unsigned FieldLine = getLineNumber(Field->getLocation());
1035    QualType FType = Field->getType();
1036    uint64_t FieldSize = 0;
1037    unsigned FieldAlign = 0;
1038
1039    if (!FType->isIncompleteArrayType()) {
1040
1041      // Bit size, align and offset of the type.
1042      FieldSize = CGM.getContext().getTypeSize(FType);
1043      Expr *BitWidth = Field->getBitWidth();
1044      if (BitWidth)
1045        FieldSize = BitWidth->EvaluateAsInt(CGM.getContext()).getZExtValue();
1046
1047      FieldAlign =  CGM.getContext().getTypeAlign(FType);
1048    }
1049
1050    uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
1051
1052    unsigned Flags = 0;
1053    if (Field->getAccessControl() == ObjCIvarDecl::Protected)
1054      Flags = llvm::DIType::FlagProtected;
1055    else if (Field->getAccessControl() == ObjCIvarDecl::Private)
1056      Flags = llvm::DIType::FlagPrivate;
1057
1058    // Create a DW_TAG_member node to remember the offset of this field in the
1059    // struct.  FIXME: This is an absolutely insane way to capture this
1060    // information.  When we gut debug info, this should be fixed.
1061    FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1062                                             FieldName, FieldDefUnit,
1063                                             FieldLine, FieldSize, FieldAlign,
1064                                             FieldOffset, Flags, FieldTy);
1065    EltTys.push_back(FieldTy);
1066  }
1067
1068  llvm::DIArray Elements =
1069    DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
1070
1071  RegionStack.pop_back();
1072  llvm::DenseMap<const Decl *, llvm::WeakVH>::iterator RI =
1073    RegionMap.find(Ty->getDecl());
1074  if (RI != RegionMap.end())
1075    RegionMap.erase(RI);
1076
1077  // Bit size, align and offset of the type.
1078  uint64_t Size = CGM.getContext().getTypeSize(Ty);
1079  uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1080
1081  llvm::DICompositeType RealDecl =
1082    DebugFactory.CreateCompositeType(Tag, Unit, ID->getName(), DefUnit,
1083                                     Line, Size, Align, 0, 0, llvm::DIType(),
1084                                     Elements, RuntimeLang);
1085
1086  // Now that we have a real decl for the struct, replace anything using the
1087  // old decl with the new one.  This will recursively update the debug info.
1088  llvm::DIType(FwdDeclNode).replaceAllUsesWith(RealDecl);
1089  RegionMap[ID] = llvm::WeakVH(RealDecl);
1090
1091  return RealDecl;
1092}
1093
1094llvm::DIType CGDebugInfo::CreateType(const EnumType *Ty,
1095                                     llvm::DIFile Unit) {
1096  return CreateEnumType(Ty->getDecl(), Unit);
1097
1098}
1099
1100llvm::DIType CGDebugInfo::CreateType(const TagType *Ty,
1101                                     llvm::DIFile Unit) {
1102  if (const RecordType *RT = dyn_cast<RecordType>(Ty))
1103    return CreateType(RT, Unit);
1104  else if (const EnumType *ET = dyn_cast<EnumType>(Ty))
1105    return CreateType(ET, Unit);
1106
1107  return llvm::DIType();
1108}
1109
1110llvm::DIType CGDebugInfo::CreateType(const VectorType *Ty,
1111                                     llvm::DIFile Unit) {
1112  llvm::DIType ElementTy = getOrCreateType(Ty->getElementType(), Unit);
1113  uint64_t NumElems = Ty->getNumElements();
1114  if (NumElems > 0)
1115    --NumElems;
1116
1117  llvm::DIDescriptor Subscript = DebugFactory.GetOrCreateSubrange(0, NumElems);
1118  llvm::DIArray SubscriptArray = DebugFactory.GetOrCreateArray(&Subscript, 1);
1119
1120  uint64_t Size = CGM.getContext().getTypeSize(Ty);
1121  uint64_t Align = CGM.getContext().getTypeAlign(Ty);
1122
1123  return
1124    DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_vector_type,
1125                                     Unit, "", Unit,
1126                                     0, Size, Align, 0, 0,
1127                                     ElementTy,  SubscriptArray);
1128}
1129
1130llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty,
1131                                     llvm::DIFile Unit) {
1132  uint64_t Size;
1133  uint64_t Align;
1134
1135
1136  // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
1137  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
1138    Size = 0;
1139    Align =
1140      CGM.getContext().getTypeAlign(CGM.getContext().getBaseElementType(VAT));
1141  } else if (Ty->isIncompleteArrayType()) {
1142    Size = 0;
1143    Align = CGM.getContext().getTypeAlign(Ty->getElementType());
1144  } else {
1145    // Size and align of the whole array, not the element type.
1146    Size = CGM.getContext().getTypeSize(Ty);
1147    Align = CGM.getContext().getTypeAlign(Ty);
1148  }
1149
1150  // Add the dimensions of the array.  FIXME: This loses CV qualifiers from
1151  // interior arrays, do we care?  Why aren't nested arrays represented the
1152  // obvious/recursive way?
1153  llvm::SmallVector<llvm::DIDescriptor, 8> Subscripts;
1154  QualType EltTy(Ty, 0);
1155  while ((Ty = dyn_cast<ArrayType>(EltTy))) {
1156    uint64_t Upper = 0;
1157    if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty))
1158      if (CAT->getSize().getZExtValue())
1159        Upper = CAT->getSize().getZExtValue() - 1;
1160    // FIXME: Verify this is right for VLAs.
1161    Subscripts.push_back(DebugFactory.GetOrCreateSubrange(0, Upper));
1162    EltTy = Ty->getElementType();
1163  }
1164
1165  llvm::DIArray SubscriptArray =
1166    DebugFactory.GetOrCreateArray(Subscripts.data(), Subscripts.size());
1167
1168  llvm::DIType DbgTy =
1169    DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_array_type,
1170                                     Unit, "", Unit,
1171                                     0, Size, Align, 0, 0,
1172                                     getOrCreateType(EltTy, Unit),
1173                                     SubscriptArray);
1174  return DbgTy;
1175}
1176
1177llvm::DIType CGDebugInfo::CreateType(const LValueReferenceType *Ty,
1178                                     llvm::DIFile Unit) {
1179  return CreatePointerLikeType(llvm::dwarf::DW_TAG_reference_type,
1180                               Ty, Ty->getPointeeType(), Unit);
1181}
1182
1183llvm::DIType CGDebugInfo::CreateType(const MemberPointerType *Ty,
1184                                     llvm::DIFile U) {
1185  QualType PointerDiffTy = CGM.getContext().getPointerDiffType();
1186  llvm::DIType PointerDiffDITy = getOrCreateType(PointerDiffTy, U);
1187
1188  if (!Ty->getPointeeType()->isFunctionType()) {
1189    // We have a data member pointer type.
1190    return PointerDiffDITy;
1191  }
1192
1193  // We have a member function pointer type. Treat it as a struct with two
1194  // ptrdiff_t members.
1195  std::pair<uint64_t, unsigned> Info = CGM.getContext().getTypeInfo(Ty);
1196
1197  uint64_t FieldOffset = 0;
1198  llvm::DIDescriptor ElementTypes[2];
1199
1200  // FIXME: This should probably be a function type instead.
1201  ElementTypes[0] =
1202    DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, U,
1203                                   "ptr", U, 0,
1204                                   Info.first, Info.second, FieldOffset, 0,
1205                                   PointerDiffDITy);
1206  FieldOffset += Info.first;
1207
1208  ElementTypes[1] =
1209    DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, U,
1210                                   "ptr", U, 0,
1211                                   Info.first, Info.second, FieldOffset, 0,
1212                                   PointerDiffDITy);
1213
1214  llvm::DIArray Elements =
1215    DebugFactory.GetOrCreateArray(&ElementTypes[0],
1216                                  llvm::array_lengthof(ElementTypes));
1217
1218  return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_structure_type,
1219                                          U, llvm::StringRef("test"),
1220                                          U, 0, FieldOffset,
1221                                          0, 0, 0, llvm::DIType(), Elements);
1222}
1223
1224/// CreateEnumType - get enumeration type.
1225llvm::DIType CGDebugInfo::CreateEnumType(const EnumDecl *ED, llvm::DIFile Unit){
1226  llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators;
1227
1228  // Create DIEnumerator elements for each enumerator.
1229  for (EnumDecl::enumerator_iterator
1230         Enum = ED->enumerator_begin(), EnumEnd = ED->enumerator_end();
1231       Enum != EnumEnd; ++Enum) {
1232    Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getName(),
1233                                            Enum->getInitVal().getZExtValue()));
1234  }
1235
1236  // Return a CompositeType for the enum itself.
1237  llvm::DIArray EltArray =
1238    DebugFactory.GetOrCreateArray(Enumerators.data(), Enumerators.size());
1239
1240  llvm::DIFile DefUnit = getOrCreateFile(ED->getLocation());
1241  unsigned Line = getLineNumber(ED->getLocation());
1242  uint64_t Size = 0;
1243  uint64_t Align = 0;
1244  if (!ED->getTypeForDecl()->isIncompleteType()) {
1245    Size = CGM.getContext().getTypeSize(ED->getTypeForDecl());
1246    Align = CGM.getContext().getTypeAlign(ED->getTypeForDecl());
1247  }
1248  llvm::DIType DbgTy =
1249    DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_enumeration_type,
1250                                     Unit, ED->getName(), DefUnit, Line,
1251                                     Size, Align, 0, 0,
1252                                     llvm::DIType(), EltArray);
1253  return DbgTy;
1254}
1255
1256static QualType UnwrapTypeForDebugInfo(QualType T) {
1257  do {
1258    QualType LastT = T;
1259    switch (T->getTypeClass()) {
1260    default:
1261      return T;
1262    case Type::TemplateSpecialization:
1263      T = cast<TemplateSpecializationType>(T)->desugar();
1264      break;
1265    case Type::TypeOfExpr: {
1266      TypeOfExprType *Ty = cast<TypeOfExprType>(T);
1267      T = Ty->getUnderlyingExpr()->getType();
1268      break;
1269    }
1270    case Type::TypeOf:
1271      T = cast<TypeOfType>(T)->getUnderlyingType();
1272      break;
1273    case Type::Decltype:
1274      T = cast<DecltypeType>(T)->getUnderlyingType();
1275      break;
1276    case Type::Elaborated:
1277      T = cast<ElaboratedType>(T)->getNamedType();
1278      break;
1279    case Type::SubstTemplateTypeParm:
1280      T = cast<SubstTemplateTypeParmType>(T)->getReplacementType();
1281      break;
1282    }
1283
1284    assert(T != LastT && "Type unwrapping failed to unwrap!");
1285    if (T == LastT)
1286      return T;
1287  } while (true);
1288
1289  return T;
1290}
1291
1292/// getOrCreateType - Get the type from the cache or create a new
1293/// one if necessary.
1294llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
1295                                          llvm::DIFile Unit) {
1296  if (Ty.isNull())
1297    return llvm::DIType();
1298
1299  // Unwrap the type as needed for debug information.
1300  Ty = UnwrapTypeForDebugInfo(Ty);
1301
1302  // Check for existing entry.
1303  llvm::DenseMap<void *, llvm::WeakVH>::iterator it =
1304    TypeCache.find(Ty.getAsOpaquePtr());
1305  if (it != TypeCache.end()) {
1306    // Verify that the debug info still exists.
1307    if (&*it->second)
1308      return llvm::DIType(cast<llvm::MDNode>(it->second));
1309  }
1310
1311  // Otherwise create the type.
1312  llvm::DIType Res = CreateTypeNode(Ty, Unit);
1313
1314  // And update the type cache.
1315  TypeCache[Ty.getAsOpaquePtr()] = Res;
1316  return Res;
1317}
1318
1319/// CreateTypeNode - Create a new debug type node.
1320llvm::DIType CGDebugInfo::CreateTypeNode(QualType Ty,
1321                                         llvm::DIFile Unit) {
1322  // Handle qualifiers, which recursively handles what they refer to.
1323  if (Ty.hasLocalQualifiers())
1324    return CreateQualifiedType(Ty, Unit);
1325
1326  const char *Diag = 0;
1327
1328  // Work out details of type.
1329  switch (Ty->getTypeClass()) {
1330#define TYPE(Class, Base)
1331#define ABSTRACT_TYPE(Class, Base)
1332#define NON_CANONICAL_TYPE(Class, Base)
1333#define DEPENDENT_TYPE(Class, Base) case Type::Class:
1334#include "clang/AST/TypeNodes.def"
1335    assert(false && "Dependent types cannot show up in debug information");
1336
1337  // FIXME: Handle these.
1338  case Type::ExtVector:
1339    return llvm::DIType();
1340
1341  case Type::Vector:
1342    return CreateType(cast<VectorType>(Ty), Unit);
1343  case Type::ObjCObjectPointer:
1344    return CreateType(cast<ObjCObjectPointerType>(Ty), Unit);
1345  case Type::ObjCObject:
1346    return CreateType(cast<ObjCObjectType>(Ty), Unit);
1347  case Type::ObjCInterface:
1348    return CreateType(cast<ObjCInterfaceType>(Ty), Unit);
1349  case Type::Builtin: return CreateType(cast<BuiltinType>(Ty), Unit);
1350  case Type::Complex: return CreateType(cast<ComplexType>(Ty), Unit);
1351  case Type::Pointer: return CreateType(cast<PointerType>(Ty), Unit);
1352  case Type::BlockPointer:
1353    return CreateType(cast<BlockPointerType>(Ty), Unit);
1354  case Type::Typedef: return CreateType(cast<TypedefType>(Ty), Unit);
1355  case Type::Record:
1356  case Type::Enum:
1357    return CreateType(cast<TagType>(Ty), Unit);
1358  case Type::FunctionProto:
1359  case Type::FunctionNoProto:
1360    return CreateType(cast<FunctionType>(Ty), Unit);
1361  case Type::ConstantArray:
1362  case Type::VariableArray:
1363  case Type::IncompleteArray:
1364    return CreateType(cast<ArrayType>(Ty), Unit);
1365
1366  case Type::LValueReference:
1367    return CreateType(cast<LValueReferenceType>(Ty), Unit);
1368
1369  case Type::MemberPointer:
1370    return CreateType(cast<MemberPointerType>(Ty), Unit);
1371
1372  case Type::TemplateSpecialization:
1373  case Type::Elaborated:
1374  case Type::SubstTemplateTypeParm:
1375  case Type::TypeOfExpr:
1376  case Type::TypeOf:
1377  case Type::Decltype:
1378    llvm_unreachable("type should have been unwrapped!");
1379    return llvm::DIType();
1380
1381  case Type::RValueReference:
1382    // FIXME: Implement!
1383    Diag = "rvalue references";
1384    break;
1385  }
1386
1387  assert(Diag && "Fall through without a diagnostic?");
1388  unsigned DiagID = CGM.getDiags().getCustomDiagID(Diagnostic::Error,
1389                               "debug information for %0 is not yet supported");
1390  CGM.getDiags().Report(FullSourceLoc(), DiagID)
1391    << Diag;
1392  return llvm::DIType();
1393}
1394
1395/// CreateMemberType - Create new member and increase Offset by FType's size.
1396llvm::DIType CGDebugInfo::CreateMemberType(llvm::DIFile Unit, QualType FType,
1397                                           llvm::StringRef Name,
1398                                           uint64_t *Offset) {
1399  llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
1400  uint64_t FieldSize = CGM.getContext().getTypeSize(FType);
1401  unsigned FieldAlign = CGM.getContext().getTypeAlign(FType);
1402  llvm::DIType Ty = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member,
1403                                                   Unit, Name, Unit, 0,
1404                                                   FieldSize, FieldAlign,
1405                                                   *Offset, 0, FieldTy);
1406  *Offset += FieldSize;
1407  return Ty;
1408}
1409
1410/// EmitFunctionStart - Constructs the debug code for entering a function -
1411/// "llvm.dbg.func.start.".
1412void CGDebugInfo::EmitFunctionStart(GlobalDecl GD, QualType FnType,
1413                                    llvm::Function *Fn,
1414                                    CGBuilderTy &Builder) {
1415
1416  llvm::StringRef Name;
1417  llvm::StringRef LinkageName;
1418
1419  FnBeginRegionCount.push_back(RegionStack.size());
1420
1421  const Decl *D = GD.getDecl();
1422  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
1423    // If there is a DISubprogram for  this function available then use it.
1424    llvm::DenseMap<const FunctionDecl *, llvm::WeakVH>::iterator
1425      FI = SPCache.find(FD);
1426    if (FI != SPCache.end()) {
1427      llvm::DIDescriptor SP(dyn_cast_or_null<llvm::MDNode>(FI->second));
1428      if (SP.isSubprogram() && llvm::DISubprogram(SP).isDefinition()) {
1429        llvm::MDNode *SPN = SP;
1430        RegionStack.push_back(SPN);
1431        RegionMap[D] = llvm::WeakVH(SP);
1432        return;
1433      }
1434    }
1435    Name = getFunctionName(FD);
1436    // Use mangled name as linkage name for c/c++ functions.
1437    LinkageName = CGM.getMangledName(GD);
1438  } else {
1439    // Use llvm function name as linkage name.
1440    Name = Fn->getName();
1441    LinkageName = Name;
1442  }
1443  if (!Name.empty() && Name[0] == '\01')
1444    Name = Name.substr(1);
1445
1446  // It is expected that CurLoc is set before using EmitFunctionStart.
1447  // Usually, CurLoc points to the left bracket location of compound
1448  // statement representing function body.
1449  llvm::DIFile Unit = getOrCreateFile(CurLoc);
1450  unsigned LineNo = getLineNumber(CurLoc);
1451
1452  llvm::DISubprogram SP =
1453    DebugFactory.CreateSubprogram(Unit, Name, Name, LinkageName, Unit, LineNo,
1454                                  getOrCreateType(FnType, Unit),
1455                                  Fn->hasInternalLinkage(), true/*definition*/,
1456                                  0, 0, llvm::DIType(),
1457                                  D->isImplicit(),
1458                                  CGM.getLangOptions().Optimize, Fn);
1459
1460  // Push function on region stack.
1461  llvm::MDNode *SPN = SP;
1462  RegionStack.push_back(SPN);
1463  RegionMap[D] = llvm::WeakVH(SP);
1464
1465  // Clear stack used to keep track of #line directives.
1466  LineDirectiveFiles.clear();
1467}
1468
1469
1470void CGDebugInfo::EmitStopPoint(CGBuilderTy &Builder) {
1471  if (CurLoc.isInvalid() || CurLoc.isMacroID()) return;
1472
1473  // Don't bother if things are the same as last time.
1474  SourceManager &SM = CGM.getContext().getSourceManager();
1475  if (CurLoc == PrevLoc
1476       || (SM.getInstantiationLineNumber(CurLoc) ==
1477           SM.getInstantiationLineNumber(PrevLoc)
1478           && SM.isFromSameFile(CurLoc, PrevLoc)))
1479    // New Builder may not be in sync with CGDebugInfo.
1480    if (!Builder.getCurrentDebugLocation().isUnknown())
1481      return;
1482
1483  // Update last state.
1484  PrevLoc = CurLoc;
1485
1486  llvm::MDNode *Scope = RegionStack.back();
1487  Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(getLineNumber(CurLoc),
1488                                                      getColumnNumber(CurLoc),
1489                                                      Scope));
1490}
1491
1492/// UpdateLineDirectiveRegion - Update region stack only if #line directive
1493/// has introduced scope change.
1494void CGDebugInfo::UpdateLineDirectiveRegion(CGBuilderTy &Builder) {
1495  if (CurLoc.isInvalid() || CurLoc.isMacroID() ||
1496      PrevLoc.isInvalid() || PrevLoc.isMacroID())
1497    return;
1498  SourceManager &SM = CGM.getContext().getSourceManager();
1499  PresumedLoc PCLoc = SM.getPresumedLoc(CurLoc);
1500  PresumedLoc PPLoc = SM.getPresumedLoc(PrevLoc);
1501
1502  if (!strcmp(PPLoc.getFilename(), PCLoc.getFilename()))
1503    return;
1504
1505  // If #line directive stack is empty then we are entering a new scope.
1506  if (LineDirectiveFiles.empty()) {
1507    EmitRegionStart(Builder);
1508    LineDirectiveFiles.push_back(PCLoc.getFilename());
1509    return;
1510  }
1511
1512  assert (RegionStack.size() >= LineDirectiveFiles.size()
1513          && "error handling  #line regions!");
1514
1515  bool SeenThisFile = false;
1516  for(std::vector<const char *>::iterator I = LineDirectiveFiles.begin(),
1517        E = LineDirectiveFiles.end(); I != E; ++I)
1518    if (!strcmp(PPLoc.getFilename(), *I)) {
1519      SeenThisFile = true;
1520      break;
1521    }
1522
1523  // If #line for this file is seen earlier then pop out #line regions.
1524  if (SeenThisFile) {
1525    while (!LineDirectiveFiles.empty()) {
1526      const char *LastFile = LineDirectiveFiles.back();
1527      RegionStack.pop_back();
1528      LineDirectiveFiles.pop_back();
1529      if (!strcmp(PPLoc.getFilename(), LastFile))
1530        break;
1531    }
1532    return;
1533  }
1534
1535  // .. otherwise insert new #line region.
1536  EmitRegionStart(Builder);
1537  LineDirectiveFiles.push_back(PCLoc.getFilename());
1538
1539  return;
1540}
1541/// EmitRegionStart- Constructs the debug code for entering a declarative
1542/// region - "llvm.dbg.region.start.".
1543void CGDebugInfo::EmitRegionStart(CGBuilderTy &Builder) {
1544  llvm::DIDescriptor D =
1545    DebugFactory.CreateLexicalBlock(RegionStack.empty() ?
1546                                    llvm::DIDescriptor() :
1547                                    llvm::DIDescriptor(RegionStack.back()),
1548                                    getOrCreateFile(CurLoc),
1549                                    getLineNumber(CurLoc),
1550                                    getColumnNumber(CurLoc));
1551  llvm::MDNode *DN = D;
1552  RegionStack.push_back(DN);
1553}
1554
1555/// EmitRegionEnd - Constructs the debug code for exiting a declarative
1556/// region - "llvm.dbg.region.end."
1557void CGDebugInfo::EmitRegionEnd(CGBuilderTy &Builder) {
1558  assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1559
1560  // Provide an region stop point.
1561  EmitStopPoint(Builder);
1562
1563  RegionStack.pop_back();
1564}
1565
1566/// EmitFunctionEnd - Constructs the debug code for exiting a function.
1567void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder) {
1568  assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1569  unsigned RCount = FnBeginRegionCount.back();
1570  assert(RCount <= RegionStack.size() && "Region stack mismatch");
1571
1572  // Pop all regions for this function.
1573  while (RegionStack.size() != RCount)
1574    EmitRegionEnd(Builder);
1575  FnBeginRegionCount.pop_back();
1576}
1577
1578// EmitTypeForVarWithBlocksAttr - Build up structure info for the byref.
1579// See BuildByRefType.
1580llvm::DIType CGDebugInfo::EmitTypeForVarWithBlocksAttr(const ValueDecl *VD,
1581                                                       uint64_t *XOffset) {
1582
1583  llvm::SmallVector<llvm::DIDescriptor, 5> EltTys;
1584
1585  QualType FType;
1586  uint64_t FieldSize, FieldOffset;
1587  unsigned FieldAlign;
1588
1589  llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
1590  QualType Type = VD->getType();
1591
1592  FieldOffset = 0;
1593  FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1594  EltTys.push_back(CreateMemberType(Unit, FType, "__isa", &FieldOffset));
1595  EltTys.push_back(CreateMemberType(Unit, FType, "__forwarding", &FieldOffset));
1596  FType = CGM.getContext().IntTy;
1597  EltTys.push_back(CreateMemberType(Unit, FType, "__flags", &FieldOffset));
1598  EltTys.push_back(CreateMemberType(Unit, FType, "__size", &FieldOffset));
1599
1600  bool HasCopyAndDispose = CGM.BlockRequiresCopying(Type);
1601  if (HasCopyAndDispose) {
1602    FType = CGM.getContext().getPointerType(CGM.getContext().VoidTy);
1603    EltTys.push_back(CreateMemberType(Unit, FType, "__copy_helper",
1604                                      &FieldOffset));
1605    EltTys.push_back(CreateMemberType(Unit, FType, "__destroy_helper",
1606                                      &FieldOffset));
1607  }
1608
1609  CharUnits Align = CGM.getContext().getDeclAlign(VD);
1610  if (Align > CharUnits::fromQuantity(
1611        CGM.getContext().Target.getPointerAlign(0) / 8)) {
1612    unsigned AlignedOffsetInBytes
1613      = llvm::RoundUpToAlignment(FieldOffset/8, Align.getQuantity());
1614    unsigned NumPaddingBytes
1615      = AlignedOffsetInBytes - FieldOffset/8;
1616
1617    if (NumPaddingBytes > 0) {
1618      llvm::APInt pad(32, NumPaddingBytes);
1619      FType = CGM.getContext().getConstantArrayType(CGM.getContext().CharTy,
1620                                                    pad, ArrayType::Normal, 0);
1621      EltTys.push_back(CreateMemberType(Unit, FType, "", &FieldOffset));
1622    }
1623  }
1624
1625  FType = Type;
1626  llvm::DIType FieldTy = CGDebugInfo::getOrCreateType(FType, Unit);
1627  FieldSize = CGM.getContext().getTypeSize(FType);
1628  FieldAlign = Align.getQuantity()*8;
1629
1630  *XOffset = FieldOffset;
1631  FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
1632                                           VD->getName(), Unit,
1633                                           0, FieldSize, FieldAlign,
1634                                           FieldOffset, 0, FieldTy);
1635  EltTys.push_back(FieldTy);
1636  FieldOffset += FieldSize;
1637
1638  llvm::DIArray Elements =
1639    DebugFactory.GetOrCreateArray(EltTys.data(), EltTys.size());
1640
1641  unsigned Flags = llvm::DIType::FlagBlockByrefStruct;
1642
1643  return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_structure_type,
1644                                          Unit, "", Unit,
1645                                          0, FieldOffset, 0, 0, Flags,
1646                                          llvm::DIType(), Elements);
1647
1648}
1649/// EmitDeclare - Emit local variable declaration debug info.
1650void CGDebugInfo::EmitDeclare(const VarDecl *VD, unsigned Tag,
1651                              llvm::Value *Storage, CGBuilderTy &Builder) {
1652  assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1653
1654  llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
1655  llvm::DIType Ty;
1656  uint64_t XOffset = 0;
1657  if (VD->hasAttr<BlocksAttr>())
1658    Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
1659  else
1660    Ty = getOrCreateType(VD->getType(), Unit);
1661
1662  // If there is not any debug info for type then do not emit debug info
1663  // for this variable.
1664  if (!Ty)
1665    return;
1666
1667  // Get location information.
1668  unsigned Line = getLineNumber(VD->getLocation());
1669  unsigned Column = getColumnNumber(VD->getLocation());
1670
1671  // Create the descriptor for the variable.
1672  llvm::DIVariable D =
1673    DebugFactory.CreateVariable(Tag, llvm::DIDescriptor(RegionStack.back()),
1674                                VD->getName(),
1675                                Unit, Line, Ty, CGM.getLangOptions().Optimize);
1676  // Insert an llvm.dbg.declare into the current block.
1677  llvm::Instruction *Call =
1678    DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock());
1679
1680  llvm::MDNode *Scope = RegionStack.back();
1681  Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
1682}
1683
1684/// EmitDeclare - Emit local variable declaration debug info.
1685void CGDebugInfo::EmitDeclare(const BlockDeclRefExpr *BDRE, unsigned Tag,
1686                              llvm::Value *Storage, CGBuilderTy &Builder,
1687                              CodeGenFunction *CGF) {
1688  const ValueDecl *VD = BDRE->getDecl();
1689  assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
1690
1691  if (Builder.GetInsertBlock() == 0)
1692    return;
1693
1694  uint64_t XOffset = 0;
1695  llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
1696  llvm::DIType Ty;
1697  if (VD->hasAttr<BlocksAttr>())
1698    Ty = EmitTypeForVarWithBlocksAttr(VD, &XOffset);
1699  else
1700    Ty = getOrCreateType(VD->getType(), Unit);
1701
1702  // Get location information.
1703  unsigned Line = getLineNumber(VD->getLocation());
1704  unsigned Column = getColumnNumber(VD->getLocation());
1705
1706  CharUnits offset = CGF->BlockDecls[VD];
1707  llvm::SmallVector<llvm::Value *, 9> addr;
1708  const llvm::Type *Int64Ty = llvm::Type::getInt64Ty(CGM.getLLVMContext());
1709  addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpDeref));
1710  addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpPlus));
1711  addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
1712  if (BDRE->isByRef()) {
1713    addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpDeref));
1714    addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpPlus));
1715    // offset of __forwarding field
1716    offset = CharUnits::fromQuantity(CGF->LLVMPointerWidth/8);
1717    addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
1718    addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpDeref));
1719    addr.push_back(llvm::ConstantInt::get(Int64Ty, llvm::DIFactory::OpPlus));
1720    // offset of x field
1721    offset = CharUnits::fromQuantity(XOffset/8);
1722    addr.push_back(llvm::ConstantInt::get(Int64Ty, offset.getQuantity()));
1723  }
1724
1725  // Create the descriptor for the variable.
1726  llvm::DIVariable D =
1727    DebugFactory.CreateComplexVariable(Tag,
1728                                       llvm::DIDescriptor(RegionStack.back()),
1729                                       VD->getName(), Unit, Line, Ty,
1730                                       addr);
1731  // Insert an llvm.dbg.declare into the current block.
1732  llvm::Instruction *Call =
1733    DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock());
1734
1735  llvm::MDNode *Scope = RegionStack.back();
1736  Call->setDebugLoc(llvm::DebugLoc::get(Line, Column, Scope));
1737}
1738
1739void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *VD,
1740                                            llvm::Value *Storage,
1741                                            CGBuilderTy &Builder) {
1742  EmitDeclare(VD, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder);
1743}
1744
1745void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
1746  const BlockDeclRefExpr *BDRE, llvm::Value *Storage, CGBuilderTy &Builder,
1747  CodeGenFunction *CGF) {
1748  EmitDeclare(BDRE, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder, CGF);
1749}
1750
1751/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
1752/// variable declaration.
1753void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *VD, llvm::Value *AI,
1754                                           CGBuilderTy &Builder) {
1755  EmitDeclare(VD, llvm::dwarf::DW_TAG_arg_variable, AI, Builder);
1756}
1757
1758
1759
1760/// EmitGlobalVariable - Emit information about a global variable.
1761void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
1762                                     const VarDecl *D) {
1763
1764  // Create global variable debug descriptor.
1765  llvm::DIFile Unit = getOrCreateFile(D->getLocation());
1766  unsigned LineNo = getLineNumber(D->getLocation());
1767
1768  QualType T = D->getType();
1769  if (T->isIncompleteArrayType()) {
1770
1771    // CodeGen turns int[] into int[1] so we'll do the same here.
1772    llvm::APSInt ConstVal(32);
1773
1774    ConstVal = 1;
1775    QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
1776
1777    T = CGM.getContext().getConstantArrayType(ET, ConstVal,
1778                                           ArrayType::Normal, 0);
1779  }
1780  llvm::StringRef DeclName = D->getName();
1781  llvm::StringRef LinkageName;
1782  if (D->getDeclContext() && !isa<FunctionDecl>(D->getDeclContext()))
1783    LinkageName = Var->getName();
1784  llvm::DIDescriptor DContext =
1785    getContextDescriptor(dyn_cast<Decl>(D->getDeclContext()), Unit);
1786  DebugFactory.CreateGlobalVariable(DContext, DeclName, DeclName, LinkageName,
1787                                    Unit, LineNo, getOrCreateType(T, Unit),
1788                                    Var->hasInternalLinkage(),
1789                                    true/*definition*/, Var);
1790}
1791
1792/// EmitGlobalVariable - Emit information about an objective-c interface.
1793void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
1794                                     ObjCInterfaceDecl *ID) {
1795  // Create global variable debug descriptor.
1796  llvm::DIFile Unit = getOrCreateFile(ID->getLocation());
1797  unsigned LineNo = getLineNumber(ID->getLocation());
1798
1799  llvm::StringRef Name = ID->getName();
1800
1801  QualType T = CGM.getContext().getObjCInterfaceType(ID);
1802  if (T->isIncompleteArrayType()) {
1803
1804    // CodeGen turns int[] into int[1] so we'll do the same here.
1805    llvm::APSInt ConstVal(32);
1806
1807    ConstVal = 1;
1808    QualType ET = CGM.getContext().getAsArrayType(T)->getElementType();
1809
1810    T = CGM.getContext().getConstantArrayType(ET, ConstVal,
1811                                           ArrayType::Normal, 0);
1812  }
1813
1814  DebugFactory.CreateGlobalVariable(Unit, Name, Name, Name, Unit, LineNo,
1815                                    getOrCreateType(T, Unit),
1816                                    Var->hasInternalLinkage(),
1817                                    true/*definition*/, Var);
1818}
1819
1820/// EmitGlobalVariable - Emit global variable's debug info.
1821void CGDebugInfo::EmitGlobalVariable(const ValueDecl *VD,
1822                                     llvm::ConstantInt *Init,
1823                                     CGBuilderTy &Builder) {
1824  // Create the descriptor for the variable.
1825  llvm::DIFile Unit = getOrCreateFile(VD->getLocation());
1826  llvm::StringRef Name = VD->getName();
1827  llvm::DIType Ty = getOrCreateType(VD->getType(), Unit);
1828  if (const EnumConstantDecl *ECD = dyn_cast<EnumConstantDecl>(VD)) {
1829    if (const EnumDecl *ED = dyn_cast<EnumDecl>(ECD->getDeclContext()))
1830      Ty = CreateEnumType(ED, Unit);
1831  }
1832  // Do not use DIGlobalVariable for enums.
1833  if (Ty.getTag() == llvm::dwarf::DW_TAG_enumeration_type)
1834    return;
1835  DebugFactory.CreateGlobalVariable(Unit, Name, Name, Name, Unit,
1836                                    getLineNumber(VD->getLocation()),
1837                                    Ty, true, true, Init);
1838}
1839
1840/// getOrCreateNamesSpace - Return namespace descriptor for the given
1841/// namespace decl.
1842llvm::DINameSpace
1843CGDebugInfo::getOrCreateNameSpace(const NamespaceDecl *NSDecl,
1844                                  llvm::DIDescriptor Unit) {
1845  llvm::DenseMap<const NamespaceDecl *, llvm::WeakVH>::iterator I =
1846    NameSpaceCache.find(NSDecl);
1847  if (I != NameSpaceCache.end())
1848    return llvm::DINameSpace(cast<llvm::MDNode>(I->second));
1849
1850  unsigned LineNo = getLineNumber(NSDecl->getLocation());
1851
1852  llvm::DIDescriptor Context =
1853    getContextDescriptor(dyn_cast<Decl>(NSDecl->getDeclContext()), Unit);
1854  llvm::DINameSpace NS =
1855    DebugFactory.CreateNameSpace(Context, NSDecl->getName(),
1856        llvm::DIFile(Unit), LineNo);
1857  NameSpaceCache[NSDecl] = llvm::WeakVH(NS);
1858  return NS;
1859}
1860