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