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 | |
| 15 | #include "llvm/Analysis/DebugInfo.h" |
| 16 | #include "llvm/Constants.h" |
| 17 | #include "llvm/DerivedTypes.h" |
| 18 | #include "llvm/Intrinsics.h" |
Torok Edwin | 620f280 | 2008-12-16 09:07:36 +0000 | [diff] [blame] | 19 | #include "llvm/IntrinsicInst.h" |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 20 | #include "llvm/Instructions.h" |
| 21 | #include "llvm/Module.h" |
| 22 | #include "llvm/Analysis/ValueTracking.h" |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 23 | #include "llvm/ADT/SmallPtrSet.h" |
Dan Gohman | 17aa92c | 2010-07-21 23:38:33 +0000 | [diff] [blame] | 24 | #include "llvm/ADT/SmallString.h" |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 25 | #include "llvm/ADT/STLExtras.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" |
Chris Lattner | a81d29b | 2009-08-23 07:33:14 +0000 | [diff] [blame] | 28 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 29 | using namespace llvm; |
Argyrios Kyrtzidis | 77eaa68 | 2009-05-03 08:50:41 +0000 | [diff] [blame] | 30 | using namespace llvm::dwarf; |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 31 | |
| 32 | //===----------------------------------------------------------------------===// |
| 33 | // DIDescriptor |
| 34 | //===----------------------------------------------------------------------===// |
| 35 | |
Devang Patel | 5b164b5 | 2010-08-02 22:51:46 +0000 | [diff] [blame] | 36 | DIDescriptor::DIDescriptor(const DIFile F) : DbgNode(F.DbgNode) { |
| 37 | } |
| 38 | |
| 39 | DIDescriptor::DIDescriptor(const DISubprogram F) : DbgNode(F.DbgNode) { |
| 40 | } |
| 41 | |
| 42 | DIDescriptor::DIDescriptor(const DILexicalBlock F) : DbgNode(F.DbgNode) { |
| 43 | } |
| 44 | |
| 45 | DIDescriptor::DIDescriptor(const DIVariable F) : DbgNode(F.DbgNode) { |
| 46 | } |
| 47 | |
| 48 | DIDescriptor::DIDescriptor(const DIType F) : DbgNode(F.DbgNode) { |
| 49 | } |
| 50 | |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 51 | StringRef |
Devang Patel | 5ccdd10 | 2009-09-29 18:40:58 +0000 | [diff] [blame] | 52 | DIDescriptor::getStringField(unsigned Elt) const { |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 53 | if (DbgNode == 0) |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 54 | return StringRef(); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 55 | |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 56 | if (Elt < DbgNode->getNumOperands()) |
| 57 | if (MDString *MDS = dyn_cast_or_null<MDString>(DbgNode->getOperand(Elt))) |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 58 | return MDS->getString(); |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 59 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 60 | return StringRef(); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 61 | } |
| 62 | |
| 63 | uint64_t DIDescriptor::getUInt64Field(unsigned Elt) const { |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 64 | if (DbgNode == 0) |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 65 | return 0; |
Bill Wendling | dc817b6 | 2009-05-14 18:26:15 +0000 | [diff] [blame] | 66 | |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 67 | if (Elt < DbgNode->getNumOperands()) |
| 68 | if (ConstantInt *CI = dyn_cast<ConstantInt>(DbgNode->getOperand(Elt))) |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 69 | return CI->getZExtValue(); |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 70 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 71 | return 0; |
| 72 | } |
| 73 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 74 | DIDescriptor DIDescriptor::getDescriptorField(unsigned Elt) const { |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 75 | if (DbgNode == 0) |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 76 | return DIDescriptor(); |
Bill Wendling | dc817b6 | 2009-05-14 18:26:15 +0000 | [diff] [blame] | 77 | |
Chris Lattner | 7a2f3e0 | 2010-03-31 05:53:47 +0000 | [diff] [blame] | 78 | if (Elt < DbgNode->getNumOperands()) |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 79 | return |
| 80 | DIDescriptor(dyn_cast_or_null<const MDNode>(DbgNode->getOperand(Elt))); |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 81 | return DIDescriptor(); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 82 | } |
| 83 | |
| 84 | GlobalVariable *DIDescriptor::getGlobalVariableField(unsigned Elt) const { |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 85 | if (DbgNode == 0) |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 86 | return 0; |
Bill Wendling | dc817b6 | 2009-05-14 18:26:15 +0000 | [diff] [blame] | 87 | |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 88 | if (Elt < DbgNode->getNumOperands()) |
| 89 | return dyn_cast_or_null<GlobalVariable>(DbgNode->getOperand(Elt)); |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 90 | return 0; |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 91 | } |
| 92 | |
Devang Patel | 2739896 | 2010-08-09 21:39:24 +0000 | [diff] [blame] | 93 | Constant *DIDescriptor::getConstantField(unsigned Elt) const { |
| 94 | if (DbgNode == 0) |
| 95 | return 0; |
| 96 | |
| 97 | if (Elt < DbgNode->getNumOperands()) |
| 98 | return dyn_cast_or_null<Constant>(DbgNode->getOperand(Elt)); |
| 99 | return 0; |
| 100 | } |
| 101 | |
Stuart Hastings | 215aa15 | 2010-06-11 20:08:44 +0000 | [diff] [blame] | 102 | Function *DIDescriptor::getFunctionField(unsigned Elt) const { |
| 103 | if (DbgNode == 0) |
| 104 | return 0; |
| 105 | |
| 106 | if (Elt < DbgNode->getNumOperands()) |
| 107 | return dyn_cast_or_null<Function>(DbgNode->getOperand(Elt)); |
| 108 | return 0; |
| 109 | } |
| 110 | |
Chris Lattner | f0908a3 | 2009-12-31 03:02:08 +0000 | [diff] [blame] | 111 | unsigned DIVariable::getNumAddrElements() const { |
Devang Patel | 3cf763d | 2010-09-29 23:07:21 +0000 | [diff] [blame] | 112 | if (getVersion() <= llvm::LLVMDebugVersion8) |
| 113 | return DbgNode->getNumOperands()-6; |
| 114 | return DbgNode->getNumOperands()-7; |
Chris Lattner | f0908a3 | 2009-12-31 03:02:08 +0000 | [diff] [blame] | 115 | } |
| 116 | |
| 117 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 118 | //===----------------------------------------------------------------------===// |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 119 | // Predicates |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 120 | //===----------------------------------------------------------------------===// |
| 121 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 122 | /// isBasicType - Return true if the specified tag is legal for |
| 123 | /// DIBasicType. |
| 124 | bool DIDescriptor::isBasicType() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 125 | return DbgNode && getTag() == dwarf::DW_TAG_base_type; |
Torok Edwin | b07fbd9 | 2008-12-13 08:25:29 +0000 | [diff] [blame] | 126 | } |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 127 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 128 | /// isDerivedType - Return true if the specified tag is legal for DIDerivedType. |
| 129 | bool DIDescriptor::isDerivedType() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 130 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 131 | switch (getTag()) { |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 132 | case dwarf::DW_TAG_typedef: |
| 133 | case dwarf::DW_TAG_pointer_type: |
| 134 | case dwarf::DW_TAG_reference_type: |
| 135 | case dwarf::DW_TAG_const_type: |
| 136 | case dwarf::DW_TAG_volatile_type: |
| 137 | case dwarf::DW_TAG_restrict_type: |
| 138 | case dwarf::DW_TAG_member: |
| 139 | case dwarf::DW_TAG_inheritance: |
Devang Patel | 49d9638 | 2010-08-23 23:16:25 +0000 | [diff] [blame] | 140 | case dwarf::DW_TAG_friend: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 141 | return true; |
| 142 | default: |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 143 | // CompositeTypes are currently modelled as DerivedTypes. |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 144 | return isCompositeType(); |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 145 | } |
| 146 | } |
| 147 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 148 | /// isCompositeType - Return true if the specified tag is legal for |
| 149 | /// DICompositeType. |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 150 | bool DIDescriptor::isCompositeType() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 151 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 152 | switch (getTag()) { |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 153 | case dwarf::DW_TAG_array_type: |
| 154 | case dwarf::DW_TAG_structure_type: |
| 155 | case dwarf::DW_TAG_union_type: |
| 156 | case dwarf::DW_TAG_enumeration_type: |
| 157 | case dwarf::DW_TAG_vector_type: |
| 158 | case dwarf::DW_TAG_subroutine_type: |
Devang Patel | 25cb0d7 | 2009-03-25 03:52:06 +0000 | [diff] [blame] | 159 | case dwarf::DW_TAG_class_type: |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 160 | return true; |
| 161 | default: |
| 162 | return false; |
| 163 | } |
| 164 | } |
| 165 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 166 | /// isVariable - Return true if the specified tag is legal for DIVariable. |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 167 | bool DIDescriptor::isVariable() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 168 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 169 | switch (getTag()) { |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 170 | case dwarf::DW_TAG_auto_variable: |
| 171 | case dwarf::DW_TAG_arg_variable: |
| 172 | case dwarf::DW_TAG_return_variable: |
| 173 | return true; |
| 174 | default: |
| 175 | return false; |
| 176 | } |
| 177 | } |
| 178 | |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 179 | /// isType - Return true if the specified tag is legal for DIType. |
| 180 | bool DIDescriptor::isType() const { |
| 181 | return isBasicType() || isCompositeType() || isDerivedType(); |
| 182 | } |
| 183 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 184 | /// isSubprogram - Return true if the specified tag is legal for |
| 185 | /// DISubprogram. |
| 186 | bool DIDescriptor::isSubprogram() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 187 | return DbgNode && getTag() == dwarf::DW_TAG_subprogram; |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | /// isGlobalVariable - Return true if the specified tag is legal for |
| 191 | /// DIGlobalVariable. |
| 192 | bool DIDescriptor::isGlobalVariable() const { |
Devang Patel | 2936807 | 2010-08-10 07:11:13 +0000 | [diff] [blame] | 193 | return DbgNode && (getTag() == dwarf::DW_TAG_variable || |
| 194 | getTag() == dwarf::DW_TAG_constant); |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 195 | } |
| 196 | |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 197 | /// isGlobal - Return true if the specified tag is legal for DIGlobal. |
| 198 | bool DIDescriptor::isGlobal() const { |
| 199 | return isGlobalVariable(); |
| 200 | } |
| 201 | |
Devang Patel | 716a67f | 2011-02-03 00:13:47 +0000 | [diff] [blame] | 202 | /// isUnspecifiedParmeter - Return true if the specified tag is |
Devang Patel | d6747df | 2010-10-06 20:50:40 +0000 | [diff] [blame] | 203 | /// DW_TAG_unspecified_parameters. |
| 204 | bool DIDescriptor::isUnspecifiedParameter() const { |
| 205 | return DbgNode && getTag() == dwarf::DW_TAG_unspecified_parameters; |
| 206 | } |
| 207 | |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 208 | /// isScope - Return true if the specified tag is one of the scope |
Devang Patel | 43d98b3 | 2009-08-31 20:44:45 +0000 | [diff] [blame] | 209 | /// related tag. |
| 210 | bool DIDescriptor::isScope() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 211 | if (!DbgNode) return false; |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 212 | switch (getTag()) { |
| 213 | case dwarf::DW_TAG_compile_unit: |
| 214 | case dwarf::DW_TAG_lexical_block: |
| 215 | case dwarf::DW_TAG_subprogram: |
| 216 | case dwarf::DW_TAG_namespace: |
| 217 | return true; |
| 218 | default: |
| 219 | break; |
Devang Patel | 43d98b3 | 2009-08-31 20:44:45 +0000 | [diff] [blame] | 220 | } |
| 221 | return false; |
| 222 | } |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 223 | |
Devang Patel | 7e2cb11 | 2011-02-02 21:38:25 +0000 | [diff] [blame] | 224 | /// isTemplateTypeParameter - Return true if the specified tag is |
| 225 | /// DW_TAG_template_type_parameter. |
| 226 | bool DIDescriptor::isTemplateTypeParameter() const { |
| 227 | return DbgNode && getTag() == dwarf::DW_TAG_template_type_parameter; |
| 228 | } |
| 229 | |
Devang Patel | e7d9387 | 2011-02-02 22:35:53 +0000 | [diff] [blame] | 230 | /// isTemplateValueParameter - Return true if the specified tag is |
| 231 | /// DW_TAG_template_value_parameter. |
| 232 | bool DIDescriptor::isTemplateValueParameter() const { |
| 233 | return DbgNode && getTag() == dwarf::DW_TAG_template_value_parameter; |
| 234 | } |
| 235 | |
Devang Patel | c9f322d | 2009-08-31 21:34:44 +0000 | [diff] [blame] | 236 | /// isCompileUnit - Return true if the specified tag is DW_TAG_compile_unit. |
| 237 | bool DIDescriptor::isCompileUnit() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 238 | return DbgNode && getTag() == dwarf::DW_TAG_compile_unit; |
Devang Patel | c9f322d | 2009-08-31 21:34:44 +0000 | [diff] [blame] | 239 | } |
| 240 | |
Devang Patel | 7aa8189 | 2010-03-08 22:27:22 +0000 | [diff] [blame] | 241 | /// isFile - Return true if the specified tag is DW_TAG_file_type. |
| 242 | bool DIDescriptor::isFile() const { |
| 243 | return DbgNode && getTag() == dwarf::DW_TAG_file_type; |
| 244 | } |
| 245 | |
Devang Patel | 6404e4e | 2009-12-15 19:16:48 +0000 | [diff] [blame] | 246 | /// isNameSpace - Return true if the specified tag is DW_TAG_namespace. |
| 247 | bool DIDescriptor::isNameSpace() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 248 | return DbgNode && getTag() == dwarf::DW_TAG_namespace; |
Devang Patel | 6404e4e | 2009-12-15 19:16:48 +0000 | [diff] [blame] | 249 | } |
| 250 | |
Devang Patel | 5e005d8 | 2009-08-31 22:00:15 +0000 | [diff] [blame] | 251 | /// isLexicalBlock - Return true if the specified tag is DW_TAG_lexical_block. |
| 252 | bool DIDescriptor::isLexicalBlock() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 253 | return DbgNode && getTag() == dwarf::DW_TAG_lexical_block; |
Devang Patel | 5e005d8 | 2009-08-31 22:00:15 +0000 | [diff] [blame] | 254 | } |
| 255 | |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 256 | /// isSubrange - Return true if the specified tag is DW_TAG_subrange_type. |
| 257 | bool DIDescriptor::isSubrange() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 258 | return DbgNode && getTag() == dwarf::DW_TAG_subrange_type; |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | /// isEnumerator - Return true if the specified tag is DW_TAG_enumerator. |
| 262 | bool DIDescriptor::isEnumerator() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 263 | return DbgNode && getTag() == dwarf::DW_TAG_enumerator; |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 264 | } |
| 265 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 266 | //===----------------------------------------------------------------------===// |
| 267 | // Simple Descriptor Constructors and other Methods |
| 268 | //===----------------------------------------------------------------------===// |
| 269 | |
Devang Patel | e9f8f5e | 2010-05-07 20:54:48 +0000 | [diff] [blame] | 270 | DIType::DIType(const MDNode *N) : DIScope(N) { |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 271 | if (!N) return; |
| 272 | if (!isBasicType() && !isDerivedType() && !isCompositeType()) { |
| 273 | DbgNode = 0; |
| 274 | } |
| 275 | } |
| 276 | |
Devang Patel | 68afdc3 | 2009-01-05 18:33:01 +0000 | [diff] [blame] | 277 | unsigned DIArray::getNumElements() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 278 | if (!DbgNode) |
| 279 | return 0; |
Chris Lattner | 5d0cacd | 2009-12-31 01:22:29 +0000 | [diff] [blame] | 280 | return DbgNode->getNumOperands(); |
Devang Patel | 68afdc3 | 2009-01-05 18:33:01 +0000 | [diff] [blame] | 281 | } |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 282 | |
Devang Patel | c4999d7 | 2009-07-22 18:23:44 +0000 | [diff] [blame] | 283 | /// replaceAllUsesWith - Replace all uses of debug info referenced by |
Dan Gohman | 872814a | 2010-07-21 18:54:18 +0000 | [diff] [blame] | 284 | /// this descriptor. |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 285 | void DIType::replaceAllUsesWith(DIDescriptor &D) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 286 | if (!DbgNode) |
Devang Patel | c4999d7 | 2009-07-22 18:23:44 +0000 | [diff] [blame] | 287 | return; |
| 288 | |
Daniel Dunbar | 48a097b | 2009-09-22 02:03:18 +0000 | [diff] [blame] | 289 | // Since we use a TrackingVH for the node, its easy for clients to manufacture |
| 290 | // legitimate situations where they want to replaceAllUsesWith() on something |
| 291 | // which, due to uniquing, has merged with the source. We shield clients from |
| 292 | // this detail by allowing a value to be replaced with replaceAllUsesWith() |
| 293 | // itself. |
Devang Patel | ed66bf5 | 2010-05-07 18:19:32 +0000 | [diff] [blame] | 294 | if (DbgNode != D) { |
Devang Patel | e9f8f5e | 2010-05-07 20:54:48 +0000 | [diff] [blame] | 295 | MDNode *Node = const_cast<MDNode*>(DbgNode); |
| 296 | const MDNode *DN = D; |
| 297 | const Value *V = cast_or_null<Value>(DN); |
| 298 | Node->replaceAllUsesWith(const_cast<Value*>(V)); |
Dan Gohman | 489b29b | 2010-08-20 22:02:26 +0000 | [diff] [blame] | 299 | MDNode::deleteTemporary(Node); |
Daniel Dunbar | 48a097b | 2009-09-22 02:03:18 +0000 | [diff] [blame] | 300 | } |
Devang Patel | c4999d7 | 2009-07-22 18:23:44 +0000 | [diff] [blame] | 301 | } |
| 302 | |
Devang Patel | 0a2551d | 2010-12-08 20:18:20 +0000 | [diff] [blame] | 303 | /// replaceAllUsesWith - Replace all uses of debug info referenced by |
| 304 | /// this descriptor. |
| 305 | void DIType::replaceAllUsesWith(MDNode *D) { |
| 306 | if (!DbgNode) |
| 307 | return; |
| 308 | |
| 309 | // Since we use a TrackingVH for the node, its easy for clients to manufacture |
| 310 | // legitimate situations where they want to replaceAllUsesWith() on something |
| 311 | // which, due to uniquing, has merged with the source. We shield clients from |
| 312 | // this detail by allowing a value to be replaced with replaceAllUsesWith() |
| 313 | // itself. |
| 314 | if (DbgNode != D) { |
| 315 | MDNode *Node = const_cast<MDNode*>(DbgNode); |
| 316 | const MDNode *DN = D; |
| 317 | const Value *V = cast_or_null<Value>(DN); |
| 318 | Node->replaceAllUsesWith(const_cast<Value*>(V)); |
| 319 | MDNode::deleteTemporary(Node); |
| 320 | } |
| 321 | } |
| 322 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 323 | /// Verify - Verify that a compile unit is well formed. |
| 324 | bool DICompileUnit::Verify() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 325 | if (!DbgNode) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 326 | return false; |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 327 | StringRef N = getFilename(); |
| 328 | if (N.empty()) |
Bill Wendling | 0582ae9 | 2009-03-13 04:39:26 +0000 | [diff] [blame] | 329 | return false; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 330 | // It is possible that directory and produce string is empty. |
Bill Wendling | 0582ae9 | 2009-03-13 04:39:26 +0000 | [diff] [blame] | 331 | return true; |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | /// Verify - Verify that a type descriptor is well formed. |
| 335 | bool DIType::Verify() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 336 | if (!DbgNode) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 337 | return false; |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 338 | if (!getContext().Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 339 | return false; |
Devang Patel | b71bbf9 | 2010-11-02 20:41:13 +0000 | [diff] [blame] | 340 | unsigned Tag = getTag(); |
| 341 | if (!isBasicType() && Tag != dwarf::DW_TAG_const_type && |
| 342 | Tag != dwarf::DW_TAG_volatile_type && Tag != dwarf::DW_TAG_pointer_type && |
Devang Patel | fe58f95 | 2010-12-07 23:25:47 +0000 | [diff] [blame] | 343 | Tag != dwarf::DW_TAG_reference_type && Tag != dwarf::DW_TAG_restrict_type |
Devang Patel | 43c249c | 2010-12-08 01:50:15 +0000 | [diff] [blame] | 344 | && Tag != dwarf::DW_TAG_vector_type && Tag != dwarf::DW_TAG_array_type |
| 345 | && Tag != dwarf::DW_TAG_enumeration_type |
Devang Patel | fe58f95 | 2010-12-07 23:25:47 +0000 | [diff] [blame] | 346 | && getFilename().empty()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 347 | return false; |
| 348 | return true; |
| 349 | } |
| 350 | |
Devang Patel | 0c4720c | 2010-08-23 18:25:56 +0000 | [diff] [blame] | 351 | /// Verify - Verify that a basic type descriptor is well formed. |
| 352 | bool DIBasicType::Verify() const { |
| 353 | return isBasicType(); |
| 354 | } |
| 355 | |
| 356 | /// Verify - Verify that a derived type descriptor is well formed. |
| 357 | bool DIDerivedType::Verify() const { |
| 358 | return isDerivedType(); |
| 359 | } |
| 360 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 361 | /// Verify - Verify that a composite type descriptor is well formed. |
| 362 | bool DICompositeType::Verify() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 363 | if (!DbgNode) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 364 | return false; |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 365 | if (!getContext().Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 366 | return false; |
| 367 | |
| 368 | DICompileUnit CU = getCompileUnit(); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 369 | if (!CU.Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 370 | return false; |
| 371 | return true; |
| 372 | } |
| 373 | |
| 374 | /// Verify - Verify that a subprogram descriptor is well formed. |
| 375 | bool DISubprogram::Verify() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 376 | if (!DbgNode) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 377 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 378 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 379 | if (!getContext().Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 380 | return false; |
| 381 | |
| 382 | DICompileUnit CU = getCompileUnit(); |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 383 | if (!CU.Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 384 | return false; |
| 385 | |
| 386 | DICompositeType Ty = getType(); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 387 | if (!Ty.Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 388 | return false; |
| 389 | return true; |
| 390 | } |
| 391 | |
| 392 | /// Verify - Verify that a global variable descriptor is well formed. |
| 393 | bool DIGlobalVariable::Verify() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 394 | if (!DbgNode) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 395 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 396 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 397 | if (getDisplayName().empty()) |
Devang Patel | 84c73e9 | 2009-11-06 17:58:12 +0000 | [diff] [blame] | 398 | return false; |
| 399 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 400 | if (!getContext().Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 401 | return false; |
| 402 | |
| 403 | DICompileUnit CU = getCompileUnit(); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 404 | if (!CU.Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 405 | return false; |
| 406 | |
| 407 | DIType Ty = getType(); |
| 408 | if (!Ty.Verify()) |
| 409 | return false; |
| 410 | |
Devang Patel | 2739896 | 2010-08-09 21:39:24 +0000 | [diff] [blame] | 411 | if (!getGlobal() && !getConstant()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 412 | return false; |
| 413 | |
| 414 | return true; |
| 415 | } |
| 416 | |
| 417 | /// Verify - Verify that a variable descriptor is well formed. |
| 418 | bool DIVariable::Verify() const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 419 | if (!DbgNode) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 420 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 421 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 422 | if (!getContext().Verify()) |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 423 | return false; |
| 424 | |
Devang Patel | 62077af | 2010-05-07 21:42:24 +0000 | [diff] [blame] | 425 | if (!getCompileUnit().Verify()) |
| 426 | return false; |
| 427 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 428 | DIType Ty = getType(); |
| 429 | if (!Ty.Verify()) |
| 430 | return false; |
| 431 | |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 432 | return true; |
| 433 | } |
| 434 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 435 | /// Verify - Verify that a location descriptor is well formed. |
| 436 | bool DILocation::Verify() const { |
| 437 | if (!DbgNode) |
| 438 | return false; |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 439 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 440 | return DbgNode->getNumOperands() == 4; |
| 441 | } |
| 442 | |
Devang Patel | 47e2265 | 2010-05-07 23:04:32 +0000 | [diff] [blame] | 443 | /// Verify - Verify that a namespace descriptor is well formed. |
| 444 | bool DINameSpace::Verify() const { |
| 445 | if (!DbgNode) |
| 446 | return false; |
| 447 | if (getName().empty()) |
| 448 | return false; |
| 449 | if (!getCompileUnit().Verify()) |
| 450 | return false; |
| 451 | return true; |
| 452 | } |
| 453 | |
Devang Patel | 36375ee | 2009-02-17 21:23:59 +0000 | [diff] [blame] | 454 | /// getOriginalTypeSize - If this type is derived from a base type then |
| 455 | /// return base type size. |
| 456 | uint64_t DIDerivedType::getOriginalTypeSize() const { |
Devang Patel | 61ecbd1 | 2009-11-04 23:48:00 +0000 | [diff] [blame] | 457 | unsigned Tag = getTag(); |
| 458 | if (Tag == dwarf::DW_TAG_member || Tag == dwarf::DW_TAG_typedef || |
| 459 | Tag == dwarf::DW_TAG_const_type || Tag == dwarf::DW_TAG_volatile_type || |
| 460 | Tag == dwarf::DW_TAG_restrict_type) { |
| 461 | DIType BaseType = getTypeDerivedFrom(); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 462 | // If this type is not derived from any type then take conservative |
Devang Patel | 5ebfa2d | 2009-11-06 18:24:05 +0000 | [diff] [blame] | 463 | // approach. |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 464 | if (!BaseType.isValid()) |
Devang Patel | 5ebfa2d | 2009-11-06 18:24:05 +0000 | [diff] [blame] | 465 | return getSizeInBits(); |
Devang Patel | 61ecbd1 | 2009-11-04 23:48:00 +0000 | [diff] [blame] | 466 | if (BaseType.isDerivedType()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 467 | return DIDerivedType(BaseType).getOriginalTypeSize(); |
Devang Patel | 61ecbd1 | 2009-11-04 23:48:00 +0000 | [diff] [blame] | 468 | else |
| 469 | return BaseType.getSizeInBits(); |
| 470 | } |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 471 | |
Devang Patel | 61ecbd1 | 2009-11-04 23:48:00 +0000 | [diff] [blame] | 472 | return getSizeInBits(); |
Devang Patel | 36375ee | 2009-02-17 21:23:59 +0000 | [diff] [blame] | 473 | } |
Devang Patel | b79b535 | 2009-01-19 23:21:49 +0000 | [diff] [blame] | 474 | |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 475 | /// isInlinedFnArgument - Return true if this variable provides debugging |
Devang Patel | 719f6a9 | 2010-04-29 20:40:36 +0000 | [diff] [blame] | 476 | /// information for an inlined function arguments. |
| 477 | bool DIVariable::isInlinedFnArgument(const Function *CurFn) { |
| 478 | assert(CurFn && "Invalid function"); |
| 479 | if (!getContext().isSubprogram()) |
| 480 | return false; |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 481 | // This variable is not inlined function argument if its scope |
Devang Patel | 719f6a9 | 2010-04-29 20:40:36 +0000 | [diff] [blame] | 482 | // does not describe current function. |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 483 | return !(DISubprogram(getContext()).describes(CurFn)); |
Devang Patel | 719f6a9 | 2010-04-29 20:40:36 +0000 | [diff] [blame] | 484 | } |
| 485 | |
Devang Patel | af5b6bb | 2009-04-15 00:06:07 +0000 | [diff] [blame] | 486 | /// describes - Return true if this subprogram provides debugging |
| 487 | /// information for the function F. |
| 488 | bool DISubprogram::describes(const Function *F) { |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 489 | assert(F && "Invalid function"); |
Devang Patel | ffd33cd | 2010-06-16 06:42:02 +0000 | [diff] [blame] | 490 | if (F == getFunction()) |
| 491 | return true; |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 492 | StringRef Name = getLinkageName(); |
| 493 | if (Name.empty()) |
Devang Patel | 5ccdd10 | 2009-09-29 18:40:58 +0000 | [diff] [blame] | 494 | Name = getName(); |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 495 | if (F->getName() == Name) |
Devang Patel | af5b6bb | 2009-04-15 00:06:07 +0000 | [diff] [blame] | 496 | return true; |
| 497 | return false; |
| 498 | } |
| 499 | |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 500 | unsigned DISubprogram::isOptimized() const { |
Devang Patel | ccff812 | 2010-04-30 19:38:23 +0000 | [diff] [blame] | 501 | assert (DbgNode && "Invalid subprogram descriptor!"); |
| 502 | if (DbgNode->getNumOperands() == 16) |
| 503 | return getUnsignedField(15); |
| 504 | return 0; |
| 505 | } |
| 506 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 507 | StringRef DIScope::getFilename() const { |
Devang Patel | 77bf295 | 2010-03-08 22:02:50 +0000 | [diff] [blame] | 508 | if (!DbgNode) |
| 509 | return StringRef(); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 510 | if (isLexicalBlock()) |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 511 | return DILexicalBlock(DbgNode).getFilename(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 512 | if (isSubprogram()) |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 513 | return DISubprogram(DbgNode).getFilename(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 514 | if (isCompileUnit()) |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 515 | return DICompileUnit(DbgNode).getFilename(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 516 | if (isNameSpace()) |
Devang Patel | 6404e4e | 2009-12-15 19:16:48 +0000 | [diff] [blame] | 517 | return DINameSpace(DbgNode).getFilename(); |
Devang Patel | 77bf295 | 2010-03-08 22:02:50 +0000 | [diff] [blame] | 518 | if (isType()) |
| 519 | return DIType(DbgNode).getFilename(); |
Devang Patel | 7aa8189 | 2010-03-08 22:27:22 +0000 | [diff] [blame] | 520 | if (isFile()) |
| 521 | return DIFile(DbgNode).getFilename(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 522 | assert(0 && "Invalid DIScope!"); |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 523 | return StringRef(); |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 524 | } |
| 525 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 526 | StringRef DIScope::getDirectory() const { |
Devang Patel | 77bf295 | 2010-03-08 22:02:50 +0000 | [diff] [blame] | 527 | if (!DbgNode) |
| 528 | return StringRef(); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 529 | if (isLexicalBlock()) |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 530 | return DILexicalBlock(DbgNode).getDirectory(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 531 | if (isSubprogram()) |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 532 | return DISubprogram(DbgNode).getDirectory(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 533 | if (isCompileUnit()) |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 534 | return DICompileUnit(DbgNode).getDirectory(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 535 | if (isNameSpace()) |
Devang Patel | 6404e4e | 2009-12-15 19:16:48 +0000 | [diff] [blame] | 536 | return DINameSpace(DbgNode).getDirectory(); |
Devang Patel | 77bf295 | 2010-03-08 22:02:50 +0000 | [diff] [blame] | 537 | if (isType()) |
| 538 | return DIType(DbgNode).getDirectory(); |
Devang Patel | 7aa8189 | 2010-03-08 22:27:22 +0000 | [diff] [blame] | 539 | if (isFile()) |
| 540 | return DIFile(DbgNode).getDirectory(); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 541 | assert(0 && "Invalid DIScope!"); |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 542 | return StringRef(); |
Devang Patel | ecbeb1a | 2009-09-30 22:34:41 +0000 | [diff] [blame] | 543 | } |
| 544 | |
Chris Lattner | a45664f | 2008-11-10 02:56:27 +0000 | [diff] [blame] | 545 | //===----------------------------------------------------------------------===// |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 546 | // DIDescriptor: dump routines for all descriptors. |
| 547 | //===----------------------------------------------------------------------===// |
| 548 | |
| 549 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 550 | /// print - Print descriptor. |
| 551 | void DIDescriptor::print(raw_ostream &OS) const { |
| 552 | OS << "[" << dwarf::TagString(getTag()) << "] "; |
| 553 | OS.write_hex((intptr_t) &*DbgNode) << ']'; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 554 | } |
| 555 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 556 | /// print - Print compile unit. |
| 557 | void DICompileUnit::print(raw_ostream &OS) const { |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 558 | if (getLanguage()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 559 | OS << " [" << dwarf::LanguageString(getLanguage()) << "] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 560 | |
Dan Gohman | faa19c3 | 2010-05-10 20:07:44 +0000 | [diff] [blame] | 561 | OS << " [" << getDirectory() << "/" << getFilename() << "]"; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 562 | } |
| 563 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 564 | /// print - Print type. |
| 565 | void DIType::print(raw_ostream &OS) const { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 566 | if (!DbgNode) return; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 567 | |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 568 | StringRef Res = getName(); |
| 569 | if (!Res.empty()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 570 | OS << " [" << Res << "] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 571 | |
| 572 | unsigned Tag = getTag(); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 573 | OS << " [" << dwarf::TagString(Tag) << "] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 574 | |
| 575 | // TODO : Print context |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 576 | getCompileUnit().print(OS); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 577 | OS << " [" |
Dan Gohman | 9a7063e | 2010-05-07 16:39:27 +0000 | [diff] [blame] | 578 | << "line " << getLineNumber() << ", " |
| 579 | << getSizeInBits() << " bits, " |
| 580 | << getAlignInBits() << " bit alignment, " |
| 581 | << getOffsetInBits() << " bit offset" |
Chris Lattner | a81d29b | 2009-08-23 07:33:14 +0000 | [diff] [blame] | 582 | << "] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 583 | |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 584 | if (isPrivate()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 585 | OS << " [private] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 586 | else if (isProtected()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 587 | OS << " [protected] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 588 | |
| 589 | if (isForwardDecl()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 590 | OS << " [fwd] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 591 | |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 592 | if (isBasicType()) |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 593 | DIBasicType(DbgNode).print(OS); |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 594 | else if (isDerivedType()) |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 595 | DIDerivedType(DbgNode).print(OS); |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 596 | else if (isCompositeType()) |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 597 | DICompositeType(DbgNode).print(OS); |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 598 | else { |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 599 | OS << "Invalid DIType\n"; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 600 | return; |
| 601 | } |
| 602 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 603 | OS << "\n"; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 604 | } |
| 605 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 606 | /// print - Print basic type. |
| 607 | void DIBasicType::print(raw_ostream &OS) const { |
| 608 | OS << " [" << dwarf::AttributeEncodingString(getEncoding()) << "] "; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 609 | } |
| 610 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 611 | /// print - Print derived type. |
| 612 | void DIDerivedType::print(raw_ostream &OS) const { |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 613 | OS << "\n\t Derived From: "; getTypeDerivedFrom().print(OS); |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 614 | } |
| 615 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 616 | /// print - Print composite type. |
| 617 | void DICompositeType::print(raw_ostream &OS) const { |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 618 | DIArray A = getTypeArray(); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 619 | OS << " [" << A.getNumElements() << " elements]"; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 620 | } |
| 621 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 622 | /// print - Print subprogram. |
| 623 | void DISubprogram::print(raw_ostream &OS) const { |
Devang Patel | 65dbc90 | 2009-11-25 17:36:49 +0000 | [diff] [blame] | 624 | StringRef Res = getName(); |
| 625 | if (!Res.empty()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 626 | OS << " [" << Res << "] "; |
Devang Patel | 82dfc0c | 2009-08-31 22:47:13 +0000 | [diff] [blame] | 627 | |
| 628 | unsigned Tag = getTag(); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 629 | OS << " [" << dwarf::TagString(Tag) << "] "; |
Devang Patel | 82dfc0c | 2009-08-31 22:47:13 +0000 | [diff] [blame] | 630 | |
| 631 | // TODO : Print context |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 632 | getCompileUnit().print(OS); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 633 | OS << " [" << getLineNumber() << "] "; |
Devang Patel | 82dfc0c | 2009-08-31 22:47:13 +0000 | [diff] [blame] | 634 | |
| 635 | if (isLocalToUnit()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 636 | OS << " [local] "; |
Devang Patel | 82dfc0c | 2009-08-31 22:47:13 +0000 | [diff] [blame] | 637 | |
| 638 | if (isDefinition()) |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 639 | OS << " [def] "; |
Devang Patel | 82dfc0c | 2009-08-31 22:47:13 +0000 | [diff] [blame] | 640 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 641 | OS << "\n"; |
| 642 | } |
| 643 | |
| 644 | /// print - Print global variable. |
| 645 | void DIGlobalVariable::print(raw_ostream &OS) const { |
| 646 | OS << " ["; |
Devang Patel | a49d877 | 2010-05-07 23:19:07 +0000 | [diff] [blame] | 647 | StringRef Res = getName(); |
| 648 | if (!Res.empty()) |
| 649 | OS << " [" << Res << "] "; |
| 650 | |
| 651 | unsigned Tag = getTag(); |
| 652 | OS << " [" << dwarf::TagString(Tag) << "] "; |
| 653 | |
| 654 | // TODO : Print context |
| 655 | getCompileUnit().print(OS); |
| 656 | OS << " [" << getLineNumber() << "] "; |
| 657 | |
| 658 | if (isLocalToUnit()) |
| 659 | OS << " [local] "; |
| 660 | |
| 661 | if (isDefinition()) |
| 662 | OS << " [def] "; |
| 663 | |
| 664 | if (isGlobalVariable()) |
| 665 | DIGlobalVariable(DbgNode).print(OS); |
| 666 | OS << "]\n"; |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 667 | } |
| 668 | |
| 669 | /// print - Print variable. |
| 670 | void DIVariable::print(raw_ostream &OS) const { |
| 671 | StringRef Res = getName(); |
| 672 | if (!Res.empty()) |
| 673 | OS << " [" << Res << "] "; |
| 674 | |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 675 | getCompileUnit().print(OS); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 676 | OS << " [" << getLineNumber() << "] "; |
Dan Gohman | c014d09 | 2010-05-07 16:17:22 +0000 | [diff] [blame] | 677 | getType().print(OS); |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 678 | OS << "\n"; |
| 679 | |
| 680 | // FIXME: Dump complex addresses |
| 681 | } |
| 682 | |
| 683 | /// dump - Print descriptor to dbgs() with a newline. |
| 684 | void DIDescriptor::dump() const { |
| 685 | print(dbgs()); dbgs() << '\n'; |
| 686 | } |
| 687 | |
| 688 | /// dump - Print compile unit to dbgs() with a newline. |
| 689 | void DICompileUnit::dump() const { |
| 690 | print(dbgs()); dbgs() << '\n'; |
| 691 | } |
| 692 | |
| 693 | /// dump - Print type to dbgs() with a newline. |
| 694 | void DIType::dump() const { |
| 695 | print(dbgs()); dbgs() << '\n'; |
| 696 | } |
| 697 | |
| 698 | /// dump - Print basic type to dbgs() with a newline. |
| 699 | void DIBasicType::dump() const { |
| 700 | print(dbgs()); dbgs() << '\n'; |
| 701 | } |
| 702 | |
| 703 | /// dump - Print derived type to dbgs() with a newline. |
| 704 | void DIDerivedType::dump() const { |
| 705 | print(dbgs()); dbgs() << '\n'; |
| 706 | } |
| 707 | |
| 708 | /// dump - Print composite type to dbgs() with a newline. |
| 709 | void DICompositeType::dump() const { |
| 710 | print(dbgs()); dbgs() << '\n'; |
| 711 | } |
| 712 | |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 713 | /// dump - Print subprogram to dbgs() with a newline. |
| 714 | void DISubprogram::dump() const { |
| 715 | print(dbgs()); dbgs() << '\n'; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 716 | } |
| 717 | |
| 718 | /// dump - Print global variable. |
| 719 | void DIGlobalVariable::dump() const { |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 720 | print(dbgs()); dbgs() << '\n'; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 721 | } |
| 722 | |
| 723 | /// dump - Print variable. |
| 724 | void DIVariable::dump() const { |
Dan Gohman | 5040436 | 2010-05-07 15:30:29 +0000 | [diff] [blame] | 725 | print(dbgs()); dbgs() << '\n'; |
Devang Patel | 7136a65 | 2009-07-01 22:10:23 +0000 | [diff] [blame] | 726 | } |
| 727 | |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 728 | /// fixupObjcLikeName - Replace contains special characters used |
| 729 | /// in a typical Objective-C names with '.' in a given string. |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame^] | 730 | static void fixupObjcLikeName(StringRef Str, SmallVectorImpl<char> &Out) { |
| 731 | bool isObjCLike = false; |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 732 | for (size_t i = 0, e = Str.size(); i < e; ++i) { |
| 733 | char C = Str[i]; |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame^] | 734 | if (C == '[') |
| 735 | isObjCLike = true; |
| 736 | |
| 737 | if (isObjCLike && (C == '[' || C == ']' || C == ' ' || C == ':' || |
| 738 | C == '+' || C == '(' || C == ')')) |
| 739 | Out.push_back('.'); |
| 740 | else |
| 741 | Out.push_back(C); |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 742 | } |
| 743 | } |
| 744 | |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 745 | /// getFnSpecificMDNode - Return a NameMDNode, if available, that is |
| 746 | /// suitable to hold function specific information. |
| 747 | NamedMDNode *llvm::getFnSpecificMDNode(const Module &M, StringRef FuncName) { |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame^] | 748 | SmallString<32> Name = StringRef("llvm.dbg.lv."); |
| 749 | fixupObjcLikeName(FuncName, Name); |
| 750 | |
| 751 | return M.getNamedMetadata(Name.str()); |
Devang Patel | 6236704 | 2010-11-10 22:19:21 +0000 | [diff] [blame] | 752 | } |
| 753 | |
Duncan Sands | 291bb70 | 2011-03-02 20:30:37 +0000 | [diff] [blame] | 754 | /// getOrInsertFnSpecificMDNode - Return a NameMDNode that is suitable |
| 755 | /// to hold function specific information. |
| 756 | NamedMDNode *llvm::getOrInsertFnSpecificMDNode(Module &M, StringRef FuncName) { |
Benjamin Kramer | 1a81d48 | 2011-06-18 14:42:42 +0000 | [diff] [blame^] | 757 | SmallString<32> Name = StringRef("llvm.dbg.lv."); |
| 758 | fixupObjcLikeName(FuncName, Name); |
| 759 | |
| 760 | return M.getOrInsertNamedMetadata(Name.str()); |
Devang Patel | 1a7ca03 | 2010-09-28 18:08:20 +0000 | [diff] [blame] | 761 | } |
| 762 | |
| 763 | |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 764 | //===----------------------------------------------------------------------===// |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 765 | // DebugInfoFinder implementations. |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 766 | //===----------------------------------------------------------------------===// |
| 767 | |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 768 | /// processModule - Process entire module and collect debug info. |
| 769 | void DebugInfoFinder::processModule(Module &M) { |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 770 | for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) |
| 771 | for (Function::iterator FI = (*I).begin(), FE = (*I).end(); FI != FE; ++FI) |
| 772 | for (BasicBlock::iterator BI = (*FI).begin(), BE = (*FI).end(); BI != BE; |
| 773 | ++BI) { |
Devang Patel | 01c5ff6 | 2010-05-04 01:05:02 +0000 | [diff] [blame] | 774 | if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(BI)) |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 775 | processDeclare(DDI); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 776 | |
Chris Lattner | 28a9bf6 | 2010-04-02 20:44:29 +0000 | [diff] [blame] | 777 | DebugLoc Loc = BI->getDebugLoc(); |
| 778 | if (Loc.isUnknown()) |
| 779 | continue; |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 780 | |
Chris Lattner | 28a9bf6 | 2010-04-02 20:44:29 +0000 | [diff] [blame] | 781 | LLVMContext &Ctx = BI->getContext(); |
| 782 | DIDescriptor Scope(Loc.getScope(Ctx)); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 783 | |
Chris Lattner | 28a9bf6 | 2010-04-02 20:44:29 +0000 | [diff] [blame] | 784 | if (Scope.isCompileUnit()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 785 | addCompileUnit(DICompileUnit(Scope)); |
Chris Lattner | 28a9bf6 | 2010-04-02 20:44:29 +0000 | [diff] [blame] | 786 | else if (Scope.isSubprogram()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 787 | processSubprogram(DISubprogram(Scope)); |
Chris Lattner | 28a9bf6 | 2010-04-02 20:44:29 +0000 | [diff] [blame] | 788 | else if (Scope.isLexicalBlock()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 789 | processLexicalBlock(DILexicalBlock(Scope)); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 790 | |
Chris Lattner | 28a9bf6 | 2010-04-02 20:44:29 +0000 | [diff] [blame] | 791 | if (MDNode *IA = Loc.getInlinedAt(Ctx)) |
| 792 | processLocation(DILocation(IA)); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 793 | } |
Devang Patel | e4b2756 | 2009-08-28 23:24:31 +0000 | [diff] [blame] | 794 | |
Devang Patel | fd5fdc3 | 2010-06-28 05:53:08 +0000 | [diff] [blame] | 795 | if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.gv")) { |
| 796 | for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) { |
| 797 | DIGlobalVariable DIG(cast<MDNode>(NMD->getOperand(i))); |
| 798 | if (addGlobalVariable(DIG)) { |
| 799 | addCompileUnit(DIG.getCompileUnit()); |
| 800 | processType(DIG.getType()); |
| 801 | } |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 802 | } |
| 803 | } |
Devang Patel | fd5fdc3 | 2010-06-28 05:53:08 +0000 | [diff] [blame] | 804 | |
| 805 | if (NamedMDNode *NMD = M.getNamedMetadata("llvm.dbg.sp")) |
| 806 | for (unsigned i = 0, e = NMD->getNumOperands(); i != e; ++i) |
| 807 | processSubprogram(DISubprogram(NMD->getOperand(i))); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 808 | } |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 809 | |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 810 | /// processLocation - Process DILocation. |
| 811 | void DebugInfoFinder::processLocation(DILocation Loc) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 812 | if (!Loc.Verify()) return; |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 813 | DIDescriptor S(Loc.getScope()); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 814 | if (S.isCompileUnit()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 815 | addCompileUnit(DICompileUnit(S)); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 816 | else if (S.isSubprogram()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 817 | processSubprogram(DISubprogram(S)); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 818 | else if (S.isLexicalBlock()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 819 | processLexicalBlock(DILexicalBlock(S)); |
Devang Patel | 6daf99b | 2009-11-10 22:05:35 +0000 | [diff] [blame] | 820 | processLocation(Loc.getOrigLocation()); |
| 821 | } |
| 822 | |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 823 | /// processType - Process DIType. |
| 824 | void DebugInfoFinder::processType(DIType DT) { |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 825 | if (!addType(DT)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 826 | return; |
| 827 | |
| 828 | addCompileUnit(DT.getCompileUnit()); |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 829 | if (DT.isCompositeType()) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 830 | DICompositeType DCT(DT); |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 831 | processType(DCT.getTypeDerivedFrom()); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 832 | DIArray DA = DCT.getTypeArray(); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 833 | for (unsigned i = 0, e = DA.getNumElements(); i != e; ++i) { |
| 834 | DIDescriptor D = DA.getElement(i); |
| 835 | if (D.isType()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 836 | processType(DIType(D)); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 837 | else if (D.isSubprogram()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 838 | processSubprogram(DISubprogram(D)); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 839 | } |
Devang Patel | 6ceea33 | 2009-08-31 18:49:10 +0000 | [diff] [blame] | 840 | } else if (DT.isDerivedType()) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 841 | DIDerivedType DDT(DT); |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 842 | processType(DDT.getTypeDerivedFrom()); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 843 | } |
| 844 | } |
| 845 | |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 846 | /// processLexicalBlock |
| 847 | void DebugInfoFinder::processLexicalBlock(DILexicalBlock LB) { |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 848 | DIScope Context = LB.getContext(); |
| 849 | if (Context.isLexicalBlock()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 850 | return processLexicalBlock(DILexicalBlock(Context)); |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 851 | else |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 852 | return processSubprogram(DISubprogram(Context)); |
Devang Patel | beab41b | 2009-10-07 22:04:08 +0000 | [diff] [blame] | 853 | } |
| 854 | |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 855 | /// processSubprogram - Process DISubprogram. |
| 856 | void DebugInfoFinder::processSubprogram(DISubprogram SP) { |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 857 | if (!addSubprogram(SP)) |
| 858 | return; |
| 859 | addCompileUnit(SP.getCompileUnit()); |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 860 | processType(SP.getType()); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 861 | } |
| 862 | |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 863 | /// processDeclare - Process DbgDeclareInst. |
| 864 | void DebugInfoFinder::processDeclare(DbgDeclareInst *DDI) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 865 | MDNode *N = dyn_cast<MDNode>(DDI->getVariable()); |
| 866 | if (!N) return; |
| 867 | |
| 868 | DIDescriptor DV(N); |
| 869 | if (!DV.isVariable()) |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 870 | return; |
| 871 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 872 | if (!NodesSeen.insert(DV)) |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 873 | return; |
| 874 | |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 875 | addCompileUnit(DIVariable(N).getCompileUnit()); |
| 876 | processType(DIVariable(N).getType()); |
Devang Patel | b4d3130 | 2009-07-31 18:18:52 +0000 | [diff] [blame] | 877 | } |
| 878 | |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 879 | /// addType - Add type into Tys. |
| 880 | bool DebugInfoFinder::addType(DIType DT) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 881 | if (!DT.isValid()) |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 882 | return false; |
| 883 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 884 | if (!NodesSeen.insert(DT)) |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 885 | return false; |
| 886 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 887 | TYs.push_back(DT); |
Devang Patel | 72bcdb6 | 2009-08-10 22:09:58 +0000 | [diff] [blame] | 888 | return true; |
| 889 | } |
| 890 | |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 891 | /// addCompileUnit - Add compile unit into CUs. |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 892 | bool DebugInfoFinder::addCompileUnit(DICompileUnit CU) { |
Devang Patel | 3c91b05 | 2010-03-08 20:52:55 +0000 | [diff] [blame] | 893 | if (!CU.Verify()) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 894 | return false; |
| 895 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 896 | if (!NodesSeen.insert(CU)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 897 | return false; |
| 898 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 899 | CUs.push_back(CU); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 900 | return true; |
| 901 | } |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 902 | |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 903 | /// addGlobalVariable - Add global variable into GVs. |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 904 | bool DebugInfoFinder::addGlobalVariable(DIGlobalVariable DIG) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 905 | if (!DIDescriptor(DIG).isGlobalVariable()) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 906 | return false; |
| 907 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 908 | if (!NodesSeen.insert(DIG)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 909 | return false; |
| 910 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 911 | GVs.push_back(DIG); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 912 | return true; |
| 913 | } |
| 914 | |
| 915 | // addSubprogram - Add subprgoram into SPs. |
Devang Patel | 98c6517 | 2009-07-30 18:25:15 +0000 | [diff] [blame] | 916 | bool DebugInfoFinder::addSubprogram(DISubprogram SP) { |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 917 | if (!DIDescriptor(SP).isSubprogram()) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 918 | return false; |
Daniel Dunbar | f612ff6 | 2009-09-19 20:40:05 +0000 | [diff] [blame] | 919 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 920 | if (!NodesSeen.insert(SP)) |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 921 | return false; |
| 922 | |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 923 | SPs.push_back(SP); |
Devang Patel | d2f79a1 | 2009-07-28 19:55:13 +0000 | [diff] [blame] | 924 | return true; |
| 925 | } |
| 926 | |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 927 | /// getDISubprogram - Find subprogram that is enclosing this scope. |
Devang Patel | e9f8f5e | 2010-05-07 20:54:48 +0000 | [diff] [blame] | 928 | DISubprogram llvm::getDISubprogram(const MDNode *Scope) { |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 929 | DIDescriptor D(Scope); |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 930 | if (D.isSubprogram()) |
| 931 | return DISubprogram(Scope); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 932 | |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 933 | if (D.isLexicalBlock()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 934 | return getDISubprogram(DILexicalBlock(Scope).getContext()); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 935 | |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 936 | return DISubprogram(); |
| 937 | } |
Devang Patel | 193f720 | 2009-11-24 01:14:22 +0000 | [diff] [blame] | 938 | |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 939 | /// getDICompositeType - Find underlying composite type. |
| 940 | DICompositeType llvm::getDICompositeType(DIType T) { |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 941 | if (T.isCompositeType()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 942 | return DICompositeType(T); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 943 | |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 944 | if (T.isDerivedType()) |
Devang Patel | 2db49d7 | 2010-05-07 18:11:54 +0000 | [diff] [blame] | 945 | return getDICompositeType(DIDerivedType(T).getTypeDerivedFrom()); |
Jim Grosbach | e62b690 | 2010-07-21 21:36:25 +0000 | [diff] [blame] | 946 | |
Chris Lattner | 099b779 | 2009-12-29 09:22:47 +0000 | [diff] [blame] | 947 | return DICompositeType(); |
Torok Edwin | 620f280 | 2008-12-16 09:07:36 +0000 | [diff] [blame] | 948 | } |