LCOV - code coverage report
Current view: top level - lib/BinaryFormat - Dwarf.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 163 256 63.7 %
Date: 2018-09-23 13:06:45 Functions: 33 50 66.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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             : 
      21       83450 : StringRef llvm::dwarf::TagString(unsigned Tag) {
      22       83450 :   switch (Tag) {
      23          19 :   default:
      24          19 :     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             : 
      32        3875 : unsigned llvm::dwarf::getTag(StringRef TagString) {
      33        3875 :   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        3875 :       .Default(DW_TAG_invalid);
      38             : }
      39             : 
      40           0 : 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             : 
      51           0 : unsigned llvm::dwarf::TagVendor(dwarf::Tag Tag) {
      52           0 :   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             : 
      62       65989 : StringRef llvm::dwarf::ChildrenString(unsigned Children) {
      63       65989 :   switch (Children) {
      64             :   case DW_CHILDREN_no:
      65       38101 :     return "DW_CHILDREN_no";
      66             :   case DW_CHILDREN_yes:
      67       27888 :     return "DW_CHILDREN_yes";
      68             :   }
      69           0 :   return StringRef();
      70             : }
      71             : 
      72      337051 : StringRef llvm::dwarf::AttributeString(unsigned Attribute) {
      73      337051 :   switch (Attribute) {
      74         131 :   default:
      75         131 :     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           0 : 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           0 : unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) {
      95           0 :   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      315972 : StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) {
     106      315972 :   switch (Encoding) {
     107           3 :   default:
     108           3 :     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           0 : 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           0 : 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      103489 : StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
     139      103489 :   switch (Encoding) {
     140           0 :   default:
     141           0 :     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         157 :     return "DW_OP_LLVM_fragment";
     148             :   }
     149             : }
     150             : 
     151         430 : unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
     152         430 :   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         430 :       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
     157         430 :       .Default(0);
     158             : }
     159             : 
     160           0 : 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             : 
     171           0 : unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) {
     172           0 :   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             : 
     182        1702 : StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) {
     183        1702 :   switch (Encoding) {
     184           3 :   default:
     185           3 :     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             : 
     193        1534 : unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) {
     194        1534 :   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        1534 :       .Default(0);
     199             : }
     200             : 
     201           0 : 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             : 
     212           0 : 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             : 
     223           0 : StringRef llvm::dwarf::DecimalSignString(unsigned Sign) {
     224           0 :   switch (Sign) {
     225             :   case DW_DS_unsigned:
     226           0 :     return "DW_DS_unsigned";
     227             :   case DW_DS_leading_overpunch:
     228           0 :     return "DW_DS_leading_overpunch";
     229             :   case DW_DS_trailing_overpunch:
     230           0 :     return "DW_DS_trailing_overpunch";
     231             :   case DW_DS_leading_separate:
     232           0 :     return "DW_DS_leading_separate";
     233             :   case DW_DS_trailing_separate:
     234           0 :     return "DW_DS_trailing_separate";
     235             :   }
     236           0 :   return StringRef();
     237             : }
     238             : 
     239           0 : StringRef llvm::dwarf::EndianityString(unsigned Endian) {
     240           0 :   switch (Endian) {
     241             :   case DW_END_default:
     242           0 :     return "DW_END_default";
     243             :   case DW_END_big:
     244           0 :     return "DW_END_big";
     245             :   case DW_END_little:
     246           0 :     return "DW_END_little";
     247             :   case DW_END_lo_user:
     248           0 :     return "DW_END_lo_user";
     249             :   case DW_END_hi_user:
     250           0 :     return "DW_END_hi_user";
     251             :   }
     252           0 :   return StringRef();
     253             : }
     254             : 
     255         314 : StringRef llvm::dwarf::AccessibilityString(unsigned Access) {
     256         314 :   switch (Access) {
     257             :   // Accessibility codes
     258             :   case DW_ACCESS_public:
     259         220 :     return "DW_ACCESS_public";
     260             :   case DW_ACCESS_protected:
     261          20 :     return "DW_ACCESS_protected";
     262             :   case DW_ACCESS_private:
     263          74 :     return "DW_ACCESS_private";
     264             :   }
     265           0 :   return StringRef();
     266             : }
     267             : 
     268           8 : StringRef llvm::dwarf::VisibilityString(unsigned Visibility) {
     269           8 :   switch (Visibility) {
     270             :   case DW_VIS_local:
     271           8 :     return "DW_VIS_local";
     272             :   case DW_VIS_exported:
     273           0 :     return "DW_VIS_exported";
     274             :   case DW_VIS_qualified:
     275           0 :     return "DW_VIS_qualified";
     276             :   }
     277           0 :   return StringRef();
     278             : }
     279             : 
     280         109 : StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) {
     281         109 :   switch (Virtuality) {
     282           2 :   default:
     283           2 :     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             : 
     291          74 : unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) {
     292          74 :   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          74 :       .Default(DW_VIRTUALITY_invalid);
     297             : }
     298             : 
     299        2007 : StringRef llvm::dwarf::LanguageString(unsigned Language) {
     300        2007 :   switch (Language) {
     301           5 :   default:
     302           5 :     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             : 
     310        2057 : unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
     311        2057 :   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        2057 :       .Default(0);
     316             : }
     317             : 
     318           0 : 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             : 
     329           0 : unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
     330           0 :   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             : 
     340           0 : StringRef llvm::dwarf::CaseString(unsigned Case) {
     341           0 :   switch (Case) {
     342             :   case DW_ID_case_sensitive:
     343           0 :     return "DW_ID_case_sensitive";
     344             :   case DW_ID_up_case:
     345           0 :     return "DW_ID_up_case";
     346             :   case DW_ID_down_case:
     347           0 :     return "DW_ID_down_case";
     348             :   case DW_ID_case_insensitive:
     349           0 :     return "DW_ID_case_insensitive";
     350             :   }
     351           0 :   return StringRef();
     352             : }
     353             : 
     354         105 : StringRef llvm::dwarf::ConventionString(unsigned CC) {
     355         105 :   switch (CC) {
     356           0 :   default:
     357           0 :     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             : 
     365          79 : unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
     366          79 :   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          79 :       .Default(0);
     370             : }
     371             : 
     372          85 : StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
     373          85 :   switch (Code) {
     374             :   case DW_INL_not_inlined:
     375           0 :     return "DW_INL_not_inlined";
     376             :   case DW_INL_inlined:
     377          85 :     return "DW_INL_inlined";
     378             :   case DW_INL_declared_not_inlined:
     379           0 :     return "DW_INL_declared_not_inlined";
     380             :   case DW_INL_declared_inlined:
     381           0 :     return "DW_INL_declared_inlined";
     382             :   }
     383           0 :   return StringRef();
     384             : }
     385             : 
     386           0 : StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
     387           0 :   switch (Order) {
     388             :   case DW_ORD_row_major:
     389           0 :     return "DW_ORD_row_major";
     390             :   case DW_ORD_col_major:
     391           0 :     return "DW_ORD_col_major";
     392             :   }
     393           0 :   return StringRef();
     394             : }
     395             : 
     396        5092 : StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
     397        5092 :   switch (Standard) {
     398         189 :   default:
     399         189 :     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             : 
     407         260 : StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
     408         260 :   switch (Encoding) {
     409           2 :   default:
     410           2 :     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             : 
     418        1585 : StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
     419        1585 :   switch (Encoding) {
     420             :   // Macinfo Type Encodings
     421             :   case DW_MACINFO_define:
     422        1550 :     return "DW_MACINFO_define";
     423             :   case DW_MACINFO_undef:
     424          23 :     return "DW_MACINFO_undef";
     425             :   case DW_MACINFO_start_file:
     426           6 :     return "DW_MACINFO_start_file";
     427             :   case DW_MACINFO_end_file:
     428           6 :     return "DW_MACINFO_end_file";
     429             :   case DW_MACINFO_vendor_ext:
     430           0 :     return "DW_MACINFO_vendor_ext";
     431             :   case DW_MACINFO_invalid:
     432           0 :     return "DW_MACINFO_invalid";
     433             :   }
     434           0 :   return StringRef();
     435             : }
     436             : 
     437          23 : unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
     438          23 :   return StringSwitch<unsigned>(MacinfoString)
     439          23 :       .Case("DW_MACINFO_define", DW_MACINFO_define)
     440          23 :       .Case("DW_MACINFO_undef", DW_MACINFO_undef)
     441          23 :       .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
     442          23 :       .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
     443          23 :       .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
     444          23 :       .Default(DW_MACINFO_invalid);
     445             : }
     446             : 
     447          58 : StringRef llvm::dwarf::RangeListEncodingString(unsigned Encoding) {
     448          58 :   switch (Encoding) {
     449           0 :   default:
     450           0 :     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             : 
     458        2871 : StringRef llvm::dwarf::CallFrameString(unsigned Encoding) {
     459        2871 :   switch (Encoding) {
     460           0 :   default:
     461           0 :     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             : 
     469          98 : StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
     470          98 :   switch (Prop) {
     471           0 :   default:
     472           0 :     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             : 
     480          73 : StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
     481          73 :   switch (UT) {
     482           0 :   default:
     483           0 :     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             : 
     491        2319 : StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
     492        2319 :   switch (AT) {
     493             :   case dwarf::DW_ATOM_null:
     494           0 :     return "DW_ATOM_null";
     495             :   case dwarf::DW_ATOM_die_offset:
     496        1465 :     return "DW_ATOM_die_offset";
     497             :   case DW_ATOM_cu_offset:
     498           0 :     return "DW_ATOM_cu_offset";
     499             :   case DW_ATOM_die_tag:
     500         368 :     return "DW_ATOM_die_tag";
     501             :   case DW_ATOM_type_flags:
     502             :   case DW_ATOM_type_type_flags:
     503         368 :     return "DW_ATOM_type_flags";
     504             :   case DW_ATOM_qual_name_hash:
     505         118 :     return "DW_ATOM_qual_name_hash";
     506             :   }
     507           0 :   return StringRef();
     508             : }
     509             : 
     510       24446 : StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
     511       24446 :   switch (Kind) {
     512             :   case GIEK_NONE:
     513         177 :     return "NONE";
     514             :   case GIEK_TYPE:
     515       16028 :     return "TYPE";
     516             :   case GIEK_VARIABLE:
     517         503 :     return "VARIABLE";
     518             :   case GIEK_FUNCTION:
     519        7738 :     return "FUNCTION";
     520             :   case GIEK_OTHER:
     521           0 :     return "OTHER";
     522             :   case GIEK_UNUSED5:
     523           0 :     return "UNUSED5";
     524             :   case GIEK_UNUSED6:
     525           0 :     return "UNUSED6";
     526             :   case GIEK_UNUSED7:
     527           0 :     return "UNUSED7";
     528             :   }
     529           0 :   llvm_unreachable("Unknown GDBIndexEntryKind value");
     530             : }
     531             : 
     532             : StringRef
     533       24446 : llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
     534       24446 :   switch (Linkage) {
     535             :   case GIEL_EXTERNAL:
     536       13757 :     return "EXTERNAL";
     537             :   case GIEL_STATIC:
     538       10689 :     return "STATIC";
     539             :   }
     540           0 :   llvm_unreachable("Unknown GDBIndexEntryLinkage value");
     541             : }
     542             : 
     543       10120 : StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
     544       10120 :   switch (Attr) {
     545         275 :   case DW_AT_accessibility:
     546         275 :     return AccessibilityString(Val);
     547           8 :   case DW_AT_virtuality:
     548           8 :     return VirtualityString(Val);
     549         693 :   case DW_AT_language:
     550         693 :     return LanguageString(Val);
     551         568 :   case DW_AT_encoding:
     552         568 :     return AttributeEncodingString(Val);
     553           0 :   case DW_AT_decimal_sign:
     554           0 :     return DecimalSignString(Val);
     555           0 :   case DW_AT_endianity:
     556           0 :     return EndianityString(Val);
     557           8 :   case DW_AT_visibility:
     558           8 :     return VisibilityString(Val);
     559           0 :   case DW_AT_identifier_case:
     560           0 :     return CaseString(Val);
     561           5 :   case DW_AT_calling_convention:
     562           5 :     return ConventionString(Val);
     563          85 :   case DW_AT_inline:
     564          85 :     return InlineCodeString(Val);
     565           0 :   case DW_AT_ordering:
     566           0 :     return ArrayOrderString(Val);
     567          27 :   case DW_AT_APPLE_runtime_class:
     568          27 :     return LanguageString(Val);
     569             :   }
     570             : 
     571        8451 :   return StringRef();
     572             : }
     573             : 
     574        1295 : StringRef llvm::dwarf::AtomValueString(uint16_t Atom, unsigned Val) {
     575        1295 :   switch (Atom) {
     576             :   case DW_ATOM_null:
     577           0 :     return "NULL";
     578         230 :   case DW_ATOM_die_tag:
     579         230 :     return TagString(Val);
     580             :   }
     581             : 
     582        1065 :   return StringRef();
     583             : }
     584             : 
     585        1636 : StringRef llvm::dwarf::IndexString(unsigned Idx) {
     586        1636 :   switch (Idx) {
     587           2 :   default:
     588           2 :     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             : 
     596     5030450 : Optional<uint8_t> llvm::dwarf::getFixedFormByteSize(dwarf::Form Form,
     597             :                                                     FormParams Params) {
     598     5030450 :   switch (Form) {
     599       11268 :   case DW_FORM_addr:
     600             :     if (Params)
     601       11268 :       return Params.AddrSize;
     602           0 :     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      260198 :     return None;
     621             : 
     622        1198 :   case DW_FORM_ref_addr:
     623             :     if (Params)
     624        1197 :       return Params.getRefAddrByteSize();
     625           1 :     return None;
     626             : 
     627     3172721 :   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     3172721 :     return 1;
     633             : 
     634      722627 :   case DW_FORM_data2:
     635             :   case DW_FORM_ref2:
     636             :   case DW_FORM_strx2:
     637             :   case DW_FORM_addrx2:
     638      722627 :     return 2;
     639             : 
     640           8 :   case DW_FORM_strx3:
     641           8 :     return 3;
     642             : 
     643       32139 :   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       32139 :     return 4;
     649             : 
     650       58708 :   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       58708 :       return Params.getDwarfOffsetByteSize();
     658           0 :     return None;
     659             : 
     660        2744 :   case DW_FORM_data8:
     661             :   case DW_FORM_ref8:
     662             :   case DW_FORM_ref_sig8:
     663             :   case DW_FORM_ref_sup8:
     664        2744 :     return 8;
     665             : 
     666      768832 :   case DW_FORM_flag_present:
     667      768832 :     return 0;
     668             : 
     669           2 :   case DW_FORM_data16:
     670           2 :     return 16;
     671             : 
     672           5 :   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           5 :     return 0;
     676             : 
     677             :   default:
     678             :     break;
     679             :   }
     680           0 :   return None;
     681             : }
     682             : 
     683           0 : bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
     684             :                                         bool ExtensionsOk) {
     685           0 :   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
     686           0 :     unsigned FV = FormVersion(F);
     687           0 :     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[];

Generated by: LCOV version 1.13