1 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the DIBuilder.
11 //
12 //===----------------------------------------------------------------------===//
14 #include "llvm/DIBuilder.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/DebugInfo.h"
17 #include "llvm/IR/Constants.h"
18 #include "llvm/IR/IntrinsicInst.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Support/Debug.h"
21 #include "llvm/Support/Dwarf.h"
23 using namespace llvm;
24 using namespace llvm::dwarf;
26 static Constant *GetTagConstant(LLVMContext &VMContext, unsigned Tag) {
27 assert((Tag & LLVMDebugVersionMask) == 0 &&
28 "Tag too large for debug encoding!");
29 return ConstantInt::get(Type::getInt32Ty(VMContext), Tag | LLVMDebugVersion);
30 }
32 DIBuilder::DIBuilder(Module &m)
33 : M(m), VMContext(M.getContext()), TheCU(0), TempEnumTypes(0),
34 TempRetainTypes(0), TempSubprograms(0), TempGVs(0), DeclareFn(0),
35 ValueFn(0)
36 {}
38 /// finalize - Construct any deferred debug info descriptors.
39 void DIBuilder::finalize() {
40 DIArray Enums = getOrCreateArray(AllEnumTypes);
41 DIType(TempEnumTypes).replaceAllUsesWith(Enums);
43 DIArray RetainTypes = getOrCreateArray(AllRetainTypes);
44 DIType(TempRetainTypes).replaceAllUsesWith(RetainTypes);
46 DIArray SPs = getOrCreateArray(AllSubprograms);
47 DIType(TempSubprograms).replaceAllUsesWith(SPs);
48 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) {
49 DISubprogram SP(SPs.getElement(i));
50 SmallVector<Value *, 4> Variables;
51 if (NamedMDNode *NMD = getFnSpecificMDNode(M, SP)) {
52 for (unsigned ii = 0, ee = NMD->getNumOperands(); ii != ee; ++ii)
53 Variables.push_back(NMD->getOperand(ii));
54 NMD->eraseFromParent();
55 }
56 if (MDNode *Temp = SP.getVariablesNodes()) {
57 DIArray AV = getOrCreateArray(Variables);
58 DIType(Temp).replaceAllUsesWith(AV);
59 }
60 }
62 DIArray GVs = getOrCreateArray(AllGVs);
63 DIType(TempGVs).replaceAllUsesWith(GVs);
64 }
66 /// getNonCompileUnitScope - If N is compile unit return NULL otherwise return
67 /// N.
68 static MDNode *getNonCompileUnitScope(MDNode *N) {
69 if (DIDescriptor(N).isCompileUnit())
70 return NULL;
71 return N;
72 }
74 /// createCompileUnit - A CompileUnit provides an anchor for all debugging
75 /// information generated during this instance of compilation.
76 void DIBuilder::createCompileUnit(unsigned Lang, StringRef Filename,
77 StringRef Directory, StringRef Producer,
78 bool isOptimized, StringRef Flags,
79 unsigned RunTimeVer, StringRef SplitName) {
80 assert(((Lang <= dwarf::DW_LANG_Python && Lang >= dwarf::DW_LANG_C89) ||
81 (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
82 "Invalid Language tag");
83 assert(!Filename.empty() &&
84 "Unable to create compile unit without filename");
85 Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
86 TempEnumTypes = MDNode::getTemporary(VMContext, TElts);
88 TempRetainTypes = MDNode::getTemporary(VMContext, TElts);
90 TempSubprograms = MDNode::getTemporary(VMContext, TElts);
92 TempGVs = MDNode::getTemporary(VMContext, TElts);
94 Value *Elts[] = {
95 GetTagConstant(VMContext, dwarf::DW_TAG_compile_unit),
96 Constant::getNullValue(Type::getInt32Ty(VMContext)),
97 ConstantInt::get(Type::getInt32Ty(VMContext), Lang),
98 createFile(Filename, Directory),
99 MDString::get(VMContext, Producer),
100 ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
101 MDString::get(VMContext, Flags),
102 ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeVer),
103 TempEnumTypes,
104 TempRetainTypes,
105 TempSubprograms,
106 TempGVs,
107 MDString::get(VMContext, SplitName)
108 };
109 TheCU = DICompileUnit(MDNode::get(VMContext, Elts));
111 // Create a named metadata so that it is easier to find cu in a module.
112 NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
113 NMD->addOperand(TheCU);
114 }
116 /// createFile - Create a file descriptor to hold debugging information
117 /// for a file.
118 DIFile DIBuilder::createFile(StringRef Filename, StringRef Directory) {
119 assert(!Filename.empty() && "Unable to create file without name");
120 Value *Pair[] = {
121 MDString::get(VMContext, Filename),
122 MDString::get(VMContext, Directory),
123 };
124 Value *Elts[] = {
125 GetTagConstant(VMContext, dwarf::DW_TAG_file_type),
126 MDNode::get(VMContext, Pair)
127 };
128 return DIFile(MDNode::get(VMContext, Elts));
129 }
131 /// createEnumerator - Create a single enumerator value.
132 DIEnumerator DIBuilder::createEnumerator(StringRef Name, uint64_t Val) {
133 assert(!Name.empty() && "Unable to create enumerator without name");
134 Value *Elts[] = {
135 GetTagConstant(VMContext, dwarf::DW_TAG_enumerator),
136 MDString::get(VMContext, Name),
137 ConstantInt::get(Type::getInt64Ty(VMContext), Val)
138 };
139 return DIEnumerator(MDNode::get(VMContext, Elts));
140 }
142 /// createNullPtrType - Create C++0x nullptr type.
143 DIType DIBuilder::createNullPtrType(StringRef Name) {
144 assert(!Name.empty() && "Unable to create type without name");
145 // nullptr is encoded in DIBasicType format. Line number, filename,
146 // ,size, alignment, offset and flags are always empty here.
147 Value *Elts[] = {
148 GetTagConstant(VMContext, dwarf::DW_TAG_unspecified_type),
149 NULL, // Filename
150 NULL, //TheCU,
151 MDString::get(VMContext, Name),
152 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
153 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
154 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
155 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
156 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags;
157 ConstantInt::get(Type::getInt32Ty(VMContext), 0) // Encoding
158 };
159 return DIType(MDNode::get(VMContext, Elts));
160 }
162 /// createBasicType - Create debugging information entry for a basic
163 /// type, e.g 'char'.
164 DIBasicType
165 DIBuilder::createBasicType(StringRef Name, uint64_t SizeInBits,
166 uint64_t AlignInBits, unsigned Encoding) {
167 assert(!Name.empty() && "Unable to create type without name");
168 // Basic types are encoded in DIBasicType format. Line number, filename,
169 // offset and flags are always empty here.
170 Value *Elts[] = {
171 GetTagConstant(VMContext, dwarf::DW_TAG_base_type),
172 NULL, // File/directory name
173 NULL, //TheCU,
174 MDString::get(VMContext, Name),
175 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
176 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
177 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
178 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
179 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags;
180 ConstantInt::get(Type::getInt32Ty(VMContext), Encoding)
181 };
182 return DIBasicType(MDNode::get(VMContext, Elts));
183 }
185 /// createQualifiedType - Create debugging information entry for a qualified
186 /// type, e.g. 'const int'.
187 DIDerivedType DIBuilder::createQualifiedType(unsigned Tag, DIType FromTy) {
188 // Qualified types are encoded in DIDerivedType format.
189 Value *Elts[] = {
190 GetTagConstant(VMContext, Tag),
191 NULL, // Filename
192 NULL, //TheCU,
193 MDString::get(VMContext, StringRef()), // Empty name.
194 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
195 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
196 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
197 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
198 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
199 FromTy
200 };
201 return DIDerivedType(MDNode::get(VMContext, Elts));
202 }
204 /// createPointerType - Create debugging information entry for a pointer.
205 DIDerivedType
206 DIBuilder::createPointerType(DIType PointeeTy, uint64_t SizeInBits,
207 uint64_t AlignInBits, StringRef Name) {
208 // Pointer types are encoded in DIDerivedType format.
209 Value *Elts[] = {
210 GetTagConstant(VMContext, dwarf::DW_TAG_pointer_type),
211 NULL, // Filename
212 NULL, //TheCU,
213 MDString::get(VMContext, Name),
214 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
215 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
216 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
217 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
218 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
219 PointeeTy
220 };
221 return DIDerivedType(MDNode::get(VMContext, Elts));
222 }
224 DIDerivedType DIBuilder::createMemberPointerType(DIType PointeeTy, DIType Base) {
225 // Pointer types are encoded in DIDerivedType format.
226 Value *Elts[] = {
227 GetTagConstant(VMContext, dwarf::DW_TAG_ptr_to_member_type),
228 NULL, // Filename
229 NULL, //TheCU,
230 NULL,
231 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
232 ConstantInt::get(Type::getInt64Ty(VMContext), 0),
233 ConstantInt::get(Type::getInt64Ty(VMContext), 0),
234 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
235 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
236 PointeeTy,
237 Base
238 };
239 return DIDerivedType(MDNode::get(VMContext, Elts));
240 }
242 /// createReferenceType - Create debugging information entry for a reference
243 /// type.
244 DIDerivedType DIBuilder::createReferenceType(unsigned Tag, DIType RTy) {
245 assert(RTy.Verify() && "Unable to create reference type");
246 // References are encoded in DIDerivedType format.
247 Value *Elts[] = {
248 GetTagConstant(VMContext, Tag),
249 NULL, // Filename
250 NULL, // TheCU,
251 NULL, // Name
252 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
253 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
254 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
255 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
256 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
257 RTy
258 };
259 return DIDerivedType(MDNode::get(VMContext, Elts));
260 }
262 /// createTypedef - Create debugging information entry for a typedef.
263 DIDerivedType DIBuilder::createTypedef(DIType Ty, StringRef Name, DIFile File,
264 unsigned LineNo, DIDescriptor Context) {
265 // typedefs are encoded in DIDerivedType format.
266 assert(Ty.Verify() && "Invalid typedef type!");
267 Value *Elts[] = {
268 GetTagConstant(VMContext, dwarf::DW_TAG_typedef),
269 File.getFileNode(),
270 getNonCompileUnitScope(Context),
271 MDString::get(VMContext, Name),
272 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
273 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
274 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
275 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
276 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
277 Ty
278 };
279 return DIDerivedType(MDNode::get(VMContext, Elts));
280 }
282 /// createFriend - Create debugging information entry for a 'friend'.
283 DIType DIBuilder::createFriend(DIType Ty, DIType FriendTy) {
284 // typedefs are encoded in DIDerivedType format.
285 assert(Ty.Verify() && "Invalid type!");
286 assert(FriendTy.Verify() && "Invalid friend type!");
287 Value *Elts[] = {
288 GetTagConstant(VMContext, dwarf::DW_TAG_friend),
289 NULL,
290 Ty,
291 NULL, // Name
292 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
293 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
294 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
295 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Offset
296 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Flags
297 FriendTy
298 };
299 return DIType(MDNode::get(VMContext, Elts));
300 }
302 /// createInheritance - Create debugging information entry to establish
303 /// inheritance relationship between two types.
304 DIDerivedType DIBuilder::createInheritance(
305 DIType Ty, DIType BaseTy, uint64_t BaseOffset, unsigned Flags) {
306 assert(Ty.Verify() && "Unable to create inheritance");
307 // TAG_inheritance is encoded in DIDerivedType format.
308 Value *Elts[] = {
309 GetTagConstant(VMContext, dwarf::DW_TAG_inheritance),
310 NULL,
311 Ty,
312 NULL, // Name
313 ConstantInt::get(Type::getInt32Ty(VMContext), 0), // Line
314 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Size
315 ConstantInt::get(Type::getInt64Ty(VMContext), 0), // Align
316 ConstantInt::get(Type::getInt64Ty(VMContext), BaseOffset),
317 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
318 BaseTy
319 };
320 return DIDerivedType(MDNode::get(VMContext, Elts));
321 }
323 /// createMemberType - Create debugging information entry for a member.
324 DIDerivedType DIBuilder::createMemberType(
325 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
326 uint64_t SizeInBits, uint64_t AlignInBits, uint64_t OffsetInBits,
327 unsigned Flags, DIType Ty) {
328 // TAG_member is encoded in DIDerivedType format.
329 Value *Elts[] = {
330 GetTagConstant(VMContext, dwarf::DW_TAG_member),
331 File.getFileNode(),
332 getNonCompileUnitScope(Scope),
333 MDString::get(VMContext, Name),
334 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
335 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
336 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
337 ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
338 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
339 Ty
340 };
341 return DIDerivedType(MDNode::get(VMContext, Elts));
342 }
344 /// createStaticMemberType - Create debugging information entry for a
345 /// C++ static data member.
346 DIType DIBuilder::createStaticMemberType(DIDescriptor Scope, StringRef Name,
347 DIFile File, unsigned LineNumber,
348 DIType Ty, unsigned Flags,
349 llvm::Value *Val) {
350 // TAG_member is encoded in DIDerivedType format.
351 Flags |= DIDescriptor::FlagStaticMember;
352 Value *Elts[] = {
353 GetTagConstant(VMContext, dwarf::DW_TAG_member),
354 File.getFileNode(),
355 getNonCompileUnitScope(Scope),
356 MDString::get(VMContext, Name),
357 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
358 ConstantInt::get(Type::getInt64Ty(VMContext), 0/*SizeInBits*/),
359 ConstantInt::get(Type::getInt64Ty(VMContext), 0/*AlignInBits*/),
360 ConstantInt::get(Type::getInt64Ty(VMContext), 0/*OffsetInBits*/),
361 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
362 Ty,
363 Val
364 };
365 return DIType(MDNode::get(VMContext, Elts));
366 }
368 /// createObjCIVar - Create debugging information entry for Objective-C
369 /// instance variable.
370 DIType DIBuilder::createObjCIVar(StringRef Name,
371 DIFile File, unsigned LineNumber,
372 uint64_t SizeInBits, uint64_t AlignInBits,
373 uint64_t OffsetInBits, unsigned Flags,
374 DIType Ty, StringRef PropertyName,
375 StringRef GetterName, StringRef SetterName,
376 unsigned PropertyAttributes) {
377 // TAG_member is encoded in DIDerivedType format.
378 Value *Elts[] = {
379 GetTagConstant(VMContext, dwarf::DW_TAG_member),
380 File.getFileNode(),
381 getNonCompileUnitScope(File),
382 MDString::get(VMContext, Name),
383 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
384 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
385 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
386 ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
387 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
388 Ty,
389 MDString::get(VMContext, PropertyName),
390 MDString::get(VMContext, GetterName),
391 MDString::get(VMContext, SetterName),
392 ConstantInt::get(Type::getInt32Ty(VMContext), PropertyAttributes)
393 };
394 return DIType(MDNode::get(VMContext, Elts));
395 }
397 /// createObjCIVar - Create debugging information entry for Objective-C
398 /// instance variable.
399 DIType DIBuilder::createObjCIVar(StringRef Name,
400 DIFile File, unsigned LineNumber,
401 uint64_t SizeInBits, uint64_t AlignInBits,
402 uint64_t OffsetInBits, unsigned Flags,
403 DIType Ty, MDNode *PropertyNode) {
404 // TAG_member is encoded in DIDerivedType format.
405 Value *Elts[] = {
406 GetTagConstant(VMContext, dwarf::DW_TAG_member),
407 File.getFileNode(),
408 getNonCompileUnitScope(File),
409 MDString::get(VMContext, Name),
410 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
411 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
412 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
413 ConstantInt::get(Type::getInt64Ty(VMContext), OffsetInBits),
414 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
415 Ty,
416 PropertyNode
417 };
418 return DIType(MDNode::get(VMContext, Elts));
419 }
421 /// createObjCProperty - Create debugging information entry for Objective-C
422 /// property.
423 DIObjCProperty DIBuilder::createObjCProperty(StringRef Name,
424 DIFile File, unsigned LineNumber,
425 StringRef GetterName,
426 StringRef SetterName,
427 unsigned PropertyAttributes,
428 DIType Ty) {
429 Value *Elts[] = {
430 GetTagConstant(VMContext, dwarf::DW_TAG_APPLE_property),
431 MDString::get(VMContext, Name),
432 File,
433 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
434 MDString::get(VMContext, GetterName),
435 MDString::get(VMContext, SetterName),
436 ConstantInt::get(Type::getInt32Ty(VMContext), PropertyAttributes),
437 Ty
438 };
439 return DIObjCProperty(MDNode::get(VMContext, Elts));
440 }
442 /// createTemplateTypeParameter - Create debugging information for template
443 /// type parameter.
444 DITemplateTypeParameter
445 DIBuilder::createTemplateTypeParameter(DIDescriptor Context, StringRef Name,
446 DIType Ty, MDNode *File, unsigned LineNo,
447 unsigned ColumnNo) {
448 Value *Elts[] = {
449 GetTagConstant(VMContext, dwarf::DW_TAG_template_type_parameter),
450 getNonCompileUnitScope(Context),
451 MDString::get(VMContext, Name),
452 Ty,
453 File,
454 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
455 ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo)
456 };
457 return DITemplateTypeParameter(MDNode::get(VMContext, Elts));
458 }
460 /// createTemplateValueParameter - Create debugging information for template
461 /// value parameter.
462 DITemplateValueParameter
463 DIBuilder::createTemplateValueParameter(DIDescriptor Context, StringRef Name,
464 DIType Ty, uint64_t Val,
465 MDNode *File, unsigned LineNo,
466 unsigned ColumnNo) {
467 Value *Elts[] = {
468 GetTagConstant(VMContext, dwarf::DW_TAG_template_value_parameter),
469 getNonCompileUnitScope(Context),
470 MDString::get(VMContext, Name),
471 Ty,
472 ConstantInt::get(Type::getInt64Ty(VMContext), Val),
473 File,
474 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
475 ConstantInt::get(Type::getInt32Ty(VMContext), ColumnNo)
476 };
477 return DITemplateValueParameter(MDNode::get(VMContext, Elts));
478 }
480 /// createClassType - Create debugging information entry for a class.
481 DIType DIBuilder::createClassType(DIDescriptor Context, StringRef Name,
482 DIFile File, unsigned LineNumber,
483 uint64_t SizeInBits, uint64_t AlignInBits,
484 uint64_t OffsetInBits, unsigned Flags,
485 DIType DerivedFrom, DIArray Elements,
486 MDNode *VTableHolder,
487 MDNode *TemplateParams) {
488 assert((!Context || Context.Verify()) &&
489 "createClassType should be called with a valid Context");
490 // TAG_class_type is encoded in DICompositeType format.
491 Value *Elts[] = {
492 GetTagConstant(VMContext, dwarf::DW_TAG_class_type),
493 File.getFileNode(),
494 getNonCompileUnitScope(Context),
495 MDString::get(VMContext, Name),
496 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
497 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
498 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
499 ConstantInt::get(Type::getInt32Ty(VMContext), OffsetInBits),
500 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
501 DerivedFrom,
502 Elements,
503 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
504 VTableHolder,
505 TemplateParams
506 };
507 DIType R(MDNode::get(VMContext, Elts));
508 assert(R.Verify() && "createClassType should return a verifiable DIType");
509 return R;
510 }
512 /// createStructType - Create debugging information entry for a struct.
513 DICompositeType DIBuilder::createStructType(DIDescriptor Context,
514 StringRef Name, DIFile File,
515 unsigned LineNumber,
516 uint64_t SizeInBits,
517 uint64_t AlignInBits,
518 unsigned Flags, DIType DerivedFrom,
519 DIArray Elements,
520 unsigned RunTimeLang,
521 MDNode *VTableHolder) {
522 // TAG_structure_type is encoded in DICompositeType format.
523 Value *Elts[] = {
524 GetTagConstant(VMContext, dwarf::DW_TAG_structure_type),
525 File.getFileNode(),
526 getNonCompileUnitScope(Context),
527 MDString::get(VMContext, Name),
528 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
529 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
530 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
531 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
532 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
533 DerivedFrom,
534 Elements,
535 ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeLang),
536 VTableHolder,
537 NULL,
538 };
539 DICompositeType R(MDNode::get(VMContext, Elts));
540 assert(R.Verify() && "createStructType should return a verifiable DIType");
541 return R;
542 }
544 /// createUnionType - Create debugging information entry for an union.
545 DICompositeType DIBuilder::createUnionType(
546 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
547 uint64_t SizeInBits, uint64_t AlignInBits, unsigned Flags, DIArray Elements,
548 unsigned RunTimeLang) {
549 // TAG_union_type is encoded in DICompositeType format.
550 Value *Elts[] = {
551 GetTagConstant(VMContext, dwarf::DW_TAG_union_type),
552 File.getFileNode(),
553 getNonCompileUnitScope(Scope),
554 MDString::get(VMContext, Name),
555 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
556 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
557 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
558 ConstantInt::get(Type::getInt64Ty(VMContext), 0),
559 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
560 NULL,
561 Elements,
562 ConstantInt::get(Type::getInt32Ty(VMContext), RunTimeLang),
563 Constant::getNullValue(Type::getInt32Ty(VMContext))
564 };
565 return DICompositeType(MDNode::get(VMContext, Elts));
566 }
568 /// createSubroutineType - Create subroutine type.
569 DICompositeType
570 DIBuilder::createSubroutineType(DIFile File, DIArray ParameterTypes) {
571 // TAG_subroutine_type is encoded in DICompositeType format.
572 Value *Elts[] = {
573 GetTagConstant(VMContext, dwarf::DW_TAG_subroutine_type),
574 Constant::getNullValue(Type::getInt32Ty(VMContext)),
575 Constant::getNullValue(Type::getInt32Ty(VMContext)),
576 MDString::get(VMContext, ""),
577 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
578 ConstantInt::get(Type::getInt64Ty(VMContext), 0),
579 ConstantInt::get(Type::getInt64Ty(VMContext), 0),
580 ConstantInt::get(Type::getInt64Ty(VMContext), 0),
581 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
582 NULL,
583 ParameterTypes,
584 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
585 Constant::getNullValue(Type::getInt32Ty(VMContext))
586 };
587 return DICompositeType(MDNode::get(VMContext, Elts));
588 }
590 /// createEnumerationType - Create debugging information entry for an
591 /// enumeration.
592 DICompositeType DIBuilder::createEnumerationType(
593 DIDescriptor Scope, StringRef Name, DIFile File, unsigned LineNumber,
594 uint64_t SizeInBits, uint64_t AlignInBits, DIArray Elements,
595 DIType ClassType) {
596 // TAG_enumeration_type is encoded in DICompositeType format.
597 Value *Elts[] = {
598 GetTagConstant(VMContext, dwarf::DW_TAG_enumeration_type),
599 File.getFileNode(),
600 getNonCompileUnitScope(Scope),
601 MDString::get(VMContext, Name),
602 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
603 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
604 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
605 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
606 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
607 ClassType,
608 Elements,
609 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
610 Constant::getNullValue(Type::getInt32Ty(VMContext))
611 };
612 MDNode *Node = MDNode::get(VMContext, Elts);
613 AllEnumTypes.push_back(Node);
614 return DICompositeType(Node);
615 }
617 /// createArrayType - Create debugging information entry for an array.
618 DICompositeType DIBuilder::createArrayType(uint64_t Size, uint64_t AlignInBits,
619 DIType Ty, DIArray Subscripts) {
620 // TAG_array_type is encoded in DICompositeType format.
621 Value *Elts[] = {
622 GetTagConstant(VMContext, dwarf::DW_TAG_array_type),
623 NULL, // Filename/Directory,
624 NULL, //TheCU,
625 MDString::get(VMContext, ""),
626 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
627 ConstantInt::get(Type::getInt64Ty(VMContext), Size),
628 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
629 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
630 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
631 Ty,
632 Subscripts,
633 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
634 Constant::getNullValue(Type::getInt32Ty(VMContext))
635 };
636 return DICompositeType(MDNode::get(VMContext, Elts));
637 }
639 /// createVectorType - Create debugging information entry for a vector.
640 DIType DIBuilder::createVectorType(uint64_t Size, uint64_t AlignInBits,
641 DIType Ty, DIArray Subscripts) {
643 // A vector is an array type with the FlagVector flag applied.
644 Value *Elts[] = {
645 GetTagConstant(VMContext, dwarf::DW_TAG_array_type),
646 NULL, // Filename/Directory,
647 NULL, //TheCU,
648 MDString::get(VMContext, ""),
649 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
650 ConstantInt::get(Type::getInt64Ty(VMContext), Size),
651 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
652 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
653 ConstantInt::get(Type::getInt32Ty(VMContext), DIType::FlagVector),
654 Ty,
655 Subscripts,
656 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
657 Constant::getNullValue(Type::getInt32Ty(VMContext))
658 };
659 return DIType(MDNode::get(VMContext, Elts));
660 }
662 /// createArtificialType - Create a new DIType with "artificial" flag set.
663 DIType DIBuilder::createArtificialType(DIType Ty) {
664 if (Ty.isArtificial())
665 return Ty;
667 SmallVector<Value *, 9> Elts;
668 MDNode *N = Ty;
669 assert (N && "Unexpected input DIType!");
670 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
671 if (Value *V = N->getOperand(i))
672 Elts.push_back(V);
673 else
674 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
675 }
677 unsigned CurFlags = Ty.getFlags();
678 CurFlags = CurFlags | DIType::FlagArtificial;
680 // Flags are stored at this slot.
681 Elts[8] = ConstantInt::get(Type::getInt32Ty(VMContext), CurFlags);
683 return DIType(MDNode::get(VMContext, Elts));
684 }
686 /// createObjectPointerType - Create a new type with both the object pointer
687 /// and artificial flags set.
688 DIType DIBuilder::createObjectPointerType(DIType Ty) {
689 if (Ty.isObjectPointer())
690 return Ty;
692 SmallVector<Value *, 9> Elts;
693 MDNode *N = Ty;
694 assert (N && "Unexpected input DIType!");
695 for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
696 if (Value *V = N->getOperand(i))
697 Elts.push_back(V);
698 else
699 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
700 }
702 unsigned CurFlags = Ty.getFlags();
703 CurFlags = CurFlags | (DIType::FlagObjectPointer | DIType::FlagArtificial);
705 // Flags are stored at this slot.
706 Elts[8] = ConstantInt::get(Type::getInt32Ty(VMContext), CurFlags);
708 return DIType(MDNode::get(VMContext, Elts));
709 }
711 /// retainType - Retain DIType in a module even if it is not referenced
712 /// through debug info anchors.
713 void DIBuilder::retainType(DIType T) {
714 AllRetainTypes.push_back(T);
715 }
717 /// createUnspecifiedParameter - Create unspeicified type descriptor
718 /// for the subroutine type.
719 DIDescriptor DIBuilder::createUnspecifiedParameter() {
720 Value *Elts[] = {
721 GetTagConstant(VMContext, dwarf::DW_TAG_unspecified_parameters)
722 };
723 return DIDescriptor(MDNode::get(VMContext, Elts));
724 }
726 /// createForwardDecl - Create a temporary forward-declared type that
727 /// can be RAUW'd if the full type is seen.
728 DIType DIBuilder::createForwardDecl(unsigned Tag, StringRef Name,
729 DIDescriptor Scope, DIFile F,
730 unsigned Line, unsigned RuntimeLang,
731 uint64_t SizeInBits,
732 uint64_t AlignInBits) {
733 // Create a temporary MDNode.
734 Value *Elts[] = {
735 GetTagConstant(VMContext, Tag),
736 F.getFileNode(),
737 getNonCompileUnitScope(Scope),
738 MDString::get(VMContext, Name),
739 ConstantInt::get(Type::getInt32Ty(VMContext), Line),
740 ConstantInt::get(Type::getInt64Ty(VMContext), SizeInBits),
741 ConstantInt::get(Type::getInt64Ty(VMContext), AlignInBits),
742 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
743 ConstantInt::get(Type::getInt32Ty(VMContext),
744 DIDescriptor::FlagFwdDecl),
745 NULL,
746 DIArray(),
747 ConstantInt::get(Type::getInt32Ty(VMContext), RuntimeLang)
748 };
749 MDNode *Node = MDNode::getTemporary(VMContext, Elts);
750 assert(DIType(Node).Verify() &&
751 "createForwardDecl result should be verifiable");
752 return DIType(Node);
753 }
755 /// getOrCreateArray - Get a DIArray, create one if required.
756 DIArray DIBuilder::getOrCreateArray(ArrayRef<Value *> Elements) {
757 if (Elements.empty()) {
758 Value *Null = Constant::getNullValue(Type::getInt32Ty(VMContext));
759 return DIArray(MDNode::get(VMContext, Null));
760 }
761 return DIArray(MDNode::get(VMContext, Elements));
762 }
764 /// getOrCreateSubrange - Create a descriptor for a value range. This
765 /// implicitly uniques the values returned.
766 DISubrange DIBuilder::getOrCreateSubrange(int64_t Lo, int64_t Count) {
767 Value *Elts[] = {
768 GetTagConstant(VMContext, dwarf::DW_TAG_subrange_type),
769 ConstantInt::get(Type::getInt64Ty(VMContext), Lo),
770 ConstantInt::get(Type::getInt64Ty(VMContext), Count)
771 };
773 return DISubrange(MDNode::get(VMContext, Elts));
774 }
776 /// createGlobalVariable - Create a new descriptor for the specified global.
777 DIGlobalVariable DIBuilder::
778 createGlobalVariable(StringRef Name, DIFile F, unsigned LineNumber,
779 DIType Ty, bool isLocalToUnit, Value *Val) {
780 Value *Elts[] = {
781 GetTagConstant(VMContext, dwarf::DW_TAG_variable),
782 Constant::getNullValue(Type::getInt32Ty(VMContext)),
783 NULL, // TheCU,
784 MDString::get(VMContext, Name),
785 MDString::get(VMContext, Name),
786 MDString::get(VMContext, Name),
787 F,
788 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
789 Ty,
790 ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
791 ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
792 Val,
793 DIDescriptor()
794 };
795 MDNode *Node = MDNode::get(VMContext, Elts);
796 AllGVs.push_back(Node);
797 return DIGlobalVariable(Node);
798 }
800 /// createStaticVariable - Create a new descriptor for the specified static
801 /// variable.
802 DIGlobalVariable DIBuilder::
803 createStaticVariable(DIDescriptor Context, StringRef Name,
804 StringRef LinkageName, DIFile F, unsigned LineNumber,
805 DIType Ty, bool isLocalToUnit, Value *Val, MDNode *Decl) {
806 Value *Elts[] = {
807 GetTagConstant(VMContext, dwarf::DW_TAG_variable),
808 Constant::getNullValue(Type::getInt32Ty(VMContext)),
809 getNonCompileUnitScope(Context),
810 MDString::get(VMContext, Name),
811 MDString::get(VMContext, Name),
812 MDString::get(VMContext, LinkageName),
813 F,
814 ConstantInt::get(Type::getInt32Ty(VMContext), LineNumber),
815 Ty,
816 ConstantInt::get(Type::getInt32Ty(VMContext), isLocalToUnit),
817 ConstantInt::get(Type::getInt32Ty(VMContext), 1), /* isDefinition*/
818 Val,
819 DIDescriptor(Decl)
820 };
821 MDNode *Node = MDNode::get(VMContext, Elts);
822 AllGVs.push_back(Node);
823 return DIGlobalVariable(Node);
824 }
826 /// createVariable - Create a new descriptor for the specified variable.
827 DIVariable DIBuilder::createLocalVariable(unsigned Tag, DIDescriptor Scope,
828 StringRef Name, DIFile File,
829 unsigned LineNo, DIType Ty,
830 bool AlwaysPreserve, unsigned Flags,
831 unsigned ArgNo) {
832 DIDescriptor Context(getNonCompileUnitScope(Scope));
833 assert((!Context || Context.Verify()) &&
834 "createLocalVariable should be called with a valid Context");
835 assert(Ty.Verify() &&
836 "createLocalVariable should be called with a valid type");
837 Value *Elts[] = {
838 GetTagConstant(VMContext, Tag),
839 getNonCompileUnitScope(Scope),
840 MDString::get(VMContext, Name),
841 File,
842 ConstantInt::get(Type::getInt32Ty(VMContext), (LineNo | (ArgNo << 24))),
843 Ty,
844 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
845 Constant::getNullValue(Type::getInt32Ty(VMContext))
846 };
847 MDNode *Node = MDNode::get(VMContext, Elts);
848 if (AlwaysPreserve) {
849 // The optimizer may remove local variable. If there is an interest
850 // to preserve variable info in such situation then stash it in a
851 // named mdnode.
852 DISubprogram Fn(getDISubprogram(Scope));
853 NamedMDNode *FnLocals = getOrInsertFnSpecificMDNode(M, Fn);
854 FnLocals->addOperand(Node);
855 }
856 assert(DIVariable(Node).Verify() &&
857 "createLocalVariable should return a verifiable DIVariable");
858 return DIVariable(Node);
859 }
861 /// createComplexVariable - Create a new descriptor for the specified variable
862 /// which has a complex address expression for its address.
863 DIVariable DIBuilder::createComplexVariable(unsigned Tag, DIDescriptor Scope,
864 StringRef Name, DIFile F,
865 unsigned LineNo,
866 DIType Ty, ArrayRef<Value *> Addr,
867 unsigned ArgNo) {
868 SmallVector<Value *, 15> Elts;
869 Elts.push_back(GetTagConstant(VMContext, Tag));
870 Elts.push_back(getNonCompileUnitScope(Scope)),
871 Elts.push_back(MDString::get(VMContext, Name));
872 Elts.push_back(F);
873 Elts.push_back(ConstantInt::get(Type::getInt32Ty(VMContext),
874 (LineNo | (ArgNo << 24))));
875 Elts.push_back(Ty);
876 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
877 Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext)));
878 Elts.append(Addr.begin(), Addr.end());
880 return DIVariable(MDNode::get(VMContext, Elts));
881 }
883 /// createFunction - Create a new descriptor for the specified function.
884 DISubprogram DIBuilder::createFunction(DIDescriptor Context,
885 StringRef Name,
886 StringRef LinkageName,
887 DIFile File, unsigned LineNo,
888 DIType Ty,
889 bool isLocalToUnit, bool isDefinition,
890 unsigned ScopeLine,
891 unsigned Flags, bool isOptimized,
892 Function *Fn,
893 MDNode *TParams,
894 MDNode *Decl) {
895 Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
896 Value *Elts[] = {
897 GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
898 Constant::getNullValue(Type::getInt32Ty(VMContext)),
899 getNonCompileUnitScope(Context),
900 MDString::get(VMContext, Name),
901 MDString::get(VMContext, Name),
902 MDString::get(VMContext, LinkageName),
903 File,
904 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
905 Ty,
906 ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
907 ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
908 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
909 ConstantInt::get(Type::getInt32Ty(VMContext), 0),
910 NULL,
911 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
912 ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
913 Fn,
914 TParams,
915 Decl,
916 MDNode::getTemporary(VMContext, TElts),
917 ConstantInt::get(Type::getInt32Ty(VMContext), ScopeLine)
918 };
919 MDNode *Node = MDNode::get(VMContext, Elts);
921 // Create a named metadata so that we do not lose this mdnode.
922 if (isDefinition)
923 AllSubprograms.push_back(Node);
924 return DISubprogram(Node);
925 }
927 /// createMethod - Create a new descriptor for the specified C++ method.
928 DISubprogram DIBuilder::createMethod(DIDescriptor Context,
929 StringRef Name,
930 StringRef LinkageName,
931 DIFile F,
932 unsigned LineNo, DIType Ty,
933 bool isLocalToUnit,
934 bool isDefinition,
935 unsigned VK, unsigned VIndex,
936 MDNode *VTableHolder,
937 unsigned Flags,
938 bool isOptimized,
939 Function *Fn,
940 MDNode *TParam) {
941 Value *TElts[] = { GetTagConstant(VMContext, DW_TAG_base_type) };
942 Value *Elts[] = {
943 GetTagConstant(VMContext, dwarf::DW_TAG_subprogram),
944 Constant::getNullValue(Type::getInt32Ty(VMContext)),
945 getNonCompileUnitScope(Context),
946 MDString::get(VMContext, Name),
947 MDString::get(VMContext, Name),
948 MDString::get(VMContext, LinkageName),
949 F,
950 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo),
951 Ty,
952 ConstantInt::get(Type::getInt1Ty(VMContext), isLocalToUnit),
953 ConstantInt::get(Type::getInt1Ty(VMContext), isDefinition),
954 ConstantInt::get(Type::getInt32Ty(VMContext), (unsigned)VK),
955 ConstantInt::get(Type::getInt32Ty(VMContext), VIndex),
956 VTableHolder,
957 ConstantInt::get(Type::getInt32Ty(VMContext), Flags),
958 ConstantInt::get(Type::getInt1Ty(VMContext), isOptimized),
959 Fn,
960 TParam,
961 Constant::getNullValue(Type::getInt32Ty(VMContext)),
962 MDNode::getTemporary(VMContext, TElts),
963 // FIXME: Do we want to use different scope/lines?
964 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
965 };
966 MDNode *Node = MDNode::get(VMContext, Elts);
967 if (isDefinition)
968 AllSubprograms.push_back(Node);
969 return DISubprogram(Node);
970 }
972 /// createNameSpace - This creates new descriptor for a namespace
973 /// with the specified parent scope.
974 DINameSpace DIBuilder::createNameSpace(DIDescriptor Scope, StringRef Name,
975 DIFile File, unsigned LineNo) {
976 Value *Elts[] = {
977 GetTagConstant(VMContext, dwarf::DW_TAG_namespace),
978 File,
979 getNonCompileUnitScope(Scope),
980 MDString::get(VMContext, Name),
981 ConstantInt::get(Type::getInt32Ty(VMContext), LineNo)
982 };
983 DINameSpace R(MDNode::get(VMContext, Elts));
984 assert(R.Verify() &&
985 "createNameSpace should return a verifiable DINameSpace");
986 return R;
987 }
989 /// createLexicalBlockFile - This creates a new MDNode that encapsulates
990 /// an existing scope with a new filename.
991 DILexicalBlockFile DIBuilder::createLexicalBlockFile(DIDescriptor Scope,
992 DIFile File) {
993 Value *Elts[] = {
994 GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
995 Scope,
996 File
997 };
998 DILexicalBlockFile R(MDNode::get(VMContext, Elts));
999 assert(
1000 R.Verify() &&
1001 "createLexicalBlockFile should return a verifiable DILexicalBlockFile");
1002 return R;
1003 }
1005 DILexicalBlock DIBuilder::createLexicalBlock(DIDescriptor Scope, DIFile File,
1006 unsigned Line, unsigned Col) {
1007 // Defeat MDNode uniqing for lexical blocks by using unique id.
1008 static unsigned int unique_id = 0;
1009 Value *Elts[] = {
1010 GetTagConstant(VMContext, dwarf::DW_TAG_lexical_block),
1011 getNonCompileUnitScope(Scope),
1012 ConstantInt::get(Type::getInt32Ty(VMContext), Line),
1013 ConstantInt::get(Type::getInt32Ty(VMContext), Col),
1014 File,
1015 ConstantInt::get(Type::getInt32Ty(VMContext), unique_id++)
1016 };
1017 DILexicalBlock R(MDNode::get(VMContext, Elts));
1018 assert(R.Verify() &&
1019 "createLexicalBlock should return a verifiable DILexicalBlock");
1020 return R;
1021 }
1023 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1024 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1025 Instruction *InsertBefore) {
1026 assert(Storage && "no storage passed to dbg.declare");
1027 assert(VarInfo.Verify() && "empty DIVariable passed to dbg.declare");
1028 if (!DeclareFn)
1029 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1031 Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
1032 return CallInst::Create(DeclareFn, Args, "", InsertBefore);
1033 }
1035 /// insertDeclare - Insert a new llvm.dbg.declare intrinsic call.
1036 Instruction *DIBuilder::insertDeclare(Value *Storage, DIVariable VarInfo,
1037 BasicBlock *InsertAtEnd) {
1038 assert(Storage && "no storage passed to dbg.declare");
1039 assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.declare");
1040 if (!DeclareFn)
1041 DeclareFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_declare);
1043 Value *Args[] = { MDNode::get(Storage->getContext(), Storage), VarInfo };
1045 // If this block already has a terminator then insert this intrinsic
1046 // before the terminator.
1047 if (TerminatorInst *T = InsertAtEnd->getTerminator())
1048 return CallInst::Create(DeclareFn, Args, "", T);
1049 else
1050 return CallInst::Create(DeclareFn, Args, "", InsertAtEnd);
1051 }
1053 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1054 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1055 DIVariable VarInfo,
1056 Instruction *InsertBefore) {
1057 assert(V && "no value passed to dbg.value");
1058 assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.value");
1059 if (!ValueFn)
1060 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1062 Value *Args[] = { MDNode::get(V->getContext(), V),
1063 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1064 VarInfo };
1065 return CallInst::Create(ValueFn, Args, "", InsertBefore);
1066 }
1068 /// insertDbgValueIntrinsic - Insert a new llvm.dbg.value intrinsic call.
1069 Instruction *DIBuilder::insertDbgValueIntrinsic(Value *V, uint64_t Offset,
1070 DIVariable VarInfo,
1071 BasicBlock *InsertAtEnd) {
1072 assert(V && "no value passed to dbg.value");
1073 assert(VarInfo.Verify() && "invalid DIVariable passed to dbg.value");
1074 if (!ValueFn)
1075 ValueFn = Intrinsic::getDeclaration(&M, Intrinsic::dbg_value);
1077 Value *Args[] = { MDNode::get(V->getContext(), V),
1078 ConstantInt::get(Type::getInt64Ty(V->getContext()), Offset),
1079 VarInfo };
1080 return CallInst::Create(ValueFn, Args, "", InsertAtEnd);
1081 }