• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- llvm/BinaryFormat/Dwarf.cpp - Dwarf Framework ------------*- C++-*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains support for generic dwarf information.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/BinaryFormat/Dwarf.h"
15 #include "llvm/ADT/StringSwitch.h"
16 #include "llvm/Support/ErrorHandling.h"
17 
18 using namespace llvm;
19 using namespace dwarf;
20 
TagString(unsigned Tag)21 StringRef llvm::dwarf::TagString(unsigned Tag) {
22   switch (Tag) {
23   default:
24     return StringRef();
25 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
26   case DW_TAG_##NAME:                                                          \
27     return "DW_TAG_" #NAME;
28 #include "llvm/BinaryFormat/Dwarf.def"
29   }
30 }
31 
getTag(StringRef TagString)32 unsigned llvm::dwarf::getTag(StringRef TagString) {
33   return StringSwitch<unsigned>(TagString)
34 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
35   .Case("DW_TAG_" #NAME, DW_TAG_##NAME)
36 #include "llvm/BinaryFormat/Dwarf.def"
37       .Default(DW_TAG_invalid);
38 }
39 
TagVersion(dwarf::Tag Tag)40 unsigned llvm::dwarf::TagVersion(dwarf::Tag Tag) {
41   switch (Tag) {
42   default:
43     return 0;
44 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
45   case DW_TAG_##NAME:                                                          \
46     return VERSION;
47 #include "llvm/BinaryFormat/Dwarf.def"
48   }
49 }
50 
TagVendor(dwarf::Tag Tag)51 unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) {
52   switch (Tag) {
53   default:
54     return 0;
55 #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
56   case DW_TAG_##NAME:                                                          \
57     return DWARF_VENDOR_##VENDOR;
58 #include "llvm/BinaryFormat/Dwarf.def"
59   }
60 }
61 
ChildrenString(unsigned Children)62 StringRef llvm::dwarf::ChildrenString(unsigned Children) {
63   switch (Children) {
64   case DW_CHILDREN_no:
65     return "DW_CHILDREN_no";
66   case DW_CHILDREN_yes:
67     return "DW_CHILDREN_yes";
68   }
69   return StringRef();
70 }
71 
AttributeString(unsigned Attribute)72 StringRef llvm::dwarf::AttributeString(unsigned Attribute) {
73   switch (Attribute) {
74   default:
75     return StringRef();
76 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)                                \
77   case DW_AT_##NAME:                                                           \
78     return "DW_AT_" #NAME;
79 #include "llvm/BinaryFormat/Dwarf.def"
80   }
81 }
82 
AttributeVersion(dwarf::Attribute Attribute)83 unsigned llvm::dwarf::AttributeVersion(dwarf::Attribute Attribute) {
84   switch (Attribute) {
85   default:
86     return 0;
87 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)                                \
88   case DW_AT_##NAME:                                                           \
89     return VERSION;
90 #include "llvm/BinaryFormat/Dwarf.def"
91   }
92 }
93 
AttributeVendor(dwarf::Attribute Attribute)94 unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) {
95   switch (Attribute) {
96   default:
97     return 0;
98 #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)                                \
99   case DW_AT_##NAME:                                                           \
100     return DWARF_VENDOR_##VENDOR;
101 #include "llvm/BinaryFormat/Dwarf.def"
102   }
103 }
104 
FormEncodingString(unsigned Encoding)105 StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) {
106   switch (Encoding) {
107   default:
108     return StringRef();
109 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)                              \
110   case DW_FORM_##NAME:                                                         \
111     return "DW_FORM_" #NAME;
112 #include "llvm/BinaryFormat/Dwarf.def"
113   }
114 }
115 
FormVersion(dwarf::Form Form)116 unsigned llvm::dwarf::FormVersion(dwarf::Form Form) {
117   switch (Form) {
118   default:
119     return 0;
120 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)                              \
121   case DW_FORM_##NAME:                                                         \
122     return VERSION;
123 #include "llvm/BinaryFormat/Dwarf.def"
124   }
125 }
126 
FormVendor(dwarf::Form Form)127 unsigned llvm::dwarf::FormVendor(dwarf::Form Form) {
128   switch (Form) {
129   default:
130     return 0;
131 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)                              \
132   case DW_FORM_##NAME:                                                         \
133     return DWARF_VENDOR_##VENDOR;
134 #include "llvm/BinaryFormat/Dwarf.def"
135   }
136 }
137 
OperationEncodingString(unsigned Encoding)138 StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
139   switch (Encoding) {
140   default:
141     return StringRef();
142 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
143   case DW_OP_##NAME:                                                           \
144     return "DW_OP_" #NAME;
145 #include "llvm/BinaryFormat/Dwarf.def"
146   case DW_OP_LLVM_fragment:
147     return "DW_OP_LLVM_fragment";
148   }
149 }
150 
getOperationEncoding(StringRef OperationEncodingString)151 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
152   return StringSwitch<unsigned>(OperationEncodingString)
153 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
154   .Case("DW_OP_" #NAME, DW_OP_##NAME)
155 #include "llvm/BinaryFormat/Dwarf.def"
156       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
157       .Default(0);
158 }
159 
OperationVersion(dwarf::LocationAtom Op)160 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
161   switch (Op) {
162   default:
163     return 0;
164 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
165   case DW_OP_##NAME:                                                           \
166     return VERSION;
167 #include "llvm/BinaryFormat/Dwarf.def"
168   }
169 }
170 
OperationVendor(dwarf::LocationAtom Op)171 unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) {
172   switch (Op) {
173   default:
174     return 0;
175 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
176   case DW_OP_##NAME:                                                           \
177     return DWARF_VENDOR_##VENDOR;
178 #include "llvm/BinaryFormat/Dwarf.def"
179   }
180 }
181 
AttributeEncodingString(unsigned Encoding)182 StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) {
183   switch (Encoding) {
184   default:
185     return StringRef();
186 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
187   case DW_ATE_##NAME:                                                          \
188     return "DW_ATE_" #NAME;
189 #include "llvm/BinaryFormat/Dwarf.def"
190   }
191 }
192 
getAttributeEncoding(StringRef EncodingString)193 unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) {
194   return StringSwitch<unsigned>(EncodingString)
195 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
196   .Case("DW_ATE_" #NAME, DW_ATE_##NAME)
197 #include "llvm/BinaryFormat/Dwarf.def"
198       .Default(0);
199 }
200 
AttributeEncodingVersion(dwarf::TypeKind ATE)201 unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) {
202   switch (ATE) {
203   default:
204     return 0;
205 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
206   case DW_ATE_##NAME:                                                          \
207     return VERSION;
208 #include "llvm/BinaryFormat/Dwarf.def"
209   }
210 }
211 
AttributeEncodingVendor(dwarf::TypeKind ATE)212 unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) {
213   switch (ATE) {
214   default:
215     return 0;
216 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
217   case DW_ATE_##NAME:                                                          \
218     return DWARF_VENDOR_##VENDOR;
219 #include "llvm/BinaryFormat/Dwarf.def"
220   }
221 }
222 
DecimalSignString(unsigned Sign)223 StringRef llvm::dwarf::DecimalSignString(unsigned Sign) {
224   switch (Sign) {
225   case DW_DS_unsigned:
226     return "DW_DS_unsigned";
227   case DW_DS_leading_overpunch:
228     return "DW_DS_leading_overpunch";
229   case DW_DS_trailing_overpunch:
230     return "DW_DS_trailing_overpunch";
231   case DW_DS_leading_separate:
232     return "DW_DS_leading_separate";
233   case DW_DS_trailing_separate:
234     return "DW_DS_trailing_separate";
235   }
236   return StringRef();
237 }
238 
EndianityString(unsigned Endian)239 StringRef llvm::dwarf::EndianityString(unsigned Endian) {
240   switch (Endian) {
241   case DW_END_default:
242     return "DW_END_default";
243   case DW_END_big:
244     return "DW_END_big";
245   case DW_END_little:
246     return "DW_END_little";
247   case DW_END_lo_user:
248     return "DW_END_lo_user";
249   case DW_END_hi_user:
250     return "DW_END_hi_user";
251   }
252   return StringRef();
253 }
254 
AccessibilityString(unsigned Access)255 StringRef llvm::dwarf::AccessibilityString(unsigned Access) {
256   switch (Access) {
257   // Accessibility codes
258   case DW_ACCESS_public:
259     return "DW_ACCESS_public";
260   case DW_ACCESS_protected:
261     return "DW_ACCESS_protected";
262   case DW_ACCESS_private:
263     return "DW_ACCESS_private";
264   }
265   return StringRef();
266 }
267 
VisibilityString(unsigned Visibility)268 StringRef llvm::dwarf::VisibilityString(unsigned Visibility) {
269   switch (Visibility) {
270   case DW_VIS_local:
271     return "DW_VIS_local";
272   case DW_VIS_exported:
273     return "DW_VIS_exported";
274   case DW_VIS_qualified:
275     return "DW_VIS_qualified";
276   }
277   return StringRef();
278 }
279 
VirtualityString(unsigned Virtuality)280 StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) {
281   switch (Virtuality) {
282   default:
283     return StringRef();
284 #define HANDLE_DW_VIRTUALITY(ID, NAME)                                         \
285   case DW_VIRTUALITY_##NAME:                                                   \
286     return "DW_VIRTUALITY_" #NAME;
287 #include "llvm/BinaryFormat/Dwarf.def"
288   }
289 }
290 
getVirtuality(StringRef VirtualityString)291 unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) {
292   return StringSwitch<unsigned>(VirtualityString)
293 #define HANDLE_DW_VIRTUALITY(ID, NAME)                                         \
294   .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME)
295 #include "llvm/BinaryFormat/Dwarf.def"
296       .Default(DW_VIRTUALITY_invalid);
297 }
298 
LanguageString(unsigned Language)299 StringRef llvm::dwarf::LanguageString(unsigned Language) {
300   switch (Language) {
301   default:
302     return StringRef();
303 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
304   case DW_LANG_##NAME:                                                         \
305     return "DW_LANG_" #NAME;
306 #include "llvm/BinaryFormat/Dwarf.def"
307   }
308 }
309 
getLanguage(StringRef LanguageString)310 unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
311   return StringSwitch<unsigned>(LanguageString)
312 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
313   .Case("DW_LANG_" #NAME, DW_LANG_##NAME)
314 #include "llvm/BinaryFormat/Dwarf.def"
315       .Default(0);
316 }
317 
LanguageVersion(dwarf::SourceLanguage Lang)318 unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) {
319   switch (Lang) {
320   default:
321     return 0;
322 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
323   case DW_LANG_##NAME:                                                         \
324     return VERSION;
325 #include "llvm/BinaryFormat/Dwarf.def"
326   }
327 }
328 
LanguageVendor(dwarf::SourceLanguage Lang)329 unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
330   switch (Lang) {
331   default:
332     return 0;
333 #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
334   case DW_LANG_##NAME:                                                         \
335     return DWARF_VENDOR_##VENDOR;
336 #include "llvm/BinaryFormat/Dwarf.def"
337   }
338 }
339 
CaseString(unsigned Case)340 StringRef llvm::dwarf::CaseString(unsigned Case) {
341   switch (Case) {
342   case DW_ID_case_sensitive:
343     return "DW_ID_case_sensitive";
344   case DW_ID_up_case:
345     return "DW_ID_up_case";
346   case DW_ID_down_case:
347     return "DW_ID_down_case";
348   case DW_ID_case_insensitive:
349     return "DW_ID_case_insensitive";
350   }
351   return StringRef();
352 }
353 
ConventionString(unsigned CC)354 StringRef llvm::dwarf::ConventionString(unsigned CC) {
355   switch (CC) {
356   default:
357     return StringRef();
358 #define HANDLE_DW_CC(ID, NAME)                                                 \
359   case DW_CC_##NAME:                                                           \
360     return "DW_CC_" #NAME;
361 #include "llvm/BinaryFormat/Dwarf.def"
362   }
363 }
364 
getCallingConvention(StringRef CCString)365 unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
366   return StringSwitch<unsigned>(CCString)
367 #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)
368 #include "llvm/BinaryFormat/Dwarf.def"
369       .Default(0);
370 }
371 
InlineCodeString(unsigned Code)372 StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
373   switch (Code) {
374   case DW_INL_not_inlined:
375     return "DW_INL_not_inlined";
376   case DW_INL_inlined:
377     return "DW_INL_inlined";
378   case DW_INL_declared_not_inlined:
379     return "DW_INL_declared_not_inlined";
380   case DW_INL_declared_inlined:
381     return "DW_INL_declared_inlined";
382   }
383   return StringRef();
384 }
385 
ArrayOrderString(unsigned Order)386 StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
387   switch (Order) {
388   case DW_ORD_row_major:
389     return "DW_ORD_row_major";
390   case DW_ORD_col_major:
391     return "DW_ORD_col_major";
392   }
393   return StringRef();
394 }
395 
LNStandardString(unsigned Standard)396 StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
397   switch (Standard) {
398   default:
399     return StringRef();
400 #define HANDLE_DW_LNS(ID, NAME)                                                \
401   case DW_LNS_##NAME:                                                          \
402     return "DW_LNS_" #NAME;
403 #include "llvm/BinaryFormat/Dwarf.def"
404   }
405 }
406 
LNExtendedString(unsigned Encoding)407 StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
408   switch (Encoding) {
409   default:
410     return StringRef();
411 #define HANDLE_DW_LNE(ID, NAME)                                                \
412   case DW_LNE_##NAME:                                                          \
413     return "DW_LNE_" #NAME;
414 #include "llvm/BinaryFormat/Dwarf.def"
415   }
416 }
417 
MacinfoString(unsigned Encoding)418 StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
419   switch (Encoding) {
420   // Macinfo Type Encodings
421   case DW_MACINFO_define:
422     return "DW_MACINFO_define";
423   case DW_MACINFO_undef:
424     return "DW_MACINFO_undef";
425   case DW_MACINFO_start_file:
426     return "DW_MACINFO_start_file";
427   case DW_MACINFO_end_file:
428     return "DW_MACINFO_end_file";
429   case DW_MACINFO_vendor_ext:
430     return "DW_MACINFO_vendor_ext";
431   case DW_MACINFO_invalid:
432     return "DW_MACINFO_invalid";
433   }
434   return StringRef();
435 }
436 
getMacinfo(StringRef MacinfoString)437 unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
438   return StringSwitch<unsigned>(MacinfoString)
439       .Case("DW_MACINFO_define", DW_MACINFO_define)
440       .Case("DW_MACINFO_undef", DW_MACINFO_undef)
441       .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
442       .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
443       .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
444       .Default(DW_MACINFO_invalid);
445 }
446 
RangeListEncodingString(unsigned Encoding)447 StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
448   switch (Encoding) {
449   default:
450     return StringRef();
451 #define HANDLE_DW_RLE(ID, NAME)                                                \
452   case DW_RLE_##NAME:                                                          \
453     return "DW_RLE_" #NAME;
454 #include "llvm/BinaryFormat/Dwarf.def"
455   }
456 }
457 
CallFrameString(unsigned Encoding)458 StringRef llvm::dwarf::CallFrameString(unsigned Encoding) {
459   switch (Encoding) {
460   default:
461     return StringRef();
462 #define HANDLE_DW_CFA(ID, NAME)                                                \
463   case DW_CFA_##NAME:                                                          \
464     return "DW_CFA_" #NAME;
465 #include "llvm/BinaryFormat/Dwarf.def"
466   }
467 }
468 
ApplePropertyString(unsigned Prop)469 StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
470   switch (Prop) {
471   default:
472     return StringRef();
473 #define HANDLE_DW_APPLE_PROPERTY(ID, NAME)                                     \
474   case DW_APPLE_PROPERTY_##NAME:                                               \
475     return "DW_APPLE_PROPERTY_" #NAME;
476 #include "llvm/BinaryFormat/Dwarf.def"
477   }
478 }
479 
UnitTypeString(unsigned UT)480 StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
481   switch (UT) {
482   default:
483     return StringRef();
484 #define HANDLE_DW_UT(ID, NAME)                                                 \
485   case DW_UT_##NAME:                                                           \
486     return "DW_UT_" #NAME;
487 #include "llvm/BinaryFormat/Dwarf.def"
488   }
489 }
490 
AtomTypeString(unsigned AT)491 StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
492   switch (AT) {
493   case dwarf::DW_ATOM_null:
494     return "DW_ATOM_null";
495   case dwarf::DW_ATOM_die_offset:
496     return "DW_ATOM_die_offset";
497   case DW_ATOM_cu_offset:
498     return "DW_ATOM_cu_offset";
499   case DW_ATOM_die_tag:
500     return "DW_ATOM_die_tag";
501   case DW_ATOM_type_flags:
502   case DW_ATOM_type_type_flags:
503     return "DW_ATOM_type_flags";
504   case DW_ATOM_qual_name_hash:
505     return "DW_ATOM_qual_name_hash";
506   }
507   return StringRef();
508 }
509 
GDBIndexEntryKindString(GDBIndexEntryKind Kind)510 StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
511   switch (Kind) {
512   case GIEK_NONE:
513     return "NONE";
514   case GIEK_TYPE:
515     return "TYPE";
516   case GIEK_VARIABLE:
517     return "VARIABLE";
518   case GIEK_FUNCTION:
519     return "FUNCTION";
520   case GIEK_OTHER:
521     return "OTHER";
522   case GIEK_UNUSED5:
523     return "UNUSED5";
524   case GIEK_UNUSED6:
525     return "UNUSED6";
526   case GIEK_UNUSED7:
527     return "UNUSED7";
528   }
529   llvm_unreachable("Unknown GDBIndexEntryKind value");
530 }
531 
532 StringRef
GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage)533 llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
534   switch (Linkage) {
535   case GIEL_EXTERNAL:
536     return "EXTERNAL";
537   case GIEL_STATIC:
538     return "STATIC";
539   }
540   llvm_unreachable("Unknown GDBIndexEntryLinkage value");
541 }
542 
AttributeValueString(uint16_t Attr,unsigned Val)543 StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
544   switch (Attr) {
545   case DW_AT_accessibility:
546     return AccessibilityString(Val);
547   case DW_AT_virtuality:
548     return VirtualityString(Val);
549   case DW_AT_language:
550     return LanguageString(Val);
551   case DW_AT_encoding:
552     return AttributeEncodingString(Val);
553   case DW_AT_decimal_sign:
554     return DecimalSignString(Val);
555   case DW_AT_endianity:
556     return EndianityString(Val);
557   case DW_AT_visibility:
558     return VisibilityString(Val);
559   case DW_AT_identifier_case:
560     return CaseString(Val);
561   case DW_AT_calling_convention:
562     return ConventionString(Val);
563   case DW_AT_inline:
564     return InlineCodeString(Val);
565   case DW_AT_ordering:
566     return ArrayOrderString(Val);
567   case DW_AT_APPLE_runtime_class:
568     return LanguageString(Val);
569   }
570 
571   return StringRef();
572 }
573 
AtomValueString(uint16_t Atom,unsigned Val)574 StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) {
575   switch (Atom) {
576   case DW_ATOM_null:
577     return "NULL";
578   case DW_ATOM_die_tag:
579     return TagString(Val);
580   }
581 
582   return StringRef();
583 }
584 
IndexString(unsigned Idx)585 StringRef llvm::dwarf::IndexString(unsigned Idx) {
586   switch (Idx) {
587   default:
588     return StringRef();
589 #define HANDLE_DW_IDX(ID, NAME)                                                \
590   case DW_IDX_##NAME:                                                          \
591     return "DW_IDX_" #NAME;
592 #include "llvm/BinaryFormat/Dwarf.def"
593   }
594 }
595 
getFixedFormByteSize(dwarf::Form Form,FormParams Params)596 Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
597                                                     FormParams Params) {
598   switch (Form) {
599   case DW_FORM_addr:
600     if (Params)
601       return Params.AddrSize;
602     return None;
603 
604   case DW_FORM_block:          // ULEB128 length L followed by L bytes.
605   case DW_FORM_block1:         // 1 byte length L followed by L bytes.
606   case DW_FORM_block2:         // 2 byte length L followed by L bytes.
607   case DW_FORM_block4:         // 4 byte length L followed by L bytes.
608   case DW_FORM_string:         // C-string with null terminator.
609   case DW_FORM_sdata:          // SLEB128.
610   case DW_FORM_udata:          // ULEB128.
611   case DW_FORM_ref_udata:      // ULEB128.
612   case DW_FORM_indirect:       // ULEB128.
613   case DW_FORM_exprloc:        // ULEB128 length L followed by L bytes.
614   case DW_FORM_strx:           // ULEB128.
615   case DW_FORM_addrx:          // ULEB128.
616   case DW_FORM_loclistx:       // ULEB128.
617   case DW_FORM_rnglistx:       // ULEB128.
618   case DW_FORM_GNU_addr_index: // ULEB128.
619   case DW_FORM_GNU_str_index:  // ULEB128.
620     return None;
621 
622   case DW_FORM_ref_addr:
623     if (Params)
624       return Params.getRefAddrByteSize();
625     return None;
626 
627   case DW_FORM_flag:
628   case DW_FORM_data1:
629   case DW_FORM_ref1:
630   case DW_FORM_strx1:
631   case DW_FORM_addrx1:
632     return 1;
633 
634   case DW_FORM_data2:
635   case DW_FORM_ref2:
636   case DW_FORM_strx2:
637   case DW_FORM_addrx2:
638     return 2;
639 
640   case DW_FORM_strx3:
641     return 3;
642 
643   case DW_FORM_data4:
644   case DW_FORM_ref4:
645   case DW_FORM_ref_sup4:
646   case DW_FORM_strx4:
647   case DW_FORM_addrx4:
648     return 4;
649 
650   case DW_FORM_strp:
651   case DW_FORM_GNU_ref_alt:
652   case DW_FORM_GNU_strp_alt:
653   case DW_FORM_line_strp:
654   case DW_FORM_sec_offset:
655   case DW_FORM_strp_sup:
656     if (Params)
657       return Params.getDwarfOffsetByteSize();
658     return None;
659 
660   case DW_FORM_data8:
661   case DW_FORM_ref8:
662   case DW_FORM_ref_sig8:
663   case DW_FORM_ref_sup8:
664     return 8;
665 
666   case DW_FORM_flag_present:
667     return 0;
668 
669   case DW_FORM_data16:
670     return 16;
671 
672   case DW_FORM_implicit_const:
673     // The implicit value is stored in the abbreviation as a SLEB128, and
674     // there no data in debug info.
675     return 0;
676 
677   default:
678     break;
679   }
680   return None;
681 }
682 
isValidFormForVersion(Form F,unsigned Version,bool ExtensionsOk)683 bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
684                                         bool ExtensionsOk) {
685   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
686     unsigned FV = FormVersion(F);
687     return FV > 0 && FV <= Version;
688   }
689   return ExtensionsOk;
690 }
691 
692 constexpr char llvm::dwarf::EnumTraits<Attribute>::Type[];
693 constexpr char llvm::dwarf::EnumTraits<Form>::Type[];
694 constexpr char llvm::dwarf::EnumTraits<Index>::Type[];
695 constexpr char llvm::dwarf::EnumTraits<Tag>::Type[];
696