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
18using namespace llvm;
19using namespace dwarf;
20
21StringRef 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
32unsigned 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
40unsigned 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
51unsigned 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
62StringRef 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
72StringRef 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
83unsigned 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
94unsigned 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
105StringRef 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
116unsigned 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
127unsigned 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
138StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
139 switch (Encoding) {
140 default:
141 return StringRef();
142#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, 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 case DW_OP_LLVM_extract_bits_sext:
159 return "DW_OP_LLVM_extract_bits_sext";
160 case DW_OP_LLVM_extract_bits_zext:
161 return "DW_OP_LLVM_extract_bits_zext";
162 }
163}
164
165unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
166 return StringSwitch<unsigned>(OperationEncodingString)
167#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \
168 .Case("DW_OP_" #NAME, DW_OP_##NAME)
169#include "llvm/BinaryFormat/Dwarf.def"
170 .Case(S: "DW_OP_LLVM_convert", Value: DW_OP_LLVM_convert)
171 .Case(S: "DW_OP_LLVM_fragment", Value: DW_OP_LLVM_fragment)
172 .Case(S: "DW_OP_LLVM_tag_offset", Value: DW_OP_LLVM_tag_offset)
173 .Case(S: "DW_OP_LLVM_entry_value", Value: DW_OP_LLVM_entry_value)
174 .Case(S: "DW_OP_LLVM_implicit_pointer", Value: DW_OP_LLVM_implicit_pointer)
175 .Case(S: "DW_OP_LLVM_arg", Value: DW_OP_LLVM_arg)
176 .Case(S: "DW_OP_LLVM_extract_bits_sext", Value: DW_OP_LLVM_extract_bits_sext)
177 .Case(S: "DW_OP_LLVM_extract_bits_zext", Value: DW_OP_LLVM_extract_bits_zext)
178 .Default(Value: 0);
179}
180
181static StringRef LlvmUserOperationEncodingString(unsigned Encoding) {
182 switch (Encoding) {
183 default:
184 llvm_unreachable("unhandled DWARF operation with LLVM user op");
185#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) \
186 case DW_OP_LLVM_##NAME: \
187 return "DW_OP_LLVM_" #NAME;
188#include "llvm/BinaryFormat/Dwarf.def"
189 }
190}
191
192static unsigned
193getLlvmUserOperationEncoding(StringRef LlvmUserOperationEncodingString) {
194 unsigned E = StringSwitch<unsigned>(LlvmUserOperationEncodingString)
195#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) .Case(#NAME, DW_OP_LLVM_##NAME)
196#include "llvm/BinaryFormat/Dwarf.def"
197 .Default(Value: 0);
198 assert(E && "unhandled DWARF operation string with LLVM user op");
199 return E;
200}
201
202StringRef llvm::dwarf::SubOperationEncodingString(unsigned OpEncoding,
203 unsigned SubOpEncoding) {
204 assert(OpEncoding == DW_OP_LLVM_user);
205 return LlvmUserOperationEncodingString(Encoding: SubOpEncoding);
206}
207
208unsigned
209llvm::dwarf::getSubOperationEncoding(unsigned OpEncoding,
210 StringRef SubOperationEncodingString) {
211 assert(OpEncoding == DW_OP_LLVM_user);
212 return getLlvmUserOperationEncoding(LlvmUserOperationEncodingString: SubOperationEncodingString);
213}
214
215unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
216 switch (Op) {
217 default:
218 return 0;
219#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \
220 case DW_OP_##NAME: \
221 return VERSION;
222#include "llvm/BinaryFormat/Dwarf.def"
223 }
224}
225
226std::optional<unsigned> llvm::dwarf::OperationOperands(dwarf::LocationAtom Op) {
227 switch (Op) {
228 default:
229 return std::nullopt;
230#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \
231 case DW_OP_##NAME: \
232 if (OPERANDS == -1) \
233 return std::nullopt; \
234 return OPERANDS;
235#include "llvm/BinaryFormat/Dwarf.def"
236 }
237}
238
239std::optional<unsigned> llvm::dwarf::OperationArity(dwarf::LocationAtom Op) {
240 switch (Op) {
241 default:
242 return std::nullopt;
243#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \
244 case DW_OP_##NAME: \
245 if (ARITY == -1) \
246 return std::nullopt; \
247 return ARITY;
248#include "llvm/BinaryFormat/Dwarf.def"
249 }
250}
251
252unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) {
253 switch (Op) {
254 default:
255 return 0;
256#define HANDLE_DW_OP(ID, NAME, OPERANDS, ARITY, VERSION, VENDOR) \
257 case DW_OP_##NAME: \
258 return DWARF_VENDOR_##VENDOR;
259#include "llvm/BinaryFormat/Dwarf.def"
260 }
261}
262
263StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) {
264 switch (Encoding) {
265 default:
266 return StringRef();
267#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
268 case DW_ATE_##NAME: \
269 return "DW_ATE_" #NAME;
270#include "llvm/BinaryFormat/Dwarf.def"
271 }
272}
273
274unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) {
275 return StringSwitch<unsigned>(EncodingString)
276#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
277 .Case("DW_ATE_" #NAME, DW_ATE_##NAME)
278#include "llvm/BinaryFormat/Dwarf.def"
279 .Default(Value: 0);
280}
281
282unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) {
283 switch (ATE) {
284 default:
285 return 0;
286#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
287 case DW_ATE_##NAME: \
288 return VERSION;
289#include "llvm/BinaryFormat/Dwarf.def"
290 }
291}
292
293unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) {
294 switch (ATE) {
295 default:
296 return 0;
297#define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) \
298 case DW_ATE_##NAME: \
299 return DWARF_VENDOR_##VENDOR;
300#include "llvm/BinaryFormat/Dwarf.def"
301 }
302}
303
304StringRef llvm::dwarf::DecimalSignString(unsigned Sign) {
305 switch (Sign) {
306 case DW_DS_unsigned:
307 return "DW_DS_unsigned";
308 case DW_DS_leading_overpunch:
309 return "DW_DS_leading_overpunch";
310 case DW_DS_trailing_overpunch:
311 return "DW_DS_trailing_overpunch";
312 case DW_DS_leading_separate:
313 return "DW_DS_leading_separate";
314 case DW_DS_trailing_separate:
315 return "DW_DS_trailing_separate";
316 }
317 return StringRef();
318}
319
320StringRef llvm::dwarf::EndianityString(unsigned Endian) {
321 switch (Endian) {
322 case DW_END_default:
323 return "DW_END_default";
324 case DW_END_big:
325 return "DW_END_big";
326 case DW_END_little:
327 return "DW_END_little";
328 case DW_END_lo_user:
329 return "DW_END_lo_user";
330 case DW_END_hi_user:
331 return "DW_END_hi_user";
332 }
333 return StringRef();
334}
335
336StringRef llvm::dwarf::AccessibilityString(unsigned Access) {
337 switch (Access) {
338 // Accessibility codes
339 case DW_ACCESS_public:
340 return "DW_ACCESS_public";
341 case DW_ACCESS_protected:
342 return "DW_ACCESS_protected";
343 case DW_ACCESS_private:
344 return "DW_ACCESS_private";
345 }
346 return StringRef();
347}
348
349StringRef llvm::dwarf::DefaultedMemberString(unsigned DefaultedEncodings) {
350 switch (DefaultedEncodings) {
351 // Defaulted Member Encodings codes
352 case DW_DEFAULTED_no:
353 return "DW_DEFAULTED_no";
354 case DW_DEFAULTED_in_class:
355 return "DW_DEFAULTED_in_class";
356 case DW_DEFAULTED_out_of_class:
357 return "DW_DEFAULTED_out_of_class";
358 }
359 return StringRef();
360}
361
362StringRef llvm::dwarf::VisibilityString(unsigned Visibility) {
363 switch (Visibility) {
364 case DW_VIS_local:
365 return "DW_VIS_local";
366 case DW_VIS_exported:
367 return "DW_VIS_exported";
368 case DW_VIS_qualified:
369 return "DW_VIS_qualified";
370 }
371 return StringRef();
372}
373
374StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) {
375 switch (Virtuality) {
376 default:
377 return StringRef();
378#define HANDLE_DW_VIRTUALITY(ID, NAME) \
379 case DW_VIRTUALITY_##NAME: \
380 return "DW_VIRTUALITY_" #NAME;
381#include "llvm/BinaryFormat/Dwarf.def"
382 }
383}
384
385unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) {
386 return StringSwitch<unsigned>(VirtualityString)
387#define HANDLE_DW_VIRTUALITY(ID, NAME) \
388 .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME)
389#include "llvm/BinaryFormat/Dwarf.def"
390 .Default(Value: DW_VIRTUALITY_invalid);
391}
392
393StringRef llvm::dwarf::EnumKindString(unsigned EnumKind) {
394 switch (EnumKind) {
395 default:
396 return StringRef();
397#define HANDLE_DW_APPLE_ENUM_KIND(ID, NAME) \
398 case DW_APPLE_ENUM_KIND_##NAME: \
399 return "DW_APPLE_ENUM_KIND_" #NAME;
400#include "llvm/BinaryFormat/Dwarf.def"
401 }
402}
403
404unsigned llvm::dwarf::getEnumKind(StringRef EnumKindString) {
405 return StringSwitch<unsigned>(EnumKindString)
406#define HANDLE_DW_APPLE_ENUM_KIND(ID, NAME) \
407 .Case("DW_APPLE_ENUM_KIND_" #NAME, DW_APPLE_ENUM_KIND_##NAME)
408#include "llvm/BinaryFormat/Dwarf.def"
409 .Default(Value: DW_APPLE_ENUM_KIND_invalid);
410}
411
412StringRef llvm::dwarf::LanguageString(unsigned Language) {
413 switch (Language) {
414 default:
415 return StringRef();
416#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
417 case DW_LANG_##NAME: \
418 return "DW_LANG_" #NAME;
419#include "llvm/BinaryFormat/Dwarf.def"
420 }
421}
422
423unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
424 return StringSwitch<unsigned>(LanguageString)
425#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
426 .Case("DW_LANG_" #NAME, DW_LANG_##NAME)
427#include "llvm/BinaryFormat/Dwarf.def"
428 .Default(Value: 0);
429}
430
431unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) {
432 switch (Lang) {
433 default:
434 return 0;
435#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
436 case DW_LANG_##NAME: \
437 return VERSION;
438#include "llvm/BinaryFormat/Dwarf.def"
439 }
440}
441
442unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
443 switch (Lang) {
444 default:
445 return 0;
446#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
447 case DW_LANG_##NAME: \
448 return DWARF_VENDOR_##VENDOR;
449#include "llvm/BinaryFormat/Dwarf.def"
450 }
451}
452
453std::optional<unsigned>
454llvm::dwarf::LanguageLowerBound(dwarf::SourceLanguage Lang) {
455 switch (Lang) {
456 default:
457 return std::nullopt;
458#define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR) \
459 case DW_LANG_##NAME: \
460 return LOWER_BOUND;
461#include "llvm/BinaryFormat/Dwarf.def"
462 }
463}
464
465StringRef llvm::dwarf::LanguageDescription(dwarf::SourceLanguageName lname) {
466 switch (lname) {
467#define HANDLE_DW_LNAME(ID, NAME, DESC, LOWER_BOUND) \
468 case DW_LNAME_##NAME: \
469 return DESC;
470#include "llvm/BinaryFormat/Dwarf.def"
471 }
472 return "Unknown";
473}
474
475StringRef llvm::dwarf::LanguageDescription(dwarf::SourceLanguageName Name,
476 uint32_t Version) {
477 switch (Name) {
478 // YYYY
479 case DW_LNAME_Ada: {
480 if (Version <= 1983)
481 return "Ada 83";
482 if (Version <= 1995)
483 return "Ada 95";
484 if (Version <= 2005)
485 return "Ada 2005";
486 if (Version <= 2012)
487 return "Ada 2012";
488 } break;
489
490 case DW_LNAME_Cobol: {
491 if (Version <= 1974)
492 return "COBOL-74";
493 if (Version <= 1985)
494 return "COBOL-85";
495 } break;
496
497 case DW_LNAME_Fortran: {
498 if (Version <= 1977)
499 return "FORTRAN 77";
500 if (Version <= 1990)
501 return "FORTRAN 90";
502 if (Version <= 1995)
503 return "Fortran 95";
504 if (Version <= 2003)
505 return "Fortran 2003";
506 if (Version <= 2008)
507 return "Fortran 2008";
508 if (Version <= 2018)
509 return "Fortran 2018";
510 } break;
511
512 // YYYYMM
513 case DW_LNAME_C: {
514 if (Version == 0)
515 break;
516 if (Version <= 198912)
517 return "C89";
518 if (Version <= 199901)
519 return "C99";
520 if (Version <= 201112)
521 return "C11";
522 if (Version <= 201710)
523 return "C17";
524 } break;
525
526 case DW_LNAME_C_plus_plus: {
527 if (Version == 0)
528 break;
529 if (Version <= 199711)
530 return "C++98";
531 if (Version <= 200310)
532 return "C++03";
533 if (Version <= 201103)
534 return "C++11";
535 if (Version <= 201402)
536 return "C++14";
537 if (Version <= 201703)
538 return "C++17";
539 if (Version <= 202002)
540 return "C++20";
541 } break;
542
543 case DW_LNAME_ObjC_plus_plus:
544 case DW_LNAME_ObjC:
545 case DW_LNAME_Move:
546 case DW_LNAME_SYCL:
547 case DW_LNAME_BLISS:
548 case DW_LNAME_Crystal:
549 case DW_LNAME_D:
550 case DW_LNAME_Dylan:
551 case DW_LNAME_Go:
552 case DW_LNAME_Haskell:
553 case DW_LNAME_HIP:
554 case DW_LNAME_HLSL:
555 case DW_LNAME_Java:
556 case DW_LNAME_Julia:
557 case DW_LNAME_Kotlin:
558 case DW_LNAME_Modula2:
559 case DW_LNAME_Modula3:
560 case DW_LNAME_OCaml:
561 case DW_LNAME_OpenCL_C:
562 case DW_LNAME_Pascal:
563 case DW_LNAME_PLI:
564 case DW_LNAME_Python:
565 case DW_LNAME_RenderScript:
566 case DW_LNAME_Rust:
567 case DW_LNAME_Swift:
568 case DW_LNAME_UPC:
569 case DW_LNAME_Zig:
570 case DW_LNAME_Assembly:
571 case DW_LNAME_C_sharp:
572 case DW_LNAME_Mojo:
573 case DW_LNAME_GLSL:
574 case DW_LNAME_GLSL_ES:
575 case DW_LNAME_OpenCL_CPP:
576 case DW_LNAME_CPP_for_OpenCL:
577 case DW_LNAME_Ruby:
578 case DW_LNAME_Hylo:
579 case DW_LNAME_Metal:
580 break;
581 }
582
583 // Fallback to un-versioned name.
584 return LanguageDescription(lname: Name);
585}
586
587llvm::StringRef llvm::dwarf::SourceLanguageNameString(SourceLanguageName Lang) {
588 switch (Lang) {
589#define HANDLE_DW_LNAME(ID, NAME, DESC, LOWER_BOUND) \
590 case DW_LNAME_##NAME: \
591 return "DW_LNAME_" #NAME;
592#include "llvm/BinaryFormat/Dwarf.def"
593 }
594
595 return {};
596}
597
598unsigned
599llvm::dwarf::getSourceLanguageName(StringRef SourceLanguageNameString) {
600 return StringSwitch<unsigned>(SourceLanguageNameString)
601#define HANDLE_DW_LNAME(ID, NAME, DESC, LOWER_BOUND) \
602 .Case("DW_LNAME_" #NAME, DW_LNAME_##NAME)
603#include "llvm/BinaryFormat/Dwarf.def"
604 .Default(Value: 0);
605}
606
607StringRef llvm::dwarf::CaseString(unsigned Case) {
608 switch (Case) {
609 case DW_ID_case_sensitive:
610 return "DW_ID_case_sensitive";
611 case DW_ID_up_case:
612 return "DW_ID_up_case";
613 case DW_ID_down_case:
614 return "DW_ID_down_case";
615 case DW_ID_case_insensitive:
616 return "DW_ID_case_insensitive";
617 }
618 return StringRef();
619}
620
621StringRef llvm::dwarf::ConventionString(unsigned CC) {
622 switch (CC) {
623 default:
624 return StringRef();
625#define HANDLE_DW_CC(ID, NAME) \
626 case DW_CC_##NAME: \
627 return "DW_CC_" #NAME;
628#include "llvm/BinaryFormat/Dwarf.def"
629 }
630}
631
632unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
633 return StringSwitch<unsigned>(CCString)
634#define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)
635#include "llvm/BinaryFormat/Dwarf.def"
636 .Default(Value: 0);
637}
638
639StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
640 switch (Code) {
641 case DW_INL_not_inlined:
642 return "DW_INL_not_inlined";
643 case DW_INL_inlined:
644 return "DW_INL_inlined";
645 case DW_INL_declared_not_inlined:
646 return "DW_INL_declared_not_inlined";
647 case DW_INL_declared_inlined:
648 return "DW_INL_declared_inlined";
649 }
650 return StringRef();
651}
652
653StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
654 switch (Order) {
655 case DW_ORD_row_major:
656 return "DW_ORD_row_major";
657 case DW_ORD_col_major:
658 return "DW_ORD_col_major";
659 }
660 return StringRef();
661}
662
663StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
664 switch (Standard) {
665 default:
666 return StringRef();
667#define HANDLE_DW_LNS(ID, NAME) \
668 case DW_LNS_##NAME: \
669 return "DW_LNS_" #NAME;
670#include "llvm/BinaryFormat/Dwarf.def"
671 }
672}
673
674StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
675 switch (Encoding) {
676 default:
677 return StringRef();
678#define HANDLE_DW_LNE(ID, NAME) \
679 case DW_LNE_##NAME: \
680 return "DW_LNE_" #NAME;
681#include "llvm/BinaryFormat/Dwarf.def"
682 }
683}
684
685StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
686 switch (Encoding) {
687 // Macinfo Type Encodings
688 case DW_MACINFO_define:
689 return "DW_MACINFO_define";
690 case DW_MACINFO_undef:
691 return "DW_MACINFO_undef";
692 case DW_MACINFO_start_file:
693 return "DW_MACINFO_start_file";
694 case DW_MACINFO_end_file:
695 return "DW_MACINFO_end_file";
696 case DW_MACINFO_vendor_ext:
697 return "DW_MACINFO_vendor_ext";
698 case DW_MACINFO_invalid:
699 return "DW_MACINFO_invalid";
700 }
701 return StringRef();
702}
703
704unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
705 return StringSwitch<unsigned>(MacinfoString)
706 .Case(S: "DW_MACINFO_define", Value: DW_MACINFO_define)
707 .Case(S: "DW_MACINFO_undef", Value: DW_MACINFO_undef)
708 .Case(S: "DW_MACINFO_start_file", Value: DW_MACINFO_start_file)
709 .Case(S: "DW_MACINFO_end_file", Value: DW_MACINFO_end_file)
710 .Case(S: "DW_MACINFO_vendor_ext", Value: DW_MACINFO_vendor_ext)
711 .Default(Value: DW_MACINFO_invalid);
712}
713
714StringRef llvm::dwarf::MacroString(unsigned Encoding) {
715 switch (Encoding) {
716 default:
717 return StringRef();
718#define HANDLE_DW_MACRO(ID, NAME) \
719 case DW_MACRO_##NAME: \
720 return "DW_MACRO_" #NAME;
721#include "llvm/BinaryFormat/Dwarf.def"
722 }
723}
724
725StringRef llvm::dwarf::GnuMacroString(unsigned Encoding) {
726 switch (Encoding) {
727 default:
728 return StringRef();
729#define HANDLE_DW_MACRO_GNU(ID, NAME) \
730 case DW_MACRO_GNU_##NAME: \
731 return "DW_MACRO_GNU_" #NAME;
732#include "llvm/BinaryFormat/Dwarf.def"
733 }
734}
735
736unsigned llvm::dwarf::getMacro(StringRef MacroString) {
737 return StringSwitch<unsigned>(MacroString)
738#define HANDLE_DW_MACRO(ID, NAME) .Case("DW_MACRO_" #NAME, ID)
739#include "llvm/BinaryFormat/Dwarf.def"
740 .Default(Value: DW_MACINFO_invalid);
741}
742StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
743 switch (Encoding) {
744 default:
745 return StringRef();
746#define HANDLE_DW_RLE(ID, NAME) \
747 case DW_RLE_##NAME: \
748 return "DW_RLE_" #NAME;
749#include "llvm/BinaryFormat/Dwarf.def"
750 }
751}
752
753StringRef llvm::dwarf::LocListEncodingString(unsigned Encoding) {
754 switch (Encoding) {
755 default:
756 return StringRef();
757#define HANDLE_DW_LLE(ID, NAME) \
758 case DW_LLE_##NAME: \
759 return "DW_LLE_" #NAME;
760#include "llvm/BinaryFormat/Dwarf.def"
761 }
762}
763
764StringRef llvm::dwarf::CallFrameString(unsigned Encoding,
765 Triple::ArchType Arch) {
766 assert(Arch != llvm::Triple::ArchType::UnknownArch);
767#define SELECT_AARCH64 (Arch == llvm::Triple::aarch64_be || Arch == llvm::Triple::aarch64)
768#define SELECT_MIPS64 Arch == llvm::Triple::mips64
769#define SELECT_SPARC (Arch == llvm::Triple::sparc || Arch == llvm::Triple::sparcv9)
770#define SELECT_X86 (Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64)
771#define HANDLE_DW_CFA(ID, NAME)
772#define HANDLE_DW_CFA_PRED(ID, NAME, PRED) \
773 if (ID == Encoding && PRED) \
774 return "DW_CFA_" #NAME;
775#include "llvm/BinaryFormat/Dwarf.def"
776
777 switch (Encoding) {
778 default:
779 return StringRef();
780#define HANDLE_DW_CFA_PRED(ID, NAME, PRED)
781#define HANDLE_DW_CFA(ID, NAME) \
782 case DW_CFA_##NAME: \
783 return "DW_CFA_" #NAME;
784#include "llvm/BinaryFormat/Dwarf.def"
785
786#undef SELECT_X86
787#undef SELECT_SPARC
788#undef SELECT_MIPS64
789#undef SELECT_AARCH64
790 }
791}
792
793StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
794 switch (Prop) {
795 default:
796 return StringRef();
797#define HANDLE_DW_APPLE_PROPERTY(ID, NAME) \
798 case DW_APPLE_PROPERTY_##NAME: \
799 return "DW_APPLE_PROPERTY_" #NAME;
800#include "llvm/BinaryFormat/Dwarf.def"
801 }
802}
803
804StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
805 switch (UT) {
806 default:
807 return StringRef();
808#define HANDLE_DW_UT(ID, NAME) \
809 case DW_UT_##NAME: \
810 return "DW_UT_" #NAME;
811#include "llvm/BinaryFormat/Dwarf.def"
812 }
813}
814
815StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
816 switch (AT) {
817 case dwarf::DW_ATOM_null:
818 return "DW_ATOM_null";
819 case dwarf::DW_ATOM_die_offset:
820 return "DW_ATOM_die_offset";
821 case DW_ATOM_cu_offset:
822 return "DW_ATOM_cu_offset";
823 case DW_ATOM_die_tag:
824 return "DW_ATOM_die_tag";
825 case DW_ATOM_type_flags:
826 case DW_ATOM_type_type_flags:
827 return "DW_ATOM_type_flags";
828 case DW_ATOM_qual_name_hash:
829 return "DW_ATOM_qual_name_hash";
830 }
831 return StringRef();
832}
833
834StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
835 switch (Kind) {
836 case GIEK_NONE:
837 return "NONE";
838 case GIEK_TYPE:
839 return "TYPE";
840 case GIEK_VARIABLE:
841 return "VARIABLE";
842 case GIEK_FUNCTION:
843 return "FUNCTION";
844 case GIEK_OTHER:
845 return "OTHER";
846 case GIEK_UNUSED5:
847 return "UNUSED5";
848 case GIEK_UNUSED6:
849 return "UNUSED6";
850 case GIEK_UNUSED7:
851 return "UNUSED7";
852 }
853 llvm_unreachable("Unknown GDBIndexEntryKind value");
854}
855
856StringRef
857llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
858 switch (Linkage) {
859 case GIEL_EXTERNAL:
860 return "EXTERNAL";
861 case GIEL_STATIC:
862 return "STATIC";
863 }
864 llvm_unreachable("Unknown GDBIndexEntryLinkage value");
865}
866
867StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
868 switch (Attr) {
869 case DW_AT_accessibility:
870 return AccessibilityString(Access: Val);
871 case DW_AT_virtuality:
872 return VirtualityString(Virtuality: Val);
873 case DW_AT_language:
874 return LanguageString(Language: Val);
875 case DW_AT_encoding:
876 return AttributeEncodingString(Encoding: Val);
877 case DW_AT_decimal_sign:
878 return DecimalSignString(Sign: Val);
879 case DW_AT_endianity:
880 return EndianityString(Endian: Val);
881 case DW_AT_visibility:
882 return VisibilityString(Visibility: Val);
883 case DW_AT_identifier_case:
884 return CaseString(Case: Val);
885 case DW_AT_calling_convention:
886 return ConventionString(CC: Val);
887 case DW_AT_inline:
888 return InlineCodeString(Code: Val);
889 case DW_AT_ordering:
890 return ArrayOrderString(Order: Val);
891 case DW_AT_APPLE_runtime_class:
892 return LanguageString(Language: Val);
893 case DW_AT_defaulted:
894 return DefaultedMemberString(DefaultedEncodings: Val);
895 case DW_AT_APPLE_enum_kind:
896 return EnumKindString(EnumKind: Val);
897 case DW_AT_language_name:
898 return SourceLanguageNameString(Lang: static_cast<SourceLanguageName>(Val));
899 }
900
901 return StringRef();
902}
903
904StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) {
905 switch (Atom) {
906 case DW_ATOM_null:
907 return "NULL";
908 case DW_ATOM_die_tag:
909 return TagString(Tag: Val);
910 }
911
912 return StringRef();
913}
914
915StringRef llvm::dwarf::IndexString(unsigned Idx) {
916 switch (Idx) {
917 default:
918 return StringRef();
919#define HANDLE_DW_IDX(ID, NAME) \
920 case DW_IDX_##NAME: \
921 return "DW_IDX_" #NAME;
922#include "llvm/BinaryFormat/Dwarf.def"
923 }
924}
925
926std::optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
927 FormParams Params) {
928 switch (Form) {
929 case DW_FORM_addr:
930 if (Params)
931 return Params.AddrSize;
932 return std::nullopt;
933
934 case DW_FORM_block: // ULEB128 length L followed by L bytes.
935 case DW_FORM_block1: // 1 byte length L followed by L bytes.
936 case DW_FORM_block2: // 2 byte length L followed by L bytes.
937 case DW_FORM_block4: // 4 byte length L followed by L bytes.
938 case DW_FORM_string: // C-string with null terminator.
939 case DW_FORM_sdata: // SLEB128.
940 case DW_FORM_udata: // ULEB128.
941 case DW_FORM_ref_udata: // ULEB128.
942 case DW_FORM_indirect: // ULEB128.
943 case DW_FORM_exprloc: // ULEB128 length L followed by L bytes.
944 case DW_FORM_strx: // ULEB128.
945 case DW_FORM_addrx: // ULEB128.
946 case DW_FORM_loclistx: // ULEB128.
947 case DW_FORM_rnglistx: // ULEB128.
948 case DW_FORM_GNU_addr_index: // ULEB128.
949 case DW_FORM_GNU_str_index: // ULEB128.
950 return std::nullopt;
951
952 case DW_FORM_ref_addr:
953 if (Params)
954 return Params.getRefAddrByteSize();
955 return std::nullopt;
956
957 case DW_FORM_flag:
958 case DW_FORM_data1:
959 case DW_FORM_ref1:
960 case DW_FORM_strx1:
961 case DW_FORM_addrx1:
962 return 1;
963
964 case DW_FORM_data2:
965 case DW_FORM_ref2:
966 case DW_FORM_strx2:
967 case DW_FORM_addrx2:
968 return 2;
969
970 case DW_FORM_strx3:
971 case DW_FORM_addrx3:
972 return 3;
973
974 case DW_FORM_data4:
975 case DW_FORM_ref4:
976 case DW_FORM_ref_sup4:
977 case DW_FORM_strx4:
978 case DW_FORM_addrx4:
979 return 4;
980
981 case DW_FORM_strp:
982 case DW_FORM_GNU_ref_alt:
983 case DW_FORM_GNU_strp_alt:
984 case DW_FORM_line_strp:
985 case DW_FORM_sec_offset:
986 case DW_FORM_strp_sup:
987 if (Params)
988 return Params.getDwarfOffsetByteSize();
989 return std::nullopt;
990
991 case DW_FORM_data8:
992 case DW_FORM_ref8:
993 case DW_FORM_ref_sig8:
994 case DW_FORM_ref_sup8:
995 return 8;
996
997 case DW_FORM_flag_present:
998 return 0;
999
1000 case DW_FORM_data16:
1001 return 16;
1002
1003 case DW_FORM_implicit_const:
1004 // The implicit value is stored in the abbreviation as a SLEB128, and
1005 // there no data in debug info.
1006 return 0;
1007
1008 default:
1009 break;
1010 }
1011 return std::nullopt;
1012}
1013
1014bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
1015 bool ExtensionsOk) {
1016 if (FormVendor(Form: F) == DWARF_VENDOR_DWARF) {
1017 unsigned FV = FormVersion(Form: F);
1018 return FV > 0 && FV <= Version;
1019 }
1020 return ExtensionsOk;
1021}
1022
1023StringRef llvm::dwarf::FormatString(DwarfFormat Format) {
1024 switch (Format) {
1025 case DWARF32:
1026 return "DWARF32";
1027 case DWARF64:
1028 return "DWARF64";
1029 }
1030 return StringRef();
1031}
1032
1033StringRef llvm::dwarf::FormatString(bool IsDWARF64) {
1034 return FormatString(Format: IsDWARF64 ? DWARF64 : DWARF32);
1035}
1036
1037StringRef llvm::dwarf::RLEString(unsigned RLE) {
1038 switch (RLE) {
1039 default:
1040 return StringRef();
1041#define HANDLE_DW_RLE(ID, NAME) \
1042 case DW_RLE_##NAME: \
1043 return "DW_RLE_" #NAME;
1044#include "llvm/BinaryFormat/Dwarf.def"
1045 }
1046}
1047
1048StringRef llvm::dwarf::AddressSpaceString(unsigned AS, const llvm::Triple &TT) {
1049 switch (AS) {
1050#define HANDLE_DW_ASPACE(ID, NAME) \
1051 case DW_ASPACE_LLVM_##NAME: \
1052 return "DW_ASPACE_LLVM_" #NAME;
1053#define HANDLE_DW_ASPACE_PRED(ID, NAME, PRED)
1054#include "llvm/BinaryFormat/Dwarf.def"
1055 default:
1056 break;
1057 }
1058
1059 bool SELECT_AMDGPU = TT.isAMDGPU();
1060#define HANDLE_DW_ASPACE(ID, NAME)
1061#define HANDLE_DW_ASPACE_PRED(ID, NAME, PRED) \
1062 if (DW_ASPACE_LLVM_##NAME == AS && PRED) \
1063 return "DW_ASPACE_LLVM_" #NAME;
1064#include "llvm/BinaryFormat/Dwarf.def"
1065
1066 return "";
1067}
1068
1069StringRef (*const llvm::dwarf::EnumTraits<Tag>::StringFn)(unsigned) = TagString;
1070StringRef (*const llvm::dwarf::EnumTraits<Attribute>::StringFn)(unsigned) =
1071 AttributeString;
1072StringRef (*const llvm::dwarf::EnumTraits<Form>::StringFn)(unsigned) =
1073 FormEncodingString;
1074StringRef (*const llvm::dwarf::EnumTraits<LocationAtom>::StringFn)(unsigned) =
1075 OperationEncodingString;
1076StringRef (*const llvm::dwarf::EnumTraits<LineNumberOps>::StringFn)(unsigned) =
1077 LNStandardString;
1078StringRef (*const llvm::dwarf::EnumTraits<Index>::StringFn)(unsigned) =
1079 IndexString;
1080