blob: 194aed8b9f6dd8932f963b7c697e4ab6fc8567fd [file] [log] [blame]
Chris Lattnera45664f2008-11-10 02:56:27 +00001//===--- DebugInfo.cpp - Debug Information Helper Classes -----------------===//
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 helper classes used to build and interpret debug
11// information in LLVM IR form.
12//
13//===----------------------------------------------------------------------===//
14
15#include "llvm/Analysis/DebugInfo.h"
16#include "llvm/Constants.h"
17#include "llvm/DerivedTypes.h"
18#include "llvm/Intrinsics.h"
Torok Edwin620f2802008-12-16 09:07:36 +000019#include "llvm/IntrinsicInst.h"
Chris Lattnera45664f2008-11-10 02:56:27 +000020#include "llvm/Instructions.h"
21#include "llvm/Module.h"
22#include "llvm/Analysis/ValueTracking.h"
Devang Patele4b27562009-08-28 23:24:31 +000023#include "llvm/ADT/SmallPtrSet.h"
Dan Gohman17aa92c2010-07-21 23:38:33 +000024#include "llvm/ADT/SmallString.h"
Dan Gohman489b29b2010-08-20 22:02:26 +000025#include "llvm/ADT/STLExtras.h"
David Greene0eb5b662009-12-23 19:45:49 +000026#include "llvm/Support/Debug.h"
Argyrios Kyrtzidis77eaa682009-05-03 08:50:41 +000027#include "llvm/Support/Dwarf.h"
Chris Lattnera81d29b2009-08-23 07:33:14 +000028#include "llvm/Support/raw_ostream.h"
Chris Lattnera45664f2008-11-10 02:56:27 +000029using namespace llvm;
Argyrios Kyrtzidis77eaa682009-05-03 08:50:41 +000030using namespace llvm::dwarf;
Chris Lattnera45664f2008-11-10 02:56:27 +000031
32//===----------------------------------------------------------------------===//
33// DIDescriptor
34//===----------------------------------------------------------------------===//
35
Devang Patel5b164b52010-08-02 22:51:46 +000036DIDescriptor::DIDescriptor(const DIFile F) : DbgNode(F.DbgNode) {
37}
38
39DIDescriptor::DIDescriptor(const DISubprogram F) : DbgNode(F.DbgNode) {
40}
41
Eric Christopher6618a242011-10-11 22:59:11 +000042DIDescriptor::DIDescriptor(const DILexicalBlockFile F) : DbgNode(F.DbgNode) {
43}
44
Devang Patel5b164b52010-08-02 22:51:46 +000045DIDescriptor::DIDescriptor(const DILexicalBlock F) : DbgNode(F.DbgNode) {
46}
47
48DIDescriptor::DIDescriptor(const DIVariable F) : DbgNode(F.DbgNode) {
49}
50
51DIDescriptor::DIDescriptor(const DIType F) : DbgNode(F.DbgNode) {
52}
53
Jim Grosbache62b6902010-07-21 21:36:25 +000054StringRef
Devang Patel5ccdd102009-09-29 18:40:58 +000055DIDescriptor::getStringField(unsigned Elt) const {
Devang Patele4b27562009-08-28 23:24:31 +000056 if (DbgNode == 0)
Devang Patel65dbc902009-11-25 17:36:49 +000057 return StringRef();
Chris Lattnera45664f2008-11-10 02:56:27 +000058
Chris Lattner5d0cacd2009-12-31 01:22:29 +000059 if (Elt < DbgNode->getNumOperands())
60 if (MDString *MDS = dyn_cast_or_null<MDString>(DbgNode->getOperand(Elt)))
Devang Patel65dbc902009-11-25 17:36:49 +000061 return MDS->getString();
Daniel Dunbarf612ff62009-09-19 20:40:05 +000062
Devang Patel65dbc902009-11-25 17:36:49 +000063 return StringRef();
Chris Lattnera45664f2008-11-10 02:56:27 +000064}
65
66uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const {
Daniel Dunbarf612ff62009-09-19 20:40:05 +000067 if (DbgNode == 0)
Chris Lattnera45664f2008-11-10 02:56:27 +000068 return 0;
Bill Wendlingdc817b62009-05-14 18:26:15 +000069
Chris Lattner5d0cacd2009-12-31 01:22:29 +000070 if (Elt < DbgNode->getNumOperands())
Eric Christopher75df9f22012-03-16 00:21:54 +000071 if (ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt)))
Devang Patele4b27562009-08-28 23:24:31 +000072 return CI->getZExtValue();
Daniel Dunbarf612ff62009-09-19 20:40:05 +000073
Chris Lattnera45664f2008-11-10 02:56:27 +000074 return 0;
75}
76
Chris Lattnera45664f2008-11-10 02:56:27 +000077DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const {
Daniel Dunbarf612ff62009-09-19 20:40:05 +000078 if (DbgNode == 0)
Chris Lattnera45664f2008-11-10 02:56:27 +000079 return DIDescriptor();
Bill Wendlingdc817b62009-05-14 18:26:15 +000080
Chris Lattner7a2f3e02010-03-31 05:53:47 +000081 if (Elt < DbgNode->getNumOperands())
Jim Grosbache62b6902010-07-21 21:36:25 +000082 return
83 DIDescriptor(dyn_cast_or_null<const MDNode>(DbgNode->getOperand(Elt)));
Devang Patele4b27562009-08-28 23:24:31 +000084 return DIDescriptor();
Chris Lattnera45664f2008-11-10 02:56:27 +000085}
86
87GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const {
Daniel Dunbarf612ff62009-09-19 20:40:05 +000088 if (DbgNode == 0)
Chris Lattnera45664f2008-11-10 02:56:27 +000089 return 0;
Bill Wendlingdc817b62009-05-14 18:26:15 +000090
Chris Lattner5d0cacd2009-12-31 01:22:29 +000091 if (Elt < DbgNode->getNumOperands())
92 return dyn_cast_or_null<GlobalVariable>(DbgNode->getOperand(Elt));
Devang Patele4b27562009-08-28 23:24:31 +000093 return 0;
Chris Lattnera45664f2008-11-10 02:56:27 +000094}
95
Devang Patel27398962010-08-09 21:39:24 +000096Constant *DIDescriptor::getConstantField(unsigned Elt) const {
97 if (DbgNode == 0)
98 return 0;
99
100 if (Elt < DbgNode->getNumOperands())
101 return dyn_cast_or_null<Constant>(DbgNode->getOperand(Elt));
102 return 0;
103}
104
Stuart Hastings215aa152010-06-11 20:08:44 +0000105Function *DIDescriptor::getFunctionField(unsigned Elt) const {
106 if (DbgNode == 0)
107 return 0;
108
109 if (Elt < DbgNode->getNumOperands())
110 return dyn_cast_or_null<Function>(DbgNode->getOperand(Elt));
111 return 0;
112}
113
Chris Lattnerf0908a32009-12-31 03:02:08 +0000114unsigned DIVariable::getNumAddrElements() const {
Devang Patel3cf763d2010-09-29 23:07:21 +0000115 if (getVersion() <= llvm::LLVMDebugVersion8)
116 return DbgNode->getNumOperands()-6;
Devang Patel23336b42011-07-19 19:41:54 +0000117 if (getVersion() == llvm::LLVMDebugVersion9)
118 return DbgNode->getNumOperands()-7;
119 return DbgNode->getNumOperands()-8;
Chris Lattnerf0908a32009-12-31 03:02:08 +0000120}
121
Devang Patel40c7e412011-07-20 22:18:50 +0000122/// getInlinedAt - If this variable is inlined then return inline location.
Devang Patel48d726f2011-08-09 01:03:14 +0000123MDNode *DIVariable::getInlinedAt() const {
Devang Patel40c7e412011-07-20 22:18:50 +0000124 if (getVersion() <= llvm::LLVMDebugVersion9)
125 return NULL;
126 return dyn_cast_or_null<MDNode>(DbgNode->getOperand(7));
127}
Chris Lattnerf0908a32009-12-31 03:02:08 +0000128
Chris Lattnera45664f2008-11-10 02:56:27 +0000129//===----------------------------------------------------------------------===//
Devang Patel6ceea332009-08-31 18:49:10 +0000130// Predicates
Chris Lattnera45664f2008-11-10 02:56:27 +0000131//===----------------------------------------------------------------------===//
132
Devang Patel6ceea332009-08-31 18:49:10 +0000133/// isBasicType - Return true if the specified tag is legal for
134/// DIBasicType.
135bool DIDescriptor::isBasicType() const {
Devang Patel734a67c2011-09-14 23:13:28 +0000136 if (!DbgNode) return false;
137 switch (getTag()) {
138 case dwarf::DW_TAG_base_type:
139 case dwarf::DW_TAG_unspecified_type:
140 return true;
141 default:
142 return false;
143 }
Torok Edwinb07fbd92008-12-13 08:25:29 +0000144}
Chris Lattnera45664f2008-11-10 02:56:27 +0000145
Devang Patel6ceea332009-08-31 18:49:10 +0000146/// isDerivedType - Return true if the specified tag is legal for DIDerivedType.
147bool DIDescriptor::isDerivedType() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000148 if (!DbgNode) return false;
Chris Lattner099b7792009-12-29 09:22:47 +0000149 switch (getTag()) {
Chris Lattnera45664f2008-11-10 02:56:27 +0000150 case dwarf::DW_TAG_typedef:
151 case dwarf::DW_TAG_pointer_type:
152 case dwarf::DW_TAG_reference_type:
Eric Christopher791e6292012-05-19 01:36:37 +0000153 case dwarf::DW_TAG_rvalue_reference_type:
Chris Lattnera45664f2008-11-10 02:56:27 +0000154 case dwarf::DW_TAG_const_type:
155 case dwarf::DW_TAG_volatile_type:
156 case dwarf::DW_TAG_restrict_type:
157 case dwarf::DW_TAG_member:
158 case dwarf::DW_TAG_inheritance:
Devang Patel49d96382010-08-23 23:16:25 +0000159 case dwarf::DW_TAG_friend:
Chris Lattnera45664f2008-11-10 02:56:27 +0000160 return true;
161 default:
Devang Patele4b27562009-08-28 23:24:31 +0000162 // CompositeTypes are currently modelled as DerivedTypes.
Devang Patel6ceea332009-08-31 18:49:10 +0000163 return isCompositeType();
Chris Lattnera45664f2008-11-10 02:56:27 +0000164 }
165}
166
Chris Lattnera45664f2008-11-10 02:56:27 +0000167/// isCompositeType - Return true if the specified tag is legal for
168/// DICompositeType.
Devang Patel6ceea332009-08-31 18:49:10 +0000169bool DIDescriptor::isCompositeType() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000170 if (!DbgNode) return false;
Chris Lattner099b7792009-12-29 09:22:47 +0000171 switch (getTag()) {
Chris Lattnera45664f2008-11-10 02:56:27 +0000172 case dwarf::DW_TAG_array_type:
173 case dwarf::DW_TAG_structure_type:
174 case dwarf::DW_TAG_union_type:
175 case dwarf::DW_TAG_enumeration_type:
176 case dwarf::DW_TAG_vector_type:
177 case dwarf::DW_TAG_subroutine_type:
Devang Patel25cb0d72009-03-25 03:52:06 +0000178 case dwarf::DW_TAG_class_type:
Chris Lattnera45664f2008-11-10 02:56:27 +0000179 return true;
180 default:
181 return false;
182 }
183}
184
Chris Lattnera45664f2008-11-10 02:56:27 +0000185/// isVariable - Return true if the specified tag is legal for DIVariable.
Devang Patel6ceea332009-08-31 18:49:10 +0000186bool DIDescriptor::isVariable() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000187 if (!DbgNode) return false;
Chris Lattner099b7792009-12-29 09:22:47 +0000188 switch (getTag()) {
Chris Lattnera45664f2008-11-10 02:56:27 +0000189 case dwarf::DW_TAG_auto_variable:
190 case dwarf::DW_TAG_arg_variable:
191 case dwarf::DW_TAG_return_variable:
192 return true;
193 default:
194 return false;
195 }
196}
197
Devang Patelecbeb1a2009-09-30 22:34:41 +0000198/// isType - Return true if the specified tag is legal for DIType.
199bool DIDescriptor::isType() const {
200 return isBasicType() || isCompositeType() || isDerivedType();
201}
202
Devang Patel6ceea332009-08-31 18:49:10 +0000203/// isSubprogram - Return true if the specified tag is legal for
204/// DISubprogram.
205bool DIDescriptor::isSubprogram() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000206 return DbgNode && getTag() == dwarf::DW_TAG_subprogram;
Devang Patel6ceea332009-08-31 18:49:10 +0000207}
208
209/// isGlobalVariable - Return true if the specified tag is legal for
210/// DIGlobalVariable.
211bool DIDescriptor::isGlobalVariable() const {
Devang Patel29368072010-08-10 07:11:13 +0000212 return DbgNode && (getTag() == dwarf::DW_TAG_variable ||
213 getTag() == dwarf::DW_TAG_constant);
Devang Patel6ceea332009-08-31 18:49:10 +0000214}
215
Devang Patelecbeb1a2009-09-30 22:34:41 +0000216/// isGlobal - Return true if the specified tag is legal for DIGlobal.
217bool DIDescriptor::isGlobal() const {
218 return isGlobalVariable();
219}
220
Devang Patel716a67f2011-02-03 00:13:47 +0000221/// isUnspecifiedParmeter - Return true if the specified tag is
Devang Pateld6747df2010-10-06 20:50:40 +0000222/// DW_TAG_unspecified_parameters.
223bool DIDescriptor::isUnspecifiedParameter() const {
224 return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters;
225}
226
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000227/// isScope - Return true if the specified tag is one of the scope
Devang Patel43d98b32009-08-31 20:44:45 +0000228/// related tag.
229bool DIDescriptor::isScope() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000230 if (!DbgNode) return false;
Chris Lattner099b7792009-12-29 09:22:47 +0000231 switch (getTag()) {
232 case dwarf::DW_TAG_compile_unit:
233 case dwarf::DW_TAG_lexical_block:
234 case dwarf::DW_TAG_subprogram:
235 case dwarf::DW_TAG_namespace:
236 return true;
237 default:
238 break;
Devang Patel43d98b32009-08-31 20:44:45 +0000239 }
240 return false;
241}
Devang Patel6ceea332009-08-31 18:49:10 +0000242
Devang Patel7e2cb112011-02-02 21:38:25 +0000243/// isTemplateTypeParameter - Return true if the specified tag is
244/// DW_TAG_template_type_parameter.
245bool DIDescriptor::isTemplateTypeParameter() const {
246 return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter;
247}
248
Devang Patele7d93872011-02-02 22:35:53 +0000249/// isTemplateValueParameter - Return true if the specified tag is
250/// DW_TAG_template_value_parameter.
251bool DIDescriptor::isTemplateValueParameter() const {
252 return DbgNode && getTag() == dwarf::DW_TAG_template_value_parameter;
253}
254
Devang Patelc9f322d2009-08-31 21:34:44 +0000255/// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit.
256bool DIDescriptor::isCompileUnit() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000257 return DbgNode && getTag() == dwarf::DW_TAG_compile_unit;
Devang Patelc9f322d2009-08-31 21:34:44 +0000258}
259
Devang Patel7aa81892010-03-08 22:27:22 +0000260/// isFile - Return true if the specified tag is DW_TAG_file_type.
261bool DIDescriptor::isFile() const {
262 return DbgNode && getTag() == dwarf::DW_TAG_file_type;
263}
264
Devang Patel6404e4e2009-12-15 19:16:48 +0000265/// isNameSpace - Return true if the specified tag is DW_TAG_namespace.
266bool DIDescriptor::isNameSpace() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000267 return DbgNode && getTag() == dwarf::DW_TAG_namespace;
Devang Patel6404e4e2009-12-15 19:16:48 +0000268}
269
Eric Christopher6618a242011-10-11 22:59:11 +0000270/// isLexicalBlockFile - Return true if the specified descriptor is a
271/// lexical block with an extra file.
272bool DIDescriptor::isLexicalBlockFile() const {
273 return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
274 (DbgNode->getNumOperands() == 3);
275}
276
Devang Patel5e005d82009-08-31 22:00:15 +0000277/// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block.
278bool DIDescriptor::isLexicalBlock() const {
Eric Christopher6618a242011-10-11 22:59:11 +0000279 return DbgNode && getTag() == dwarf::DW_TAG_lexical_block &&
280 (DbgNode->getNumOperands() > 3);
Devang Patel5e005d82009-08-31 22:00:15 +0000281}
282
Devang Patelecbeb1a2009-09-30 22:34:41 +0000283/// isSubrange - Return true if the specified tag is DW_TAG_subrange_type.
284bool DIDescriptor::isSubrange() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000285 return DbgNode && getTag() == dwarf::DW_TAG_subrange_type;
Devang Patelecbeb1a2009-09-30 22:34:41 +0000286}
287
288/// isEnumerator - Return true if the specified tag is DW_TAG_enumerator.
289bool DIDescriptor::isEnumerator() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000290 return DbgNode && getTag() == dwarf::DW_TAG_enumerator;
Devang Patelecbeb1a2009-09-30 22:34:41 +0000291}
292
Devang Patel1ea02d42012-02-04 00:59:25 +0000293/// isObjCProperty - Return true if the specified tag is DW_TAG
294bool DIDescriptor::isObjCProperty() const {
Eric Christopher6c31ee22012-03-29 21:35:05 +0000295 return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property;
Devang Patel1ea02d42012-02-04 00:59:25 +0000296}
Devang Patel6ceea332009-08-31 18:49:10 +0000297//===----------------------------------------------------------------------===//
298// Simple Descriptor Constructors and other Methods
299//===----------------------------------------------------------------------===//
300
Devang Patele9f8f5e2010-05-07 20:54:48 +0000301DIType::DIType(const MDNode *N) : DIScope(N) {
Devang Patel6ceea332009-08-31 18:49:10 +0000302 if (!N) return;
303 if (!isBasicType() && !isDerivedType() && !isCompositeType()) {
304 DbgNode = 0;
305 }
306}
307
Devang Patel68afdc32009-01-05 18:33:01 +0000308unsigned DIArray::getNumElements() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000309 if (!DbgNode)
310 return 0;
Chris Lattner5d0cacd2009-12-31 01:22:29 +0000311 return DbgNode->getNumOperands();
Devang Patel68afdc32009-01-05 18:33:01 +0000312}
Chris Lattnera45664f2008-11-10 02:56:27 +0000313
Devang Patelc4999d72009-07-22 18:23:44 +0000314/// replaceAllUsesWith - Replace all uses of debug info referenced by
Dan Gohman872814a2010-07-21 18:54:18 +0000315/// this descriptor.
Dan Gohman489b29b2010-08-20 22:02:26 +0000316void DIType::replaceAllUsesWith(DIDescriptor &D) {
Devang Patel3c91b052010-03-08 20:52:55 +0000317 if (!DbgNode)
Devang Patelc4999d72009-07-22 18:23:44 +0000318 return;
319
Daniel Dunbar48a097b2009-09-22 02:03:18 +0000320 // Since we use a TrackingVH for the node, its easy for clients to manufacture
321 // legitimate situations where they want to replaceAllUsesWith() on something
322 // which, due to uniquing, has merged with the source. We shield clients from
323 // this detail by allowing a value to be replaced with replaceAllUsesWith()
324 // itself.
Devang Pateled66bf52010-05-07 18:19:32 +0000325 if (DbgNode != D) {
Devang Patele9f8f5e2010-05-07 20:54:48 +0000326 MDNode *Node = const_cast<MDNode*>(DbgNode);
327 const MDNode *DN = D;
328 const Value *V = cast_or_null<Value>(DN);
329 Node->replaceAllUsesWith(const_cast<Value*>(V));
Dan Gohman489b29b2010-08-20 22:02:26 +0000330 MDNode::deleteTemporary(Node);
Daniel Dunbar48a097b2009-09-22 02:03:18 +0000331 }
Devang Patelc4999d72009-07-22 18:23:44 +0000332}
333
Devang Patel0a2551d2010-12-08 20:18:20 +0000334/// replaceAllUsesWith - Replace all uses of debug info referenced by
335/// this descriptor.
336void DIType::replaceAllUsesWith(MDNode *D) {
337 if (!DbgNode)
338 return;
339
340 // Since we use a TrackingVH for the node, its easy for clients to manufacture
341 // legitimate situations where they want to replaceAllUsesWith() on something
342 // which, due to uniquing, has merged with the source. We shield clients from
343 // this detail by allowing a value to be replaced with replaceAllUsesWith()
344 // itself.
345 if (DbgNode != D) {
346 MDNode *Node = const_cast<MDNode*>(DbgNode);
347 const MDNode *DN = D;
348 const Value *V = cast_or_null<Value>(DN);
349 Node->replaceAllUsesWith(const_cast<Value*>(V));
350 MDNode::deleteTemporary(Node);
351 }
352}
353
Devang Patel6f9d8ff2011-08-15 17:57:41 +0000354/// isUnsignedDIType - Return true if type encoding is unsigned.
355bool DIType::isUnsignedDIType() {
356 DIDerivedType DTy(DbgNode);
357 if (DTy.Verify())
358 return DTy.getTypeDerivedFrom().isUnsignedDIType();
359
360 DIBasicType BTy(DbgNode);
361 if (BTy.Verify()) {
362 unsigned Encoding = BTy.getEncoding();
363 if (Encoding == dwarf::DW_ATE_unsigned ||
364 Encoding == dwarf::DW_ATE_unsigned_char)
365 return true;
366 }
367 return false;
368}
369
Devang Patelb79b5352009-01-19 23:21:49 +0000370/// Verify - Verify that a compile unit is well formed.
371bool DICompileUnit::Verify() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000372 if (!DbgNode)
Devang Patelb79b5352009-01-19 23:21:49 +0000373 return false;
Devang Patel65dbc902009-11-25 17:36:49 +0000374 StringRef N = getFilename();
375 if (N.empty())
Bill Wendling0582ae92009-03-13 04:39:26 +0000376 return false;
Devang Patelb79b5352009-01-19 23:21:49 +0000377 // It is possible that directory and produce string is empty.
Bill Wendling0582ae92009-03-13 04:39:26 +0000378 return true;
Devang Patelb79b5352009-01-19 23:21:49 +0000379}
380
Eric Christopherb8ca9882012-03-29 08:42:56 +0000381/// Verify - Verify that an ObjC property is well formed.
382bool DIObjCProperty::Verify() const {
383 if (!DbgNode)
384 return false;
385 unsigned Tag = getTag();
Eric Christopher6c31ee22012-03-29 21:35:05 +0000386 if (Tag != dwarf::DW_TAG_APPLE_property) return false;
Eric Christopherb8ca9882012-03-29 08:42:56 +0000387 DIType Ty = getType();
388 if (!Ty.Verify()) return false;
389
390 // Don't worry about the rest of the strings for now.
391 return true;
392}
393
Devang Patelb79b5352009-01-19 23:21:49 +0000394/// Verify - Verify that a type descriptor is well formed.
395bool DIType::Verify() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000396 if (!DbgNode)
Devang Patelb79b5352009-01-19 23:21:49 +0000397 return false;
Devang Patel94c7ddb2011-08-16 22:09:43 +0000398 if (getContext() && !getContext().Verify())
Devang Patelb79b5352009-01-19 23:21:49 +0000399 return false;
Devang Patelb71bbf92010-11-02 20:41:13 +0000400 unsigned Tag = getTag();
401 if (!isBasicType() && Tag != dwarf::DW_TAG_const_type &&
402 Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type &&
Eric Christopher791e6292012-05-19 01:36:37 +0000403 Tag != dwarf::DW_TAG_reference_type &&
404 Tag != dwarf::DW_TAG_rvalue_reference_type &&
405 Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_vector_type &&
406 Tag != dwarf::DW_TAG_array_type &&
407 Tag != dwarf::DW_TAG_enumeration_type &&
408 Tag != dwarf::DW_TAG_subroutine_type &&
409 getFilename().empty())
Devang Patelb79b5352009-01-19 23:21:49 +0000410 return false;
411 return true;
412}
413
Devang Patel0c4720c2010-08-23 18:25:56 +0000414/// Verify - Verify that a basic type descriptor is well formed.
415bool DIBasicType::Verify() const {
416 return isBasicType();
417}
418
419/// Verify - Verify that a derived type descriptor is well formed.
420bool DIDerivedType::Verify() const {
421 return isDerivedType();
422}
423
Devang Patelb79b5352009-01-19 23:21:49 +0000424/// Verify - Verify that a composite type descriptor is well formed.
425bool DICompositeType::Verify() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000426 if (!DbgNode)
Devang Patelb79b5352009-01-19 23:21:49 +0000427 return false;
Devang Patel94c7ddb2011-08-16 22:09:43 +0000428 if (getContext() && !getContext().Verify())
Devang Patelb79b5352009-01-19 23:21:49 +0000429 return false;
430
Devang Patelb79b5352009-01-19 23:21:49 +0000431 return true;
432}
433
434/// Verify - Verify that a subprogram descriptor is well formed.
435bool DISubprogram::Verify() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000436 if (!DbgNode)
Devang Patelb79b5352009-01-19 23:21:49 +0000437 return false;
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000438
Devang Patel94c7ddb2011-08-16 22:09:43 +0000439 if (getContext() && !getContext().Verify())
Devang Patelb79b5352009-01-19 23:21:49 +0000440 return false;
441
442 DICompositeType Ty = getType();
Devang Patel3c91b052010-03-08 20:52:55 +0000443 if (!Ty.Verify())
Devang Patelb79b5352009-01-19 23:21:49 +0000444 return false;
445 return true;
446}
447
448/// Verify - Verify that a global variable descriptor is well formed.
449bool DIGlobalVariable::Verify() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000450 if (!DbgNode)
Devang Patelb79b5352009-01-19 23:21:49 +0000451 return false;
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000452
Devang Patel65dbc902009-11-25 17:36:49 +0000453 if (getDisplayName().empty())
Devang Patel84c73e92009-11-06 17:58:12 +0000454 return false;
455
Devang Patel94c7ddb2011-08-16 22:09:43 +0000456 if (getContext() && !getContext().Verify())
Devang Patelb79b5352009-01-19 23:21:49 +0000457 return false;
458
459 DIType Ty = getType();
460 if (!Ty.Verify())
461 return false;
462
Devang Patel27398962010-08-09 21:39:24 +0000463 if (!getGlobal() && !getConstant())
Devang Patelb79b5352009-01-19 23:21:49 +0000464 return false;
465
466 return true;
467}
468
469/// Verify - Verify that a variable descriptor is well formed.
470bool DIVariable::Verify() const {
Devang Patel3c91b052010-03-08 20:52:55 +0000471 if (!DbgNode)
Devang Patelb79b5352009-01-19 23:21:49 +0000472 return false;
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000473
Devang Patel94c7ddb2011-08-16 22:09:43 +0000474 if (getContext() && !getContext().Verify())
Devang Patel62077af2010-05-07 21:42:24 +0000475 return false;
476
Devang Patelb79b5352009-01-19 23:21:49 +0000477 DIType Ty = getType();
478 if (!Ty.Verify())
479 return false;
480
Devang Patelb79b5352009-01-19 23:21:49 +0000481 return true;
482}
483
Devang Patel3c91b052010-03-08 20:52:55 +0000484/// Verify - Verify that a location descriptor is well formed.
485bool DILocation::Verify() const {
486 if (!DbgNode)
487 return false;
Jim Grosbache62b6902010-07-21 21:36:25 +0000488
Devang Patel3c91b052010-03-08 20:52:55 +0000489 return DbgNode->getNumOperands() == 4;
490}
491
Devang Patel47e22652010-05-07 23:04:32 +0000492/// Verify - Verify that a namespace descriptor is well formed.
493bool DINameSpace::Verify() const {
494 if (!DbgNode)
495 return false;
496 if (getName().empty())
497 return false;
Devang Patel47e22652010-05-07 23:04:32 +0000498 return true;
499}
500
Devang Patel36375ee2009-02-17 21:23:59 +0000501/// getOriginalTypeSize - If this type is derived from a base type then
502/// return base type size.
503uint64_t DIDerivedType::getOriginalTypeSize() const {
Devang Patel61ecbd12009-11-04 23:48:00 +0000504 unsigned Tag = getTag();
Eric Christopher2e1b0c02011-12-16 23:42:45 +0000505
Devang Patel61ecbd12009-11-04 23:48:00 +0000506 if (Tag == dwarf::DW_TAG_member || Tag == dwarf::DW_TAG_typedef ||
507 Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type ||
508 Tag == dwarf::DW_TAG_restrict_type) {
509 DIType BaseType = getTypeDerivedFrom();
Jim Grosbache62b6902010-07-21 21:36:25 +0000510 // If this type is not derived from any type then take conservative
Devang Patel5ebfa2d2009-11-06 18:24:05 +0000511 // approach.
Devang Patel3c91b052010-03-08 20:52:55 +0000512 if (!BaseType.isValid())
Devang Patel5ebfa2d2009-11-06 18:24:05 +0000513 return getSizeInBits();
Eric Christopher2e1b0c02011-12-16 23:42:45 +0000514 // If this is a derived type, go ahead and get the base type, unless
Eric Christopherdcc296d2012-01-11 00:01:29 +0000515 // it's a reference then it's just the size of the field. Pointer types
516 // have no need of this since they're a different type of qualification
517 // on the type.
Eric Christopher791e6292012-05-19 01:36:37 +0000518 if (BaseType.getTag() == dwarf::DW_TAG_reference_type ||
519 BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type)
Eric Christopher2e1b0c02011-12-16 23:42:45 +0000520 return getSizeInBits();
521 else if (BaseType.isDerivedType())
Devang Patel2db49d72010-05-07 18:11:54 +0000522 return DIDerivedType(BaseType).getOriginalTypeSize();
Devang Patel61ecbd12009-11-04 23:48:00 +0000523 else
524 return BaseType.getSizeInBits();
525 }
Jim Grosbache62b6902010-07-21 21:36:25 +0000526
Devang Patel61ecbd12009-11-04 23:48:00 +0000527 return getSizeInBits();
Devang Patel36375ee2009-02-17 21:23:59 +0000528}
Devang Patelb79b5352009-01-19 23:21:49 +0000529
Devang Patel6588abf2012-02-06 17:49:43 +0000530/// getObjCProperty - Return property node, if this ivar is associated with one.
531MDNode *DIDerivedType::getObjCProperty() const {
532 if (getVersion() <= LLVMDebugVersion11 || DbgNode->getNumOperands() <= 10)
533 return NULL;
534 return dyn_cast_or_null<MDNode>(DbgNode->getOperand(10));
535}
536
Jim Grosbache62b6902010-07-21 21:36:25 +0000537/// isInlinedFnArgument - Return true if this variable provides debugging
Devang Patel719f6a92010-04-29 20:40:36 +0000538/// information for an inlined function arguments.
539bool DIVariable::isInlinedFnArgument(const Function *CurFn) {
540 assert(CurFn && "Invalid function");
541 if (!getContext().isSubprogram())
542 return false;
Jim Grosbache62b6902010-07-21 21:36:25 +0000543 // This variable is not inlined function argument if its scope
Devang Patel719f6a92010-04-29 20:40:36 +0000544 // does not describe current function.
Devang Patel2db49d72010-05-07 18:11:54 +0000545 return !(DISubprogram(getContext()).describes(CurFn));
Devang Patel719f6a92010-04-29 20:40:36 +0000546}
547
Devang Patelaf5b6bb2009-04-15 00:06:07 +0000548/// describes - Return true if this subprogram provides debugging
549/// information for the function F.
550bool DISubprogram::describes(const Function *F) {
Chris Lattner099b7792009-12-29 09:22:47 +0000551 assert(F && "Invalid function");
Devang Patelffd33cd2010-06-16 06:42:02 +0000552 if (F == getFunction())
553 return true;
Devang Patel65dbc902009-11-25 17:36:49 +0000554 StringRef Name = getLinkageName();
555 if (Name.empty())
Devang Patel5ccdd102009-09-29 18:40:58 +0000556 Name = getName();
Devang Patel65dbc902009-11-25 17:36:49 +0000557 if (F->getName() == Name)
Devang Patelaf5b6bb2009-04-15 00:06:07 +0000558 return true;
559 return false;
560}
561
Jim Grosbache62b6902010-07-21 21:36:25 +0000562unsigned DISubprogram::isOptimized() const {
Devang Patelccff8122010-04-30 19:38:23 +0000563 assert (DbgNode && "Invalid subprogram descriptor!");
564 if (DbgNode->getNumOperands() == 16)
565 return getUnsignedField(15);
566 return 0;
567}
568
Devang Patel93d39be2011-08-19 23:28:12 +0000569MDNode *DISubprogram::getVariablesNodes() const {
570 if (!DbgNode || DbgNode->getNumOperands() <= 19)
571 return NULL;
572 if (MDNode *Temp = dyn_cast_or_null<MDNode>(DbgNode->getOperand(19)))
573 return dyn_cast_or_null<MDNode>(Temp->getOperand(0));
574 return NULL;
575}
576
577DIArray DISubprogram::getVariables() const {
578 if (!DbgNode || DbgNode->getNumOperands() <= 19)
579 return DIArray();
580 if (MDNode *T = dyn_cast_or_null<MDNode>(DbgNode->getOperand(19)))
581 if (MDNode *A = dyn_cast_or_null<MDNode>(T->getOperand(0)))
582 return DIArray(A);
583 return DIArray();
584}
585
Devang Patel65dbc902009-11-25 17:36:49 +0000586StringRef DIScope::getFilename() const {
Devang Patel77bf2952010-03-08 22:02:50 +0000587 if (!DbgNode)
588 return StringRef();
Eric Christopher6618a242011-10-11 22:59:11 +0000589 if (isLexicalBlockFile())
590 return DILexicalBlockFile(DbgNode).getFilename();
Jim Grosbache62b6902010-07-21 21:36:25 +0000591 if (isLexicalBlock())
Devang Patelecbeb1a2009-09-30 22:34:41 +0000592 return DILexicalBlock(DbgNode).getFilename();
Chris Lattner099b7792009-12-29 09:22:47 +0000593 if (isSubprogram())
Devang Patelecbeb1a2009-09-30 22:34:41 +0000594 return DISubprogram(DbgNode).getFilename();
Chris Lattner099b7792009-12-29 09:22:47 +0000595 if (isCompileUnit())
Devang Patelecbeb1a2009-09-30 22:34:41 +0000596 return DICompileUnit(DbgNode).getFilename();
Chris Lattner099b7792009-12-29 09:22:47 +0000597 if (isNameSpace())
Devang Patel6404e4e2009-12-15 19:16:48 +0000598 return DINameSpace(DbgNode).getFilename();
Devang Patel77bf2952010-03-08 22:02:50 +0000599 if (isType())
600 return DIType(DbgNode).getFilename();
Devang Patel7aa81892010-03-08 22:27:22 +0000601 if (isFile())
602 return DIFile(DbgNode).getFilename();
Craig Topper85814382012-02-07 05:05:23 +0000603 llvm_unreachable("Invalid DIScope!");
Devang Patelecbeb1a2009-09-30 22:34:41 +0000604}
605
Devang Patel65dbc902009-11-25 17:36:49 +0000606StringRef DIScope::getDirectory() const {
Devang Patel77bf2952010-03-08 22:02:50 +0000607 if (!DbgNode)
608 return StringRef();
Eric Christopher6618a242011-10-11 22:59:11 +0000609 if (isLexicalBlockFile())
610 return DILexicalBlockFile(DbgNode).getDirectory();
Jim Grosbache62b6902010-07-21 21:36:25 +0000611 if (isLexicalBlock())
Devang Patelecbeb1a2009-09-30 22:34:41 +0000612 return DILexicalBlock(DbgNode).getDirectory();
Chris Lattner099b7792009-12-29 09:22:47 +0000613 if (isSubprogram())
Devang Patelecbeb1a2009-09-30 22:34:41 +0000614 return DISubprogram(DbgNode).getDirectory();
Chris Lattner099b7792009-12-29 09:22:47 +0000615 if (isCompileUnit())
Devang Patelecbeb1a2009-09-30 22:34:41 +0000616 return DICompileUnit(DbgNode).getDirectory();
Chris Lattner099b7792009-12-29 09:22:47 +0000617 if (isNameSpace())
Devang Patel6404e4e2009-12-15 19:16:48 +0000618 return DINameSpace(DbgNode).getDirectory();
Devang Patel77bf2952010-03-08 22:02:50 +0000619 if (isType())
620 return DIType(DbgNode).getDirectory();
Devang Patel7aa81892010-03-08 22:27:22 +0000621 if (isFile())
622 return DIFile(DbgNode).getDirectory();
Craig Topper85814382012-02-07 05:05:23 +0000623 llvm_unreachable("Invalid DIScope!");
Devang Patelecbeb1a2009-09-30 22:34:41 +0000624}
625
Devang Patel94c7ddb2011-08-16 22:09:43 +0000626DIArray DICompileUnit::getEnumTypes() const {
627 if (!DbgNode || DbgNode->getNumOperands() < 14)
628 return DIArray();
629
630 if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(10)))
631 if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
632 return DIArray(A);
633 return DIArray();
634}
635
636DIArray DICompileUnit::getRetainedTypes() const {
637 if (!DbgNode || DbgNode->getNumOperands() < 14)
638 return DIArray();
639
640 if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(11)))
641 if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
642 return DIArray(A);
643 return DIArray();
644}
645
646DIArray DICompileUnit::getSubprograms() const {
647 if (!DbgNode || DbgNode->getNumOperands() < 14)
648 return DIArray();
649
650 if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(12)))
651 if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
652 return DIArray(A);
653 return DIArray();
654}
655
656
657DIArray DICompileUnit::getGlobalVariables() const {
658 if (!DbgNode || DbgNode->getNumOperands() < 14)
659 return DIArray();
660
661 if (MDNode *N = dyn_cast_or_null<MDNode>(DbgNode->getOperand(13)))
662 if (MDNode *A = dyn_cast_or_null<MDNode>(N->getOperand(0)))
663 return DIArray(A);
664 return DIArray();
665}
666
Chris Lattnera45664f2008-11-10 02:56:27 +0000667//===----------------------------------------------------------------------===//
David Blaikie2d24e2a2011-12-20 02:50:00 +0000668// DIDescriptor: vtable anchors for all descriptors.
669//===----------------------------------------------------------------------===//
670
671void DIScope::anchor() { }
672
673void DICompileUnit::anchor() { }
674
675void DIFile::anchor() { }
676
677void DIType::anchor() { }
678
679void DIBasicType::anchor() { }
680
681void DIDerivedType::anchor() { }
682
683void DICompositeType::anchor() { }
684
685void DISubprogram::anchor() { }
686
687void DILexicalBlock::anchor() { }
688
689void DINameSpace::anchor() { }
690
691void DILexicalBlockFile::anchor() { }
692
693//===----------------------------------------------------------------------===//
Devang Patel7136a652009-07-01 22:10:23 +0000694// DIDescriptor: dump routines for all descriptors.
695//===----------------------------------------------------------------------===//
696
697
Dan Gohman50404362010-05-07 15:30:29 +0000698/// print - Print descriptor.
699void DIDescriptor::print(raw_ostream &OS) const {
700 OS << "[" << dwarf::TagString(getTag()) << "] ";
701 OS.write_hex((intptr_t) &*DbgNode) << ']';
Devang Patel7136a652009-07-01 22:10:23 +0000702}
703
Dan Gohman50404362010-05-07 15:30:29 +0000704/// print - Print compile unit.
705void DICompileUnit::print(raw_ostream &OS) const {
Devang Patel7136a652009-07-01 22:10:23 +0000706 if (getLanguage())
Dan Gohman50404362010-05-07 15:30:29 +0000707 OS << " [" << dwarf::LanguageString(getLanguage()) << "] ";
Devang Patel7136a652009-07-01 22:10:23 +0000708
Dan Gohmanfaa19c32010-05-10 20:07:44 +0000709 OS << " [" << getDirectory() << "/" << getFilename() << "]";
Devang Patel7136a652009-07-01 22:10:23 +0000710}
711
Dan Gohman50404362010-05-07 15:30:29 +0000712/// print - Print type.
713void DIType::print(raw_ostream &OS) const {
Devang Patel3c91b052010-03-08 20:52:55 +0000714 if (!DbgNode) return;
Devang Patel7136a652009-07-01 22:10:23 +0000715
Devang Patel65dbc902009-11-25 17:36:49 +0000716 StringRef Res = getName();
717 if (!Res.empty())
Dan Gohman50404362010-05-07 15:30:29 +0000718 OS << " [" << Res << "] ";
Devang Patel7136a652009-07-01 22:10:23 +0000719
720 unsigned Tag = getTag();
Dan Gohman50404362010-05-07 15:30:29 +0000721 OS << " [" << dwarf::TagString(Tag) << "] ";
Devang Patel7136a652009-07-01 22:10:23 +0000722
723 // TODO : Print context
Dan Gohman50404362010-05-07 15:30:29 +0000724 OS << " ["
Dan Gohman9a7063e2010-05-07 16:39:27 +0000725 << "line " << getLineNumber() << ", "
726 << getSizeInBits() << " bits, "
727 << getAlignInBits() << " bit alignment, "
728 << getOffsetInBits() << " bit offset"
Chris Lattnera81d29b2009-08-23 07:33:14 +0000729 << "] ";
Devang Patel7136a652009-07-01 22:10:23 +0000730
Daniel Dunbarf612ff62009-09-19 20:40:05 +0000731 if (isPrivate())
Dan Gohman50404362010-05-07 15:30:29 +0000732 OS << " [private] ";
Devang Patel7136a652009-07-01 22:10:23 +0000733 else if (isProtected())
Dan Gohman50404362010-05-07 15:30:29 +0000734 OS << " [protected] ";
Devang Patel7136a652009-07-01 22:10:23 +0000735
736 if (isForwardDecl())
Dan Gohman50404362010-05-07 15:30:29 +0000737 OS << " [fwd] ";
Devang Patel7136a652009-07-01 22:10:23 +0000738
Devang Patel6ceea332009-08-31 18:49:10 +0000739 if (isBasicType())
Dan Gohmanc014d092010-05-07 16:17:22 +0000740 DIBasicType(DbgNode).print(OS);
Eric Christopherdc1eeb82012-02-20 18:04:35 +0000741 else if (isDerivedType()) {
742 DIDerivedType DTy = DIDerivedType(DbgNode);
743 DTy.print(OS);
744 DICompositeType CTy = getDICompositeType(DTy);
745 if (CTy.Verify())
746 CTy.print(OS);
747 }
Devang Patel6ceea332009-08-31 18:49:10 +0000748 else if (isCompositeType())
Dan Gohmanc014d092010-05-07 16:17:22 +0000749 DICompositeType(DbgNode).print(OS);
Devang Patel7136a652009-07-01 22:10:23 +0000750 else {
Dan Gohman50404362010-05-07 15:30:29 +0000751 OS << "Invalid DIType\n";
Devang Patel7136a652009-07-01 22:10:23 +0000752 return;
753 }
754
Dan Gohman50404362010-05-07 15:30:29 +0000755 OS << "\n";
Devang Patel7136a652009-07-01 22:10:23 +0000756}
757
Dan Gohman50404362010-05-07 15:30:29 +0000758/// print - Print basic type.
759void DIBasicType::print(raw_ostream &OS) const {
760 OS << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] ";
Devang Patel7136a652009-07-01 22:10:23 +0000761}
762
Dan Gohman50404362010-05-07 15:30:29 +0000763/// print - Print derived type.
764void DIDerivedType::print(raw_ostream &OS) const {
Eric Christopher1c7f7442012-02-20 18:04:39 +0000765 OS << "\n\t Derived From: ";
766 getTypeDerivedFrom().print(OS);
767 OS << "\n\t";
Devang Patel7136a652009-07-01 22:10:23 +0000768}
769
Dan Gohman50404362010-05-07 15:30:29 +0000770/// print - Print composite type.
771void DICompositeType::print(raw_ostream &OS) const {
Devang Patel7136a652009-07-01 22:10:23 +0000772 DIArray A = getTypeArray();
Dan Gohman50404362010-05-07 15:30:29 +0000773 OS << " [" << A.getNumElements() << " elements]";
Devang Patel7136a652009-07-01 22:10:23 +0000774}
775
Dan Gohman50404362010-05-07 15:30:29 +0000776/// print - Print subprogram.
777void DISubprogram::print(raw_ostream &OS) const {
Devang Patel65dbc902009-11-25 17:36:49 +0000778 StringRef Res = getName();
779 if (!Res.empty())
Dan Gohman50404362010-05-07 15:30:29 +0000780 OS << " [" << Res << "] ";
Devang Patel82dfc0c2009-08-31 22:47:13 +0000781
782 unsigned Tag = getTag();
Dan Gohman50404362010-05-07 15:30:29 +0000783 OS << " [" << dwarf::TagString(Tag) << "] ";
Devang Patel82dfc0c2009-08-31 22:47:13 +0000784
785 // TODO : Print context
Dan Gohman50404362010-05-07 15:30:29 +0000786 OS << " [" << getLineNumber() << "] ";
Devang Patel82dfc0c2009-08-31 22:47:13 +0000787
788 if (isLocalToUnit())
Dan Gohman50404362010-05-07 15:30:29 +0000789 OS << " [local] ";
Devang Patel82dfc0c2009-08-31 22:47:13 +0000790
791 if (isDefinition())
Dan Gohman50404362010-05-07 15:30:29 +0000792 OS << " [def] ";
Devang Patel82dfc0c2009-08-31 22:47:13 +0000793
Eric Christopher6126a1e2012-04-03 00:43:49 +0000794 if (getScopeLineNumber() != getLineNumber())
795 OS << " [Scope: " << getScopeLineNumber() << "] ";
796
Dan Gohman50404362010-05-07 15:30:29 +0000797 OS << "\n";
798}
799
800/// print - Print global variable.
801void DIGlobalVariable::print(raw_ostream &OS) const {
802 OS << " [";
Devang Patela49d8772010-05-07 23:19:07 +0000803 StringRef Res = getName();
804 if (!Res.empty())
805 OS << " [" << Res << "] ";
806
807 unsigned Tag = getTag();
808 OS << " [" << dwarf::TagString(Tag) << "] ";
809
810 // TODO : Print context
Devang Patela49d8772010-05-07 23:19:07 +0000811 OS << " [" << getLineNumber() << "] ";
812
813 if (isLocalToUnit())
814 OS << " [local] ";
815
816 if (isDefinition())
817 OS << " [def] ";
818
819 if (isGlobalVariable())
820 DIGlobalVariable(DbgNode).print(OS);
821 OS << "]\n";
Dan Gohman50404362010-05-07 15:30:29 +0000822}
823
Devang Patel48d726f2011-08-09 01:03:14 +0000824static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS,
825 const LLVMContext &Ctx) {
826 if (!DL.isUnknown()) { // Print source line info.
827 DIScope Scope(DL.getScope(Ctx));
828 // Omit the directory, because it's likely to be long and uninteresting.
829 if (Scope.Verify())
830 CommentOS << Scope.getFilename();
831 else
832 CommentOS << "<unknown>";
833 CommentOS << ':' << DL.getLine();
834 if (DL.getCol() != 0)
835 CommentOS << ':' << DL.getCol();
836 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx));
837 if (!InlinedAtDL.isUnknown()) {
838 CommentOS << " @[ ";
839 printDebugLoc(InlinedAtDL, CommentOS, Ctx);
840 CommentOS << " ]";
841 }
842 }
843}
844
845void DIVariable::printExtendedName(raw_ostream &OS) const {
846 const LLVMContext &Ctx = DbgNode->getContext();
847 StringRef Res = getName();
848 if (!Res.empty())
849 OS << Res << "," << getLineNumber();
850 if (MDNode *InlinedAt = getInlinedAt()) {
851 DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt);
852 if (!InlinedAtDL.isUnknown()) {
853 OS << " @[";
854 printDebugLoc(InlinedAtDL, OS, Ctx);
855 OS << "]";
856 }
857 }
858}
859
Dan Gohman50404362010-05-07 15:30:29 +0000860/// print - Print variable.
861void DIVariable::print(raw_ostream &OS) const {
862 StringRef Res = getName();
863 if (!Res.empty())
864 OS << " [" << Res << "] ";
865
Dan Gohman50404362010-05-07 15:30:29 +0000866 OS << " [" << getLineNumber() << "] ";
Dan Gohmanc014d092010-05-07 16:17:22 +0000867 getType().print(OS);
Dan Gohman50404362010-05-07 15:30:29 +0000868 OS << "\n";
869
870 // FIXME: Dump complex addresses
871}
872
873/// dump - Print descriptor to dbgs() with a newline.
874void DIDescriptor::dump() const {
875 print(dbgs()); dbgs() << '\n';
876}
877
878/// dump - Print compile unit to dbgs() with a newline.
879void DICompileUnit::dump() const {
880 print(dbgs()); dbgs() << '\n';
881}
882
883/// dump - Print type to dbgs() with a newline.
884void DIType::dump() const {
885 print(dbgs()); dbgs() << '\n';
886}
887
888/// dump - Print basic type to dbgs() with a newline.
889void DIBasicType::dump() const {
890 print(dbgs()); dbgs() << '\n';
891}
892
893/// dump - Print derived type to dbgs() with a newline.
894void DIDerivedType::dump() const {
895 print(dbgs()); dbgs() << '\n';
896}
897
898/// dump - Print composite type to dbgs() with a newline.
899void DICompositeType::dump() const {
900 print(dbgs()); dbgs() << '\n';
901}
902
Dan Gohman50404362010-05-07 15:30:29 +0000903/// dump - Print subprogram to dbgs() with a newline.
904void DISubprogram::dump() const {
905 print(dbgs()); dbgs() << '\n';
Devang Patel7136a652009-07-01 22:10:23 +0000906}
907
908/// dump - Print global variable.
909void DIGlobalVariable::dump() const {
Dan Gohman50404362010-05-07 15:30:29 +0000910 print(dbgs()); dbgs() << '\n';
Devang Patel7136a652009-07-01 22:10:23 +0000911}
912
913/// dump - Print variable.
914void DIVariable::dump() const {
Dan Gohman50404362010-05-07 15:30:29 +0000915 print(dbgs()); dbgs() << '\n';
Devang Patel7136a652009-07-01 22:10:23 +0000916}
917
Devang Patel62367042010-11-10 22:19:21 +0000918/// fixupObjcLikeName - Replace contains special characters used
919/// in a typical Objective-C names with '.' in a given string.
Benjamin Kramer1a81d482011-06-18 14:42:42 +0000920static void fixupObjcLikeName(StringRef Str, SmallVectorImpl<char> &Out) {
921 bool isObjCLike = false;
Devang Patel62367042010-11-10 22:19:21 +0000922 for (size_t i = 0, e = Str.size(); i < e; ++i) {
923 char C = Str[i];
Benjamin Kramer1a81d482011-06-18 14:42:42 +0000924 if (C == '[')
925 isObjCLike = true;
926
927 if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' ||
928 C == '+' || C == '(' || C == ')'))
929 Out.push_back('.');
930 else
931 Out.push_back(C);
Devang Patel62367042010-11-10 22:19:21 +0000932 }
933}
934
Devang Patel62367042010-11-10 22:19:21 +0000935/// getFnSpecificMDNode - Return a NameMDNode, if available, that is
936/// suitable to hold function specific information.
Devang Patel93d39be2011-08-19 23:28:12 +0000937NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) {
Benjamin Kramer1a81d482011-06-18 14:42:42 +0000938 SmallString<32> Name = StringRef("llvm.dbg.lv.");
Devang Patel93d39be2011-08-19 23:28:12 +0000939 StringRef FName = "fn";
940 if (Fn.getFunction())
941 FName = Fn.getFunction()->getName();
942 else
943 FName = Fn.getName();
944 char One = '\1';
945 if (FName.startswith(StringRef(&One, 1)))
946 FName = FName.substr(1);
947 fixupObjcLikeName(FName, Name);
Benjamin Kramer1a81d482011-06-18 14:42:42 +0000948 return M.getNamedMetadata(Name.str());
Devang Patel62367042010-11-10 22:19:21 +0000949}
950
Duncan Sands291bb702011-03-02 20:30:37 +0000951/// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable
952/// to hold function specific information.
Devang Patel93d39be2011-08-19 23:28:12 +0000953NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) {
Benjamin Kramer1a81d482011-06-18 14:42:42 +0000954 SmallString<32> Name = StringRef("llvm.dbg.lv.");
Devang Patel93d39be2011-08-19 23:28:12 +0000955 StringRef FName = "fn";
956 if (Fn.getFunction())
957 FName = Fn.getFunction()->getName();
958 else
959 FName = Fn.getName();
960 char One = '\1';
961 if (FName.startswith(StringRef(&One, 1)))
962 FName = FName.substr(1);
963 fixupObjcLikeName(FName, Name);
964
Benjamin Kramer1a81d482011-06-18 14:42:42 +0000965 return M.getOrInsertNamedMetadata(Name.str());
Devang Patel1a7ca032010-09-28 18:08:20 +0000966}
967
Devang Patel23336b42011-07-19 19:41:54 +0000968/// createInlinedVariable - Create a new inlined variable based on current
969/// variable.
970/// @param DV Current Variable.
971/// @param InlinedScope Location at current variable is inlined.
972DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope,
973 LLVMContext &VMContext) {
974 SmallVector<Value *, 16> Elts;
975 // Insert inlined scope as 7th element.
976 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
977 i == 7 ? Elts.push_back(InlinedScope) :
978 Elts.push_back(DV->getOperand(i));
979 return DIVariable(MDNode::get(VMContext, Elts));
980}
Devang Patel1a7ca032010-09-28 18:08:20 +0000981
Devang Patelb549bcf2011-08-10 21:50:54 +0000982/// cleanseInlinedVariable - Remove inlined scope from the variable.
983DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) {
984 SmallVector<Value *, 16> Elts;
985 // Insert inlined scope as 7th element.
986 for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i)
987 i == 7 ?
988 Elts.push_back(llvm::Constant::getNullValue(Type::getInt32Ty(VMContext))):
989 Elts.push_back(DV->getOperand(i));
990 return DIVariable(MDNode::get(VMContext, Elts));
991}
992
Devang Pateld2f79a12009-07-28 19:55:13 +0000993//===----------------------------------------------------------------------===//
Devang Patel98c65172009-07-30 18:25:15 +0000994// DebugInfoFinder implementations.
Devang Pateld2f79a12009-07-28 19:55:13 +0000995//===----------------------------------------------------------------------===//
996
Devang Patel98c65172009-07-30 18:25:15 +0000997/// processModule - Process entire module and collect debug info.
998void DebugInfoFinder::processModule(Module &M) {
Devang Patelcd2db162011-10-17 22:30:34 +0000999 if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) {
1000 for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
1001 DICompileUnit CU(CU_Nodes->getOperand(i));
1002 addCompileUnit(CU);
1003 if (CU.getVersion() > LLVMDebugVersion10) {
Devang Patel9f997212012-02-08 00:17:07 +00001004 DIArray GVs = CU.getGlobalVariables();
1005 for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) {
1006 DIGlobalVariable DIG(GVs.getElement(i));
1007 if (addGlobalVariable(DIG))
1008 processType(DIG.getType());
1009 }
1010 DIArray SPs = CU.getSubprograms();
1011 for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i)
1012 processSubprogram(DISubprogram(SPs.getElement(i)));
1013 DIArray EnumTypes = CU.getEnumTypes();
1014 for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i)
1015 processType(DIType(EnumTypes.getElement(i)));
1016 DIArray RetainedTypes = CU.getRetainedTypes();
1017 for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i)
1018 processType(DIType(RetainedTypes.getElement(i)));
1019 return;
Devang Patelcd2db162011-10-17 22:30:34 +00001020 }
1021 }
1022 }
Devang Patelfa515ec2011-09-06 17:40:08 +00001023
Devang Pateld2f79a12009-07-28 19:55:13 +00001024 for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
1025 for (Function::iterator FI = (*I).begin(), FE = (*I).end(); FI != FE; ++FI)
1026 for (BasicBlock::iterator BI = (*FI).begin(), BE = (*FI).end(); BI != BE;
1027 ++BI) {
Devang Patel01c5ff62010-05-04 01:05:02 +00001028 if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI))
Devang Patelb4d31302009-07-31 18:18:52 +00001029 processDeclare(DDI);
Jim Grosbache62b6902010-07-21 21:36:25 +00001030
Chris Lattner28a9bf62010-04-02 20:44:29 +00001031 DebugLoc Loc = BI->getDebugLoc();
1032 if (Loc.isUnknown())
1033 continue;
Jim Grosbache62b6902010-07-21 21:36:25 +00001034
Chris Lattner28a9bf62010-04-02 20:44:29 +00001035 LLVMContext &Ctx = BI->getContext();
1036 DIDescriptor Scope(Loc.getScope(Ctx));
Jim Grosbache62b6902010-07-21 21:36:25 +00001037
Chris Lattner28a9bf62010-04-02 20:44:29 +00001038 if (Scope.isCompileUnit())
Devang Patel2db49d72010-05-07 18:11:54 +00001039 addCompileUnit(DICompileUnit(Scope));
Chris Lattner28a9bf62010-04-02 20:44:29 +00001040 else if (Scope.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001041 processSubprogram(DISubprogram(Scope));
Eric Christopher6618a242011-10-11 22:59:11 +00001042 else if (Scope.isLexicalBlockFile()) {
1043 DILexicalBlockFile DBF = DILexicalBlockFile(Scope);
1044 processLexicalBlock(DILexicalBlock(DBF.getScope()));
1045 }
Chris Lattner28a9bf62010-04-02 20:44:29 +00001046 else if (Scope.isLexicalBlock())
Devang Patel2db49d72010-05-07 18:11:54 +00001047 processLexicalBlock(DILexicalBlock(Scope));
Jim Grosbache62b6902010-07-21 21:36:25 +00001048
Chris Lattner28a9bf62010-04-02 20:44:29 +00001049 if (MDNode *IA = Loc.getInlinedAt(Ctx))
1050 processLocation(DILocation(IA));
Devang Pateld2f79a12009-07-28 19:55:13 +00001051 }
Devang Patele4b27562009-08-28 23:24:31 +00001052
Devang Patelfd5fdc32010-06-28 05:53:08 +00001053 if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv")) {
1054 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) {
1055 DIGlobalVariable DIG(cast<MDNode>(NMD->getOperand(i)));
1056 if (addGlobalVariable(DIG)) {
Devang Patelfa515ec2011-09-06 17:40:08 +00001057 if (DIG.getVersion() <= LLVMDebugVersion10)
1058 addCompileUnit(DIG.getCompileUnit());
Devang Patelfd5fdc32010-06-28 05:53:08 +00001059 processType(DIG.getType());
1060 }
Devang Pateld2f79a12009-07-28 19:55:13 +00001061 }
1062 }
Devang Patelfd5fdc32010-06-28 05:53:08 +00001063
1064 if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp"))
1065 for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i)
1066 processSubprogram(DISubprogram(NMD->getOperand(i)));
Devang Pateld2f79a12009-07-28 19:55:13 +00001067}
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001068
Devang Patel6daf99b2009-11-10 22:05:35 +00001069/// processLocation - Process DILocation.
1070void DebugInfoFinder::processLocation(DILocation Loc) {
Devang Patel3c91b052010-03-08 20:52:55 +00001071 if (!Loc.Verify()) return;
Devang Patel2db49d72010-05-07 18:11:54 +00001072 DIDescriptor S(Loc.getScope());
Devang Patel6daf99b2009-11-10 22:05:35 +00001073 if (S.isCompileUnit())
Devang Patel2db49d72010-05-07 18:11:54 +00001074 addCompileUnit(DICompileUnit(S));
Devang Patel6daf99b2009-11-10 22:05:35 +00001075 else if (S.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001076 processSubprogram(DISubprogram(S));
Devang Patel6daf99b2009-11-10 22:05:35 +00001077 else if (S.isLexicalBlock())
Devang Patel2db49d72010-05-07 18:11:54 +00001078 processLexicalBlock(DILexicalBlock(S));
Eric Christopher6618a242011-10-11 22:59:11 +00001079 else if (S.isLexicalBlockFile()) {
1080 DILexicalBlockFile DBF = DILexicalBlockFile(S);
1081 processLexicalBlock(DILexicalBlock(DBF.getScope()));
1082 }
Devang Patel6daf99b2009-11-10 22:05:35 +00001083 processLocation(Loc.getOrigLocation());
1084}
1085
Devang Patel98c65172009-07-30 18:25:15 +00001086/// processType - Process DIType.
1087void DebugInfoFinder::processType(DIType DT) {
Devang Patel72bcdb62009-08-10 22:09:58 +00001088 if (!addType(DT))
Devang Pateld2f79a12009-07-28 19:55:13 +00001089 return;
Devang Patelfa515ec2011-09-06 17:40:08 +00001090 if (DT.getVersion() <= LLVMDebugVersion10)
1091 addCompileUnit(DT.getCompileUnit());
Devang Patel6ceea332009-08-31 18:49:10 +00001092 if (DT.isCompositeType()) {
Devang Patel2db49d72010-05-07 18:11:54 +00001093 DICompositeType DCT(DT);
Devang Patel98c65172009-07-30 18:25:15 +00001094 processType(DCT.getTypeDerivedFrom());
Devang Pateld2f79a12009-07-28 19:55:13 +00001095 DIArray DA = DCT.getTypeArray();
Devang Patel3c91b052010-03-08 20:52:55 +00001096 for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) {
1097 DIDescriptor D = DA.getElement(i);
1098 if (D.isType())
Devang Patel2db49d72010-05-07 18:11:54 +00001099 processType(DIType(D));
Devang Patel3c91b052010-03-08 20:52:55 +00001100 else if (D.isSubprogram())
Devang Patel2db49d72010-05-07 18:11:54 +00001101 processSubprogram(DISubprogram(D));
Devang Patel3c91b052010-03-08 20:52:55 +00001102 }
Devang Patel6ceea332009-08-31 18:49:10 +00001103 } else if (DT.isDerivedType()) {
Devang Patel2db49d72010-05-07 18:11:54 +00001104 DIDerivedType DDT(DT);
Devang Patel3c91b052010-03-08 20:52:55 +00001105 processType(DDT.getTypeDerivedFrom());
Devang Pateld2f79a12009-07-28 19:55:13 +00001106 }
1107}
1108
Devang Patelbeab41b2009-10-07 22:04:08 +00001109/// processLexicalBlock
1110void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) {
Devang Patelbeab41b2009-10-07 22:04:08 +00001111 DIScope Context = LB.getContext();
1112 if (Context.isLexicalBlock())
Devang Patel2db49d72010-05-07 18:11:54 +00001113 return processLexicalBlock(DILexicalBlock(Context));
Eric Christopher6618a242011-10-11 22:59:11 +00001114 else if (Context.isLexicalBlockFile()) {
1115 DILexicalBlockFile DBF = DILexicalBlockFile(Context);
1116 return processLexicalBlock(DILexicalBlock(DBF.getScope()));
1117 }
Devang Patelbeab41b2009-10-07 22:04:08 +00001118 else
Devang Patel2db49d72010-05-07 18:11:54 +00001119 return processSubprogram(DISubprogram(Context));
Devang Patelbeab41b2009-10-07 22:04:08 +00001120}
1121
Devang Patel98c65172009-07-30 18:25:15 +00001122/// processSubprogram - Process DISubprogram.
1123void DebugInfoFinder::processSubprogram(DISubprogram SP) {
Devang Pateld2f79a12009-07-28 19:55:13 +00001124 if (!addSubprogram(SP))
1125 return;
Devang Patelfa515ec2011-09-06 17:40:08 +00001126 if (SP.getVersion() <= LLVMDebugVersion10)
1127 addCompileUnit(SP.getCompileUnit());
Devang Patel98c65172009-07-30 18:25:15 +00001128 processType(SP.getType());
Devang Pateld2f79a12009-07-28 19:55:13 +00001129}
1130
Devang Patelb4d31302009-07-31 18:18:52 +00001131/// processDeclare - Process DbgDeclareInst.
1132void DebugInfoFinder::processDeclare(DbgDeclareInst *DDI) {
Devang Patel3c91b052010-03-08 20:52:55 +00001133 MDNode *N = dyn_cast<MDNode>(DDI->getVariable());
1134 if (!N) return;
1135
1136 DIDescriptor DV(N);
1137 if (!DV.isVariable())
Devang Patelb4d31302009-07-31 18:18:52 +00001138 return;
1139
Devang Patel2db49d72010-05-07 18:11:54 +00001140 if (!NodesSeen.insert(DV))
Devang Patelb4d31302009-07-31 18:18:52 +00001141 return;
Devang Patelfa515ec2011-09-06 17:40:08 +00001142 if (DIVariable(N).getVersion() <= LLVMDebugVersion10)
1143 addCompileUnit(DIVariable(N).getCompileUnit());
Devang Patel3c91b052010-03-08 20:52:55 +00001144 processType(DIVariable(N).getType());
Devang Patelb4d31302009-07-31 18:18:52 +00001145}
1146
Devang Patel72bcdb62009-08-10 22:09:58 +00001147/// addType - Add type into Tys.
1148bool DebugInfoFinder::addType(DIType DT) {
Devang Patel3c91b052010-03-08 20:52:55 +00001149 if (!DT.isValid())
Devang Patel72bcdb62009-08-10 22:09:58 +00001150 return false;
1151
Devang Patel2db49d72010-05-07 18:11:54 +00001152 if (!NodesSeen.insert(DT))
Devang Patel72bcdb62009-08-10 22:09:58 +00001153 return false;
1154
Devang Patel2db49d72010-05-07 18:11:54 +00001155 TYs.push_back(DT);
Devang Patel72bcdb62009-08-10 22:09:58 +00001156 return true;
1157}
1158
Devang Pateld2f79a12009-07-28 19:55:13 +00001159/// addCompileUnit - Add compile unit into CUs.
Devang Patel98c65172009-07-30 18:25:15 +00001160bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) {
Devang Patel3c91b052010-03-08 20:52:55 +00001161 if (!CU.Verify())
Devang Pateld2f79a12009-07-28 19:55:13 +00001162 return false;
1163
Devang Patel2db49d72010-05-07 18:11:54 +00001164 if (!NodesSeen.insert(CU))
Devang Pateld2f79a12009-07-28 19:55:13 +00001165 return false;
1166
Devang Patel2db49d72010-05-07 18:11:54 +00001167 CUs.push_back(CU);
Devang Pateld2f79a12009-07-28 19:55:13 +00001168 return true;
1169}
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001170
Devang Pateld2f79a12009-07-28 19:55:13 +00001171/// addGlobalVariable - Add global variable into GVs.
Devang Patel98c65172009-07-30 18:25:15 +00001172bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) {
Devang Patel2db49d72010-05-07 18:11:54 +00001173 if (!DIDescriptor(DIG).isGlobalVariable())
Devang Pateld2f79a12009-07-28 19:55:13 +00001174 return false;
1175
Devang Patel2db49d72010-05-07 18:11:54 +00001176 if (!NodesSeen.insert(DIG))
Devang Pateld2f79a12009-07-28 19:55:13 +00001177 return false;
1178
Devang Patel2db49d72010-05-07 18:11:54 +00001179 GVs.push_back(DIG);
Devang Pateld2f79a12009-07-28 19:55:13 +00001180 return true;
1181}
1182
1183// addSubprogram - Add subprgoram into SPs.
Devang Patel98c65172009-07-30 18:25:15 +00001184bool DebugInfoFinder::addSubprogram(DISubprogram SP) {
Devang Patel2db49d72010-05-07 18:11:54 +00001185 if (!DIDescriptor(SP).isSubprogram())
Devang Pateld2f79a12009-07-28 19:55:13 +00001186 return false;
Daniel Dunbarf612ff62009-09-19 20:40:05 +00001187
Devang Patel2db49d72010-05-07 18:11:54 +00001188 if (!NodesSeen.insert(SP))
Devang Pateld2f79a12009-07-28 19:55:13 +00001189 return false;
1190
Devang Patel2db49d72010-05-07 18:11:54 +00001191 SPs.push_back(SP);
Devang Pateld2f79a12009-07-28 19:55:13 +00001192 return true;
1193}
1194
Chris Lattner099b7792009-12-29 09:22:47 +00001195/// getDISubprogram - Find subprogram that is enclosing this scope.
Devang Patele9f8f5e2010-05-07 20:54:48 +00001196DISubprogram llvm::getDISubprogram(const MDNode *Scope) {
Chris Lattner099b7792009-12-29 09:22:47 +00001197 DIDescriptor D(Scope);
Chris Lattner099b7792009-12-29 09:22:47 +00001198 if (D.isSubprogram())
1199 return DISubprogram(Scope);
Jim Grosbache62b6902010-07-21 21:36:25 +00001200
Eric Christopher6618a242011-10-11 22:59:11 +00001201 if (D.isLexicalBlockFile())
1202 return getDISubprogram(DILexicalBlockFile(Scope).getContext());
1203
Chris Lattner099b7792009-12-29 09:22:47 +00001204 if (D.isLexicalBlock())
Devang Patel2db49d72010-05-07 18:11:54 +00001205 return getDISubprogram(DILexicalBlock(Scope).getContext());
Jim Grosbache62b6902010-07-21 21:36:25 +00001206
Chris Lattner099b7792009-12-29 09:22:47 +00001207 return DISubprogram();
1208}
Devang Patel193f7202009-11-24 01:14:22 +00001209
Chris Lattner099b7792009-12-29 09:22:47 +00001210/// getDICompositeType - Find underlying composite type.
1211DICompositeType llvm::getDICompositeType(DIType T) {
Chris Lattner099b7792009-12-29 09:22:47 +00001212 if (T.isCompositeType())
Devang Patel2db49d72010-05-07 18:11:54 +00001213 return DICompositeType(T);
Jim Grosbache62b6902010-07-21 21:36:25 +00001214
Chris Lattner099b7792009-12-29 09:22:47 +00001215 if (T.isDerivedType())
Devang Patel2db49d72010-05-07 18:11:54 +00001216 return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom());
Jim Grosbache62b6902010-07-21 21:36:25 +00001217
Chris Lattner099b7792009-12-29 09:22:47 +00001218 return DICompositeType();
Torok Edwin620f2802008-12-16 09:07:36 +00001219}
Devang Patel6f9d8ff2011-08-15 17:57:41 +00001220
1221/// isSubprogramContext - Return true if Context is either a subprogram
1222/// or another context nested inside a subprogram.
1223bool llvm::isSubprogramContext(const MDNode *Context) {
1224 if (!Context)
1225 return false;
1226 DIDescriptor D(Context);
1227 if (D.isSubprogram())
1228 return true;
1229 if (D.isType())
1230 return isSubprogramContext(DIType(Context).getContext());
1231 return false;
1232}
1233