LCOV - code coverage report
Current view: top level - lib/Support - Dwarf.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 102 192 53.1 %
Date: 2017-05-20 02:07:48 Functions: 28 47 59.6 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/Support/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/Support/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       19809 : StringRef llvm::dwarf::TagString(unsigned Tag) {
      22       19809 :   switch (Tag) {
      23             :   default:
      24          16 :     return StringRef();
      25             : #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
      26             :   case DW_TAG_##NAME:                                                          \
      27             :     return "DW_TAG_" #NAME;
      28             : #include "llvm/Support/Dwarf.def"
      29             :   }
      30             : }
      31             : 
      32        2831 : unsigned llvm::dwarf::getTag(StringRef TagString) {
      33        2831 :   return StringSwitch<unsigned>(TagString)
      34             : #define HANDLE_DW_TAG(ID, NAME, VERSION, VENDOR)                               \
      35             :       .Case("DW_TAG_" #NAME, DW_TAG_##NAME)
      36             : #include "llvm/Support/Dwarf.def"
      37        5662 :       .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/Support/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/Support/Dwarf.def"
      59             :   }
      60             : }
      61             : 
      62        7791 : StringRef llvm::dwarf::ChildrenString(unsigned Children) {
      63        7791 :   switch (Children) {
      64        4581 :   case DW_CHILDREN_no:                   return "DW_CHILDREN_no";
      65        3210 :   case DW_CHILDREN_yes:                  return "DW_CHILDREN_yes";
      66             :   }
      67           0 :   return StringRef();
      68             : }
      69             : 
      70       71304 : StringRef llvm::dwarf::AttributeString(unsigned Attribute) {
      71       71304 :   switch (Attribute) {
      72             :   default:
      73          84 :     return StringRef();
      74             : #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)                                \
      75             :   case DW_AT_##NAME:                                                           \
      76             :     return "DW_AT_" #NAME;
      77             : #include "llvm/Support/Dwarf.def"
      78             :   }
      79             : }
      80             : 
      81           0 : unsigned llvm::dwarf::AttributeVersion(dwarf::Attribute Attribute) {
      82             :   switch (Attribute) {
      83             :   default:
      84             :     return 0;
      85             : #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)                                \
      86             :   case DW_AT_##NAME:                                                           \
      87             :     return VERSION;
      88             : #include "llvm/Support/Dwarf.def"
      89             :   }
      90             : }
      91             : 
      92           0 : unsigned llvm::dwarf::AttributeVendor(dwarf::Attribute Attribute) {
      93           0 :   switch (Attribute) {
      94             :   default:
      95             :     return 0;
      96             : #define HANDLE_DW_AT(ID, NAME, VERSION, VENDOR)                                \
      97             :   case DW_AT_##NAME:                                                           \
      98             :     return DWARF_VENDOR_##VENDOR;
      99             : #include "llvm/Support/Dwarf.def"
     100             :   }
     101             : }
     102             : 
     103       63674 : StringRef llvm::dwarf::FormEncodingString(unsigned Encoding) {
     104       63674 :   switch (Encoding) {
     105             :   default:
     106           0 :     return StringRef();
     107             : #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)                              \
     108             :   case DW_FORM_##NAME:                                                         \
     109             :     return "DW_FORM_" #NAME;
     110             : #include "llvm/Support/Dwarf.def"
     111             :   }
     112             : }
     113             : 
     114           0 : unsigned llvm::dwarf::FormVersion(dwarf::Form Form) {
     115             :   switch (Form) {
     116             :   default:
     117             :     return 0;
     118             : #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)                              \
     119             :   case DW_FORM_##NAME:                                                         \
     120             :     return VERSION;
     121             : #include "llvm/Support/Dwarf.def"
     122             :   }
     123             : }
     124             : 
     125           0 : unsigned llvm::dwarf::FormVendor(dwarf::Form Form) {
     126             :   switch (Form) {
     127             :   default:
     128             :     return 0;
     129             : #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)                              \
     130             :   case DW_FORM_##NAME:                                                         \
     131             :     return DWARF_VENDOR_##VENDOR;
     132             : #include "llvm/Support/Dwarf.def"
     133             :   }
     134             : }
     135             : 
     136       15239 : StringRef llvm::dwarf::OperationEncodingString(unsigned Encoding) {
     137       15239 :   switch (Encoding) {
     138             :   default:
     139           0 :     return StringRef();
     140             : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
     141             :   case DW_OP_##NAME:                                                           \
     142             :     return "DW_OP_" #NAME;
     143             : #include "llvm/Support/Dwarf.def"
     144             :   case DW_OP_LLVM_fragment:
     145          55 :     return "DW_OP_LLVM_fragment";
     146             :   }
     147             : }
     148             : 
     149         296 : unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
     150         296 :   return StringSwitch<unsigned>(OperationEncodingString)
     151             : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
     152             :       .Case("DW_OP_" #NAME, DW_OP_##NAME)
     153             : #include "llvm/Support/Dwarf.def"
     154         888 :       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
     155         592 :       .Default(0);
     156             : }
     157             : 
     158           0 : unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
     159             :   switch (Op) {
     160             :   default:
     161             :     return 0;
     162             : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
     163             :   case DW_OP_##NAME:                                                           \
     164             :     return VERSION;
     165             : #include "llvm/Support/Dwarf.def"
     166             :   }
     167             : }
     168             : 
     169           0 : unsigned llvm::dwarf::OperationVendor(dwarf::LocationAtom Op) {
     170           0 :   switch (Op) {
     171             :   default:
     172             :     return 0;
     173             : #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
     174             :   case DW_OP_##NAME:                                                           \
     175             :     return DWARF_VENDOR_##VENDOR;
     176             : #include "llvm/Support/Dwarf.def"
     177             :   }
     178             : }
     179             : 
     180        1058 : StringRef llvm::dwarf::AttributeEncodingString(unsigned Encoding) {
     181        1058 :   switch (Encoding) {
     182             :   default:
     183           3 :     return StringRef();
     184             : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
     185             :   case DW_ATE_##NAME:                                                          \
     186             :     return "DW_ATE_" #NAME;
     187             : #include "llvm/Support/Dwarf.def"
     188             :   }
     189             : }
     190             : 
     191        1008 : unsigned llvm::dwarf::getAttributeEncoding(StringRef EncodingString) {
     192        1008 :   return StringSwitch<unsigned>(EncodingString)
     193             : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
     194             :       .Case("DW_ATE_" #NAME, DW_ATE_##NAME)
     195             : #include "llvm/Support/Dwarf.def"
     196        2016 :       .Default(0);
     197             : }
     198             : 
     199           0 : unsigned llvm::dwarf::AttributeEncodingVersion(dwarf::TypeKind ATE) {
     200             :   switch (ATE) {
     201             :   default:
     202             :     return 0;
     203             : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
     204             :   case DW_ATE_##NAME:                                                          \
     205             :     return VERSION;
     206             : #include "llvm/Support/Dwarf.def"
     207             :   }
     208             : }
     209             : 
     210           0 : unsigned llvm::dwarf::AttributeEncodingVendor(dwarf::TypeKind ATE) {
     211             :   switch (ATE) {
     212             :   default:
     213             :     return 0;
     214             : #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)                               \
     215             :   case DW_ATE_##NAME:                                                          \
     216             :     return DWARF_VENDOR_##VENDOR;
     217             : #include "llvm/Support/Dwarf.def"
     218             :   }
     219             : }
     220             : 
     221           0 : StringRef llvm::dwarf::DecimalSignString(unsigned Sign) {
     222           0 :   switch (Sign) {
     223           0 :   case DW_DS_unsigned:                   return "DW_DS_unsigned";
     224           0 :   case DW_DS_leading_overpunch:          return "DW_DS_leading_overpunch";
     225           0 :   case DW_DS_trailing_overpunch:         return "DW_DS_trailing_overpunch";
     226           0 :   case DW_DS_leading_separate:           return "DW_DS_leading_separate";
     227           0 :   case DW_DS_trailing_separate:          return "DW_DS_trailing_separate";
     228             :   }
     229           0 :   return StringRef();
     230             : }
     231             : 
     232           0 : StringRef llvm::dwarf::EndianityString(unsigned Endian) {
     233           0 :   switch (Endian) {
     234           0 :   case DW_END_default:                   return "DW_END_default";
     235           0 :   case DW_END_big:                       return "DW_END_big";
     236           0 :   case DW_END_little:                    return "DW_END_little";
     237           0 :   case DW_END_lo_user:                   return "DW_END_lo_user";
     238           0 :   case DW_END_hi_user:                   return "DW_END_hi_user";
     239             :   }
     240           0 :   return StringRef();
     241             : }
     242             : 
     243         255 : StringRef llvm::dwarf::AccessibilityString(unsigned Access) {
     244         255 :   switch (Access) {
     245             :   // Accessibility codes
     246         173 :   case DW_ACCESS_public:                 return "DW_ACCESS_public";
     247          20 :   case DW_ACCESS_protected:              return "DW_ACCESS_protected";
     248          62 :   case DW_ACCESS_private:                return "DW_ACCESS_private";
     249             :   }
     250           0 :   return StringRef();
     251             : }
     252             : 
     253           2 : StringRef llvm::dwarf::VisibilityString(unsigned Visibility) {
     254           2 :   switch (Visibility) {
     255           2 :   case DW_VIS_local:                     return "DW_VIS_local";
     256           0 :   case DW_VIS_exported:                  return "DW_VIS_exported";
     257           0 :   case DW_VIS_qualified:                 return "DW_VIS_qualified";
     258             :   }
     259           0 :   return StringRef();
     260             : }
     261             : 
     262          62 : StringRef llvm::dwarf::VirtualityString(unsigned Virtuality) {
     263          62 :   switch (Virtuality) {
     264             :   default:
     265           2 :     return StringRef();
     266             : #define HANDLE_DW_VIRTUALITY(ID, NAME)                                         \
     267             :   case DW_VIRTUALITY_##NAME:                                                   \
     268             :     return "DW_VIRTUALITY_" #NAME;
     269             : #include "llvm/Support/Dwarf.def"
     270             :   }
     271             : }
     272             : 
     273          62 : unsigned llvm::dwarf::getVirtuality(StringRef VirtualityString) {
     274          62 :   return StringSwitch<unsigned>(VirtualityString)
     275             : #define HANDLE_DW_VIRTUALITY(ID, NAME)                                         \
     276             :   .Case("DW_VIRTUALITY_" #NAME, DW_VIRTUALITY_##NAME)
     277             : #include "llvm/Support/Dwarf.def"
     278         124 :       .Default(DW_VIRTUALITY_invalid);
     279             : }
     280             : 
     281        1419 : StringRef llvm::dwarf::LanguageString(unsigned Language) {
     282        1419 :   switch (Language) {
     283             :   default:
     284           3 :     return StringRef();
     285             : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
     286             :   case DW_LANG_##NAME:                                                         \
     287             :     return "DW_LANG_" #NAME;
     288             : #include "llvm/Support/Dwarf.def"
     289             :   }
     290             : }
     291             : 
     292        1318 : unsigned llvm::dwarf::getLanguage(StringRef LanguageString) {
     293        1318 :   return StringSwitch<unsigned>(LanguageString)
     294             : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
     295             :   .Case("DW_LANG_" #NAME, DW_LANG_##NAME)
     296             : #include "llvm/Support/Dwarf.def"
     297        2636 :       .Default(0);
     298             : }
     299             : 
     300           0 : unsigned llvm::dwarf::LanguageVersion(dwarf::SourceLanguage Lang) {
     301             :   switch (Lang) {
     302             :   default:
     303             :     return 0;
     304             : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
     305             :   case DW_LANG_##NAME:                                                         \
     306             :     return VERSION;
     307             : #include "llvm/Support/Dwarf.def"
     308             :   }
     309             : }
     310             : 
     311           0 : unsigned llvm::dwarf::LanguageVendor(dwarf::SourceLanguage Lang) {
     312           0 :   switch (Lang) {
     313             :   default:
     314             :     return 0;
     315             : #define HANDLE_DW_LANG(ID, NAME, VERSION, VENDOR)                              \
     316             :   case DW_LANG_##NAME:                                                         \
     317             :     return DWARF_VENDOR_##VENDOR;
     318             : #include "llvm/Support/Dwarf.def"
     319             :   }
     320             : }
     321             : 
     322           0 : StringRef llvm::dwarf::CaseString(unsigned Case) {
     323           0 :   switch (Case) {
     324           0 :   case DW_ID_case_sensitive:             return "DW_ID_case_sensitive";
     325           0 :   case DW_ID_up_case:                    return "DW_ID_up_case";
     326           0 :   case DW_ID_down_case:                  return "DW_ID_down_case";
     327           0 :   case DW_ID_case_insensitive:           return "DW_ID_case_insensitive";
     328             :   }
     329           0 :   return StringRef();
     330             : }
     331             : 
     332          50 : StringRef llvm::dwarf::ConventionString(unsigned CC) {
     333          50 :   switch (CC) {
     334             :   default:
     335           0 :     return StringRef();
     336             : #define HANDLE_DW_CC(ID, NAME)                                               \
     337             :   case DW_CC_##NAME:                                                         \
     338             :     return "DW_CC_" #NAME;
     339             : #include "llvm/Support/Dwarf.def"
     340             :   }
     341             : }
     342             : 
     343          41 : unsigned llvm::dwarf::getCallingConvention(StringRef CCString) {
     344          41 :   return StringSwitch<unsigned>(CCString)
     345             : #define HANDLE_DW_CC(ID, NAME) .Case("DW_CC_" #NAME, DW_CC_##NAME)
     346             : #include "llvm/Support/Dwarf.def"
     347          82 :       .Default(0);
     348             : }
     349             : 
     350          69 : StringRef llvm::dwarf::InlineCodeString(unsigned Code) {
     351          69 :   switch (Code) {
     352           0 :   case DW_INL_not_inlined:               return "DW_INL_not_inlined";
     353          69 :   case DW_INL_inlined:                   return "DW_INL_inlined";
     354           0 :   case DW_INL_declared_not_inlined:      return "DW_INL_declared_not_inlined";
     355           0 :   case DW_INL_declared_inlined:          return "DW_INL_declared_inlined";
     356             :   }
     357           0 :   return StringRef();
     358             : }
     359             : 
     360           0 : StringRef llvm::dwarf::ArrayOrderString(unsigned Order) {
     361           0 :   switch (Order) {
     362           0 :   case DW_ORD_row_major:                 return "DW_ORD_row_major";
     363           0 :   case DW_ORD_col_major:                 return "DW_ORD_col_major";
     364             :   }
     365           0 :   return StringRef();
     366             : }
     367             : 
     368           0 : StringRef llvm::dwarf::DiscriminantString(unsigned Discriminant) {
     369           0 :   switch (Discriminant) {
     370           0 :   case DW_DSC_label:                     return "DW_DSC_label";
     371           0 :   case DW_DSC_range:                     return "DW_DSC_range";
     372             :   }
     373           0 :   return StringRef();
     374             : }
     375             : 
     376        2976 : StringRef llvm::dwarf::LNStandardString(unsigned Standard) {
     377        2976 :   switch (Standard) {
     378             :   default:
     379           0 :     return StringRef();
     380             : #define HANDLE_DW_LNS(ID, NAME)                                               \
     381             :   case DW_LNS_##NAME:                                                         \
     382             :     return "DW_LNS_" #NAME;
     383             : #include "llvm/Support/Dwarf.def"
     384             :   }
     385             : }
     386             : 
     387           0 : StringRef llvm::dwarf::LNExtendedString(unsigned Encoding) {
     388           0 :   switch (Encoding) {
     389             :   default:
     390           0 :     return StringRef();
     391             : #define HANDLE_DW_LNE(ID, NAME)                                               \
     392             :   case DW_LNE_##NAME:                                                         \
     393             :     return "DW_LNE_" #NAME;
     394             : #include "llvm/Support/Dwarf.def"
     395             :   }
     396             : }
     397             : 
     398        1172 : StringRef llvm::dwarf::MacinfoString(unsigned Encoding) {
     399        1172 :   switch (Encoding) {
     400             :   // Macinfo Type Encodings
     401        1141 :   case DW_MACINFO_define:                return "DW_MACINFO_define";
     402          19 :   case DW_MACINFO_undef:                 return "DW_MACINFO_undef";
     403           6 :   case DW_MACINFO_start_file:            return "DW_MACINFO_start_file";
     404           6 :   case DW_MACINFO_end_file:              return "DW_MACINFO_end_file";
     405           0 :   case DW_MACINFO_vendor_ext:            return "DW_MACINFO_vendor_ext";
     406           0 :   case DW_MACINFO_invalid:               return "DW_MACINFO_invalid";
     407             :   }
     408           0 :   return StringRef();
     409             : }
     410             : 
     411          31 : unsigned llvm::dwarf::getMacinfo(StringRef MacinfoString) {
     412          31 :   return StringSwitch<unsigned>(MacinfoString)
     413          93 :       .Case("DW_MACINFO_define", DW_MACINFO_define)
     414          93 :       .Case("DW_MACINFO_undef", DW_MACINFO_undef)
     415          93 :       .Case("DW_MACINFO_start_file", DW_MACINFO_start_file)
     416          93 :       .Case("DW_MACINFO_end_file", DW_MACINFO_end_file)
     417          93 :       .Case("DW_MACINFO_vendor_ext", DW_MACINFO_vendor_ext)
     418          62 :       .Default(DW_MACINFO_invalid);
     419             : }
     420             : 
     421         410 : StringRef llvm::dwarf::CallFrameString(unsigned Encoding) {
     422         410 :   switch (Encoding) {
     423             :   default:
     424           0 :     return StringRef();
     425             : #define HANDLE_DW_CFA(ID, NAME)                                               \
     426             :   case DW_CFA_##NAME:                                                         \
     427             :     return "DW_CFA_" #NAME;
     428             : #include "llvm/Support/Dwarf.def"
     429             :   }
     430             : }
     431             : 
     432          98 : StringRef llvm::dwarf::ApplePropertyString(unsigned Prop) {
     433          98 :   switch (Prop) {
     434             :   default:
     435           0 :     return StringRef();
     436             : #define HANDLE_DW_APPLE_PROPERTY(ID, NAME)                                               \
     437             :   case DW_APPLE_PROPERTY_##NAME:                                                         \
     438             :     return "DW_APPLE_PROPERTY_" #NAME;
     439             : #include "llvm/Support/Dwarf.def"
     440             :   }
     441             : }
     442             : 
     443          12 : StringRef llvm::dwarf::UnitTypeString(unsigned UT) {
     444          12 :   switch (UT) {
     445             :   default:
     446           0 :     return StringRef();
     447             : #define HANDLE_DW_UT(ID, NAME)                                                 \
     448             :   case DW_UT_##NAME:                                                           \
     449             :     return "DW_UT_" #NAME;
     450             : #include "llvm/Support/Dwarf.def"
     451             :   }
     452             : }
     453             : 
     454        1315 : StringRef llvm::dwarf::AtomTypeString(unsigned AT) {
     455        1315 :   switch (AT) {
     456             :   case dwarf::DW_ATOM_null:
     457           0 :     return "DW_ATOM_null";
     458             :   case dwarf::DW_ATOM_die_offset:
     459         851 :     return "DW_ATOM_die_offset";
     460             :   case DW_ATOM_cu_offset:
     461           0 :     return "DW_ATOM_cu_offset";
     462             :   case DW_ATOM_die_tag:
     463         232 :     return "DW_ATOM_die_tag";
     464             :   case DW_ATOM_type_flags:
     465         232 :     return "DW_ATOM_type_flags";
     466             :   }
     467           0 :   return StringRef();
     468             : }
     469             : 
     470          74 : StringRef llvm::dwarf::GDBIndexEntryKindString(GDBIndexEntryKind Kind) {
     471          74 :   switch (Kind) {
     472             :   case GIEK_NONE:
     473           0 :     return "NONE";
     474             :   case GIEK_TYPE:
     475          30 :     return "TYPE";
     476             :   case GIEK_VARIABLE:
     477          26 :     return "VARIABLE";
     478             :   case GIEK_FUNCTION:
     479          18 :     return "FUNCTION";
     480             :   case GIEK_OTHER:
     481           0 :     return "OTHER";
     482             :   case GIEK_UNUSED5:
     483           0 :     return "UNUSED5";
     484             :   case GIEK_UNUSED6:
     485           0 :     return "UNUSED6";
     486             :   case GIEK_UNUSED7:
     487           0 :     return "UNUSED7";
     488             :   }
     489           0 :   llvm_unreachable("Unknown GDBIndexEntryKind value");
     490             : }
     491             : 
     492             : StringRef
     493          74 : llvm::dwarf::GDBIndexEntryLinkageString(GDBIndexEntryLinkage Linkage) {
     494          74 :   switch (Linkage) {
     495             :   case GIEL_EXTERNAL:
     496          59 :     return "EXTERNAL";
     497             :   case GIEL_STATIC:
     498          15 :     return "STATIC";
     499             :   }
     500           0 :   llvm_unreachable("Unknown GDBIndexEntryLinkage value");
     501             : }
     502             : 
     503        7794 : StringRef llvm::dwarf::AttributeValueString(uint16_t Attr, unsigned Val) {
     504        7794 :   switch (Attr) {
     505             :   case DW_AT_accessibility:
     506         233 :     return AccessibilityString(Val);
     507             :   case DW_AT_virtuality:
     508           8 :     return VirtualityString(Val);
     509             :   case DW_AT_language:
     510         499 :     return LanguageString(Val);
     511             :   case DW_AT_encoding:
     512         411 :     return AttributeEncodingString(Val);
     513             :   case DW_AT_decimal_sign:
     514           0 :     return DecimalSignString(Val);
     515             :   case DW_AT_endianity:
     516           0 :     return EndianityString(Val);
     517             :   case DW_AT_visibility:
     518           2 :     return VisibilityString(Val);
     519             :   case DW_AT_identifier_case:
     520           0 :     return CaseString(Val);
     521             :   case DW_AT_calling_convention:
     522           2 :     return ConventionString(Val);
     523             :   case DW_AT_inline:
     524          69 :     return InlineCodeString(Val);
     525             :   case DW_AT_ordering:
     526           0 :     return ArrayOrderString(Val);
     527             :   case DW_AT_discr_value:
     528           0 :     return DiscriminantString(Val);
     529             :   }
     530             : 
     531        6570 :   return StringRef();
     532             : }
     533             : 
     534           0 : bool llvm::dwarf::isValidFormForVersion(Form F, unsigned Version,
     535             :                                         bool ExtensionsOk) {
     536           0 :   if (FormVendor(F) == DWARF_VENDOR_DWARF) {
     537           0 :     unsigned FV = FormVersion(F);
     538           0 :     return FV > 0 && FV <= Version;
     539             :   }
     540             :   return ExtensionsOk;
     541             : }

Generated by: LCOV version 1.13