LCOV - code coverage report
Current view: top level - lib/MC - MCSymbolELF.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 89 101 88.1 %
Date: 2018-02-21 17:27:13 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- lib/MC/MCSymbolELF.cpp ---------------------------------------------===//
       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             : #include "llvm/MC/MCSymbolELF.h"
      11             : #include "llvm/BinaryFormat/ELF.h"
      12             : #include "llvm/MC/MCFixupKindInfo.h"
      13             : 
      14             : namespace llvm {
      15             : 
      16             : namespace {
      17             : enum {
      18             :   // Shift value for STT_* flags. 7 possible values. 3 bits.
      19             :   ELF_STT_Shift = 0,
      20             : 
      21             :   // Shift value for STB_* flags. 4 possible values, 2 bits.
      22             :   ELF_STB_Shift = 3,
      23             : 
      24             :   // Shift value for STV_* flags. 4 possible values, 2 bits.
      25             :   ELF_STV_Shift = 5,
      26             : 
      27             :   // Shift value for STO_* flags. 3 bits. All the values are between 0x20 and
      28             :   // 0xe0, so we shift right by 5 before storing.
      29             :   ELF_STO_Shift = 7,
      30             : 
      31             :   // One bit.
      32             :   ELF_IsSignature_Shift = 10,
      33             : 
      34             :   // One bit.
      35             :   ELF_WeakrefUsedInReloc_Shift = 11,
      36             : 
      37             :   // One bit.
      38             :   ELF_BindingSet_Shift = 12
      39             : };
      40             : }
      41             : 
      42     1654762 : void MCSymbolELF::setBinding(unsigned Binding) const {
      43     1654762 :   setIsBindingSet();
      44     1654762 :   if (getType() == ELF::STT_SECTION && Binding != ELF::STB_LOCAL)
      45           1 :     setType(ELF::STT_NOTYPE);
      46             :   unsigned Val;
      47     1654763 :   switch (Binding) {
      48           0 :   default:
      49           0 :     llvm_unreachable("Unsupported Binding");
      50             :   case ELF::STB_LOCAL:
      51             :     Val = 0;
      52             :     break;
      53       23158 :   case ELF::STB_GLOBAL:
      54             :     Val = 1;
      55       23158 :     break;
      56       35387 :   case ELF::STB_WEAK:
      57             :     Val = 2;
      58       35387 :     break;
      59           2 :   case ELF::STB_GNU_UNIQUE:
      60             :     Val = 3;
      61           2 :     break;
      62             :   }
      63     1654763 :   uint32_t OtherFlags = getFlags() & ~(0x3 << ELF_STB_Shift);
      64     1654763 :   setFlags(OtherFlags | (Val << ELF_STB_Shift));
      65     1654763 : }
      66             : 
      67     4779862 : unsigned MCSymbolELF::getBinding() const {
      68     4779862 :   if (isBindingSet()) {
      69     2039894 :     uint32_t Val = (getFlags() & (0x3 << ELF_STB_Shift)) >> ELF_STB_Shift;
      70     2039894 :     switch (Val) {
      71           0 :     default:
      72           0 :       llvm_unreachable("Invalid value");
      73             :     case 0:
      74             :       return ELF::STB_LOCAL;
      75       65978 :     case 1:
      76       65978 :       return ELF::STB_GLOBAL;
      77      205389 :     case 2:
      78      205389 :       return ELF::STB_WEAK;
      79           4 :     case 3:
      80           4 :       return ELF::STB_GNU_UNIQUE;
      81             :     }
      82             :   }
      83             : 
      84     5479938 :   if (isDefined())
      85             :     return ELF::STB_LOCAL;
      86       34070 :   if (isUsedInReloc())
      87             :     return ELF::STB_GLOBAL;
      88         151 :   if (isWeakrefUsedInReloc())
      89             :     return ELF::STB_WEAK;
      90         139 :   if (isSignature())
      91             :     return ELF::STB_LOCAL;
      92          35 :   return ELF::STB_GLOBAL;
      93             : }
      94             : 
      95     1715325 : void MCSymbolELF::setType(unsigned Type) const {
      96             :   unsigned Val;
      97     1715325 :   if (Type == ELF::STT_SECTION && getBinding() != ELF::STB_LOCAL)
      98             :     return;
      99     1715326 :   switch (Type) {
     100           0 :   default:
     101           0 :     llvm_unreachable("Unsupported Binding");
     102             :   case ELF::STT_NOTYPE:
     103             :     Val = 0;
     104             :     break;
     105       72970 :   case ELF::STT_OBJECT:
     106             :     Val = 1;
     107       72970 :     break;
     108       45546 :   case ELF::STT_FUNC:
     109             :     Val = 2;
     110       45546 :     break;
     111     1594095 :   case ELF::STT_SECTION:
     112             :     Val = 3;
     113     1594095 :     break;
     114           0 :   case ELF::STT_COMMON:
     115             :     Val = 4;
     116           0 :     break;
     117        1135 :   case ELF::STT_TLS:
     118             :     Val = 5;
     119        1135 :     break;
     120         301 :   case ELF::STT_GNU_IFUNC:
     121             :     Val = 6;
     122         301 :     break;
     123             :   }
     124     1715326 :   uint32_t OtherFlags = getFlags() & ~(0x7 << ELF_STT_Shift);
     125     1715326 :   setFlags(OtherFlags | (Val << ELF_STT_Shift));
     126             : }
     127             : 
     128     7232392 : unsigned MCSymbolELF::getType() const {
     129             :   uint32_t Val = (getFlags() & (0x7 << ELF_STT_Shift)) >> ELF_STT_Shift;
     130     7232392 :   switch (Val) {
     131           0 :   default:
     132           0 :     llvm_unreachable("Invalid value");
     133             :   case 0:
     134             :     return ELF::STT_NOTYPE;
     135     1993345 :   case 1:
     136     1993345 :     return ELF::STT_OBJECT;
     137      976262 :   case 2:
     138      976262 :     return ELF::STT_FUNC;
     139     1371557 :   case 3:
     140     1371557 :     return ELF::STT_SECTION;
     141           0 :   case 4:
     142           0 :     return ELF::STT_COMMON;
     143        1986 :   case 5:
     144        1986 :     return ELF::STT_TLS;
     145        3652 :   case 6:
     146        3652 :     return ELF::STT_GNU_IFUNC;
     147             :   }
     148             : }
     149             : 
     150        3693 : void MCSymbolELF::setVisibility(unsigned Visibility) {
     151             :   assert(Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_INTERNAL ||
     152             :          Visibility == ELF::STV_HIDDEN || Visibility == ELF::STV_PROTECTED);
     153             : 
     154        3693 :   uint32_t OtherFlags = getFlags() & ~(0x3 << ELF_STV_Shift);
     155        3693 :   setFlags(OtherFlags | (Visibility << ELF_STV_Shift));
     156        3693 : }
     157             : 
     158      231607 : unsigned MCSymbolELF::getVisibility() const {
     159      231607 :   unsigned Visibility = (getFlags() & (0x3 << ELF_STV_Shift)) >> ELF_STV_Shift;
     160             :   assert(Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_INTERNAL ||
     161             :          Visibility == ELF::STV_HIDDEN || Visibility == ELF::STV_PROTECTED);
     162      231607 :   return Visibility;
     163             : }
     164             : 
     165         109 : void MCSymbolELF::setOther(unsigned Other) {
     166             :   assert((Other & 0x1f) == 0);
     167         109 :   Other >>= 5;
     168             :   assert(Other <= 0x7);
     169         109 :   uint32_t OtherFlags = getFlags() & ~(0x7 << ELF_STO_Shift);
     170         109 :   setFlags(OtherFlags | (Other << ELF_STO_Shift));
     171         109 : }
     172             : 
     173      232033 : unsigned MCSymbolELF::getOther() const {
     174      232033 :   unsigned Other = (getFlags() & (0x7 << ELF_STO_Shift)) >> ELF_STO_Shift;
     175      232033 :   return Other << 5;
     176             : }
     177             : 
     178          12 : void MCSymbolELF::setIsWeakrefUsedInReloc() const {
     179          12 :   uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_WeakrefUsedInReloc_Shift);
     180          12 :   setFlags(OtherFlags | (1 << ELF_WeakrefUsedInReloc_Shift));
     181          12 : }
     182             : 
     183     3226506 : bool MCSymbolELF::isWeakrefUsedInReloc() const {
     184     3226506 :   return getFlags() & (0x1 << ELF_WeakrefUsedInReloc_Shift);
     185             : }
     186             : 
     187       95710 : void MCSymbolELF::setIsSignature() const {
     188       95710 :   uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_IsSignature_Shift);
     189       95710 :   setFlags(OtherFlags | (1 << ELF_IsSignature_Shift));
     190       95710 : }
     191             : 
     192     3226495 : bool MCSymbolELF::isSignature() const {
     193     3226495 :   return getFlags() & (0x1 << ELF_IsSignature_Shift);
     194             : }
     195             : 
     196     1654762 : void MCSymbolELF::setIsBindingSet() const {
     197     1654762 :   uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_BindingSet_Shift);
     198     1654762 :   setFlags(OtherFlags | (1 << ELF_BindingSet_Shift));
     199     1654762 : }
     200             : 
     201     4781074 : bool MCSymbolELF::isBindingSet() const {
     202     4781074 :   return getFlags() & (0x1 << ELF_BindingSet_Shift);
     203             : }
     204             : }

Generated by: LCOV version 1.13