Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 1 | //===--- 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 | |
Bill Wendling | 0bcbd1d | 2012-06-28 00:05:13 +0000 | [diff] [blame] | 15 | #include "llvm/DebugInfo.h" |
Chandler Carruth | d04a8d4 | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 16 | #include "llvm/ADT/STLExtras.h" |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/SmallPtrSet.h" |
Dan Gohman | 17aa92c | 2010-07-21 23:38:33 +0000 | [diff] [blame] | 18 | #include "llvm/ADT/SmallString.h" |
Chandler Carruth | d04a8d4 | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 19 | #include "llvm/Analysis/ValueTracking.h" |
Chandler Carruth | 0b8c9a8 | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 20 | #include "llvm/IR/Constants.h" |
| 21 | #include "llvm/IR/DerivedTypes.h" |
| 22 | #include "llvm/IR/Instructions.h" |
| 23 | #include "llvm/IR/IntrinsicInst.h" |
| 24 | #include "llvm/IR/Intrinsics.h" |
| 25 | #include "llvm/IR/Module.h" |
David Greene | 0eb5b66 | 2009-12-23 19:45:49 +0000 | [diff] [blame] | 26 | #include "llvm/Support/Debug.h" |
Argyrios Kyrtzidis | 77eaa68 | 2009-05-03 08:50:41 +0000 | [diff] [blame] | 27 | #include "llvm/Support/Dwarf.h" |
David Blaikie | d072a16 | 2013-03-26 21:59:17 +0000 | [diff] [blame] | 28 | #include "llvm/Support/ValueHandle.h" |
Chris Lattner | a81d29b | 2009-08-23 07:33:14 +0000 | [diff] [blame] | 29 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 30 | using namespace llvm; |
Argyrios Kyrtzidis | 77eaa68 | 2009-05-03 08:50:41 +0000 | [diff] [blame] | 31 | using namespace llvm::dwarf; |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 32 | |
| 33 | //===----------------------------------------------------------------------===// |
| 34 | // DIDescriptor |
| 35 | //===----------------------------------------------------------------------===// |
| 36 | |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 37 | bool DIDescriptor::Verify() const { |
| 38 | return DbgNode && |
| 39 | (DIDerivedType(DbgNode).Verify() || |
| 40 | DICompositeType(DbgNode).Verify() || DIBasicType(DbgNode).Verify() || |
| 41 | DIVariable(DbgNode).Verify() || DISubprogram(DbgNode).Verify() || |
| 42 | DIGlobalVariable(DbgNode).Verify() || DIFile(DbgNode).Verify() || |
| 43 | DICompileUnit(DbgNode).Verify() || DINameSpace(DbgNode).Verify() || |
| 44 | DILexicalBlock(DbgNode).Verify() || |
| 45 | DILexicalBlockFile(DbgNode).Verify() || |
| 46 | DISubrange(DbgNode).Verify() || DIEnumerator(DbgNode).Verify() || |
| 47 | DIObjCProperty(DbgNode).Verify() || |
| 48 | DITemplateTypeParameter(DbgNode).Verify() || |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 49 | DITemplateValueParameter(DbgNode).Verify() || |
David Blaikie | 20d9e41 | 2013-05-07 21:35:53 +0000 | [diff] [blame] | 50 | DIImportedEntity(DbgNode).Verify()); |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 51 | } |
| 52 | |
David Blaikie | b4cf0ab | 2013-03-17 21:13:55 +0000 | [diff] [blame] | 53 | static Value *getField(const MDNode *DbgNode, unsigned Elt) { |
| 54 | if (DbgNode == 0 || Elt >= DbgNode->getNumOperands()) |
| 55 | return 0; |
| 56 | return DbgNode->getOperand(Elt); |
| 57 | } |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 58 | |
Manman Ren | d2ed53c | 2013-07-23 20:39:32 +0000 | [diff] [blame] | 59 | static MDNode *getNodeField(const MDNode *DbgNode, unsigned Elt) { |
| 60 | return dyn_cast_or_null<MDNode>(getField(DbgNode, Elt)); |
David Blaikie | b4cf0ab | 2013-03-17 21:13:55 +0000 | [diff] [blame] | 61 | } |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 62 | |
David Blaikie | b4cf0ab | 2013-03-17 21:13:55 +0000 | [diff] [blame] | 63 | static StringRef getStringField(const MDNode *DbgNode, unsigned Elt) { |
| 64 | if (MDString *MDS = dyn_cast_or_null<MDString>(getField(DbgNode, Elt))) |
| 65 | return MDS->getString(); |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 66 | return StringRef(); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 67 | } |
| 68 | |
David Blaikie | b4cf0ab | 2013-03-17 21:13:55 +0000 | [diff] [blame] | 69 | StringRef DIDescriptor::getStringField(unsigned Elt) const { |
| 70 | return ::getStringField(DbgNode, Elt); |
| 71 | } |
| 72 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 73 | uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const { |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 74 | if (DbgNode == 0) |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 75 | return 0; |
Bill Wendling | dc817b6 | 2009-05-14 18:26:15 +0000 | [diff] [blame] | 76 | |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 77 | if (Elt < DbgNode->getNumOperands()) |
Eric Christopher | 5f214ae | 2012-11-20 00:15:36 +0000 | [diff] [blame] | 78 | if (ConstantInt *CI |
| 79 | = dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt))) |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 80 | return CI->getZExtValue(); |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 81 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 82 | return 0; |
| 83 | } |
| 84 | |
Bill Wendling | 9127be8 | 2012-12-03 19:44:25 +0000 | [diff] [blame] | 85 | int64_t DIDescriptor::getInt64Field(unsigned Elt) const { |
| 86 | if (DbgNode == 0) |
| 87 | return 0; |
| 88 | |
| 89 | if (Elt < DbgNode->getNumOperands()) |
| 90 | if (ConstantInt *CI |
| 91 | = dyn_cast_or_null<ConstantInt>(DbgNode->getOperand(Elt))) |
| 92 | return CI->getSExtValue(); |
| 93 | |
| 94 | return 0; |
| 95 | } |
| 96 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 97 | DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const { |
Manman Ren | d2ed53c | 2013-07-23 20:39:32 +0000 | [diff] [blame] | 98 | MDNode *Field = getNodeField(DbgNode, Elt); |
| 99 | return DIDescriptor(Field); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 100 | } |
| 101 | |
| 102 | GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const { |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 103 | if (DbgNode == 0) |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 104 | return 0; |
Bill Wendling | dc817b6 | 2009-05-14 18:26:15 +0000 | [diff] [blame] | 105 | |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 106 | if (Elt < DbgNode->getNumOperands()) |
| 107 | return dyn_cast_or_null<GlobalVariable>(DbgNode->getOperand(Elt)); |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 108 | return 0; |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 109 | } |
| 110 | |
Devang Patel | 2739896 | 2010-08-09 21:39:24 +0000 | [diff] [blame] | 111 | Constant *DIDescriptor::getConstantField(unsigned Elt) const { |
| 112 | if (DbgNode == 0) |
| 113 | return 0; |
| 114 | |
| 115 | if (Elt < DbgNode->getNumOperands()) |
| 116 | return dyn_cast_or_null<Constant>(DbgNode->getOperand(Elt)); |
| 117 | return 0; |
| 118 | } |
| 119 | |
Stuart Hastings | 215aa15 | 2010-06-11 20:08:44 +0000 | [diff] [blame] | 120 | Function *DIDescriptor::getFunctionField(unsigned Elt) const { |
| 121 | if (DbgNode == 0) |
| 122 | return 0; |
| 123 | |
| 124 | if (Elt < DbgNode->getNumOperands()) |
| 125 | return dyn_cast_or_null<Function>(DbgNode->getOperand(Elt)); |
| 126 | return 0; |
| 127 | } |
| 128 | |
Alexey Samsonov | e97a3a4 | 2012-10-09 08:13:15 +0000 | [diff] [blame] | 129 | void DIDescriptor::replaceFunctionField(unsigned Elt, Function *F) { |
| 130 | if (DbgNode == 0) |
| 131 | return; |
| 132 | |
| 133 | if (Elt < DbgNode->getNumOperands()) { |
| 134 | MDNode *Node = const_cast<MDNode*>(DbgNode); |
| 135 | Node->replaceOperandWith(Elt, F); |
| 136 | } |
| 137 | } |
| 138 | |
Chris Lattner | f0908a3 | 2009-12-31 03:02:08 +0000 | [diff] [blame] | 139 | unsigned DIVariable::getNumAddrElements() const { |
Devang Patel | 23336b4 | 2011-07-19 19:41:54 +0000 | [diff] [blame] | 140 | return DbgNode->getNumOperands()-8; |
Chris Lattner | f0908a3 | 2009-12-31 03:02:08 +0000 | [diff] [blame] | 141 | } |
| 142 | |
Devang Patel | 40c7e41 | 2011-07-20 22:18:50 +0000 | [diff] [blame] | 143 | /// getInlinedAt - If this variable is inlined then return inline location. |
Devang Patel | 48d726f | 2011-08-09 01:03:14 +0000 | [diff] [blame] | 144 | MDNode *DIVariable::getInlinedAt() const { |
Manman Ren | d2ed53c | 2013-07-23 20:39:32 +0000 | [diff] [blame] | 145 | return getNodeField(DbgNode, 7); |
Devang Patel | 40c7e41 | 2011-07-20 22:18:50 +0000 | [diff] [blame] | 146 | } |
Chris Lattner | f0908a3 | 2009-12-31 03:02:08 +0000 | [diff] [blame] | 147 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 148 | //===----------------------------------------------------------------------===// |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 149 | // Predicates |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 150 | //===----------------------------------------------------------------------===// |
| 151 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 152 | /// isBasicType - Return true if the specified tag is legal for |
| 153 | /// DIBasicType. |
| 154 | bool DIDescriptor::isBasicType() const { |
Devang Patel | 734a67c | 2011-09-14 23:13:28 +0000 | [diff] [blame] | 155 | if (!DbgNode) return false; |
| 156 | switch (getTag()) { |
| 157 | case dwarf::DW_TAG_base_type: |
| 158 | case dwarf::DW_TAG_unspecified_type: |
| 159 | return true; |
| 160 | default: |
| 161 | return false; |
| 162 | } |
Torok Edwin | b07fbd9 | 2008-12-13 08:25:29 +0000 | [diff] [blame] | 163 | } |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 164 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 165 | /// isDerivedType - Return true if the specified tag is legal for DIDerivedType. |
| 166 | bool DIDescriptor::isDerivedType() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 167 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 168 | switch (getTag()) { |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 169 | case dwarf::DW_TAG_typedef: |
| 170 | case dwarf::DW_TAG_pointer_type: |
David Blaikie | 62fdfb5 | 2013-01-07 05:51:15 +0000 | [diff] [blame] | 171 | case dwarf::DW_TAG_ptr_to_member_type: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 172 | case dwarf::DW_TAG_reference_type: |
Eric Christopher | 791e629 | 2012-05-19 01:36:37 +0000 | [diff] [blame] | 173 | case dwarf::DW_TAG_rvalue_reference_type: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 174 | case dwarf::DW_TAG_const_type: |
| 175 | case dwarf::DW_TAG_volatile_type: |
| 176 | case dwarf::DW_TAG_restrict_type: |
| 177 | case dwarf::DW_TAG_member: |
| 178 | case dwarf::DW_TAG_inheritance: |
Devang Patel | 49d9638 | 2010-08-23 23:16:25 +0000 | [diff] [blame] | 179 | case dwarf::DW_TAG_friend: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 180 | return true; |
| 181 | default: |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 182 | // CompositeTypes are currently modelled as DerivedTypes. |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 183 | return isCompositeType(); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 184 | } |
| 185 | } |
| 186 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 187 | /// isCompositeType - Return true if the specified tag is legal for |
| 188 | /// DICompositeType. |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 189 | bool DIDescriptor::isCompositeType() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 190 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 191 | switch (getTag()) { |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 192 | case dwarf::DW_TAG_array_type: |
| 193 | case dwarf::DW_TAG_structure_type: |
| 194 | case dwarf::DW_TAG_union_type: |
| 195 | case dwarf::DW_TAG_enumeration_type: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 196 | case dwarf::DW_TAG_subroutine_type: |
Devang Patel | 25cb0d7 | 2009-03-25 03:52:06 +0000 | [diff] [blame] | 197 | case dwarf::DW_TAG_class_type: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 198 | return true; |
| 199 | default: |
| 200 | return false; |
| 201 | } |
| 202 | } |
| 203 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 204 | /// isVariable - Return true if the specified tag is legal for DIVariable. |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 205 | bool DIDescriptor::isVariable() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 206 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 207 | switch (getTag()) { |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 208 | case dwarf::DW_TAG_auto_variable: |
| 209 | case dwarf::DW_TAG_arg_variable: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 210 | return true; |
| 211 | default: |
| 212 | return false; |
| 213 | } |
| 214 | } |
| 215 | |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 216 | /// isType - Return true if the specified tag is legal for DIType. |
| 217 | bool DIDescriptor::isType() const { |
| 218 | return isBasicType() || isCompositeType() || isDerivedType(); |
| 219 | } |
| 220 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 221 | /// isSubprogram - Return true if the specified tag is legal for |
| 222 | /// DISubprogram. |
| 223 | bool DIDescriptor::isSubprogram() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 224 | return DbgNode && getTag() == dwarf::DW_TAG_subprogram; |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | /// isGlobalVariable - Return true if the specified tag is legal for |
| 228 | /// DIGlobalVariable. |
| 229 | bool DIDescriptor::isGlobalVariable() const { |
Devang Patel | 2936807 | 2010-08-10 07:11:13 +0000 | [diff] [blame] | 230 | return DbgNode && (getTag() == dwarf::DW_TAG_variable || |
| 231 | getTag() == dwarf::DW_TAG_constant); |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 232 | } |
| 233 | |
Devang Patel | 716a67f | 2011-02-03 00:13:47 +0000 | [diff] [blame] | 234 | /// isUnspecifiedParmeter - Return true if the specified tag is |
Devang Patel | d6747df | 2010-10-06 20:50:40 +0000 | [diff] [blame] | 235 | /// DW_TAG_unspecified_parameters. |
| 236 | bool DIDescriptor::isUnspecifiedParameter() const { |
| 237 | return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters; |
| 238 | } |
| 239 | |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 240 | /// isScope - Return true if the specified tag is one of the scope |
Devang Patel | 43d98b3 | 2009-08-31 20:44:45 +0000 | [diff] [blame] | 241 | /// related tag. |
| 242 | bool DIDescriptor::isScope() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 243 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 244 | switch (getTag()) { |
| 245 | case dwarf::DW_TAG_compile_unit: |
| 246 | case dwarf::DW_TAG_lexical_block: |
| 247 | case dwarf::DW_TAG_subprogram: |
| 248 | case dwarf::DW_TAG_namespace: |
| 249 | return true; |
| 250 | default: |
| 251 | break; |
Devang Patel | 43d98b3 | 2009-08-31 20:44:45 +0000 | [diff] [blame] | 252 | } |
| 253 | return false; |
| 254 | } |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 255 | |
Devang Patel | 7e2cb11 | 2011-02-02 21:38:25 +0000 | [diff] [blame] | 256 | /// isTemplateTypeParameter - Return true if the specified tag is |
| 257 | /// DW_TAG_template_type_parameter. |
| 258 | bool DIDescriptor::isTemplateTypeParameter() const { |
| 259 | return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter; |
| 260 | } |
| 261 | |
Devang Patel | e7d9387 | 2011-02-02 22:35:53 +0000 | [diff] [blame] | 262 | /// isTemplateValueParameter - Return true if the specified tag is |
| 263 | /// DW_TAG_template_value_parameter. |
| 264 | bool DIDescriptor::isTemplateValueParameter() const { |
David Blaikie | e88939c | 2013-06-22 18:59:11 +0000 | [diff] [blame] | 265 | return DbgNode && (getTag() == dwarf::DW_TAG_template_value_parameter || |
| 266 | getTag() == dwarf::DW_TAG_GNU_template_template_param || |
| 267 | getTag() == dwarf::DW_TAG_GNU_template_parameter_pack); |
Devang Patel | e7d9387 | 2011-02-02 22:35:53 +0000 | [diff] [blame] | 268 | } |
| 269 | |
Devang Patel | c9f322d | 2009-08-31 21:34:44 +0000 | [diff] [blame] | 270 | /// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit. |
| 271 | bool DIDescriptor::isCompileUnit() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 272 | return DbgNode && getTag() == dwarf::DW_TAG_compile_unit; |
Devang Patel | c9f322d | 2009-08-31 21:34:44 +0000 | [diff] [blame] | 273 | } |
| 274 | |
Devang Patel | 7aa8189 | 2010-03-08 22:27:22 +0000 | [diff] [blame] | 275 | /// isFile - Return true if the specified tag is DW_TAG_file_type. |
| 276 | bool DIDescriptor::isFile() const { |
| 277 | return DbgNode && getTag() == dwarf::DW_TAG_file_type; |
| 278 | } |
| 279 | |
Devang Patel | 6404e4e | 2009-12-15 19:16:48 +0000 | [diff] [blame] | 280 | /// isNameSpace - Return true if the specified tag is DW_TAG_namespace. |
| 281 | bool DIDescriptor::isNameSpace() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 282 | return DbgNode && getTag() == dwarf::DW_TAG_namespace; |
Devang Patel | 6404e4e | 2009-12-15 19:16:48 +0000 | [diff] [blame] | 283 | } |
| 284 | |
Eric Christopher | 6618a24 | 2011-10-11 22:59:11 +0000 | [diff] [blame] | 285 | /// isLexicalBlockFile - Return true if the specified descriptor is a |
| 286 | /// lexical block with an extra file. |
| 287 | bool DIDescriptor::isLexicalBlockFile() const { |
| 288 | return DbgNode && getTag() == dwarf::DW_TAG_lexical_block && |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 289 | (DbgNode->getNumOperands() == 3); |
Eric Christopher | 6618a24 | 2011-10-11 22:59:11 +0000 | [diff] [blame] | 290 | } |
| 291 | |
Devang Patel | 5e005d8 | 2009-08-31 22:00:15 +0000 | [diff] [blame] | 292 | /// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block. |
| 293 | bool DIDescriptor::isLexicalBlock() const { |
Eric Christopher | 6618a24 | 2011-10-11 22:59:11 +0000 | [diff] [blame] | 294 | return DbgNode && getTag() == dwarf::DW_TAG_lexical_block && |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 295 | (DbgNode->getNumOperands() > 3); |
Devang Patel | 5e005d8 | 2009-08-31 22:00:15 +0000 | [diff] [blame] | 296 | } |
| 297 | |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 298 | /// isSubrange - Return true if the specified tag is DW_TAG_subrange_type. |
| 299 | bool DIDescriptor::isSubrange() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 300 | return DbgNode && getTag() == dwarf::DW_TAG_subrange_type; |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | /// isEnumerator - Return true if the specified tag is DW_TAG_enumerator. |
| 304 | bool DIDescriptor::isEnumerator() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 305 | return DbgNode && getTag() == dwarf::DW_TAG_enumerator; |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 306 | } |
| 307 | |
David Blaikie | 3545043 | 2013-03-27 17:50:12 +0000 | [diff] [blame] | 308 | /// isObjCProperty - Return true if the specified tag is DW_TAG_APPLE_property. |
Devang Patel | 1ea02d4 | 2012-02-04 00:59:25 +0000 | [diff] [blame] | 309 | bool DIDescriptor::isObjCProperty() const { |
Eric Christopher | 6c31ee2 | 2012-03-29 21:35:05 +0000 | [diff] [blame] | 310 | return DbgNode && getTag() == dwarf::DW_TAG_APPLE_property; |
Devang Patel | 1ea02d4 | 2012-02-04 00:59:25 +0000 | [diff] [blame] | 311 | } |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 312 | |
David Blaikie | 20d9e41 | 2013-05-07 21:35:53 +0000 | [diff] [blame] | 313 | /// \brief Return true if the specified tag is DW_TAG_imported_module or |
| 314 | /// DW_TAG_imported_declaration. |
| 315 | bool DIDescriptor::isImportedEntity() const { |
| 316 | return DbgNode && (getTag() == dwarf::DW_TAG_imported_module || |
| 317 | getTag() == dwarf::DW_TAG_imported_declaration); |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 318 | } |
| 319 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 320 | //===----------------------------------------------------------------------===// |
| 321 | // Simple Descriptor Constructors and other Methods |
| 322 | //===----------------------------------------------------------------------===// |
| 323 | |
Devang Patel | 68afdc3 | 2009-01-05 18:33:01 +0000 | [diff] [blame] | 324 | unsigned DIArray::getNumElements() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 325 | if (!DbgNode) |
| 326 | return 0; |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 327 | return DbgNode->getNumOperands(); |
Devang Patel | 68afdc3 | 2009-01-05 18:33:01 +0000 | [diff] [blame] | 328 | } |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 329 | |
Eric Christopher | e6f774e | 2013-07-24 01:51:12 +0000 | [diff] [blame] | 330 | /// replaceAllUsesWith - Replace all uses of the MDNode used by this |
| 331 | /// type with the one in the passed descriptor. |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 332 | void DIType::replaceAllUsesWith(DIDescriptor &D) { |
Eric Christopher | e6f774e | 2013-07-24 01:51:12 +0000 | [diff] [blame] | 333 | |
| 334 | assert(DbgNode && "Trying to replace an unverified type!"); |
Devang Patel | c4999d7 | 2009-07-22 18:23:44 +0000 | [diff] [blame] | 335 | |
Daniel Dunbar | 48a097b | 2009-09-22 02:03:18 +0000 | [diff] [blame] | 336 | // Since we use a TrackingVH for the node, its easy for clients to manufacture |
| 337 | // legitimate situations where they want to replaceAllUsesWith() on something |
| 338 | // which, due to uniquing, has merged with the source. We shield clients from |
| 339 | // this detail by allowing a value to be replaced with replaceAllUsesWith() |
| 340 | // itself. |
Devang Patel | ed66bf5 | 2010-05-07 18:19:32 +0000 | [diff] [blame] | 341 | if (DbgNode != D) { |
Devang Patel | e9f8f5e | 2010-05-07 20:54:48 +0000 | [diff] [blame] | 342 | MDNode *Node = const_cast<MDNode*>(DbgNode); |
| 343 | const MDNode *DN = D; |
| 344 | const Value *V = cast_or_null<Value>(DN); |
| 345 | Node->replaceAllUsesWith(const_cast<Value*>(V)); |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 346 | MDNode::deleteTemporary(Node); |
Daniel Dunbar | 48a097b | 2009-09-22 02:03:18 +0000 | [diff] [blame] | 347 | } |
Devang Patel | c4999d7 | 2009-07-22 18:23:44 +0000 | [diff] [blame] | 348 | } |
| 349 | |
Eric Christopher | e6f774e | 2013-07-24 01:51:12 +0000 | [diff] [blame] | 350 | /// replaceAllUsesWith - Replace all uses of the MDNode used by this |
| 351 | /// type with the one in D. |
Devang Patel | 0a2551d | 2010-12-08 20:18:20 +0000 | [diff] [blame] | 352 | void DIType::replaceAllUsesWith(MDNode *D) { |
Eric Christopher | e6f774e | 2013-07-24 01:51:12 +0000 | [diff] [blame] | 353 | |
| 354 | assert(DbgNode && "Trying to replace an unverified type!"); |
Devang Patel | 0a2551d | 2010-12-08 20:18:20 +0000 | [diff] [blame] | 355 | |
| 356 | // Since we use a TrackingVH for the node, its easy for clients to manufacture |
| 357 | // legitimate situations where they want to replaceAllUsesWith() on something |
| 358 | // which, due to uniquing, has merged with the source. We shield clients from |
| 359 | // this detail by allowing a value to be replaced with replaceAllUsesWith() |
| 360 | // itself. |
| 361 | if (DbgNode != D) { |
| 362 | MDNode *Node = const_cast<MDNode*>(DbgNode); |
| 363 | const MDNode *DN = D; |
| 364 | const Value *V = cast_or_null<Value>(DN); |
| 365 | Node->replaceAllUsesWith(const_cast<Value*>(V)); |
| 366 | MDNode::deleteTemporary(Node); |
| 367 | } |
| 368 | } |
| 369 | |
Devang Patel | 6f9d8ff | 2011-08-15 17:57:41 +0000 | [diff] [blame] | 370 | /// isUnsignedDIType - Return true if type encoding is unsigned. |
| 371 | bool DIType::isUnsignedDIType() { |
| 372 | DIDerivedType DTy(DbgNode); |
| 373 | if (DTy.Verify()) |
| 374 | return DTy.getTypeDerivedFrom().isUnsignedDIType(); |
| 375 | |
| 376 | DIBasicType BTy(DbgNode); |
| 377 | if (BTy.Verify()) { |
| 378 | unsigned Encoding = BTy.getEncoding(); |
| 379 | if (Encoding == dwarf::DW_ATE_unsigned || |
David Blaikie | fe07db3 | 2013-01-19 23:00:25 +0000 | [diff] [blame] | 380 | Encoding == dwarf::DW_ATE_unsigned_char || |
| 381 | Encoding == dwarf::DW_ATE_boolean) |
Devang Patel | 6f9d8ff | 2011-08-15 17:57:41 +0000 | [diff] [blame] | 382 | return true; |
| 383 | } |
| 384 | return false; |
| 385 | } |
| 386 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 387 | /// Verify - Verify that a compile unit is well formed. |
| 388 | bool DICompileUnit::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 389 | if (!isCompileUnit()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 390 | return false; |
Eric Christopher | 78ac65f | 2013-07-24 00:54:39 +0000 | [diff] [blame] | 391 | |
| 392 | // Don't bother verifying the compilation directory or producer string |
| 393 | // as those could be empty. |
| 394 | if (getFilename().empty()) |
Bill Wendling | 0582ae9 | 2009-03-13 04:39:26 +0000 | [diff] [blame] | 395 | return false; |
Eric Christopher | 78ac65f | 2013-07-24 00:54:39 +0000 | [diff] [blame] | 396 | |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 397 | return DbgNode->getNumOperands() == 13; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 398 | } |
| 399 | |
Eric Christopher | b8ca988 | 2012-03-29 08:42:56 +0000 | [diff] [blame] | 400 | /// Verify - Verify that an ObjC property is well formed. |
| 401 | bool DIObjCProperty::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 402 | if (!isObjCProperty()) |
Eric Christopher | b8ca988 | 2012-03-29 08:42:56 +0000 | [diff] [blame] | 403 | return false; |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 404 | |
Eric Christopher | b8ca988 | 2012-03-29 08:42:56 +0000 | [diff] [blame] | 405 | // Don't worry about the rest of the strings for now. |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 406 | return DbgNode->getNumOperands() == 8; |
Eric Christopher | b8ca988 | 2012-03-29 08:42:56 +0000 | [diff] [blame] | 407 | } |
| 408 | |
Manman Ren | 27ce44d | 2013-07-25 06:43:01 +0000 | [diff] [blame^] | 409 | /// We allow an empty string to represent null. But we don't allow |
| 410 | /// a non-empty string in a MDNode field. |
| 411 | static bool fieldIsMDNode(const MDNode *DbgNode, unsigned Elt) { |
| 412 | Value *Fld = getField(DbgNode, Elt); |
| 413 | if (Fld && isa<MDString>(Fld) && |
| 414 | !cast<MDString>(Fld)->getString().empty()) |
| 415 | return false; |
| 416 | return true; |
| 417 | } |
| 418 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 419 | /// Verify - Verify that a type descriptor is well formed. |
| 420 | bool DIType::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 421 | if (!isType()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 422 | return false; |
Eric Christopher | bf7644a | 2013-07-24 00:54:36 +0000 | [diff] [blame] | 423 | // FIXME: Sink this into the various subclass verifies. |
Devang Patel | b71bbf9 | 2010-11-02 20:41:13 +0000 | [diff] [blame] | 424 | unsigned Tag = getTag(); |
| 425 | if (!isBasicType() && Tag != dwarf::DW_TAG_const_type && |
| 426 | Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type && |
David Blaikie | 62fdfb5 | 2013-01-07 05:51:15 +0000 | [diff] [blame] | 427 | Tag != dwarf::DW_TAG_ptr_to_member_type && |
Eric Christopher | 791e629 | 2012-05-19 01:36:37 +0000 | [diff] [blame] | 428 | Tag != dwarf::DW_TAG_reference_type && |
| 429 | Tag != dwarf::DW_TAG_rvalue_reference_type && |
Eric Christopher | bf7644a | 2013-07-24 00:54:36 +0000 | [diff] [blame] | 430 | Tag != dwarf::DW_TAG_restrict_type && Tag != dwarf::DW_TAG_array_type && |
Eric Christopher | 791e629 | 2012-05-19 01:36:37 +0000 | [diff] [blame] | 431 | Tag != dwarf::DW_TAG_enumeration_type && |
| 432 | Tag != dwarf::DW_TAG_subroutine_type && |
Eric Christopher | bf7644a | 2013-07-24 00:54:36 +0000 | [diff] [blame] | 433 | Tag != dwarf::DW_TAG_inheritance && Tag != dwarf::DW_TAG_friend && |
Eric Christopher | 791e629 | 2012-05-19 01:36:37 +0000 | [diff] [blame] | 434 | getFilename().empty()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 435 | return false; |
Manman Ren | 9fd6178 | 2013-07-23 18:14:25 +0000 | [diff] [blame] | 436 | // DIType is abstract, it should be a BasicType, a DerivedType or |
| 437 | // a CompositeType. |
| 438 | if (isBasicType()) |
| 439 | DIBasicType(DbgNode).Verify(); |
| 440 | else if (isCompositeType()) |
| 441 | DICompositeType(DbgNode).Verify(); |
| 442 | else if (isDerivedType()) |
| 443 | DIDerivedType(DbgNode).Verify(); |
| 444 | else |
| 445 | return false; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 446 | return true; |
| 447 | } |
| 448 | |
Devang Patel | 0c4720c | 2010-08-23 18:25:56 +0000 | [diff] [blame] | 449 | /// Verify - Verify that a basic type descriptor is well formed. |
| 450 | bool DIBasicType::Verify() const { |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 451 | return isBasicType() && DbgNode->getNumOperands() == 10; |
Devang Patel | 0c4720c | 2010-08-23 18:25:56 +0000 | [diff] [blame] | 452 | } |
| 453 | |
| 454 | /// Verify - Verify that a derived type descriptor is well formed. |
| 455 | bool DIDerivedType::Verify() const { |
Manman Ren | 27ce44d | 2013-07-25 06:43:01 +0000 | [diff] [blame^] | 456 | // Make sure DerivedFrom @ field 9 is MDNode. |
| 457 | if (!fieldIsMDNode(DbgNode, 9)) |
| 458 | return false; |
| 459 | if (getTag() == dwarf::DW_TAG_ptr_to_member_type) |
| 460 | // Make sure ClassType @ field 10 is MDNode. |
| 461 | if (!fieldIsMDNode(DbgNode, 10)) |
| 462 | return false; |
| 463 | |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 464 | return isDerivedType() && DbgNode->getNumOperands() >= 10 && |
| 465 | DbgNode->getNumOperands() <= 14; |
Devang Patel | 0c4720c | 2010-08-23 18:25:56 +0000 | [diff] [blame] | 466 | } |
| 467 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 468 | /// Verify - Verify that a composite type descriptor is well formed. |
| 469 | bool DICompositeType::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 470 | if (!isCompositeType()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 471 | return false; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 472 | |
Manman Ren | 27ce44d | 2013-07-25 06:43:01 +0000 | [diff] [blame^] | 473 | // Make sure DerivedFrom @ field 9 and ContainingType @ field 12 are MDNodes. |
| 474 | if (!fieldIsMDNode(DbgNode, 9)) |
| 475 | return false; |
| 476 | if (!fieldIsMDNode(DbgNode, 12)) |
| 477 | return false; |
| 478 | |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 479 | return DbgNode->getNumOperands() >= 10 && DbgNode->getNumOperands() <= 14; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 480 | } |
| 481 | |
| 482 | /// Verify - Verify that a subprogram descriptor is well formed. |
| 483 | bool DISubprogram::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 484 | if (!isSubprogram()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 485 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 486 | |
Manman Ren | 27ce44d | 2013-07-25 06:43:01 +0000 | [diff] [blame^] | 487 | // Make sure context @ field 2 and type @ field 7 are MDNodes. |
| 488 | if (!fieldIsMDNode(DbgNode, 2)) |
| 489 | return false; |
| 490 | if (!fieldIsMDNode(DbgNode, 7)) |
| 491 | return false; |
| 492 | // Containing type @ field 12. |
| 493 | if (!fieldIsMDNode(DbgNode, 12)) |
| 494 | return false; |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 495 | return DbgNode->getNumOperands() == 20; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 496 | } |
| 497 | |
| 498 | /// Verify - Verify that a global variable descriptor is well formed. |
| 499 | bool DIGlobalVariable::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 500 | if (!isGlobalVariable()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 501 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 502 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 503 | if (getDisplayName().empty()) |
Devang Patel | 84c73e9 | 2009-11-06 17:58:12 +0000 | [diff] [blame] | 504 | return false; |
Manman Ren | 27ce44d | 2013-07-25 06:43:01 +0000 | [diff] [blame^] | 505 | // Make sure context @ field 2 and type @ field 8 are MDNodes. |
| 506 | if (!fieldIsMDNode(DbgNode, 2)) |
| 507 | return false; |
| 508 | if (!fieldIsMDNode(DbgNode, 8)) |
| 509 | return false; |
| 510 | // Make sure StaticDataMemberDeclaration @ field 12 is MDNode. |
| 511 | if (!fieldIsMDNode(DbgNode, 12)) |
| 512 | return false; |
Devang Patel | 84c73e9 | 2009-11-06 17:58:12 +0000 | [diff] [blame] | 513 | |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 514 | return DbgNode->getNumOperands() == 13; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 515 | } |
| 516 | |
| 517 | /// Verify - Verify that a variable descriptor is well formed. |
| 518 | bool DIVariable::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 519 | if (!isVariable()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 520 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 521 | |
Manman Ren | 27ce44d | 2013-07-25 06:43:01 +0000 | [diff] [blame^] | 522 | // Make sure context @ field 1 and type @ field 5 are MDNodes. |
| 523 | if (!fieldIsMDNode(DbgNode, 1)) |
| 524 | return false; |
| 525 | if (!fieldIsMDNode(DbgNode, 5)) |
| 526 | return false; |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 527 | return DbgNode->getNumOperands() >= 8; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 528 | } |
| 529 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 530 | /// Verify - Verify that a location descriptor is well formed. |
| 531 | bool DILocation::Verify() const { |
| 532 | if (!DbgNode) |
| 533 | return false; |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 534 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 535 | return DbgNode->getNumOperands() == 4; |
| 536 | } |
| 537 | |
Devang Patel | 47e2265 | 2010-05-07 23:04:32 +0000 | [diff] [blame] | 538 | /// Verify - Verify that a namespace descriptor is well formed. |
| 539 | bool DINameSpace::Verify() const { |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 540 | if (!isNameSpace()) |
Devang Patel | 47e2265 | 2010-05-07 23:04:32 +0000 | [diff] [blame] | 541 | return false; |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 542 | return DbgNode->getNumOperands() == 5; |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 543 | } |
| 544 | |
David Blaikie | 4776bce | 2013-03-20 00:26:26 +0000 | [diff] [blame] | 545 | /// \brief Retrieve the MDNode for the directory/file pair. |
| 546 | MDNode *DIFile::getFileNode() const { |
Manman Ren | d2ed53c | 2013-07-23 20:39:32 +0000 | [diff] [blame] | 547 | return getNodeField(DbgNode, 1); |
David Blaikie | 4776bce | 2013-03-20 00:26:26 +0000 | [diff] [blame] | 548 | } |
| 549 | |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 550 | /// \brief Verify that the file descriptor is well formed. |
| 551 | bool DIFile::Verify() const { |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 552 | return isFile() && DbgNode->getNumOperands() == 2; |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 553 | } |
| 554 | |
| 555 | /// \brief Verify that the enumerator descriptor is well formed. |
| 556 | bool DIEnumerator::Verify() const { |
| 557 | return isEnumerator() && DbgNode->getNumOperands() == 3; |
| 558 | } |
| 559 | |
| 560 | /// \brief Verify that the subrange descriptor is well formed. |
| 561 | bool DISubrange::Verify() const { |
| 562 | return isSubrange() && DbgNode->getNumOperands() == 3; |
| 563 | } |
| 564 | |
| 565 | /// \brief Verify that the lexical block descriptor is well formed. |
| 566 | bool DILexicalBlock::Verify() const { |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 567 | return isLexicalBlock() && DbgNode->getNumOperands() == 6; |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 568 | } |
| 569 | |
| 570 | /// \brief Verify that the file-scoped lexical block descriptor is well formed. |
| 571 | bool DILexicalBlockFile::Verify() const { |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 572 | return isLexicalBlockFile() && DbgNode->getNumOperands() == 3; |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 573 | } |
| 574 | |
| 575 | /// \brief Verify that the template type parameter descriptor is well formed. |
| 576 | bool DITemplateTypeParameter::Verify() const { |
| 577 | return isTemplateTypeParameter() && DbgNode->getNumOperands() == 7; |
| 578 | } |
| 579 | |
| 580 | /// \brief Verify that the template value parameter descriptor is well formed. |
| 581 | bool DITemplateValueParameter::Verify() const { |
| 582 | return isTemplateValueParameter() && DbgNode->getNumOperands() == 8; |
Devang Patel | 47e2265 | 2010-05-07 23:04:32 +0000 | [diff] [blame] | 583 | } |
| 584 | |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 585 | /// \brief Verify that the imported module descriptor is well formed. |
David Blaikie | 20d9e41 | 2013-05-07 21:35:53 +0000 | [diff] [blame] | 586 | bool DIImportedEntity::Verify() const { |
David Blaikie | 7b72cc7 | 2013-05-20 22:50:35 +0000 | [diff] [blame] | 587 | return isImportedEntity() && |
| 588 | (DbgNode->getNumOperands() == 4 || DbgNode->getNumOperands() == 5); |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 589 | } |
| 590 | |
Devang Patel | 36375ee | 2009-02-17 21:23:59 +0000 | [diff] [blame] | 591 | /// getOriginalTypeSize - If this type is derived from a base type then |
| 592 | /// return base type size. |
| 593 | uint64_t DIDerivedType::getOriginalTypeSize() const { |
Devang Patel | 61ecbd1 | 2009-11-04 23:48:00 +0000 | [diff] [blame] | 594 | unsigned Tag = getTag(); |
Eric Christopher | 2e1b0c0 | 2011-12-16 23:42:45 +0000 | [diff] [blame] | 595 | |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 596 | if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef && |
| 597 | Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type && |
| 598 | Tag != dwarf::DW_TAG_restrict_type) |
| 599 | return getSizeInBits(); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 600 | |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 601 | DIType BaseType = getTypeDerivedFrom(); |
| 602 | |
| 603 | // If this type is not derived from any type then take conservative approach. |
| 604 | if (!BaseType.isValid()) |
| 605 | return getSizeInBits(); |
| 606 | |
| 607 | // If this is a derived type, go ahead and get the base type, unless it's a |
| 608 | // reference then it's just the size of the field. Pointer types have no need |
| 609 | // of this since they're a different type of qualification on the type. |
| 610 | if (BaseType.getTag() == dwarf::DW_TAG_reference_type || |
| 611 | BaseType.getTag() == dwarf::DW_TAG_rvalue_reference_type) |
| 612 | return getSizeInBits(); |
| 613 | |
| 614 | if (BaseType.isDerivedType()) |
| 615 | return DIDerivedType(BaseType).getOriginalTypeSize(); |
| 616 | |
| 617 | return BaseType.getSizeInBits(); |
Devang Patel | 36375ee | 2009-02-17 21:23:59 +0000 | [diff] [blame] | 618 | } |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 619 | |
Devang Patel | 6588abf | 2012-02-06 17:49:43 +0000 | [diff] [blame] | 620 | /// getObjCProperty - Return property node, if this ivar is associated with one. |
| 621 | MDNode *DIDerivedType::getObjCProperty() const { |
Manman Ren | d2ed53c | 2013-07-23 20:39:32 +0000 | [diff] [blame] | 622 | return getNodeField(DbgNode, 10); |
Devang Patel | 6588abf | 2012-02-06 17:49:43 +0000 | [diff] [blame] | 623 | } |
| 624 | |
David Blaikie | f34ea64 | 2013-03-26 23:46:36 +0000 | [diff] [blame] | 625 | /// \brief Set the array of member DITypes. |
David Blaikie | d072a16 | 2013-03-26 21:59:17 +0000 | [diff] [blame] | 626 | void DICompositeType::setTypeArray(DIArray Elements, DIArray TParams) { |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 627 | assert((!TParams || DbgNode->getNumOperands() == 14) && |
Benjamin Kramer | 2b393fb | 2013-03-27 15:03:14 +0000 | [diff] [blame] | 628 | "If you're setting the template parameters this should include a slot " |
| 629 | "for that!"); |
David Blaikie | d072a16 | 2013-03-26 21:59:17 +0000 | [diff] [blame] | 630 | TrackingVH<MDNode> N(*this); |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 631 | N->replaceOperandWith(10, Elements); |
David Blaikie | d072a16 | 2013-03-26 21:59:17 +0000 | [diff] [blame] | 632 | if (TParams) |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 633 | N->replaceOperandWith(13, TParams); |
David Blaikie | d072a16 | 2013-03-26 21:59:17 +0000 | [diff] [blame] | 634 | DbgNode = N; |
| 635 | } |
| 636 | |
David Blaikie | f34ea64 | 2013-03-26 23:46:36 +0000 | [diff] [blame] | 637 | /// \brief Set the containing type. |
| 638 | void DICompositeType::setContainingType(DICompositeType ContainingType) { |
| 639 | TrackingVH<MDNode> N(*this); |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 640 | N->replaceOperandWith(12, ContainingType); |
David Blaikie | f34ea64 | 2013-03-26 23:46:36 +0000 | [diff] [blame] | 641 | DbgNode = N; |
| 642 | } |
| 643 | |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 644 | /// isInlinedFnArgument - Return true if this variable provides debugging |
Devang Patel | 719f6a9 | 2010-04-29 20:40:36 +0000 | [diff] [blame] | 645 | /// information for an inlined function arguments. |
| 646 | bool DIVariable::isInlinedFnArgument(const Function *CurFn) { |
| 647 | assert(CurFn && "Invalid function"); |
| 648 | if (!getContext().isSubprogram()) |
| 649 | return false; |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 650 | // This variable is not inlined function argument if its scope |
Devang Patel | 719f6a9 | 2010-04-29 20:40:36 +0000 | [diff] [blame] | 651 | // does not describe current function. |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 652 | return !DISubprogram(getContext()).describes(CurFn); |
Devang Patel | 719f6a9 | 2010-04-29 20:40:36 +0000 | [diff] [blame] | 653 | } |
| 654 | |
Devang Patel | af5b6bb | 2009-04-15 00:06:07 +0000 | [diff] [blame] | 655 | /// describes - Return true if this subprogram provides debugging |
| 656 | /// information for the function F. |
| 657 | bool DISubprogram::describes(const Function *F) { |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 658 | assert(F && "Invalid function"); |
Devang Patel | ffd33cd | 2010-06-16 06:42:02 +0000 | [diff] [blame] | 659 | if (F == getFunction()) |
| 660 | return true; |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 661 | StringRef Name = getLinkageName(); |
| 662 | if (Name.empty()) |
Devang Patel | 5ccdd10 | 2009-09-29 18:40:58 +0000 | [diff] [blame] | 663 | Name = getName(); |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 664 | if (F->getName() == Name) |
Devang Patel | af5b6bb | 2009-04-15 00:06:07 +0000 | [diff] [blame] | 665 | return true; |
| 666 | return false; |
| 667 | } |
| 668 | |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 669 | unsigned DISubprogram::isOptimized() const { |
Devang Patel | ccff812 | 2010-04-30 19:38:23 +0000 | [diff] [blame] | 670 | assert (DbgNode && "Invalid subprogram descriptor!"); |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 671 | if (DbgNode->getNumOperands() == 15) |
| 672 | return getUnsignedField(14); |
Devang Patel | ccff812 | 2010-04-30 19:38:23 +0000 | [diff] [blame] | 673 | return 0; |
| 674 | } |
| 675 | |
Devang Patel | 93d39be | 2011-08-19 23:28:12 +0000 | [diff] [blame] | 676 | MDNode *DISubprogram::getVariablesNodes() const { |
Manman Ren | d2ed53c | 2013-07-23 20:39:32 +0000 | [diff] [blame] | 677 | return getNodeField(DbgNode, 18); |
Devang Patel | 93d39be | 2011-08-19 23:28:12 +0000 | [diff] [blame] | 678 | } |
| 679 | |
| 680 | DIArray DISubprogram::getVariables() const { |
Manman Ren | 4f2c297 | 2013-07-23 23:07:38 +0000 | [diff] [blame] | 681 | return DIArray(getNodeField(DbgNode, 18)); |
Devang Patel | 93d39be | 2011-08-19 23:28:12 +0000 | [diff] [blame] | 682 | } |
| 683 | |
David Blaikie | 4de9d72 | 2013-05-10 21:52:07 +0000 | [diff] [blame] | 684 | Value *DITemplateValueParameter::getValue() const { |
| 685 | return getField(DbgNode, 4); |
| 686 | } |
| 687 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 688 | StringRef DIScope::getFilename() const { |
Devang Patel | 77bf295 | 2010-03-08 22:02:50 +0000 | [diff] [blame] | 689 | if (!DbgNode) |
| 690 | return StringRef(); |
David Blaikie | b4cf0ab | 2013-03-17 21:13:55 +0000 | [diff] [blame] | 691 | return ::getStringField(getNodeField(DbgNode, 1), 0); |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 692 | } |
| 693 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 694 | StringRef DIScope::getDirectory() const { |
Devang Patel | 77bf295 | 2010-03-08 22:02:50 +0000 | [diff] [blame] | 695 | if (!DbgNode) |
| 696 | return StringRef(); |
David Blaikie | b4cf0ab | 2013-03-17 21:13:55 +0000 | [diff] [blame] | 697 | return ::getStringField(getNodeField(DbgNode, 1), 1); |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 698 | } |
| 699 | |
Devang Patel | 94c7ddb | 2011-08-16 22:09:43 +0000 | [diff] [blame] | 700 | DIArray DICompileUnit::getEnumTypes() const { |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 701 | if (!DbgNode || DbgNode->getNumOperands() < 13) |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 702 | return DIArray(); |
| 703 | |
Manman Ren | 4f2c297 | 2013-07-23 23:07:38 +0000 | [diff] [blame] | 704 | return DIArray(getNodeField(DbgNode, 7)); |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 705 | } |
| 706 | |
| 707 | DIArray DICompileUnit::getRetainedTypes() const { |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 708 | if (!DbgNode || DbgNode->getNumOperands() < 13) |
David Blaikie | de3077a | 2013-03-13 00:01:35 +0000 | [diff] [blame] | 709 | return DIArray(); |
| 710 | |
Manman Ren | 4f2c297 | 2013-07-23 23:07:38 +0000 | [diff] [blame] | 711 | return DIArray(getNodeField(DbgNode, 8)); |
David Blaikie | de3077a | 2013-03-13 00:01:35 +0000 | [diff] [blame] | 712 | } |
| 713 | |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 714 | DIArray DICompileUnit::getSubprograms() const { |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 715 | if (!DbgNode || DbgNode->getNumOperands() < 13) |
David Blaikie | 46561ce | 2013-03-12 22:43:04 +0000 | [diff] [blame] | 716 | return DIArray(); |
| 717 | |
Manman Ren | 4f2c297 | 2013-07-23 23:07:38 +0000 | [diff] [blame] | 718 | return DIArray(getNodeField(DbgNode, 9)); |
David Blaikie | 46561ce | 2013-03-12 22:43:04 +0000 | [diff] [blame] | 719 | } |
| 720 | |
David Blaikie | 72dfb05 | 2013-03-28 02:44:59 +0000 | [diff] [blame] | 721 | |
| 722 | DIArray DICompileUnit::getGlobalVariables() const { |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 723 | if (!DbgNode || DbgNode->getNumOperands() < 13) |
Devang Patel | 94c7ddb | 2011-08-16 22:09:43 +0000 | [diff] [blame] | 724 | return DIArray(); |
| 725 | |
Manman Ren | 4f2c297 | 2013-07-23 23:07:38 +0000 | [diff] [blame] | 726 | return DIArray(getNodeField(DbgNode, 10)); |
Devang Patel | 94c7ddb | 2011-08-16 22:09:43 +0000 | [diff] [blame] | 727 | } |
| 728 | |
David Blaikie | 20d9e41 | 2013-05-07 21:35:53 +0000 | [diff] [blame] | 729 | DIArray DICompileUnit::getImportedEntities() const { |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 730 | if (!DbgNode || DbgNode->getNumOperands() < 13) |
| 731 | return DIArray(); |
| 732 | |
Manman Ren | 4f2c297 | 2013-07-23 23:07:38 +0000 | [diff] [blame] | 733 | return DIArray(getNodeField(DbgNode, 11)); |
David Blaikie | c462db6 | 2013-04-22 06:12:31 +0000 | [diff] [blame] | 734 | } |
| 735 | |
Benjamin Kramer | 7c2b4be | 2013-06-01 17:51:14 +0000 | [diff] [blame] | 736 | /// fixupSubprogramName - Replace contains special characters used |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 737 | /// in a typical Objective-C names with '.' in a given string. |
Benjamin Kramer | 7c2b4be | 2013-06-01 17:51:14 +0000 | [diff] [blame] | 738 | static void fixupSubprogramName(DISubprogram Fn, SmallVectorImpl<char> &Out) { |
| 739 | StringRef FName = |
| 740 | Fn.getFunction() ? Fn.getFunction()->getName() : Fn.getName(); |
| 741 | FName = Function::getRealLinkageName(FName); |
| 742 | |
| 743 | StringRef Prefix("llvm.dbg.lv."); |
| 744 | Out.reserve(FName.size() + Prefix.size()); |
| 745 | Out.append(Prefix.begin(), Prefix.end()); |
| 746 | |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame] | 747 | bool isObjCLike = false; |
Benjamin Kramer | 7c2b4be | 2013-06-01 17:51:14 +0000 | [diff] [blame] | 748 | for (size_t i = 0, e = FName.size(); i < e; ++i) { |
| 749 | char C = FName[i]; |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame] | 750 | if (C == '[') |
| 751 | isObjCLike = true; |
| 752 | |
| 753 | if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' || |
| 754 | C == '+' || C == '(' || C == ')')) |
| 755 | Out.push_back('.'); |
| 756 | else |
| 757 | Out.push_back(C); |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 758 | } |
| 759 | } |
| 760 | |
Eric Christopher | 5f214ae | 2012-11-20 00:15:36 +0000 | [diff] [blame] | 761 | /// getFnSpecificMDNode - Return a NameMDNode, if available, that is |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 762 | /// suitable to hold function specific information. |
Devang Patel | 93d39be | 2011-08-19 23:28:12 +0000 | [diff] [blame] | 763 | NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, DISubprogram Fn) { |
Benjamin Kramer | 7c2b4be | 2013-06-01 17:51:14 +0000 | [diff] [blame] | 764 | SmallString<32> Name; |
| 765 | fixupSubprogramName(Fn, Name); |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame] | 766 | return M.getNamedMetadata(Name.str()); |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 767 | } |
| 768 | |
Duncan Sands | 291bb70 | 2011-03-02 20:30:37 +0000 | [diff] [blame] | 769 | /// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable |
| 770 | /// to hold function specific information. |
Devang Patel | 93d39be | 2011-08-19 23:28:12 +0000 | [diff] [blame] | 771 | NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, DISubprogram Fn) { |
Benjamin Kramer | 7c2b4be | 2013-06-01 17:51:14 +0000 | [diff] [blame] | 772 | SmallString<32> Name; |
| 773 | fixupSubprogramName(Fn, Name); |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame] | 774 | return M.getOrInsertNamedMetadata(Name.str()); |
Devang Patel | 1a7ca03 | 2010-09-28 18:08:20 +0000 | [diff] [blame] | 775 | } |
| 776 | |
Devang Patel | 23336b4 | 2011-07-19 19:41:54 +0000 | [diff] [blame] | 777 | /// createInlinedVariable - Create a new inlined variable based on current |
| 778 | /// variable. |
| 779 | /// @param DV Current Variable. |
| 780 | /// @param InlinedScope Location at current variable is inlined. |
| 781 | DIVariable llvm::createInlinedVariable(MDNode *DV, MDNode *InlinedScope, |
| 782 | LLVMContext &VMContext) { |
| 783 | SmallVector<Value *, 16> Elts; |
| 784 | // Insert inlined scope as 7th element. |
| 785 | for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) |
| 786 | i == 7 ? Elts.push_back(InlinedScope) : |
| 787 | Elts.push_back(DV->getOperand(i)); |
| 788 | return DIVariable(MDNode::get(VMContext, Elts)); |
| 789 | } |
Devang Patel | 1a7ca03 | 2010-09-28 18:08:20 +0000 | [diff] [blame] | 790 | |
Devang Patel | b549bcf | 2011-08-10 21:50:54 +0000 | [diff] [blame] | 791 | /// cleanseInlinedVariable - Remove inlined scope from the variable. |
| 792 | DIVariable llvm::cleanseInlinedVariable(MDNode *DV, LLVMContext &VMContext) { |
| 793 | SmallVector<Value *, 16> Elts; |
| 794 | // Insert inlined scope as 7th element. |
| 795 | for (unsigned i = 0, e = DV->getNumOperands(); i != e; ++i) |
Eric Christopher | 5f214ae | 2012-11-20 00:15:36 +0000 | [diff] [blame] | 796 | i == 7 ? |
Bill Wendling | 0735e81 | 2012-07-06 17:46:28 +0000 | [diff] [blame] | 797 | Elts.push_back(Constant::getNullValue(Type::getInt32Ty(VMContext))): |
Devang Patel | b549bcf | 2011-08-10 21:50:54 +0000 | [diff] [blame] | 798 | Elts.push_back(DV->getOperand(i)); |
| 799 | return DIVariable(MDNode::get(VMContext, Elts)); |
| 800 | } |
| 801 | |
Bill Wendling | 0bcbd1d | 2012-06-28 00:05:13 +0000 | [diff] [blame] | 802 | /// getDISubprogram - Find subprogram that is enclosing this scope. |
| 803 | DISubprogram llvm::getDISubprogram(const MDNode *Scope) { |
| 804 | DIDescriptor D(Scope); |
| 805 | if (D.isSubprogram()) |
| 806 | return DISubprogram(Scope); |
| 807 | |
| 808 | if (D.isLexicalBlockFile()) |
| 809 | return getDISubprogram(DILexicalBlockFile(Scope).getContext()); |
Eric Christopher | 5f214ae | 2012-11-20 00:15:36 +0000 | [diff] [blame] | 810 | |
Bill Wendling | 0bcbd1d | 2012-06-28 00:05:13 +0000 | [diff] [blame] | 811 | if (D.isLexicalBlock()) |
| 812 | return getDISubprogram(DILexicalBlock(Scope).getContext()); |
| 813 | |
| 814 | return DISubprogram(); |
| 815 | } |
| 816 | |
Eric Christopher | 7bb386a | 2013-07-09 00:16:56 +0000 | [diff] [blame] | 817 | /// getDICompositeType - Find underlying composite type. |
| 818 | DICompositeType llvm::getDICompositeType(DIType T) { |
| 819 | if (T.isCompositeType()) |
| 820 | return DICompositeType(T); |
| 821 | |
| 822 | if (T.isDerivedType()) |
| 823 | return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom()); |
| 824 | |
| 825 | return DICompositeType(); |
| 826 | } |
| 827 | |
Bill Wendling | 0bcbd1d | 2012-06-28 00:05:13 +0000 | [diff] [blame] | 828 | /// isSubprogramContext - Return true if Context is either a subprogram |
| 829 | /// or another context nested inside a subprogram. |
| 830 | bool llvm::isSubprogramContext(const MDNode *Context) { |
| 831 | if (!Context) |
| 832 | return false; |
| 833 | DIDescriptor D(Context); |
| 834 | if (D.isSubprogram()) |
| 835 | return true; |
| 836 | if (D.isType()) |
| 837 | return isSubprogramContext(DIType(Context).getContext()); |
| 838 | return false; |
| 839 | } |
| 840 | |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 841 | //===----------------------------------------------------------------------===// |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 842 | // DebugInfoFinder implementations. |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 843 | //===----------------------------------------------------------------------===// |
| 844 | |
Manman Ren | 0e29eee | 2013-07-23 00:22:51 +0000 | [diff] [blame] | 845 | void DebugInfoFinder::reset() { |
| 846 | CUs.clear(); |
| 847 | SPs.clear(); |
| 848 | GVs.clear(); |
| 849 | TYs.clear(); |
| 850 | Scopes.clear(); |
| 851 | NodesSeen.clear(); |
| 852 | } |
| 853 | |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 854 | /// processModule - Process entire module and collect debug info. |
Eric Christopher | c4639d6 | 2012-11-19 22:42:15 +0000 | [diff] [blame] | 855 | void DebugInfoFinder::processModule(const Module &M) { |
Devang Patel | cd2db16 | 2011-10-17 22:30:34 +0000 | [diff] [blame] | 856 | if (NamedMDNode *CU_Nodes = M.getNamedMetadata("llvm.dbg.cu")) { |
| 857 | for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) { |
| 858 | DICompileUnit CU(CU_Nodes->getOperand(i)); |
| 859 | addCompileUnit(CU); |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 860 | DIArray GVs = CU.getGlobalVariables(); |
| 861 | for (unsigned i = 0, e = GVs.getNumElements(); i != e; ++i) { |
| 862 | DIGlobalVariable DIG(GVs.getElement(i)); |
Manman Ren | 96ea038 | 2013-07-20 00:38:46 +0000 | [diff] [blame] | 863 | if (addGlobalVariable(DIG)) { |
Manman Ren | fdd16bb | 2013-07-22 20:28:53 +0000 | [diff] [blame] | 864 | processScope(DIG.getContext()); |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 865 | processType(DIG.getType()); |
Manman Ren | 96ea038 | 2013-07-20 00:38:46 +0000 | [diff] [blame] | 866 | } |
Devang Patel | cd2db16 | 2011-10-17 22:30:34 +0000 | [diff] [blame] | 867 | } |
David Blaikie | c0ec8a4 | 2013-03-11 23:39:23 +0000 | [diff] [blame] | 868 | DIArray SPs = CU.getSubprograms(); |
| 869 | for (unsigned i = 0, e = SPs.getNumElements(); i != e; ++i) |
| 870 | processSubprogram(DISubprogram(SPs.getElement(i))); |
| 871 | DIArray EnumTypes = CU.getEnumTypes(); |
| 872 | for (unsigned i = 0, e = EnumTypes.getNumElements(); i != e; ++i) |
| 873 | processType(DIType(EnumTypes.getElement(i))); |
| 874 | DIArray RetainedTypes = CU.getRetainedTypes(); |
| 875 | for (unsigned i = 0, e = RetainedTypes.getNumElements(); i != e; ++i) |
| 876 | processType(DIType(RetainedTypes.getElement(i))); |
| 877 | // FIXME: We really shouldn't be bailing out after visiting just one CU |
| 878 | return; |
Devang Patel | cd2db16 | 2011-10-17 22:30:34 +0000 | [diff] [blame] | 879 | } |
| 880 | } |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 881 | } |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 882 | |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 883 | /// processLocation - Process DILocation. |
| 884 | void DebugInfoFinder::processLocation(DILocation Loc) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 885 | if (!Loc.Verify()) return; |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 886 | DIDescriptor S(Loc.getScope()); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 887 | if (S.isCompileUnit()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 888 | addCompileUnit(DICompileUnit(S)); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 889 | else if (S.isSubprogram()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 890 | processSubprogram(DISubprogram(S)); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 891 | else if (S.isLexicalBlock()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 892 | processLexicalBlock(DILexicalBlock(S)); |
Eric Christopher | 6618a24 | 2011-10-11 22:59:11 +0000 | [diff] [blame] | 893 | else if (S.isLexicalBlockFile()) { |
| 894 | DILexicalBlockFile DBF = DILexicalBlockFile(S); |
| 895 | processLexicalBlock(DILexicalBlock(DBF.getScope())); |
| 896 | } |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 897 | processLocation(Loc.getOrigLocation()); |
| 898 | } |
| 899 | |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 900 | /// processType - Process DIType. |
| 901 | void DebugInfoFinder::processType(DIType DT) { |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 902 | if (!addType(DT)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 903 | return; |
Manman Ren | fdd16bb | 2013-07-22 20:28:53 +0000 | [diff] [blame] | 904 | processScope(DT.getContext()); |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 905 | if (DT.isCompositeType()) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 906 | DICompositeType DCT(DT); |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 907 | processType(DCT.getTypeDerivedFrom()); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 908 | DIArray DA = DCT.getTypeArray(); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 909 | for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) { |
| 910 | DIDescriptor D = DA.getElement(i); |
| 911 | if (D.isType()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 912 | processType(DIType(D)); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 913 | else if (D.isSubprogram()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 914 | processSubprogram(DISubprogram(D)); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 915 | } |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 916 | } else if (DT.isDerivedType()) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 917 | DIDerivedType DDT(DT); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 918 | processType(DDT.getTypeDerivedFrom()); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 919 | } |
| 920 | } |
| 921 | |
Manman Ren | fdd16bb | 2013-07-22 20:28:53 +0000 | [diff] [blame] | 922 | void DebugInfoFinder::processScope(DIScope Scope) { |
| 923 | if (Scope.isType()) { |
| 924 | DIType Ty(Scope); |
| 925 | processType(Ty); |
| 926 | return; |
| 927 | } |
Manman Ren | 7894ffd | 2013-07-23 23:10:00 +0000 | [diff] [blame] | 928 | if (Scope.isCompileUnit()) { |
| 929 | addCompileUnit(DICompileUnit(Scope)); |
| 930 | return; |
| 931 | } |
| 932 | if (Scope.isSubprogram()) { |
| 933 | processSubprogram(DISubprogram(Scope)); |
| 934 | return; |
| 935 | } |
Manman Ren | fdd16bb | 2013-07-22 20:28:53 +0000 | [diff] [blame] | 936 | if (!addScope(Scope)) |
| 937 | return; |
| 938 | if (Scope.isLexicalBlock()) { |
| 939 | DILexicalBlock LB(Scope); |
| 940 | processScope(LB.getContext()); |
| 941 | } else if (Scope.isLexicalBlockFile()) { |
| 942 | DILexicalBlockFile LBF = DILexicalBlockFile(Scope); |
| 943 | processScope(LBF.getScope()); |
| 944 | } else if (Scope.isNameSpace()) { |
| 945 | DINameSpace NS(Scope); |
| 946 | processScope(NS.getContext()); |
| 947 | } |
| 948 | } |
| 949 | |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 950 | /// processLexicalBlock |
| 951 | void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) { |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 952 | DIScope Context = LB.getContext(); |
| 953 | if (Context.isLexicalBlock()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 954 | return processLexicalBlock(DILexicalBlock(Context)); |
Eric Christopher | 6618a24 | 2011-10-11 22:59:11 +0000 | [diff] [blame] | 955 | else if (Context.isLexicalBlockFile()) { |
| 956 | DILexicalBlockFile DBF = DILexicalBlockFile(Context); |
| 957 | return processLexicalBlock(DILexicalBlock(DBF.getScope())); |
| 958 | } |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 959 | else |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 960 | return processSubprogram(DISubprogram(Context)); |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 961 | } |
| 962 | |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 963 | /// processSubprogram - Process DISubprogram. |
| 964 | void DebugInfoFinder::processSubprogram(DISubprogram SP) { |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 965 | if (!addSubprogram(SP)) |
| 966 | return; |
Manman Ren | fdd16bb | 2013-07-22 20:28:53 +0000 | [diff] [blame] | 967 | processScope(SP.getContext()); |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 968 | processType(SP.getType()); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 969 | } |
| 970 | |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 971 | /// processDeclare - Process DbgDeclareInst. |
Eric Christopher | c4639d6 | 2012-11-19 22:42:15 +0000 | [diff] [blame] | 972 | void DebugInfoFinder::processDeclare(const DbgDeclareInst *DDI) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 973 | MDNode *N = dyn_cast<MDNode>(DDI->getVariable()); |
| 974 | if (!N) return; |
| 975 | |
| 976 | DIDescriptor DV(N); |
| 977 | if (!DV.isVariable()) |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 978 | return; |
| 979 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 980 | if (!NodesSeen.insert(DV)) |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 981 | return; |
Manman Ren | 7894ffd | 2013-07-23 23:10:00 +0000 | [diff] [blame] | 982 | processScope(DIVariable(N).getContext()); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 983 | processType(DIVariable(N).getType()); |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 984 | } |
| 985 | |
Manman Ren | 0e29eee | 2013-07-23 00:22:51 +0000 | [diff] [blame] | 986 | void DebugInfoFinder::processValue(const DbgValueInst *DVI) { |
| 987 | MDNode *N = dyn_cast<MDNode>(DVI->getVariable()); |
| 988 | if (!N) return; |
| 989 | |
| 990 | DIDescriptor DV(N); |
| 991 | if (!DV.isVariable()) |
| 992 | return; |
| 993 | |
| 994 | if (!NodesSeen.insert(DV)) |
| 995 | return; |
Manman Ren | 504a7fb | 2013-07-24 17:10:09 +0000 | [diff] [blame] | 996 | processScope(DIVariable(N).getContext()); |
Manman Ren | 0e29eee | 2013-07-23 00:22:51 +0000 | [diff] [blame] | 997 | processType(DIVariable(N).getType()); |
| 998 | } |
| 999 | |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 1000 | /// addType - Add type into Tys. |
| 1001 | bool DebugInfoFinder::addType(DIType DT) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 1002 | if (!DT.isValid()) |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 1003 | return false; |
| 1004 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1005 | if (!NodesSeen.insert(DT)) |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 1006 | return false; |
| 1007 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1008 | TYs.push_back(DT); |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 1009 | return true; |
| 1010 | } |
| 1011 | |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1012 | /// addCompileUnit - Add compile unit into CUs. |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 1013 | bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 1014 | if (!CU.Verify()) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1015 | return false; |
| 1016 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1017 | if (!NodesSeen.insert(CU)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1018 | return false; |
| 1019 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1020 | CUs.push_back(CU); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1021 | return true; |
| 1022 | } |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 1023 | |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1024 | /// addGlobalVariable - Add global variable into GVs. |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 1025 | bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1026 | if (!DIDescriptor(DIG).isGlobalVariable()) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1027 | return false; |
| 1028 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1029 | if (!NodesSeen.insert(DIG)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1030 | return false; |
| 1031 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1032 | GVs.push_back(DIG); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1033 | return true; |
| 1034 | } |
| 1035 | |
| 1036 | // addSubprogram - Add subprgoram into SPs. |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 1037 | bool DebugInfoFinder::addSubprogram(DISubprogram SP) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1038 | if (!DIDescriptor(SP).isSubprogram()) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1039 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 1040 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1041 | if (!NodesSeen.insert(SP)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1042 | return false; |
| 1043 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 1044 | SPs.push_back(SP); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 1045 | return true; |
| 1046 | } |
| 1047 | |
Manman Ren | 96ea038 | 2013-07-20 00:38:46 +0000 | [diff] [blame] | 1048 | bool DebugInfoFinder::addScope(DIScope Scope) { |
| 1049 | if (!Scope) |
| 1050 | return false; |
| 1051 | if (!NodesSeen.insert(Scope)) |
| 1052 | return false; |
| 1053 | Scopes.push_back(Scope); |
| 1054 | return true; |
| 1055 | } |
| 1056 | |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1057 | //===----------------------------------------------------------------------===// |
| 1058 | // DIDescriptor: dump routines for all descriptors. |
| 1059 | //===----------------------------------------------------------------------===// |
| 1060 | |
| 1061 | /// dump - Print descriptor to dbgs() with a newline. |
| 1062 | void DIDescriptor::dump() const { |
| 1063 | print(dbgs()); dbgs() << '\n'; |
| 1064 | } |
| 1065 | |
| 1066 | /// print - Print descriptor. |
| 1067 | void DIDescriptor::print(raw_ostream &OS) const { |
| 1068 | if (!DbgNode) return; |
| 1069 | |
Bill Wendling | 97a7592 | 2012-06-28 02:17:58 +0000 | [diff] [blame] | 1070 | if (const char *Tag = dwarf::TagString(getTag())) |
| 1071 | OS << "[ " << Tag << " ]"; |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1072 | |
| 1073 | if (this->isSubrange()) { |
| 1074 | DISubrange(DbgNode).printInternal(OS); |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1075 | } else if (this->isCompileUnit()) { |
| 1076 | DICompileUnit(DbgNode).printInternal(OS); |
| 1077 | } else if (this->isFile()) { |
| 1078 | DIFile(DbgNode).printInternal(OS); |
| 1079 | } else if (this->isEnumerator()) { |
| 1080 | DIEnumerator(DbgNode).printInternal(OS); |
| 1081 | } else if (this->isBasicType()) { |
| 1082 | DIType(DbgNode).printInternal(OS); |
| 1083 | } else if (this->isDerivedType()) { |
| 1084 | DIDerivedType(DbgNode).printInternal(OS); |
| 1085 | } else if (this->isCompositeType()) { |
| 1086 | DICompositeType(DbgNode).printInternal(OS); |
| 1087 | } else if (this->isSubprogram()) { |
| 1088 | DISubprogram(DbgNode).printInternal(OS); |
| 1089 | } else if (this->isGlobalVariable()) { |
| 1090 | DIGlobalVariable(DbgNode).printInternal(OS); |
| 1091 | } else if (this->isVariable()) { |
| 1092 | DIVariable(DbgNode).printInternal(OS); |
Bill Wendling | 2da1a16 | 2012-07-06 19:12:31 +0000 | [diff] [blame] | 1093 | } else if (this->isObjCProperty()) { |
| 1094 | DIObjCProperty(DbgNode).printInternal(OS); |
David Blaikie | 1cd30fd | 2013-03-20 05:14:14 +0000 | [diff] [blame] | 1095 | } else if (this->isNameSpace()) { |
| 1096 | DINameSpace(DbgNode).printInternal(OS); |
Bill Wendling | 625252f | 2012-07-06 23:06:16 +0000 | [diff] [blame] | 1097 | } else if (this->isScope()) { |
| 1098 | DIScope(DbgNode).printInternal(OS); |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1099 | } |
| 1100 | } |
| 1101 | |
| 1102 | void DISubrange::printInternal(raw_ostream &OS) const { |
Bill Wendling | 9493dae | 2012-12-04 21:34:03 +0000 | [diff] [blame] | 1103 | int64_t Count = getCount(); |
| 1104 | if (Count != -1) |
| 1105 | OS << " [" << getLo() << ", " << Count - 1 << ']'; |
| 1106 | else |
Bill Wendling | 46defa5 | 2012-12-05 21:43:30 +0000 | [diff] [blame] | 1107 | OS << " [unbounded]"; |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1108 | } |
| 1109 | |
| 1110 | void DIScope::printInternal(raw_ostream &OS) const { |
| 1111 | OS << " [" << getDirectory() << "/" << getFilename() << ']'; |
| 1112 | } |
| 1113 | |
| 1114 | void DICompileUnit::printInternal(raw_ostream &OS) const { |
| 1115 | DIScope::printInternal(OS); |
David Blaikie | 2ca02c6 | 2013-04-17 03:41:36 +0000 | [diff] [blame] | 1116 | OS << " ["; |
| 1117 | unsigned Lang = getLanguage(); |
| 1118 | if (const char *LangStr = dwarf::LanguageString(Lang)) |
| 1119 | OS << LangStr; |
| 1120 | else |
| 1121 | (OS << "lang 0x").write_hex(Lang); |
| 1122 | OS << ']'; |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1123 | } |
| 1124 | |
| 1125 | void DIEnumerator::printInternal(raw_ostream &OS) const { |
| 1126 | OS << " [" << getName() << " :: " << getEnumValue() << ']'; |
| 1127 | } |
| 1128 | |
| 1129 | void DIType::printInternal(raw_ostream &OS) const { |
| 1130 | if (!DbgNode) return; |
| 1131 | |
| 1132 | StringRef Res = getName(); |
| 1133 | if (!Res.empty()) |
| 1134 | OS << " [" << Res << "]"; |
| 1135 | |
| 1136 | // TODO: Print context? |
| 1137 | |
| 1138 | OS << " [line " << getLineNumber() |
| 1139 | << ", size " << getSizeInBits() |
| 1140 | << ", align " << getAlignInBits() |
| 1141 | << ", offset " << getOffsetInBits(); |
| 1142 | if (isBasicType()) |
Eric Christopher | 5f214ae | 2012-11-20 00:15:36 +0000 | [diff] [blame] | 1143 | if (const char *Enc = |
Bill Wendling | fc1c70a | 2012-06-28 02:12:20 +0000 | [diff] [blame] | 1144 | dwarf::AttributeEncodingString(DIBasicType(DbgNode).getEncoding())) |
| 1145 | OS << ", enc " << Enc; |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1146 | OS << "]"; |
| 1147 | |
| 1148 | if (isPrivate()) |
| 1149 | OS << " [private]"; |
| 1150 | else if (isProtected()) |
| 1151 | OS << " [protected]"; |
| 1152 | |
David Blaikie | 0fecdfb | 2013-01-08 00:31:02 +0000 | [diff] [blame] | 1153 | if (isArtificial()) |
| 1154 | OS << " [artificial]"; |
| 1155 | |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1156 | if (isForwardDecl()) |
David Blaikie | e954d98 | 2013-06-21 03:41:54 +0000 | [diff] [blame] | 1157 | OS << " [decl]"; |
| 1158 | else if (getTag() == dwarf::DW_TAG_structure_type || |
| 1159 | getTag() == dwarf::DW_TAG_union_type || |
| 1160 | getTag() == dwarf::DW_TAG_enumeration_type || |
| 1161 | getTag() == dwarf::DW_TAG_class_type) |
| 1162 | OS << " [def]"; |
Eric Christopher | 9a1e0e2 | 2013-01-08 01:53:52 +0000 | [diff] [blame] | 1163 | if (isVector()) |
| 1164 | OS << " [vector]"; |
Eric Christopher | 6b6061f | 2013-01-16 01:22:23 +0000 | [diff] [blame] | 1165 | if (isStaticMember()) |
| 1166 | OS << " [static]"; |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1167 | } |
| 1168 | |
| 1169 | void DIDerivedType::printInternal(raw_ostream &OS) const { |
| 1170 | DIType::printInternal(OS); |
| 1171 | OS << " [from " << getTypeDerivedFrom().getName() << ']'; |
| 1172 | } |
| 1173 | |
| 1174 | void DICompositeType::printInternal(raw_ostream &OS) const { |
| 1175 | DIType::printInternal(OS); |
| 1176 | DIArray A = getTypeArray(); |
| 1177 | OS << " [" << A.getNumElements() << " elements]"; |
| 1178 | } |
| 1179 | |
David Blaikie | 1cd30fd | 2013-03-20 05:14:14 +0000 | [diff] [blame] | 1180 | void DINameSpace::printInternal(raw_ostream &OS) const { |
| 1181 | StringRef Name = getName(); |
| 1182 | if (!Name.empty()) |
| 1183 | OS << " [" << Name << ']'; |
| 1184 | |
| 1185 | OS << " [line " << getLineNumber() << ']'; |
| 1186 | } |
| 1187 | |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1188 | void DISubprogram::printInternal(raw_ostream &OS) const { |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1189 | // TODO : Print context |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1190 | OS << " [line " << getLineNumber() << ']'; |
| 1191 | |
| 1192 | if (isLocalToUnit()) |
| 1193 | OS << " [local]"; |
| 1194 | |
| 1195 | if (isDefinition()) |
| 1196 | OS << " [def]"; |
| 1197 | |
| 1198 | if (getScopeLineNumber() != getLineNumber()) |
| 1199 | OS << " [scope " << getScopeLineNumber() << "]"; |
Bill Wendling | ee17cee | 2012-07-06 23:43:12 +0000 | [diff] [blame] | 1200 | |
David Blaikie | e302b6c | 2013-01-05 21:39:33 +0000 | [diff] [blame] | 1201 | if (isPrivate()) |
| 1202 | OS << " [private]"; |
| 1203 | else if (isProtected()) |
| 1204 | OS << " [protected]"; |
| 1205 | |
Bill Wendling | ee17cee | 2012-07-06 23:43:12 +0000 | [diff] [blame] | 1206 | StringRef Res = getName(); |
| 1207 | if (!Res.empty()) |
| 1208 | OS << " [" << Res << ']'; |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1209 | } |
| 1210 | |
| 1211 | void DIGlobalVariable::printInternal(raw_ostream &OS) const { |
| 1212 | StringRef Res = getName(); |
| 1213 | if (!Res.empty()) |
| 1214 | OS << " [" << Res << ']'; |
| 1215 | |
| 1216 | OS << " [line " << getLineNumber() << ']'; |
| 1217 | |
| 1218 | // TODO : Print context |
| 1219 | |
| 1220 | if (isLocalToUnit()) |
| 1221 | OS << " [local]"; |
| 1222 | |
| 1223 | if (isDefinition()) |
| 1224 | OS << " [def]"; |
| 1225 | } |
| 1226 | |
| 1227 | void DIVariable::printInternal(raw_ostream &OS) const { |
| 1228 | StringRef Res = getName(); |
| 1229 | if (!Res.empty()) |
| 1230 | OS << " [" << Res << ']'; |
| 1231 | |
| 1232 | OS << " [line " << getLineNumber() << ']'; |
| 1233 | } |
| 1234 | |
Bill Wendling | 2da1a16 | 2012-07-06 19:12:31 +0000 | [diff] [blame] | 1235 | void DIObjCProperty::printInternal(raw_ostream &OS) const { |
| 1236 | StringRef Name = getObjCPropertyName(); |
| 1237 | if (!Name.empty()) |
| 1238 | OS << " [" << Name << ']'; |
| 1239 | |
| 1240 | OS << " [line " << getLineNumber() |
| 1241 | << ", properties " << getUnsignedField(6) << ']'; |
| 1242 | } |
| 1243 | |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1244 | static void printDebugLoc(DebugLoc DL, raw_ostream &CommentOS, |
| 1245 | const LLVMContext &Ctx) { |
| 1246 | if (!DL.isUnknown()) { // Print source line info. |
| 1247 | DIScope Scope(DL.getScope(Ctx)); |
Manman Ren | c7b61c6 | 2013-07-01 18:20:30 +0000 | [diff] [blame] | 1248 | assert(Scope.isScope() && |
| 1249 | "Scope of a DebugLoc should be a DIScope."); |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1250 | // Omit the directory, because it's likely to be long and uninteresting. |
Manman Ren | c7b61c6 | 2013-07-01 18:20:30 +0000 | [diff] [blame] | 1251 | CommentOS << Scope.getFilename(); |
Bill Wendling | e877824 | 2012-06-26 23:22:18 +0000 | [diff] [blame] | 1252 | CommentOS << ':' << DL.getLine(); |
| 1253 | if (DL.getCol() != 0) |
| 1254 | CommentOS << ':' << DL.getCol(); |
| 1255 | DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(DL.getInlinedAt(Ctx)); |
| 1256 | if (!InlinedAtDL.isUnknown()) { |
| 1257 | CommentOS << " @[ "; |
| 1258 | printDebugLoc(InlinedAtDL, CommentOS, Ctx); |
| 1259 | CommentOS << " ]"; |
| 1260 | } |
| 1261 | } |
| 1262 | } |
| 1263 | |
| 1264 | void DIVariable::printExtendedName(raw_ostream &OS) const { |
| 1265 | const LLVMContext &Ctx = DbgNode->getContext(); |
| 1266 | StringRef Res = getName(); |
| 1267 | if (!Res.empty()) |
| 1268 | OS << Res << "," << getLineNumber(); |
| 1269 | if (MDNode *InlinedAt = getInlinedAt()) { |
| 1270 | DebugLoc InlinedAtDL = DebugLoc::getFromDILocation(InlinedAt); |
| 1271 | if (!InlinedAtDL.isUnknown()) { |
| 1272 | OS << " @["; |
| 1273 | printDebugLoc(InlinedAtDL, OS, Ctx); |
| 1274 | OS << "]"; |
| 1275 | } |
| 1276 | } |
| 1277 | } |