1 | //===-- llvm/BinaryFormat/Dwarf.cpp - Dwarf Framework ------------*- C++-*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file contains support for generic dwarf information. |
10 | // |
11 | //===----------------------------------------------------------------------===// |
12 | |
13 | #include "llvm/BinaryFormat/Dwarf.h" |
14 | #include "llvm/ADT/StringSwitch.h" |
15 | #include "llvm/Support/ErrorHandling.h" |
16 | #include "llvm/TargetParser/Triple.h" |
17 | |
18 | using namespace llvm; |
19 | using namespace dwarf; |
20 | |
21 | StringRef llvm::dwarf::TagString(unsigned Tag) { |
22 | switch (Tag) { |
23 | default: |
24 | return StringRef(); |
25 | #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \ |
26 | case DW_TAG_##NAME: \ |
27 | return "DW_TAG_" #NAME; |
28 | #include "llvm/BinaryFormat/Dwarf.def" |
29 | } |
30 | } |
31 | |
32 | unsigned llvm::dwarf::getTag(StringRef TagString) { |
33 | return StringSwitch<unsigned>(TagString) |
34 | #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \ |
35 | .Case("DW_TAG_" #NAME, DW_TAG_##NAME) |
36 | #include "llvm/BinaryFormat/Dwarf.def" |
37 | .Default(Value: DW_TAG_invalid); |
38 | } |
39 | |
40 | unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) { |
41 | switch (Tag) { |
42 | default: |
43 | return 0; |
44 | #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \ |
45 | case DW_TAG_##NAME: \ |
46 | return VERSION; |
47 | #include "llvm/BinaryFormat/Dwarf.def" |
48 | } |
49 | } |
50 | |
51 | unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) { |
52 | switch (Tag) { |
53 | default: |
54 | return 0; |
55 | #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR, KIND) \ |
56 | case DW_TAG_##NAME: \ |
57 | return DWARF_VENDOR_##VENDOR; |
58 | #include "llvm/BinaryFormat/Dwarf.def" |
59 | } |
60 | } |
61 | |
62 | StringRef llvm::dwarf::ChildrenString(unsigned Children) { |
63 | switch (Children) { |
64 | case DW_CHILDREN_no: |
65 | return "DW_CHILDREN_no" ; |
66 | case DW_CHILDREN_yes: |
67 | return "DW_CHILDREN_yes" ; |
68 | } |
69 | return StringRef(); |
70 | } |
71 | |
72 | StringRef llvm::dwarf::AttributeString(unsigned Attribute) { |
73 | switch (Attribute) { |
74 | default: |
75 | return StringRef(); |
76 | #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \ |
77 | case DW_AT_##NAME: \ |
78 | return "DW_AT_" #NAME; |
79 | #include "llvm/BinaryFormat/Dwarf.def" |
80 | } |
81 | } |
82 | |
83 | unsigned llvm::dwarf::AttributeVersion(dwarf::Attribute Attribute) { |
84 | switch (Attribute) { |
85 | default: |
86 | return 0; |
87 | #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \ |
88 | case DW_AT_##NAME: \ |
89 | return VERSION; |
90 | #include "llvm/BinaryFormat/Dwarf.def" |
91 | } |
92 | } |
93 | |
94 | unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) { |
95 | switch (Attribute) { |
96 | default: |
97 | return 0; |
98 | #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR) \ |
99 | case DW_AT_##NAME: \ |
100 | return DWARF_VENDOR_##VENDOR; |
101 | #include "llvm/BinaryFormat/Dwarf.def" |
102 | } |
103 | } |
104 | |
105 | StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) { |
106 | switch (Encoding) { |
107 | default: |
108 | return StringRef(); |
109 | #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \ |
110 | case DW_FORM_##NAME: \ |
111 | return "DW_FORM_" #NAME; |
112 | #include "llvm/BinaryFormat/Dwarf.def" |
113 | } |
114 | } |
115 | |
116 | unsigned llvm::dwarf::FormVersion(dwarf::Form Form) { |
117 | switch (Form) { |
118 | default: |
119 | return 0; |
120 | #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \ |
121 | case DW_FORM_##NAME: \ |
122 | return VERSION; |
123 | #include "llvm/BinaryFormat/Dwarf.def" |
124 | } |
125 | } |
126 | |
127 | unsigned llvm::dwarf::FormVendor(dwarf::Form Form) { |
128 | switch (Form) { |
129 | default: |
130 | return 0; |
131 | #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR) \ |
132 | case DW_FORM_##NAME: \ |
133 | return DWARF_VENDOR_##VENDOR; |
134 | #include "llvm/BinaryFormat/Dwarf.def" |
135 | } |
136 | } |
137 | |
138 | StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) { |
139 | switch (Encoding) { |
140 | default: |
141 | return StringRef(); |
142 | #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ |
143 | case DW_OP_##NAME: \ |
144 | return "DW_OP_" #NAME; |
145 | #include "llvm/BinaryFormat/Dwarf.def" |
146 | case DW_OP_LLVM_convert: |
147 | return "DW_OP_LLVM_convert" ; |
148 | case DW_OP_LLVM_fragment: |
149 | return "DW_OP_LLVM_fragment" ; |
150 | case DW_OP_LLVM_tag_offset: |
151 | return "DW_OP_LLVM_tag_offset" ; |
152 | case DW_OP_LLVM_entry_value: |
153 | return "DW_OP_LLVM_entry_value" ; |
154 | case DW_OP_LLVM_implicit_pointer: |
155 | return "DW_OP_LLVM_implicit_pointer" ; |
156 | case DW_OP_LLVM_arg: |
157 | return "DW_OP_LLVM_arg" ; |
158 | } |
159 | } |
160 | |
161 | unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) { |
162 | return StringSwitch<unsigned>(OperationEncodingString) |
163 | #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ |
164 | .Case("DW_OP_" #NAME, DW_OP_##NAME) |
165 | #include "llvm/BinaryFormat/Dwarf.def" |
166 | .Case(S: "DW_OP_LLVM_convert" , Value: DW_OP_LLVM_convert) |
167 | .Case(S: "DW_OP_LLVM_fragment" , Value: DW_OP_LLVM_fragment) |
168 | .Case(S: "DW_OP_LLVM_tag_offset" , Value: DW_OP_LLVM_tag_offset) |
169 | .Case(S: "DW_OP_LLVM_entry_value" , Value: DW_OP_LLVM_entry_value) |
170 | .Case(S: "DW_OP_LLVM_implicit_pointer" , Value: DW_OP_LLVM_implicit_pointer) |
171 | .Case(S: "DW_OP_LLVM_arg" , Value: DW_OP_LLVM_arg) |
172 | .Default(Value: 0); |
173 | } |
174 | |
175 | static StringRef LlvmUserOperationEncodingString(unsigned Encoding) { |
176 | switch (Encoding) { |
177 | default: |
178 | llvm_unreachable("unhandled DWARF operation with LLVM user op" ); |
179 | #define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) \ |
180 | case DW_OP_LLVM_##NAME: \ |
181 | return "DW_OP_LLVM_" #NAME; |
182 | #include "llvm/BinaryFormat/Dwarf.def" |
183 | } |
184 | } |
185 | |
186 | static unsigned |
187 | getLlvmUserOperationEncoding(StringRef LlvmUserOperationEncodingString) { |
188 | unsigned E = StringSwitch<unsigned>(LlvmUserOperationEncodingString) |
189 | #define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) .Case(#NAME, DW_OP_LLVM_##NAME) |
190 | #include "llvm/BinaryFormat/Dwarf.def" |
191 | .Default(Value: 0); |
192 | assert(E && "unhandled DWARF operation string with LLVM user op" ); |
193 | return E; |
194 | } |
195 | |
196 | StringRef llvm::dwarf::SubOperationEncodingString(unsigned OpEncoding, |
197 | unsigned SubOpEncoding) { |
198 | assert(OpEncoding == DW_OP_LLVM_user); |
199 | return LlvmUserOperationEncodingString(Encoding: SubOpEncoding); |
200 | } |
201 | |
202 | unsigned |
203 | llvm::dwarf::getSubOperationEncoding(unsigned OpEncoding, |
204 | StringRef SubOperationEncodingString) { |
205 | assert(OpEncoding == DW_OP_LLVM_user); |
206 | return getLlvmUserOperationEncoding(LlvmUserOperationEncodingString: SubOperationEncodingString); |
207 | } |
208 | |
209 | unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) { |
210 | switch (Op) { |
211 | default: |
212 | return 0; |
213 | #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ |
214 | case DW_OP_##NAME: \ |
215 | return VERSION; |
216 | #include "llvm/BinaryFormat/Dwarf.def" |
217 | } |
218 | } |
219 | |
220 | unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) { |
221 | switch (Op) { |
222 | default: |
223 | return 0; |
224 | #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) \ |
225 | case DW_OP_##NAME: \ |
226 | return DWARF_VENDOR_##VENDOR; |
227 | #include "llvm/BinaryFormat/Dwarf.def" |
228 | } |
229 | } |
230 | |
231 | StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) { |
232 | switch (Encoding) { |
233 | default: |
234 | return StringRef(); |
235 | #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ |
236 | case DW_ATE_##NAME: \ |
237 | return "DW_ATE_" #NAME; |
238 | #include "llvm/BinaryFormat/Dwarf.def" |
239 | } |
240 | } |
241 | |
242 | unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) { |
243 | return StringSwitch<unsigned>(EncodingString) |
244 | #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ |
245 | .Case("DW_ATE_" #NAME, DW_ATE_##NAME) |
246 | #include "llvm/BinaryFormat/Dwarf.def" |
247 | .Default(Value: 0); |
248 | } |
249 | |
250 | unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) { |
251 | switch (ATE) { |
252 | default: |
253 | return 0; |
254 | #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ |
255 | case DW_ATE_##NAME: \ |
256 | return VERSION; |
257 | #include "llvm/BinaryFormat/Dwarf.def" |
258 | } |
259 | } |
260 | |
261 | unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) { |
262 | switch (ATE) { |
263 | default: |
264 | return 0; |
265 | #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \ |
266 | case DW_ATE_##NAME: \ |
267 | return DWARF_VENDOR_##VENDOR; |
268 | #include "llvm/BinaryFormat/Dwarf.def" |
269 | } |
270 | } |
271 | |
272 | StringRef llvm::dwarf::DecimalSignString(unsigned Sign) { |
273 | switch (Sign) { |
274 | case DW_DS_unsigned: |
275 | return "DW_DS_unsigned" ; |
276 | case DW_DS_leading_overpunch: |
277 | return "DW_DS_leading_overpunch" ; |
278 | case DW_DS_trailing_overpunch: |
279 | return "DW_DS_trailing_overpunch" ; |
280 | case DW_DS_leading_separate: |
281 | return "DW_DS_leading_separate" ; |
282 | case DW_DS_trailing_separate: |
283 | return "DW_DS_trailing_separate" ; |
284 | } |
285 | return StringRef(); |
286 | } |
287 | |
288 | StringRef llvm::dwarf::EndianityString(unsigned Endian) { |
289 | switch (Endian) { |
290 | case DW_END_default: |
291 | return "DW_END_default" ; |
292 | case DW_END_big: |
293 | return "DW_END_big" ; |
294 | case DW_END_little: |
295 | return "DW_END_little" ; |
296 | case DW_END_lo_user: |
297 | return "DW_END_lo_user" ; |
298 | case DW_END_hi_user: |
299 | return "DW_END_hi_user" ; |
300 | } |
301 | return StringRef(); |
302 | } |
303 | |
304 | StringRef llvm::dwarf::AccessibilityString(unsigned Access) { |
305 | switch (Access) { |
306 | // Accessibility codes |
307 | case DW_ACCESS_public: |
308 | return "DW_ACCESS_public" ; |
309 | case DW_ACCESS_protected: |
310 | return "DW_ACCESS_protected" ; |
311 | case DW_ACCESS_private: |
312 | return "DW_ACCESS_private" ; |
313 | } |
314 | return StringRef(); |
315 | } |
316 | |
317 | StringRef llvm::dwarf::DefaultedMemberString(unsigned DefaultedEncodings) { |
318 | switch (DefaultedEncodings) { |
319 | // Defaulted Member Encodings codes |
320 | case DW_DEFAULTED_no: |
321 | return "DW_DEFAULTED_no" ; |
322 | case DW_DEFAULTED_in_class: |
323 | return "DW_DEFAULTED_in_class" ; |
324 | case DW_DEFAULTED_out_of_class: |
325 | return "DW_DEFAULTED_out_of_class" ; |
326 | } |
327 | return StringRef(); |
328 | } |
329 | |
330 | StringRef llvm::dwarf::VisibilityString(unsigned Visibility) { |
331 | switch (Visibility) { |
332 | case DW_VIS_local: |
333 | return "DW_VIS_local" ; |
334 | case DW_VIS_exported: |
335 | return "DW_VIS_exported" ; |
336 | case DW_VIS_qualified: |
337 | return "DW_VIS_qualified" ; |
338 | } |
339 | return StringRef(); |
340 | } |
341 | |
342 | StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) { |
343 | switch (Virtuality) { |
344 | default: |
345 | return StringRef(); |
346 | #define HANDLE_DW_VIRTUALITY(ID, NAME) \ |
347 | case DW_VIRTUALITY_##NAME: \ |
348 | return "DW_VIRTUALITY_" #NAME; |
349 | #include "llvm/BinaryFormat/Dwarf.def" |
350 | } |
351 | } |
352 | |
353 | unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) { |
354 | return StringSwitch<unsigned>(VirtualityString) |
355 | #define HANDLE_DW_VIRTUALITY(ID, NAME) \ |
356 | .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME) |
357 | #include "llvm/BinaryFormat/Dwarf.def" |
358 | .Default(Value: DW_VIRTUALITY_invalid); |
359 | } |
360 | |
361 | StringRef llvm::dwarf::LanguageString(unsigned Language) { |
362 | switch (Language) { |
363 | default: |
364 | return StringRef(); |
365 | #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ |
366 | case DW_LANG_##NAME: \ |
367 | return "DW_LANG_" #NAME; |
368 | #include "llvm/BinaryFormat/Dwarf.def" |
369 | } |
370 | } |
371 | |
372 | unsigned llvm::dwarf::getLanguage(StringRef LanguageString) { |
373 | return StringSwitch<unsigned>(LanguageString) |
374 | #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ |
375 | .Case("DW_LANG_" #NAME, DW_LANG_##NAME) |
376 | #include "llvm/BinaryFormat/Dwarf.def" |
377 | .Default(Value: 0); |
378 | } |
379 | |
380 | unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) { |
381 | switch (Lang) { |
382 | default: |
383 | return 0; |
384 | #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ |
385 | case DW_LANG_##NAME: \ |
386 | return VERSION; |
387 | #include "llvm/BinaryFormat/Dwarf.def" |
388 | } |
389 | } |
390 | |
391 | unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) { |
392 | switch (Lang) { |
393 | default: |
394 | return 0; |
395 | #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ |
396 | case DW_LANG_##NAME: \ |
397 | return DWARF_VENDOR_##VENDOR; |
398 | #include "llvm/BinaryFormat/Dwarf.def" |
399 | } |
400 | } |
401 | |
402 | std::optional<unsigned> |
403 | llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) { |
404 | switch (Lang) { |
405 | default: |
406 | return std::nullopt; |
407 | #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \ |
408 | case DW_LANG_##NAME: \ |
409 | return LOWER_BOUND; |
410 | #include "llvm/BinaryFormat/Dwarf.def" |
411 | } |
412 | } |
413 | |
414 | StringRef llvm::dwarf::CaseString(unsigned Case) { |
415 | switch (Case) { |
416 | case DW_ID_case_sensitive: |
417 | return "DW_ID_case_sensitive" ; |
418 | case DW_ID_up_case: |
419 | return "DW_ID_up_case" ; |
420 | case DW_ID_down_case: |
421 | return "DW_ID_down_case" ; |
422 | case DW_ID_case_insensitive: |
423 | return "DW_ID_case_insensitive" ; |
424 | } |
425 | return StringRef(); |
426 | } |
427 | |
428 | StringRef llvm::dwarf::ConventionString(unsigned CC) { |
429 | switch (CC) { |
430 | default: |
431 | return StringRef(); |
432 | #define HANDLE_DW_CC(ID, NAME) \ |
433 | case DW_CC_##NAME: \ |
434 | return "DW_CC_" #NAME; |
435 | #include "llvm/BinaryFormat/Dwarf.def" |
436 | } |
437 | } |
438 | |
439 | unsigned llvm::dwarf::getCallingConvention(StringRef CCString) { |
440 | return StringSwitch<unsigned>(CCString) |
441 | #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME) |
442 | #include "llvm/BinaryFormat/Dwarf.def" |
443 | .Default(Value: 0); |
444 | } |
445 | |
446 | StringRef llvm::dwarf::InlineCodeString(unsigned Code) { |
447 | switch (Code) { |
448 | case DW_INL_not_inlined: |
449 | return "DW_INL_not_inlined" ; |
450 | case DW_INL_inlined: |
451 | return "DW_INL_inlined" ; |
452 | case DW_INL_declared_not_inlined: |
453 | return "DW_INL_declared_not_inlined" ; |
454 | case DW_INL_declared_inlined: |
455 | return "DW_INL_declared_inlined" ; |
456 | } |
457 | return StringRef(); |
458 | } |
459 | |
460 | StringRef llvm::dwarf::ArrayOrderString(unsigned Order) { |
461 | switch (Order) { |
462 | case DW_ORD_row_major: |
463 | return "DW_ORD_row_major" ; |
464 | case DW_ORD_col_major: |
465 | return "DW_ORD_col_major" ; |
466 | } |
467 | return StringRef(); |
468 | } |
469 | |
470 | StringRef llvm::dwarf::LNStandardString(unsigned Standard) { |
471 | switch (Standard) { |
472 | default: |
473 | return StringRef(); |
474 | #define HANDLE_DW_LNS(ID, NAME) \ |
475 | case DW_LNS_##NAME: \ |
476 | return "DW_LNS_" #NAME; |
477 | #include "llvm/BinaryFormat/Dwarf.def" |
478 | } |
479 | } |
480 | |
481 | StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) { |
482 | switch (Encoding) { |
483 | default: |
484 | return StringRef(); |
485 | #define HANDLE_DW_LNE(ID, NAME) \ |
486 | case DW_LNE_##NAME: \ |
487 | return "DW_LNE_" #NAME; |
488 | #include "llvm/BinaryFormat/Dwarf.def" |
489 | } |
490 | } |
491 | |
492 | StringRef llvm::dwarf::MacinfoString(unsigned Encoding) { |
493 | switch (Encoding) { |
494 | // Macinfo Type Encodings |
495 | case DW_MACINFO_define: |
496 | return "DW_MACINFO_define" ; |
497 | case DW_MACINFO_undef: |
498 | return "DW_MACINFO_undef" ; |
499 | case DW_MACINFO_start_file: |
500 | return "DW_MACINFO_start_file" ; |
501 | case DW_MACINFO_end_file: |
502 | return "DW_MACINFO_end_file" ; |
503 | case DW_MACINFO_vendor_ext: |
504 | return "DW_MACINFO_vendor_ext" ; |
505 | case DW_MACINFO_invalid: |
506 | return "DW_MACINFO_invalid" ; |
507 | } |
508 | return StringRef(); |
509 | } |
510 | |
511 | unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) { |
512 | return StringSwitch<unsigned>(MacinfoString) |
513 | .Case(S: "DW_MACINFO_define" , Value: DW_MACINFO_define) |
514 | .Case(S: "DW_MACINFO_undef" , Value: DW_MACINFO_undef) |
515 | .Case(S: "DW_MACINFO_start_file" , Value: DW_MACINFO_start_file) |
516 | .Case(S: "DW_MACINFO_end_file" , Value: DW_MACINFO_end_file) |
517 | .Case(S: "DW_MACINFO_vendor_ext" , Value: DW_MACINFO_vendor_ext) |
518 | .Default(Value: DW_MACINFO_invalid); |
519 | } |
520 | |
521 | StringRef llvm::dwarf::MacroString(unsigned Encoding) { |
522 | switch (Encoding) { |
523 | default: |
524 | return StringRef(); |
525 | #define HANDLE_DW_MACRO(ID, NAME) \ |
526 | case DW_MACRO_##NAME: \ |
527 | return "DW_MACRO_" #NAME; |
528 | #include "llvm/BinaryFormat/Dwarf.def" |
529 | } |
530 | } |
531 | |
532 | StringRef llvm::dwarf::GnuMacroString(unsigned Encoding) { |
533 | switch (Encoding) { |
534 | default: |
535 | return StringRef(); |
536 | #define HANDLE_DW_MACRO_GNU(ID, NAME) \ |
537 | case DW_MACRO_GNU_##NAME: \ |
538 | return "DW_MACRO_GNU_" #NAME; |
539 | #include "llvm/BinaryFormat/Dwarf.def" |
540 | } |
541 | } |
542 | |
543 | unsigned llvm::dwarf::getMacro(StringRef MacroString) { |
544 | return StringSwitch<unsigned>(MacroString) |
545 | #define HANDLE_DW_MACRO(ID, NAME) .Case("DW_MACRO_" #NAME, ID) |
546 | #include "llvm/BinaryFormat/Dwarf.def" |
547 | .Default(Value: DW_MACINFO_invalid); |
548 | } |
549 | StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) { |
550 | switch (Encoding) { |
551 | default: |
552 | return StringRef(); |
553 | #define HANDLE_DW_RLE(ID, NAME) \ |
554 | case DW_RLE_##NAME: \ |
555 | return "DW_RLE_" #NAME; |
556 | #include "llvm/BinaryFormat/Dwarf.def" |
557 | } |
558 | } |
559 | |
560 | StringRef llvm::dwarf::LocListEncodingString(unsigned Encoding) { |
561 | switch (Encoding) { |
562 | default: |
563 | return StringRef(); |
564 | #define HANDLE_DW_LLE(ID, NAME) \ |
565 | case DW_LLE_##NAME: \ |
566 | return "DW_LLE_" #NAME; |
567 | #include "llvm/BinaryFormat/Dwarf.def" |
568 | } |
569 | } |
570 | |
571 | StringRef llvm::dwarf::CallFrameString(unsigned Encoding, |
572 | Triple::ArchType Arch) { |
573 | assert(Arch != llvm::Triple::ArchType::UnknownArch); |
574 | #define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64) |
575 | #define SELECT_MIPS64 Arch == llvm::Triple::mips64 |
576 | #define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9) |
577 | #define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64) |
578 | #define HANDLE_DW_CFA(ID, NAME) |
579 | #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \ |
580 | if (ID == Encoding && PRED) \ |
581 | return "DW_CFA_" #NAME; |
582 | #include "llvm/BinaryFormat/Dwarf.def" |
583 | |
584 | switch (Encoding) { |
585 | default: |
586 | return StringRef(); |
587 | #define HANDLE_DW_CFA_PRED(ID, NAME, PRED) |
588 | #define HANDLE_DW_CFA(ID, NAME) \ |
589 | case DW_CFA_##NAME: \ |
590 | return "DW_CFA_" #NAME; |
591 | #include "llvm/BinaryFormat/Dwarf.def" |
592 | |
593 | #undef SELECT_X86 |
594 | #undef SELECT_SPARC |
595 | #undef SELECT_MIPS64 |
596 | #undef SELECT_AARCH64 |
597 | } |
598 | } |
599 | |
600 | StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) { |
601 | switch (Prop) { |
602 | default: |
603 | return StringRef(); |
604 | #define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \ |
605 | case DW_APPLE_PROPERTY_##NAME: \ |
606 | return "DW_APPLE_PROPERTY_" #NAME; |
607 | #include "llvm/BinaryFormat/Dwarf.def" |
608 | } |
609 | } |
610 | |
611 | StringRef llvm::dwarf::UnitTypeString(unsigned UT) { |
612 | switch (UT) { |
613 | default: |
614 | return StringRef(); |
615 | #define HANDLE_DW_UT(ID, NAME) \ |
616 | case DW_UT_##NAME: \ |
617 | return "DW_UT_" #NAME; |
618 | #include "llvm/BinaryFormat/Dwarf.def" |
619 | } |
620 | } |
621 | |
622 | StringRef llvm::dwarf::AtomTypeString(unsigned AT) { |
623 | switch (AT) { |
624 | case dwarf::DW_ATOM_null: |
625 | return "DW_ATOM_null" ; |
626 | case dwarf::DW_ATOM_die_offset: |
627 | return "DW_ATOM_die_offset" ; |
628 | case DW_ATOM_cu_offset: |
629 | return "DW_ATOM_cu_offset" ; |
630 | case DW_ATOM_die_tag: |
631 | return "DW_ATOM_die_tag" ; |
632 | case DW_ATOM_type_flags: |
633 | case DW_ATOM_type_type_flags: |
634 | return "DW_ATOM_type_flags" ; |
635 | case DW_ATOM_qual_name_hash: |
636 | return "DW_ATOM_qual_name_hash" ; |
637 | } |
638 | return StringRef(); |
639 | } |
640 | |
641 | StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) { |
642 | switch (Kind) { |
643 | case GIEK_NONE: |
644 | return "NONE" ; |
645 | case GIEK_TYPE: |
646 | return "TYPE" ; |
647 | case GIEK_VARIABLE: |
648 | return "VARIABLE" ; |
649 | case GIEK_FUNCTION: |
650 | return "FUNCTION" ; |
651 | case GIEK_OTHER: |
652 | return "OTHER" ; |
653 | case GIEK_UNUSED5: |
654 | return "UNUSED5" ; |
655 | case GIEK_UNUSED6: |
656 | return "UNUSED6" ; |
657 | case GIEK_UNUSED7: |
658 | return "UNUSED7" ; |
659 | } |
660 | llvm_unreachable("Unknown GDBIndexEntryKind value" ); |
661 | } |
662 | |
663 | StringRef |
664 | llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) { |
665 | switch (Linkage) { |
666 | case GIEL_EXTERNAL: |
667 | return "EXTERNAL" ; |
668 | case GIEL_STATIC: |
669 | return "STATIC" ; |
670 | } |
671 | llvm_unreachable("Unknown GDBIndexEntryLinkage value" ); |
672 | } |
673 | |
674 | StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) { |
675 | switch (Attr) { |
676 | case DW_AT_accessibility: |
677 | return AccessibilityString(Access: Val); |
678 | case DW_AT_virtuality: |
679 | return VirtualityString(Virtuality: Val); |
680 | case DW_AT_language: |
681 | return LanguageString(Language: Val); |
682 | case DW_AT_encoding: |
683 | return AttributeEncodingString(Encoding: Val); |
684 | case DW_AT_decimal_sign: |
685 | return DecimalSignString(Sign: Val); |
686 | case DW_AT_endianity: |
687 | return EndianityString(Endian: Val); |
688 | case DW_AT_visibility: |
689 | return VisibilityString(Visibility: Val); |
690 | case DW_AT_identifier_case: |
691 | return CaseString(Case: Val); |
692 | case DW_AT_calling_convention: |
693 | return ConventionString(CC: Val); |
694 | case DW_AT_inline: |
695 | return InlineCodeString(Code: Val); |
696 | case DW_AT_ordering: |
697 | return ArrayOrderString(Order: Val); |
698 | case DW_AT_APPLE_runtime_class: |
699 | return LanguageString(Language: Val); |
700 | case DW_AT_defaulted: |
701 | return DefaultedMemberString(DefaultedEncodings: Val); |
702 | } |
703 | |
704 | return StringRef(); |
705 | } |
706 | |
707 | StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) { |
708 | switch (Atom) { |
709 | case DW_ATOM_null: |
710 | return "NULL" ; |
711 | case DW_ATOM_die_tag: |
712 | return TagString(Tag: Val); |
713 | } |
714 | |
715 | return StringRef(); |
716 | } |
717 | |
718 | StringRef llvm::dwarf::IndexString(unsigned Idx) { |
719 | switch (Idx) { |
720 | default: |
721 | return StringRef(); |
722 | #define HANDLE_DW_IDX(ID, NAME) \ |
723 | case DW_IDX_##NAME: \ |
724 | return "DW_IDX_" #NAME; |
725 | #include "llvm/BinaryFormat/Dwarf.def" |
726 | } |
727 | } |
728 | |
729 | std::optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form, |
730 | FormParams Params) { |
731 | switch (Form) { |
732 | case DW_FORM_addr: |
733 | if (Params) |
734 | return Params.AddrSize; |
735 | return std::nullopt; |
736 | |
737 | case DW_FORM_block: // ULEB128 length L followed by L bytes. |
738 | case DW_FORM_block1: // 1 byte length L followed by L bytes. |
739 | case DW_FORM_block2: // 2 byte length L followed by L bytes. |
740 | case DW_FORM_block4: // 4 byte length L followed by L bytes. |
741 | case DW_FORM_string: // C-string with null terminator. |
742 | case DW_FORM_sdata: // SLEB128. |
743 | case DW_FORM_udata: // ULEB128. |
744 | case DW_FORM_ref_udata: // ULEB128. |
745 | case DW_FORM_indirect: // ULEB128. |
746 | case DW_FORM_exprloc: // ULEB128 length L followed by L bytes. |
747 | case DW_FORM_strx: // ULEB128. |
748 | case DW_FORM_addrx: // ULEB128. |
749 | case DW_FORM_loclistx: // ULEB128. |
750 | case DW_FORM_rnglistx: // ULEB128. |
751 | case DW_FORM_GNU_addr_index: // ULEB128. |
752 | case DW_FORM_GNU_str_index: // ULEB128. |
753 | return std::nullopt; |
754 | |
755 | case DW_FORM_ref_addr: |
756 | if (Params) |
757 | return Params.getRefAddrByteSize(); |
758 | return std::nullopt; |
759 | |
760 | case DW_FORM_flag: |
761 | case DW_FORM_data1: |
762 | case DW_FORM_ref1: |
763 | case DW_FORM_strx1: |
764 | case DW_FORM_addrx1: |
765 | return 1; |
766 | |
767 | case DW_FORM_data2: |
768 | case DW_FORM_ref2: |
769 | case DW_FORM_strx2: |
770 | case DW_FORM_addrx2: |
771 | return 2; |
772 | |
773 | case DW_FORM_strx3: |
774 | case DW_FORM_addrx3: |
775 | return 3; |
776 | |
777 | case DW_FORM_data4: |
778 | case DW_FORM_ref4: |
779 | case DW_FORM_ref_sup4: |
780 | case DW_FORM_strx4: |
781 | case DW_FORM_addrx4: |
782 | return 4; |
783 | |
784 | case DW_FORM_strp: |
785 | case DW_FORM_GNU_ref_alt: |
786 | case DW_FORM_GNU_strp_alt: |
787 | case DW_FORM_line_strp: |
788 | case DW_FORM_sec_offset: |
789 | case DW_FORM_strp_sup: |
790 | if (Params) |
791 | return Params.getDwarfOffsetByteSize(); |
792 | return std::nullopt; |
793 | |
794 | case DW_FORM_data8: |
795 | case DW_FORM_ref8: |
796 | case DW_FORM_ref_sig8: |
797 | case DW_FORM_ref_sup8: |
798 | return 8; |
799 | |
800 | case DW_FORM_flag_present: |
801 | return 0; |
802 | |
803 | case DW_FORM_data16: |
804 | return 16; |
805 | |
806 | case DW_FORM_implicit_const: |
807 | // The implicit value is stored in the abbreviation as a SLEB128, and |
808 | // there no data in debug info. |
809 | return 0; |
810 | |
811 | default: |
812 | break; |
813 | } |
814 | return std::nullopt; |
815 | } |
816 | |
817 | bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version, |
818 | bool ExtensionsOk) { |
819 | if (FormVendor(Form: F) == DWARF_VENDOR_DWARF) { |
820 | unsigned FV = FormVersion(Form: F); |
821 | return FV > 0 && FV <= Version; |
822 | } |
823 | return ExtensionsOk; |
824 | } |
825 | |
826 | StringRef llvm::dwarf::FormatString(DwarfFormat Format) { |
827 | switch (Format) { |
828 | case DWARF32: |
829 | return "DWARF32" ; |
830 | case DWARF64: |
831 | return "DWARF64" ; |
832 | } |
833 | return StringRef(); |
834 | } |
835 | |
836 | StringRef llvm::dwarf::FormatString(bool IsDWARF64) { |
837 | return FormatString(Format: IsDWARF64 ? DWARF64 : DWARF32); |
838 | } |
839 | |
840 | StringRef llvm::dwarf::RLEString(unsigned RLE) { |
841 | switch (RLE) { |
842 | default: |
843 | return StringRef(); |
844 | #define HANDLE_DW_RLE(ID, NAME) \ |
845 | case DW_RLE_##NAME: \ |
846 | return "DW_RLE_" #NAME; |
847 | #include "llvm/BinaryFormat/Dwarf.def" |
848 | } |
849 | } |
850 | |
851 | constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[]; |
852 | constexpr char llvm::dwarf::EnumTraits<Form>::Type[]; |
853 | constexpr char llvm::dwarf::EnumTraits<Index>::Type[]; |
854 | constexpr char llvm::dwarf::EnumTraits<Tag>::Type[]; |
855 | constexpr char llvm::dwarf::EnumTraits<LineNumberOps>::Type[]; |
856 | constexpr char llvm::dwarf::EnumTraits<LocationAtom>::Type[]; |
857 | |