CGDebugInfo.cpp revision 72564e73277e29f6db3305d1f27ba408abb7ed88 
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 "CodeGenModule.h"
16#include "clang/AST/ASTContext.h"
17#include "clang/AST/DeclObjC.h"
18#include "clang/AST/Expr.h"
19#include "clang/AST/RecordLayout.h"
20#include "clang/Basic/SourceManager.h"
21#include "clang/Basic/FileManager.h"
22#include "llvm/Constants.h"
23#include "llvm/DerivedTypes.h"
24#include "llvm/Instructions.h"
25#include "llvm/Intrinsics.h"
26#include "llvm/Module.h"
27#include "llvm/ADT/StringExtras.h"
28#include "llvm/ADT/SmallVector.h"
29#include "llvm/Support/Dwarf.h"
30#include "llvm/Target/TargetMachine.h"
31using namespace clang;
32using namespace clang::CodeGen;
33
34CGDebugInfo::CGDebugInfo(CodeGenModule *m)
35  : M(m), DebugFactory(M->getModule()) {
36}
37
38CGDebugInfo::~CGDebugInfo() {
39  assert(RegionStack.empty() && "Region stack mismatch, stack not empty!");
40}
41
42void CGDebugInfo::setLocation(SourceLocation Loc) {
43  if (Loc.isValid())
44    CurLoc = M->getContext().getSourceManager().getInstantiationLoc(Loc);
45}
46
47/// getOrCreateCompileUnit - Get the compile unit from the cache or create a new
48/// one if necessary. This returns null for invalid source locations.
49llvm::DICompileUnit CGDebugInfo::getOrCreateCompileUnit(SourceLocation Loc) {
50  // FIXME: Until we do a complete job of emitting debug information,
51  // we need to support making dummy compile units so that we generate
52  // "well formed" debug info.
53  const FileEntry *FE = 0;
54
55  SourceManager &SM = M->getContext().getSourceManager();
56  if (Loc.isValid()) {
57    Loc = SM.getInstantiationLoc(Loc);
58    FE = SM.getFileEntryForID(SM.getFileID(Loc));
59  } else {
60    // If Loc is not valid then use main file id.
61    FE = SM.getFileEntryForID(SM.getMainFileID());
62  }
63
64  // See if this compile unit has been used before.
65  llvm::DICompileUnit &Unit = CompileUnitCache[FE];
66  if (!Unit.isNull()) return Unit;
67
68  // Get source file information.
69  const char *FileName = FE ? FE->getName() : "<unknown>";
70  const char *DirName = FE ? FE->getDir()->getName() : "<unknown>";
71
72  // Create new compile unit.
73  // FIXME: Handle other language IDs as well.
74  // FIXME: Do not know how to get clang version yet.
75  return Unit = DebugFactory.CreateCompileUnit(llvm::dwarf::DW_LANG_C89,
76                                               FileName, DirName, "clang");
77}
78
79/// CreateType - Get the Basic type from the cache or create a new
80/// one if necessary.
81llvm::DIType CGDebugInfo::CreateType(const BuiltinType *BT,
82                                     llvm::DICompileUnit Unit) {
83  unsigned Encoding = 0;
84  switch (BT->getKind()) {
85  default:
86  case BuiltinType::Void:
87    return llvm::DIType();
88  case BuiltinType::UChar:
89  case BuiltinType::Char_U: Encoding = llvm::dwarf::DW_ATE_unsigned_char; break;
90  case BuiltinType::Char_S:
91  case BuiltinType::SChar: Encoding = llvm::dwarf::DW_ATE_signed_char; break;
92  case BuiltinType::UShort:
93  case BuiltinType::UInt:
94  case BuiltinType::ULong:
95  case BuiltinType::ULongLong: Encoding = llvm::dwarf::DW_ATE_unsigned; break;
96  case BuiltinType::Short:
97  case BuiltinType::Int:
98  case BuiltinType::Long:
99  case BuiltinType::LongLong:  Encoding = llvm::dwarf::DW_ATE_signed; break;
100  case BuiltinType::Bool:      Encoding = llvm::dwarf::DW_ATE_boolean; break;
101  case BuiltinType::Float:
102  case BuiltinType::Double:    Encoding = llvm::dwarf::DW_ATE_float; break;
103  }
104  // Bit size, align and offset of the type.
105  uint64_t Size = M->getContext().getTypeSize(BT);
106  uint64_t Align = M->getContext().getTypeAlign(BT);
107  uint64_t Offset = 0;
108
109  return DebugFactory.CreateBasicType(Unit, BT->getName(), Unit, 0, Size, Align,
110                                      Offset, /*flags*/ 0, Encoding);
111}
112
113/// getOrCreateCVRType - Get the CVR qualified type from the cache or create
114/// a new one if necessary.
115llvm::DIType CGDebugInfo::CreateCVRType(QualType Ty, llvm::DICompileUnit Unit) {
116  // We will create one Derived type for one qualifier and recurse to handle any
117  // additional ones.
118  llvm::DIType FromTy;
119  unsigned Tag;
120  if (Ty.isConstQualified()) {
121    Tag = llvm::dwarf::DW_TAG_const_type;
122    Ty.removeConst();
123    FromTy = getOrCreateType(Ty, Unit);
124  } else if (Ty.isVolatileQualified()) {
125    Tag = llvm::dwarf::DW_TAG_volatile_type;
126    Ty.removeVolatile();
127    FromTy = getOrCreateType(Ty, Unit);
128  } else {
129    assert(Ty.isRestrictQualified() && "Unknown type qualifier for debug info");
130    Tag = llvm::dwarf::DW_TAG_restrict_type;
131    Ty.removeRestrict();
132    FromTy = getOrCreateType(Ty, Unit);
133  }
134
135  // No need to fill in the Name, Line, Size, Alignment, Offset in case of
136  // CVR derived types.
137  return DebugFactory.CreateDerivedType(Tag, Unit, "", llvm::DICompileUnit(),
138                                        0, 0, 0, 0, 0, FromTy);
139}
140
141llvm::DIType CGDebugInfo::CreateType(const PointerType *Ty,
142                                     llvm::DICompileUnit Unit) {
143  llvm::DIType EltTy = getOrCreateType(Ty->getPointeeType(), Unit);
144
145  // Bit size, align and offset of the type.
146  uint64_t Size = M->getContext().getTypeSize(Ty);
147  uint64_t Align = M->getContext().getTypeAlign(Ty);
148
149  return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_pointer_type, Unit,
150                                        "", llvm::DICompileUnit(),
151                                        0, Size, Align, 0, 0, EltTy);
152}
153
154llvm::DIType CGDebugInfo::CreateType(const TypedefType *Ty,
155                                     llvm::DICompileUnit Unit) {
156  // Typedefs are derived from some other type.  If we have a typedef of a
157  // typedef, make sure to emit the whole chain.
158  llvm::DIType Src = getOrCreateType(Ty->getDecl()->getUnderlyingType(), Unit);
159
160  // We don't set size information, but do specify where the typedef was
161  // declared.
162  std::string TyName = Ty->getDecl()->getNameAsString();
163  SourceLocation DefLoc = Ty->getDecl()->getLocation();
164  llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc);
165
166  SourceManager &SM = M->getContext().getSourceManager();
167  uint64_t Line = SM.getInstantiationLineNumber(DefLoc);
168
169  return DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_typedef, Unit,
170                                        TyName, DefUnit, Line, 0, 0, 0, 0, Src);
171}
172
173llvm::DIType CGDebugInfo::CreateType(const FunctionType *Ty,
174                                     llvm::DICompileUnit Unit) {
175  llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
176
177  // Add the result type at least.
178  EltTys.push_back(getOrCreateType(Ty->getResultType(), Unit));
179
180  // Set up remainder of arguments if there is a prototype.
181  // FIXME: IF NOT, HOW IS THIS REPRESENTED?  llvm-gcc doesn't represent '...'!
182  if (const FunctionProtoType *FTP = dyn_cast<FunctionProtoType>(Ty)) {
183    for (unsigned i = 0, e = FTP->getNumArgs(); i != e; ++i)
184      EltTys.push_back(getOrCreateType(FTP->getArgType(i), Unit));
185  } else {
186    // FIXME: Handle () case in C.  llvm-gcc doesn't do it either.
187  }
188
189  llvm::DIArray EltTypeArray =
190    DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size());
191
192  return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_subroutine_type,
193                                          Unit, "", llvm::DICompileUnit(),
194                                          0, 0, 0, 0, 0,
195                                          llvm::DIType(), EltTypeArray);
196}
197
198/// CreateType - get structure or union type.
199llvm::DIType CGDebugInfo::CreateType(const RecordType *Ty,
200                                     llvm::DICompileUnit Unit) {
201  RecordDecl *Decl = Ty->getDecl();
202
203  unsigned Tag;
204  if (Decl->isStruct())
205    Tag = llvm::dwarf::DW_TAG_structure_type;
206  else if (Decl->isUnion())
207    Tag = llvm::dwarf::DW_TAG_union_type;
208  else {
209    assert(Decl->isClass() && "Unknown RecordType!");
210    Tag = llvm::dwarf::DW_TAG_class_type;
211  }
212
213  SourceManager &SM = M->getContext().getSourceManager();
214
215  // Get overall information about the record type for the debug info.
216  std::string Name = Decl->getNameAsString();
217
218  llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation());
219  unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation());
220
221
222  // Records and classes and unions can all be recursive.  To handle them, we
223  // first generate a debug descriptor for the struct as a forward declaration.
224  // Then (if it is a definition) we go through and get debug info for all of
225  // its members.  Finally, we create a descriptor for the complete type (which
226  // may refer to the forward decl if the struct is recursive) and replace all
227  // uses of the forward declaration with the final definition.
228  llvm::DIType FwdDecl =
229    DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0,
230                                     llvm::DIType(), llvm::DIArray());
231
232  // If this is just a forward declaration, return it.
233  if (!Decl->getDefinition(M->getContext()))
234    return FwdDecl;
235
236  // Otherwise, insert it into the TypeCache so that recursive uses will find
237  // it.
238  TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
239
240  // Convert all the elements.
241  llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
242
243  const ASTRecordLayout &RL = M->getContext().getASTRecordLayout(Decl);
244
245  unsigned FieldNo = 0;
246  for (RecordDecl::field_iterator I = Decl->field_begin(),
247                                  E = Decl->field_end();
248       I != E; ++I, ++FieldNo) {
249    FieldDecl *Field = *I;
250    llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
251
252    std::string FieldName = Field->getNameAsString();
253
254    // Get the location for the field.
255    SourceLocation FieldDefLoc = Field->getLocation();
256    llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc);
257    unsigned FieldLine = SM.getInstantiationLineNumber(FieldDefLoc);
258
259    // Bit size, align and offset of the type.
260    uint64_t FieldSize = M->getContext().getTypeSize(Ty);
261    unsigned FieldAlign = M->getContext().getTypeAlign(Ty);
262    uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
263
264    // Create a DW_TAG_member node to remember the offset of this field in the
265    // struct.  FIXME: This is an absolutely insane way to capture this
266    // information.  When we gut debug info, this should be fixed.
267    FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
268                                             FieldName, FieldDefUnit,
269                                             FieldLine, FieldSize, FieldAlign,
270                                             FieldOffset, 0, FieldTy);
271    EltTys.push_back(FieldTy);
272  }
273
274  llvm::DIArray Elements =
275    DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size());
276
277  // Bit size, align and offset of the type.
278  uint64_t Size = M->getContext().getTypeSize(Ty);
279  uint64_t Align = M->getContext().getTypeAlign(Ty);
280
281  llvm::DIType RealDecl =
282    DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size,
283                                     Align, 0, 0, llvm::DIType(), Elements);
284
285  // Now that we have a real decl for the struct, replace anything using the
286  // old decl with the new one.  This will recursively update the debug info.
287  FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV());
288  FwdDecl.getGV()->eraseFromParent();
289
290  return RealDecl;
291}
292
293/// CreateType - get objective-c interface type.
294llvm::DIType CGDebugInfo::CreateType(const ObjCInterfaceType *Ty,
295                                     llvm::DICompileUnit Unit) {
296  ObjCInterfaceDecl *Decl = Ty->getDecl();
297
298  unsigned Tag = llvm::dwarf::DW_TAG_structure_type;
299  SourceManager &SM = M->getContext().getSourceManager();
300
301  // Get overall information about the record type for the debug info.
302  std::string Name = Decl->getNameAsString();
303
304  llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(Decl->getLocation());
305  unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation());
306
307
308  // To handle recursive interface, we
309  // first generate a debug descriptor for the struct as a forward declaration.
310  // Then (if it is a definition) we go through and get debug info for all of
311  // its members.  Finally, we create a descriptor for the complete type (which
312  // may refer to the forward decl if the struct is recursive) and replace all
313  // uses of the forward declaration with the final definition.
314  llvm::DIType FwdDecl =
315    DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, 0, 0, 0, 0,
316                                     llvm::DIType(), llvm::DIArray());
317
318  // If this is just a forward declaration, return it.
319  if (Decl->isForwardDecl())
320    return FwdDecl;
321
322  // Otherwise, insert it into the TypeCache so that recursive uses will find
323  // it.
324  TypeCache[QualType(Ty, 0).getAsOpaquePtr()] = FwdDecl;
325
326  // Convert all the elements.
327  llvm::SmallVector<llvm::DIDescriptor, 16> EltTys;
328
329  const ASTRecordLayout &RL = M->getContext().getASTObjCInterfaceLayout(Decl);
330
331  unsigned FieldNo = 0;
332  for (ObjCInterfaceDecl::ivar_iterator I = Decl->ivar_begin(),
333         E = Decl->ivar_end();  I != E; ++I, ++FieldNo) {
334    ObjCIvarDecl *Field = *I;
335    llvm::DIType FieldTy = getOrCreateType(Field->getType(), Unit);
336
337    std::string FieldName = Field->getNameAsString();
338
339    // Get the location for the field.
340    SourceLocation FieldDefLoc = Field->getLocation();
341    llvm::DICompileUnit FieldDefUnit = getOrCreateCompileUnit(FieldDefLoc);
342    unsigned FieldLine = SM.getInstantiationLineNumber(FieldDefLoc);
343
344    // Bit size, align and offset of the type.
345    uint64_t FieldSize = M->getContext().getTypeSize(Ty);
346    unsigned FieldAlign = M->getContext().getTypeAlign(Ty);
347    uint64_t FieldOffset = RL.getFieldOffset(FieldNo);
348
349    // Create a DW_TAG_member node to remember the offset of this field in the
350    // struct.  FIXME: This is an absolutely insane way to capture this
351    // information.  When we gut debug info, this should be fixed.
352    FieldTy = DebugFactory.CreateDerivedType(llvm::dwarf::DW_TAG_member, Unit,
353                                             FieldName, FieldDefUnit,
354                                             FieldLine, FieldSize, FieldAlign,
355                                             FieldOffset, 0, FieldTy);
356    EltTys.push_back(FieldTy);
357  }
358
359  llvm::DIArray Elements =
360    DebugFactory.GetOrCreateArray(&EltTys[0], EltTys.size());
361
362  // Bit size, align and offset of the type.
363  uint64_t Size = M->getContext().getTypeSize(Ty);
364  uint64_t Align = M->getContext().getTypeAlign(Ty);
365
366  llvm::DIType RealDecl =
367    DebugFactory.CreateCompositeType(Tag, Unit, Name, DefUnit, Line, Size,
368                                     Align, 0, 0, llvm::DIType(), Elements);
369
370  // Now that we have a real decl for the struct, replace anything using the
371  // old decl with the new one.  This will recursively update the debug info.
372  FwdDecl.getGV()->replaceAllUsesWith(RealDecl.getGV());
373  FwdDecl.getGV()->eraseFromParent();
374
375  return RealDecl;
376}
377
378llvm::DIType CGDebugInfo::CreateType(const EnumType *Ty,
379                                     llvm::DICompileUnit Unit) {
380  EnumDecl *Decl = Ty->getDecl();
381
382  llvm::SmallVector<llvm::DIDescriptor, 32> Enumerators;
383
384  // Create DIEnumerator elements for each enumerator.
385  for (EnumDecl::enumerator_iterator Enum = Decl->enumerator_begin(),
386                                  EnumEnd = Decl->enumerator_end();
387       Enum != EnumEnd; ++Enum) {
388    Enumerators.push_back(DebugFactory.CreateEnumerator(Enum->getNameAsString(),
389                                            Enum->getInitVal().getZExtValue()));
390  }
391
392  // Return a CompositeType for the enum itself.
393  llvm::DIArray EltArray =
394    DebugFactory.GetOrCreateArray(&Enumerators[0], Enumerators.size());
395
396  std::string EnumName = Decl->getNameAsString();
397  SourceLocation DefLoc = Decl->getLocation();
398  llvm::DICompileUnit DefUnit = getOrCreateCompileUnit(DefLoc);
399  SourceManager &SM = M->getContext().getSourceManager();
400  unsigned Line = SM.getInstantiationLineNumber(DefLoc);
401
402  // Size and align of the type.
403  uint64_t Size = M->getContext().getTypeSize(Ty);
404  unsigned Align = M->getContext().getTypeAlign(Ty);
405
406  return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_enumeration_type,
407                                          Unit, EnumName, DefUnit, Line,
408                                          Size, Align, 0, 0,
409                                          llvm::DIType(), EltArray);
410}
411
412llvm::DIType CGDebugInfo::CreateType(const TagType *Ty,
413                                     llvm::DICompileUnit Unit) {
414  if (const RecordType *RT = dyn_cast<RecordType>(Ty))
415    return CreateType(RT, Unit);
416  else if (const EnumType *ET = dyn_cast<EnumType>(Ty))
417    return CreateType(ET, Unit);
418
419  return llvm::DIType();
420}
421
422llvm::DIType CGDebugInfo::CreateType(const ArrayType *Ty,
423                                     llvm::DICompileUnit Unit) {
424  uint64_t Size;
425  uint64_t Align;
426
427
428  // FIXME: make getTypeAlign() aware of VLAs and incomplete array types
429  if (const VariableArrayType *VAT = dyn_cast<VariableArrayType>(Ty)) {
430    Size = 0;
431    Align =
432      M->getContext().getTypeAlign(M->getContext().getBaseElementType(VAT));
433  } else if (Ty->isIncompleteArrayType()) {
434    Size = 0;
435    Align = M->getContext().getTypeAlign(Ty->getElementType());
436  } else {
437    // Size and align of the whole array, not the element type.
438    Size = M->getContext().getTypeSize(Ty);
439    Align = M->getContext().getTypeAlign(Ty);
440  }
441
442  // Add the dimensions of the array.  FIXME: This loses CV qualifiers from
443  // interior arrays, do we care?  Why aren't nested arrays represented the
444  // obvious/recursive way?
445  llvm::SmallVector<llvm::DIDescriptor, 8> Subscripts;
446  QualType EltTy(Ty, 0);
447  while ((Ty = dyn_cast<ArrayType>(EltTy))) {
448    uint64_t Upper = 0;
449    if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(Ty))
450      Upper = CAT->getSize().getZExtValue() - 1;
451    // FIXME: Verify this is right for VLAs.
452    Subscripts.push_back(DebugFactory.GetOrCreateSubrange(0, Upper));
453    EltTy = Ty->getElementType();
454  }
455
456  llvm::DIArray SubscriptArray =
457    DebugFactory.GetOrCreateArray(&Subscripts[0], Subscripts.size());
458
459  return DebugFactory.CreateCompositeType(llvm::dwarf::DW_TAG_array_type,
460                                          Unit, "", llvm::DICompileUnit(),
461                                          0, Size, Align, 0, 0,
462                                          getOrCreateType(EltTy, Unit),
463                                          SubscriptArray);
464}
465
466
467/// getOrCreateType - Get the type from the cache or create a new
468/// one if necessary.
469llvm::DIType CGDebugInfo::getOrCreateType(QualType Ty,
470                                          llvm::DICompileUnit Unit) {
471  if (Ty.isNull())
472    return llvm::DIType();
473
474  // Check to see if the compile unit already has created this type.
475  llvm::DIType &Slot = TypeCache[Ty.getAsOpaquePtr()];
476  if (!Slot.isNull()) return Slot;
477
478  // Handle CVR qualifiers, which recursively handles what they refer to.
479  if (Ty.getCVRQualifiers())
480    return Slot = CreateCVRType(Ty, Unit);
481
482  // Work out details of type.
483  switch (Ty->getTypeClass()) {
484#define TYPE(Class, Base)
485#define ABSTRACT_TYPE(Class, Base)
486#define NON_CANONICAL_TYPE(Class, Base)
487#define DEPENDENT_TYPE(Class, Base) case Type::Class:
488#include "clang/AST/TypeNodes.def"
489    assert(false && "Dependent types cannot show up in debug information");
490
491  case Type::Complex:
492  case Type::Reference:
493  case Type::Vector:
494  case Type::ExtVector:
495  case Type::ExtQual:
496  case Type::ObjCInterface:
497  case Type::ObjCQualifiedInterface:
498  case Type::ObjCQualifiedId:
499    return llvm::DIType();
500
501  case Type::Builtin: Slot = CreateType(cast<BuiltinType>(Ty), Unit); break;
502  case Type::Pointer: Slot = CreateType(cast<PointerType>(Ty), Unit); break;
503  case Type::Typedef: Slot = CreateType(cast<TypedefType>(Ty), Unit); break;
504  case Type::Record:
505  case Type::CXXRecord:
506  case Type::Enum:
507    Slot = CreateType(cast<TagType>(Ty), Unit);
508    break;
509  case Type::FunctionProto:
510  case Type::FunctionNoProto:
511    return Slot = CreateType(cast<FunctionType>(Ty), Unit);
512
513  case Type::ConstantArray:
514  case Type::VariableArray:
515  case Type::IncompleteArray:
516    return Slot = CreateType(cast<ArrayType>(Ty), Unit);
517  case Type::TypeOfExpr:
518    return Slot = getOrCreateType(cast<TypeOfExprType>(Ty)->getUnderlyingExpr()
519                                  ->getType(), Unit);
520  case Type::TypeOf:
521    return Slot = getOrCreateType(cast<TypeOfType>(Ty)->getUnderlyingType(),
522                                  Unit);
523  }
524
525  return Slot;
526}
527
528/// EmitFunctionStart - Constructs the debug code for entering a function -
529/// "llvm.dbg.func.start.".
530void CGDebugInfo::EmitFunctionStart(const char *Name, QualType ReturnType,
531                                    llvm::Function *Fn,
532                                    CGBuilderTy &Builder) {
533  // FIXME: Why is this using CurLoc???
534  llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc);
535  SourceManager &SM = M->getContext().getSourceManager();
536  unsigned LineNo = SM.getInstantiationLineNumber(CurLoc);
537
538  llvm::DISubprogram SP =
539    DebugFactory.CreateSubprogram(Unit, Name, Name, "", Unit, LineNo,
540                                  getOrCreateType(ReturnType, Unit),
541                                  Fn->hasInternalLinkage(), true/*definition*/);
542
543  DebugFactory.InsertSubprogramStart(SP, Builder.GetInsertBlock());
544
545  // Push function on region stack.
546  RegionStack.push_back(SP);
547}
548
549
550void CGDebugInfo::EmitStopPoint(llvm::Function *Fn, CGBuilderTy &Builder) {
551  if (CurLoc.isInvalid() || CurLoc.isMacroID()) return;
552
553  // Don't bother if things are the same as last time.
554  SourceManager &SM = M->getContext().getSourceManager();
555  if (CurLoc == PrevLoc
556       || (SM.getInstantiationLineNumber(CurLoc) ==
557           SM.getInstantiationLineNumber(PrevLoc)
558           && SM.isFromSameFile(CurLoc, PrevLoc)))
559    return;
560
561  // Update last state.
562  PrevLoc = CurLoc;
563
564  // Get the appropriate compile unit.
565  llvm::DICompileUnit Unit = getOrCreateCompileUnit(CurLoc);
566  DebugFactory.InsertStopPoint(Unit, SM.getInstantiationLineNumber(CurLoc),
567                               SM.getInstantiationColumnNumber(CurLoc),
568                               Builder.GetInsertBlock());
569}
570
571/// EmitRegionStart- Constructs the debug code for entering a declarative
572/// region - "llvm.dbg.region.start.".
573void CGDebugInfo::EmitRegionStart(llvm::Function *Fn, CGBuilderTy &Builder) {
574  llvm::DIDescriptor D;
575  if (!RegionStack.empty())
576    D = RegionStack.back();
577  D = DebugFactory.CreateBlock(D);
578  RegionStack.push_back(D);
579  DebugFactory.InsertRegionStart(D, Builder.GetInsertBlock());
580}
581
582/// EmitRegionEnd - Constructs the debug code for exiting a declarative
583/// region - "llvm.dbg.region.end."
584void CGDebugInfo::EmitRegionEnd(llvm::Function *Fn, CGBuilderTy &Builder) {
585  assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
586
587  // Provide an region stop point.
588  EmitStopPoint(Fn, Builder);
589
590  DebugFactory.InsertRegionEnd(RegionStack.back(), Builder.GetInsertBlock());
591  RegionStack.pop_back();
592}
593
594/// EmitDeclare - Emit local variable declaration debug info.
595void CGDebugInfo::EmitDeclare(const VarDecl *Decl, unsigned Tag,
596                              llvm::Value *Storage, CGBuilderTy &Builder) {
597  assert(!RegionStack.empty() && "Region stack mismatch, stack empty!");
598
599  // Get location information.
600  SourceManager &SM = M->getContext().getSourceManager();
601  unsigned Line = SM.getInstantiationLineNumber(Decl->getLocation());
602  llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
603
604  // Create the descriptor for the variable.
605  llvm::DIVariable D =
606    DebugFactory.CreateVariable(Tag, RegionStack.back(),Decl->getNameAsString(),
607                                Unit, Line,
608                                getOrCreateType(Decl->getType(), Unit));
609  // Insert an llvm.dbg.declare into the current block.
610  DebugFactory.InsertDeclare(Storage, D, Builder.GetInsertBlock());
611}
612
613void CGDebugInfo::EmitDeclareOfAutoVariable(const VarDecl *Decl,
614                                            llvm::Value *Storage,
615                                            CGBuilderTy &Builder) {
616  EmitDeclare(Decl, llvm::dwarf::DW_TAG_auto_variable, Storage, Builder);
617}
618
619/// EmitDeclareOfArgVariable - Emit call to llvm.dbg.declare for an argument
620/// variable declaration.
621void CGDebugInfo::EmitDeclareOfArgVariable(const VarDecl *Decl, llvm::Value *AI,
622                                           CGBuilderTy &Builder) {
623  EmitDeclare(Decl, llvm::dwarf::DW_TAG_arg_variable, AI, Builder);
624}
625
626
627
628/// EmitGlobalVariable - Emit information about a global variable.
629void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
630                                     const VarDecl *Decl) {
631  // Create global variable debug descriptor.
632  llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
633  SourceManager &SM = M->getContext().getSourceManager();
634  unsigned LineNo = SM.getInstantiationLineNumber(Decl->getLocation());
635
636  std::string Name = Decl->getNameAsString();
637
638  QualType T = Decl->getType();
639  if (T->isIncompleteArrayType()) {
640
641    // CodeGen turns int[] into int[1] so we'll do the same here.
642    llvm::APSInt ConstVal(32);
643
644    ConstVal = 1;
645    QualType ET = M->getContext().getAsArrayType(T)->getElementType();
646
647    T = M->getContext().getConstantArrayType(ET, ConstVal,
648                                           ArrayType::Normal, 0);
649  }
650
651  DebugFactory.CreateGlobalVariable(Unit, Name, Name, "", Unit, LineNo,
652                                    getOrCreateType(T, Unit),
653                                    Var->hasInternalLinkage(),
654                                    true/*definition*/, Var);
655}
656
657/// EmitGlobalVariable - Emit information about an objective-c interface.
658void CGDebugInfo::EmitGlobalVariable(llvm::GlobalVariable *Var,
659                                     ObjCInterfaceDecl *Decl) {
660  // Create global variable debug descriptor.
661  llvm::DICompileUnit Unit = getOrCreateCompileUnit(Decl->getLocation());
662  SourceManager &SM = M->getContext().getSourceManager();
663  unsigned LineNo = SM.getInstantiationLineNumber(Decl->getLocation());
664
665  std::string Name = Decl->getNameAsString();
666
667  QualType T = M->getContext().buildObjCInterfaceType(Decl);
668  if (T->isIncompleteArrayType()) {
669
670    // CodeGen turns int[] into int[1] so we'll do the same here.
671    llvm::APSInt ConstVal(32);
672
673    ConstVal = 1;
674    QualType ET = M->getContext().getAsArrayType(T)->getElementType();
675
676    T = M->getContext().getConstantArrayType(ET, ConstVal,
677                                           ArrayType::Normal, 0);
678  }
679
680  DebugFactory.CreateGlobalVariable(Unit, Name, Name, "", Unit, LineNo,
681                                    getOrCreateType(T, Unit),
682                                    Var->hasInternalLinkage(),
683                                    true/*definition*/, Var);
684}
685
686