Line data Source code
1 : //===-- llvm/Support/Dwarf.cpp - Dwarf Framework ----------------*- C++ -*-===//
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 contains support for generic dwarf information.
11 : //
12 : //===----------------------------------------------------------------------===//
13 :
14 : #include "llvm/Support/Dwarf.h"
15 : #include "llvm/ADT/StringSwitch.h"
16 : #include "llvm/Support/ErrorHandling.h"
17 :
18 : using namespace llvm;
19 : using namespace dwarf;
20 :
21 19809 : StringRef llvm::dwarf::TagString(unsigned Tag) {
22 19809 : switch (Tag) {
23 : default:
24 16 : return StringRef();
25 : #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
26 : case DW_TAG_##NAME: \
27 : return "DW_TAG_" #NAME;
28 : #include "llvm/Support/Dwarf.def"
29 : }
30 : }
31 :
32 2831 : unsigned llvm::dwarf::getTag(StringRef TagString) {
33 2831 : return StringSwitch<unsigned>(TagString)
34 : #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
35 : .Case("DW_TAG_" #NAME, DW_TAG_##NAME)
36 : #include "llvm/Support/Dwarf.def"
37 5662 : .Default(DW_TAG_invalid);
38 : }
39 :
40 0 : unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) {
41 : switch (Tag) {
42 : default:
43 : return 0;
44 : #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
45 : case DW_TAG_##NAME: \
46 : return VERSION;
47 : #include "llvm/Support/Dwarf.def"
48 : }
49 : }
50 :
51 0 : unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) {
52 0 : switch (Tag) {
53 : default:
54 : return 0;
55 : #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR) \
56 : case DW_TAG_##NAME: \
57 : return DWARF_VENDOR_##VENDOR;
58 : #include "llvm/Support/Dwarf.def"
59 : }
60 : }
61 :
62 7791 : StringRef llvm::dwarf::ChildrenString(unsigned Children) {
63 7791 : switch (Children) {
64 4581 : case DW_CHILDREN_no: return "DW_CHILDREN_no";
65 3210 : case DW_CHILDREN_yes: return "DW_CHILDREN_yes";
66 : }
67 0 : return StringRef();
68 : }
69 :
70 71304 : StringRef llvm::dwarf::AttributeString(unsigned Attribute) {
71 71304 : switch (Attribute) {
72 : default:
73 84 : return StringRef();
74 : #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \
75 : case DW_AT_##NAME: \
76 : return "DW_AT_" #NAME;
77 : #include "llvm/Support/Dwarf.def"
78 : }
79 : }
80 :
81 0 : unsigned llvm::dwarf::AttributeVersion(dwarf::Attribute Attribute) {
82 : switch (Attribute) {
83 : default:
84 : return 0;
85 : #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \
86 : case DW_AT_##NAME: \
87 : return VERSION;
88 : #include "llvm/Support/Dwarf.def"
89 : }
90 : }
91 :
92 0 : unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) {
93 0 : switch (Attribute) {
94 : default:
95 : return 0;
96 : #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \
97 : case DW_AT_##NAME: \
98 : return DWARF_VENDOR_##VENDOR;
99 : #include "llvm/Support/Dwarf.def"
100 : }
101 : }
102 :
103 63674 : StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) {
104 63674 : switch (Encoding) {
105 : default:
106 0 : return StringRef();
107 : #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \
108 : case DW_FORM_##NAME: \
109 : return "DW_FORM_" #NAME;
110 : #include "llvm/Support/Dwarf.def"
111 : }
112 : }
113 :
114 0 : unsigned llvm::dwarf::FormVersion(dwarf::Form Form) {
115 : switch (Form) {
116 : default:
117 : return 0;
118 : #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \
119 : case DW_FORM_##NAME: \
120 : return VERSION;
121 : #include "llvm/Support/Dwarf.def"
122 : }
123 : }
124 :
125 0 : unsigned llvm::dwarf::FormVendor(dwarf::Form Form) {
126 : switch (Form) {
127 : default:
128 : return 0;
129 : #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \
130 : case DW_FORM_##NAME: \
131 : return DWARF_VENDOR_##VENDOR;
132 : #include "llvm/Support/Dwarf.def"
133 : }
134 : }
135 :
136 15239 : StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
137 15239 : switch (Encoding) {
138 : default:
139 0 : return StringRef();
140 : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
141 : case DW_OP_##NAME: \
142 : return "DW_OP_" #NAME;
143 : #include "llvm/Support/Dwarf.def"
144 : case DW_OP_LLVM_fragment:
145 55 : return "DW_OP_LLVM_fragment";
146 : }
147 : }
148 :
149 296 : unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
150 296 : return StringSwitch<unsigned>(OperationEncodingString)
151 : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
152 : .Case("DW_OP_" #NAME, DW_OP_##NAME)
153 : #include "llvm/Support/Dwarf.def"
154 888 : .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
155 592 : .Default(0);
156 : }
157 :
158 0 : unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
159 : switch (Op) {
160 : default:
161 : return 0;
162 : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
163 : case DW_OP_##NAME: \
164 : return VERSION;
165 : #include "llvm/Support/Dwarf.def"
166 : }
167 : }
168 :
169 0 : unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) {
170 0 : switch (Op) {
171 : default:
172 : return 0;
173 : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \
174 : case DW_OP_##NAME: \
175 : return DWARF_VENDOR_##VENDOR;
176 : #include "llvm/Support/Dwarf.def"
177 : }
178 : }
179 :
180 1058 : StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) {
181 1058 : switch (Encoding) {
182 : default:
183 3 : return StringRef();
184 : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
185 : case DW_ATE_##NAME: \
186 : return "DW_ATE_" #NAME;
187 : #include "llvm/Support/Dwarf.def"
188 : }
189 : }
190 :
191 1008 : unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) {
192 1008 : return StringSwitch<unsigned>(EncodingString)
193 : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
194 : .Case("DW_ATE_" #NAME, DW_ATE_##NAME)
195 : #include "llvm/Support/Dwarf.def"
196 2016 : .Default(0);
197 : }
198 :
199 0 : unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) {
200 : switch (ATE) {
201 : default:
202 : return 0;
203 : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
204 : case DW_ATE_##NAME: \
205 : return VERSION;
206 : #include "llvm/Support/Dwarf.def"
207 : }
208 : }
209 :
210 0 : unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) {
211 : switch (ATE) {
212 : default:
213 : return 0;
214 : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
215 : case DW_ATE_##NAME: \
216 : return DWARF_VENDOR_##VENDOR;
217 : #include "llvm/Support/Dwarf.def"
218 : }
219 : }
220 :
221 0 : StringRef llvm::dwarf::DecimalSignString(unsigned Sign) {
222 0 : switch (Sign) {
223 0 : case DW_DS_unsigned: return "DW_DS_unsigned";
224 0 : case DW_DS_leading_overpunch: return "DW_DS_leading_overpunch";
225 0 : case DW_DS_trailing_overpunch: return "DW_DS_trailing_overpunch";
226 0 : case DW_DS_leading_separate: return "DW_DS_leading_separate";
227 0 : case DW_DS_trailing_separate: return "DW_DS_trailing_separate";
228 : }
229 0 : return StringRef();
230 : }
231 :
232 0 : StringRef llvm::dwarf::EndianityString(unsigned Endian) {
233 0 : switch (Endian) {
234 0 : case DW_END_default: return "DW_END_default";
235 0 : case DW_END_big: return "DW_END_big";
236 0 : case DW_END_little: return "DW_END_little";
237 0 : case DW_END_lo_user: return "DW_END_lo_user";
238 0 : case DW_END_hi_user: return "DW_END_hi_user";
239 : }
240 0 : return StringRef();
241 : }
242 :
243 255 : StringRef llvm::dwarf::AccessibilityString(unsigned Access) {
244 255 : switch (Access) {
245 : // Accessibility codes
246 173 : case DW_ACCESS_public: return "DW_ACCESS_public";
247 20 : case DW_ACCESS_protected: return "DW_ACCESS_protected";
248 62 : case DW_ACCESS_private: return "DW_ACCESS_private";
249 : }
250 0 : return StringRef();
251 : }
252 :
253 2 : StringRef llvm::dwarf::VisibilityString(unsigned Visibility) {
254 2 : switch (Visibility) {
255 2 : case DW_VIS_local: return "DW_VIS_local";
256 0 : case DW_VIS_exported: return "DW_VIS_exported";
257 0 : case DW_VIS_qualified: return "DW_VIS_qualified";
258 : }
259 0 : return StringRef();
260 : }
261 :
262 62 : StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) {
263 62 : switch (Virtuality) {
264 : default:
265 2 : return StringRef();
266 : #define HANDLE_DW_VIRTUALITY(ID, NAME) \
267 : case DW_VIRTUALITY_##NAME: \
268 : return "DW_VIRTUALITY_" #NAME;
269 : #include "llvm/Support/Dwarf.def"
270 : }
271 : }
272 :
273 62 : unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) {
274 62 : return StringSwitch<unsigned>(VirtualityString)
275 : #define HANDLE_DW_VIRTUALITY(ID, NAME) \
276 : .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME)
277 : #include "llvm/Support/Dwarf.def"
278 124 : .Default(DW_VIRTUALITY_invalid);
279 : }
280 :
281 1419 : StringRef llvm::dwarf::LanguageString(unsigned Language) {
282 1419 : switch (Language) {
283 : default:
284 3 : return StringRef();
285 : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
286 : case DW_LANG_##NAME: \
287 : return "DW_LANG_" #NAME;
288 : #include "llvm/Support/Dwarf.def"
289 : }
290 : }
291 :
292 1318 : unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
293 1318 : return StringSwitch<unsigned>(LanguageString)
294 : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
295 : .Case("DW_LANG_" #NAME, DW_LANG_##NAME)
296 : #include "llvm/Support/Dwarf.def"
297 2636 : .Default(0);
298 : }
299 :
300 0 : unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) {
301 : switch (Lang) {
302 : default:
303 : return 0;
304 : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
305 : case DW_LANG_##NAME: \
306 : return VERSION;
307 : #include "llvm/Support/Dwarf.def"
308 : }
309 : }
310 :
311 0 : unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
312 0 : switch (Lang) {
313 : default:
314 : return 0;
315 : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR) \
316 : case DW_LANG_##NAME: \
317 : return DWARF_VENDOR_##VENDOR;
318 : #include "llvm/Support/Dwarf.def"
319 : }
320 : }
321 :
322 0 : StringRef llvm::dwarf::CaseString(unsigned Case) {
323 0 : switch (Case) {
324 0 : case DW_ID_case_sensitive: return "DW_ID_case_sensitive";
325 0 : case DW_ID_up_case: return "DW_ID_up_case";
326 0 : case DW_ID_down_case: return "DW_ID_down_case";
327 0 : case DW_ID_case_insensitive: return "DW_ID_case_insensitive";
328 : }
329 0 : return StringRef();
330 : }
331 :
332 50 : StringRef llvm::dwarf::ConventionString(unsigned CC) {
333 50 : switch (CC) {
334 : default:
335 0 : return StringRef();
336 : #define HANDLE_DW_CC(ID, NAME) \
337 : case DW_CC_##NAME: \
338 : return "DW_CC_" #NAME;
339 : #include "llvm/Support/Dwarf.def"
340 : }
341 : }
342 :
343 41 : unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
344 41 : return StringSwitch<unsigned>(CCString)
345 : #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)
346 : #include "llvm/Support/Dwarf.def"
347 82 : .Default(0);
348 : }
349 :
350 69 : StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
351 69 : switch (Code) {
352 0 : case DW_INL_not_inlined: return "DW_INL_not_inlined";
353 69 : case DW_INL_inlined: return "DW_INL_inlined";
354 0 : case DW_INL_declared_not_inlined: return "DW_INL_declared_not_inlined";
355 0 : case DW_INL_declared_inlined: return "DW_INL_declared_inlined";
356 : }
357 0 : return StringRef();
358 : }
359 :
360 0 : StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
361 0 : switch (Order) {
362 0 : case DW_ORD_row_major: return "DW_ORD_row_major";
363 0 : case DW_ORD_col_major: return "DW_ORD_col_major";
364 : }
365 0 : return StringRef();
366 : }
367 :
368 0 : StringRef llvm::dwarf::DiscriminantString(unsigned Discriminant) {
369 0 : switch (Discriminant) {
370 0 : case DW_DSC_label: return "DW_DSC_label";
371 0 : case DW_DSC_range: return "DW_DSC_range";
372 : }
373 0 : return StringRef();
374 : }
375 :
376 2976 : StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
377 2976 : switch (Standard) {
378 : default:
379 0 : return StringRef();
380 : #define HANDLE_DW_LNS(ID, NAME) \
381 : case DW_LNS_##NAME: \
382 : return "DW_LNS_" #NAME;
383 : #include "llvm/Support/Dwarf.def"
384 : }
385 : }
386 :
387 0 : StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
388 0 : switch (Encoding) {
389 : default:
390 0 : return StringRef();
391 : #define HANDLE_DW_LNE(ID, NAME) \
392 : case DW_LNE_##NAME: \
393 : return "DW_LNE_" #NAME;
394 : #include "llvm/Support/Dwarf.def"
395 : }
396 : }
397 :
398 1172 : StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
399 1172 : switch (Encoding) {
400 : // Macinfo Type Encodings
401 1141 : case DW_MACINFO_define: return "DW_MACINFO_define";
402 19 : case DW_MACINFO_undef: return "DW_MACINFO_undef";
403 6 : case DW_MACINFO_start_file: return "DW_MACINFO_start_file";
404 6 : case DW_MACINFO_end_file: return "DW_MACINFO_end_file";
405 0 : case DW_MACINFO_vendor_ext: return "DW_MACINFO_vendor_ext";
406 0 : case DW_MACINFO_invalid: return "DW_MACINFO_invalid";
407 : }
408 0 : return StringRef();
409 : }
410 :
411 31 : unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
412 31 : return StringSwitch<unsigned>(MacinfoString)
413 93 : .Case("DW_MACINFO_define", DW_MACINFO_define)
414 93 : .Case("DW_MACINFO_undef", DW_MACINFO_undef)
415 93 : .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
416 93 : .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
417 93 : .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
418 62 : .Default(DW_MACINFO_invalid);
419 : }
420 :
421 410 : StringRef llvm::dwarf::CallFrameString(unsigned Encoding) {
422 410 : switch (Encoding) {
423 : default:
424 0 : return StringRef();
425 : #define HANDLE_DW_CFA(ID, NAME) \
426 : case DW_CFA_##NAME: \
427 : return "DW_CFA_" #NAME;
428 : #include "llvm/Support/Dwarf.def"
429 : }
430 : }
431 :
432 98 : StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
433 98 : switch (Prop) {
434 : default:
435 0 : return StringRef();
436 : #define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \
437 : case DW_APPLE_PROPERTY_##NAME: \
438 : return "DW_APPLE_PROPERTY_" #NAME;
439 : #include "llvm/Support/Dwarf.def"
440 : }
441 : }
442 :
443 12 : StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
444 12 : switch (UT) {
445 : default:
446 0 : return StringRef();
447 : #define HANDLE_DW_UT(ID, NAME) \
448 : case DW_UT_##NAME: \
449 : return "DW_UT_" #NAME;
450 : #include "llvm/Support/Dwarf.def"
451 : }
452 : }
453 :
454 1315 : StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
455 1315 : switch (AT) {
456 : case dwarf::DW_ATOM_null:
457 0 : return "DW_ATOM_null";
458 : case dwarf::DW_ATOM_die_offset:
459 851 : return "DW_ATOM_die_offset";
460 : case DW_ATOM_cu_offset:
461 0 : return "DW_ATOM_cu_offset";
462 : case DW_ATOM_die_tag:
463 232 : return "DW_ATOM_die_tag";
464 : case DW_ATOM_type_flags:
465 232 : return "DW_ATOM_type_flags";
466 : }
467 0 : return StringRef();
468 : }
469 :
470 74 : StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
471 74 : switch (Kind) {
472 : case GIEK_NONE:
473 0 : return "NONE";
474 : case GIEK_TYPE:
475 30 : return "TYPE";
476 : case GIEK_VARIABLE:
477 26 : return "VARIABLE";
478 : case GIEK_FUNCTION:
479 18 : return "FUNCTION";
480 : case GIEK_OTHER:
481 0 : return "OTHER";
482 : case GIEK_UNUSED5:
483 0 : return "UNUSED5";
484 : case GIEK_UNUSED6:
485 0 : return "UNUSED6";
486 : case GIEK_UNUSED7:
487 0 : return "UNUSED7";
488 : }
489 0 : llvm_unreachable("Unknown GDBIndexEntryKind value");
490 : }
491 :
492 : StringRef
493 74 : llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
494 74 : switch (Linkage) {
495 : case GIEL_EXTERNAL:
496 59 : return "EXTERNAL";
497 : case GIEL_STATIC:
498 15 : return "STATIC";
499 : }
500 0 : llvm_unreachable("Unknown GDBIndexEntryLinkage value");
501 : }
502 :
503 7794 : StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
504 7794 : switch (Attr) {
505 : case DW_AT_accessibility:
506 233 : return AccessibilityString(Val);
507 : case DW_AT_virtuality:
508 8 : return VirtualityString(Val);
509 : case DW_AT_language:
510 499 : return LanguageString(Val);
511 : case DW_AT_encoding:
512 411 : return AttributeEncodingString(Val);
513 : case DW_AT_decimal_sign:
514 0 : return DecimalSignString(Val);
515 : case DW_AT_endianity:
516 0 : return EndianityString(Val);
517 : case DW_AT_visibility:
518 2 : return VisibilityString(Val);
519 : case DW_AT_identifier_case:
520 0 : return CaseString(Val);
521 : case DW_AT_calling_convention:
522 2 : return ConventionString(Val);
523 : case DW_AT_inline:
524 69 : return InlineCodeString(Val);
525 : case DW_AT_ordering:
526 0 : return ArrayOrderString(Val);
527 : case DW_AT_discr_value:
528 0 : return DiscriminantString(Val);
529 : }
530 :
531 6570 : return StringRef();
532 : }
533 :
534 0 : bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
535 : bool ExtensionsOk) {
536 0 : if (FormVendor(F) == DWARF_VENDOR_DWARF) {
537 0 : unsigned FV = FormVersion(F);
538 0 : return FV > 0 && FV <= Version;
539 : }
540 : return ExtensionsOk;
541 : }
|