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
TagString(unsigned Tag)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
getTag(StringRef TagString)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(DW_TAG_invalid);
38 }
39
TagVersion(dwarf::Tag Tag)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
TagVendor(dwarf::Tag Tag)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
ChildrenString(unsigned Children)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
AttributeString(unsigned Attribute)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
AttributeVersion(dwarf::Attribute Attribute)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
AttributeVendor(dwarf::Attribute Attribute)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
FormEncodingString(unsigned Encoding)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
FormVersion(dwarf::Form Form)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
FormVendor(dwarf::Form Form)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
OperationEncodingString(unsigned Encoding)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
getOperationEncoding(StringRef OperationEncodingString)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("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
167 .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
168 .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
169 .Case("DW_OP_LLVM_entry_value", DW_OP_LLVM_entry_value)
170 .Case("DW_OP_LLVM_implicit_pointer", DW_OP_LLVM_implicit_pointer)
171 .Case("DW_OP_LLVM_arg", DW_OP_LLVM_arg)
172 .Default(0);
173 }
174
LlvmUserOperationEncodingString(unsigned Encoding)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
getLlvmUserOperationEncoding(StringRef LlvmUserOperationEncodingString)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(0);
192 assert(E && "unhandled DWARF operation string with LLVM user op");
193 return E;
194 }
195
SubOperationEncodingString(unsigned OpEncoding,unsigned SubOpEncoding)196 StringRef llvm::dwarf::SubOperationEncodingString(unsigned OpEncoding,
197 unsigned SubOpEncoding) {
198 assert(OpEncoding == DW_OP_LLVM_user);
199 return LlvmUserOperationEncodingString(SubOpEncoding);
200 }
201
202 unsigned
getSubOperationEncoding(unsigned OpEncoding,StringRef SubOperationEncodingString)203 llvm::dwarf::getSubOperationEncoding(unsigned OpEncoding,
204 StringRef SubOperationEncodingString) {
205 assert(OpEncoding == DW_OP_LLVM_user);
206 return getLlvmUserOperationEncoding(SubOperationEncodingString);
207 }
208
OperationVersion(dwarf::LocationAtom Op)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
OperationVendor(dwarf::LocationAtom Op)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
AttributeEncodingString(unsigned Encoding)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
getAttributeEncoding(StringRef EncodingString)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(0);
248 }
249
AttributeEncodingVersion(dwarf::TypeKind ATE)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
AttributeEncodingVendor(dwarf::TypeKind ATE)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
DecimalSignString(unsigned Sign)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
EndianityString(unsigned Endian)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
AccessibilityString(unsigned Access)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
DefaultedMemberString(unsigned DefaultedEncodings)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
VisibilityString(unsigned Visibility)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
VirtualityString(unsigned Virtuality)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
getVirtuality(StringRef VirtualityString)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(DW_VIRTUALITY_invalid);
359 }
360
LanguageString(unsigned Language)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
getLanguage(StringRef LanguageString)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(0);
378 }
379
LanguageVersion(dwarf::SourceLanguage Lang)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
LanguageVendor(dwarf::SourceLanguage Lang)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>
LanguageLowerBound(dwarf::SourceLanguage Lang)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
CaseString(unsigned Case)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
ConventionString(unsigned CC)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
getCallingConvention(StringRef CCString)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(0);
444 }
445
InlineCodeString(unsigned Code)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
ArrayOrderString(unsigned Order)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
LNStandardString(unsigned Standard)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
LNExtendedString(unsigned Encoding)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
MacinfoString(unsigned Encoding)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
getMacinfo(StringRef MacinfoString)511 unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
512 return StringSwitch<unsigned>(MacinfoString)
513 .Case("DW_MACINFO_define", DW_MACINFO_define)
514 .Case("DW_MACINFO_undef", DW_MACINFO_undef)
515 .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
516 .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
517 .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
518 .Default(DW_MACINFO_invalid);
519 }
520
MacroString(unsigned Encoding)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
GnuMacroString(unsigned Encoding)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
getMacro(StringRef MacroString)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(DW_MACINFO_invalid);
548 }
RangeListEncodingString(unsigned Encoding)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
LocListEncodingString(unsigned Encoding)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
CallFrameString(unsigned Encoding,Triple::ArchType Arch)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
ApplePropertyString(unsigned Prop)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
UnitTypeString(unsigned UT)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
AtomTypeString(unsigned AT)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
GDBIndexEntryKindString(GDBIndexEntryKind Kind)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
GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)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
AttributeValueString(uint16_t Attr,unsigned Val)674 StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
675 switch (Attr) {
676 case DW_AT_accessibility:
677 return AccessibilityString(Val);
678 case DW_AT_virtuality:
679 return VirtualityString(Val);
680 case DW_AT_language:
681 return LanguageString(Val);
682 case DW_AT_encoding:
683 return AttributeEncodingString(Val);
684 case DW_AT_decimal_sign:
685 return DecimalSignString(Val);
686 case DW_AT_endianity:
687 return EndianityString(Val);
688 case DW_AT_visibility:
689 return VisibilityString(Val);
690 case DW_AT_identifier_case:
691 return CaseString(Val);
692 case DW_AT_calling_convention:
693 return ConventionString(Val);
694 case DW_AT_inline:
695 return InlineCodeString(Val);
696 case DW_AT_ordering:
697 return ArrayOrderString(Val);
698 case DW_AT_APPLE_runtime_class:
699 return LanguageString(Val);
700 case DW_AT_defaulted:
701 return DefaultedMemberString(Val);
702 }
703
704 return StringRef();
705 }
706
AtomValueString(uint16_t Atom,unsigned Val)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(Val);
713 }
714
715 return StringRef();
716 }
717
IndexString(unsigned Idx)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
getFixedFormByteSize(dwarf::Form Form,FormParams Params)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
isValidFormForVersion(Form F,unsigned Version,bool ExtensionsOk)817 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
818 bool ExtensionsOk) {
819 if (FormVendor(F) == DWARF_VENDOR_DWARF) {
820 unsigned FV = FormVersion(F);
821 return FV > 0 && FV <= Version;
822 }
823 return ExtensionsOk;
824 }
825
FormatString(DwarfFormat Format)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
FormatString(bool IsDWARF64)836 StringRef llvm::dwarf::FormatString(bool IsDWARF64) {
837 return FormatString(IsDWARF64 ? DWARF64 : DWARF32);
838 }
839
RLEString(unsigned RLE)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