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(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("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 
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(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(SubOpEncoding);
200 }
201 
202 unsigned
203 llvm::dwarf::getSubOperationEncoding(unsigned OpEncoding,
204                                      StringRef SubOperationEncodingString) {
205   assert(OpEncoding == DW_OP_LLVM_user);
206   return getLlvmUserOperationEncoding(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(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(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(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(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("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 
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(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(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 
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 
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(F) == DWARF_VENDOR_DWARF) {
820     unsigned FV = FormVersion(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(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