LCOV - code coverage report
Current view: top level - lib/MC - MCSymbolELF.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 97 111 87.4 %
Date: 2017-09-14 15:23:50 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/MCAssembler.h"
      13             : #include "llvm/MC/MCFixupKindInfo.h"
      14             : 
      15             : namespace llvm {
      16             : 
      17             : namespace {
      18             : enum {
      19             :   // Shift value for STT_* flags. 7 possible values. 3 bits.
      20             :   ELF_STT_Shift = 0,
      21             : 
      22             :   // Shift value for STB_* flags. 4 possible values, 2 bits.
      23             :   ELF_STB_Shift = 3,
      24             : 
      25             :   // Shift value for STV_* flags. 4 possible values, 2 bits.
      26             :   ELF_STV_Shift = 5,
      27             : 
      28             :   // Shift value for STO_* flags. 3 bits. All the values are between 0x20 and
      29             :   // 0xe0, so we shift right by 5 before storing.
      30             :   ELF_STO_Shift = 7,
      31             : 
      32             :   // One bit.
      33             :   ELF_IsSignature_Shift = 10,
      34             : 
      35             :   // One bit.
      36             :   ELF_WeakrefUsedInReloc_Shift = 11,
      37             : 
      38             :   // One bit.
      39             :   ELF_BindingSet_Shift = 12
      40             : };
      41             : }
      42             : 
      43     1246131 : void MCSymbolELF::setBinding(unsigned Binding) const {
      44     1246131 :   setIsBindingSet();
      45     1246131 :   if (getType() == ELF::STT_SECTION && Binding != ELF::STB_LOCAL)
      46           0 :     setType(ELF::STT_NOTYPE);
      47             :   unsigned Val;
      48     1246131 :   switch (Binding) {
      49           0 :   default:
      50           0 :     llvm_unreachable("Unsupported Binding");
      51             :   case ELF::STB_LOCAL:
      52             :     Val = 0;
      53             :     break;
      54        6418 :   case ELF::STB_GLOBAL:
      55        6418 :     Val = 1;
      56        6418 :     break;
      57        4577 :   case ELF::STB_WEAK:
      58        4577 :     Val = 2;
      59        4577 :     break;
      60           2 :   case ELF::STB_GNU_UNIQUE:
      61           2 :     Val = 3;
      62           2 :     break;
      63             :   }
      64     2492262 :   uint32_t OtherFlags = getFlags() & ~(0x3 << ELF_STB_Shift);
      65     2492262 :   setFlags(OtherFlags | (Val << ELF_STB_Shift));
      66     1246131 : }
      67             : 
      68     3101373 : unsigned MCSymbolELF::getBinding() const {
      69     3101373 :   if (isBindingSet()) {
      70     2726874 :     uint32_t Val = (getFlags() & (0x3 << ELF_STB_Shift)) >> ELF_STB_Shift;
      71     1363437 :     switch (Val) {
      72           0 :     default:
      73           0 :       llvm_unreachable("Invalid value");
      74             :     case 0:
      75             :       return ELF::STB_LOCAL;
      76       14852 :     case 1:
      77       14852 :       return ELF::STB_GLOBAL;
      78       42066 :     case 2:
      79       42066 :       return ELF::STB_WEAK;
      80           4 :     case 3:
      81           4 :       return ELF::STB_GNU_UNIQUE;
      82             :     }
      83             :   }
      84             : 
      85     3475874 :   if (isDefined())
      86             :     return ELF::STB_LOCAL;
      87       24826 :   if (isUsedInReloc())
      88             :     return ELF::STB_GLOBAL;
      89         137 :   if (isWeakrefUsedInReloc())
      90             :     return ELF::STB_WEAK;
      91         125 :   if (isSignature())
      92             :     return ELF::STB_LOCAL;
      93          35 :   return ELF::STB_GLOBAL;
      94             : }
      95             : 
      96     1300078 : void MCSymbolELF::setType(unsigned Type) const {
      97             :   unsigned Val;
      98     1300078 :   if (Type == ELF::STT_SECTION && getBinding() != ELF::STB_LOCAL)
      99             :     return;
     100     1300079 :   switch (Type) {
     101           0 :   default:
     102           0 :     llvm_unreachable("Unsupported Binding");
     103             :   case ELF::STT_NOTYPE:
     104             :     Val = 0;
     105             :     break;
     106       54638 :   case ELF::STT_OBJECT:
     107       54638 :     Val = 1;
     108       54638 :     break;
     109        9092 :   case ELF::STT_FUNC:
     110        9092 :     Val = 2;
     111        9092 :     break;
     112     1234205 :   case ELF::STT_SECTION:
     113     1234205 :     Val = 3;
     114     1234205 :     break;
     115           0 :   case ELF::STT_COMMON:
     116           0 :     Val = 4;
     117           0 :     break;
     118        1036 :   case ELF::STT_TLS:
     119        1036 :     Val = 5;
     120        1036 :     break;
     121         261 :   case ELF::STT_GNU_IFUNC:
     122         261 :     Val = 6;
     123         261 :     break;
     124             :   }
     125     2600158 :   uint32_t OtherFlags = getFlags() & ~(0x7 << ELF_STT_Shift);
     126     1300079 :   setFlags(OtherFlags | (Val << ELF_STT_Shift));
     127             : }
     128             : 
     129     4862670 : unsigned MCSymbolELF::getType() const {
     130     9725340 :   uint32_t Val = (getFlags() & (0x7 << ELF_STT_Shift)) >> ELF_STT_Shift;
     131     4862670 :   switch (Val) {
     132           0 :   default:
     133           0 :     llvm_unreachable("Invalid value");
     134             :   case 0:
     135             :     return ELF::STT_NOTYPE;
     136     1817040 :   case 1:
     137     1817040 :     return ELF::STT_OBJECT;
     138      228715 :   case 2:
     139      228715 :     return ELF::STT_FUNC;
     140      875794 :   case 3:
     141      875794 :     return ELF::STT_SECTION;
     142           0 :   case 4:
     143           0 :     return ELF::STT_COMMON;
     144        1783 :   case 5:
     145        1783 :     return ELF::STT_TLS;
     146        3245 :   case 6:
     147        3245 :     return ELF::STT_GNU_IFUNC;
     148             :   }
     149             : }
     150             : 
     151        3092 : void MCSymbolELF::setVisibility(unsigned Visibility) {
     152             :   assert(Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_INTERNAL ||
     153             :          Visibility == ELF::STV_HIDDEN || Visibility == ELF::STV_PROTECTED);
     154             : 
     155        6184 :   uint32_t OtherFlags = getFlags() & ~(0x3 << ELF_STV_Shift);
     156        6184 :   setFlags(OtherFlags | (Visibility << ELF_STV_Shift));
     157        3092 : }
     158             : 
     159      116287 : unsigned MCSymbolELF::getVisibility() const {
     160      232574 :   unsigned Visibility = (getFlags() & (0x3 << ELF_STV_Shift)) >> ELF_STV_Shift;
     161             :   assert(Visibility == ELF::STV_DEFAULT || Visibility == ELF::STV_INTERNAL ||
     162             :          Visibility == ELF::STV_HIDDEN || Visibility == ELF::STV_PROTECTED);
     163      116287 :   return Visibility;
     164             : }
     165             : 
     166          79 : void MCSymbolELF::setOther(unsigned Other) {
     167             :   assert((Other & 0x1f) == 0);
     168          79 :   Other >>= 5;
     169             :   assert(Other <= 0x7);
     170         158 :   uint32_t OtherFlags = getFlags() & ~(0x7 << ELF_STO_Shift);
     171         158 :   setFlags(OtherFlags | (Other << ELF_STO_Shift));
     172          79 : }
     173             : 
     174      116703 : unsigned MCSymbolELF::getOther() const {
     175      233406 :   unsigned Other = (getFlags() & (0x7 << ELF_STO_Shift)) >> ELF_STO_Shift;
     176      116703 :   return Other << 5;
     177             : }
     178             : 
     179          12 : void MCSymbolELF::setIsWeakrefUsedInReloc() const {
     180          24 :   uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_WeakrefUsedInReloc_Shift);
     181          24 :   setFlags(OtherFlags | (1 << ELF_WeakrefUsedInReloc_Shift));
     182          12 : }
     183             : 
     184     1630901 : bool MCSymbolELF::isWeakrefUsedInReloc() const {
     185     3261802 :   return getFlags() & (0x1 << ELF_WeakrefUsedInReloc_Shift);
     186             : }
     187             : 
     188       13297 : void MCSymbolELF::setIsSignature() const {
     189       26594 :   uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_IsSignature_Shift);
     190       26594 :   setFlags(OtherFlags | (1 << ELF_IsSignature_Shift));
     191       13297 : }
     192             : 
     193     1630890 : bool MCSymbolELF::isSignature() const {
     194     3261780 :   return getFlags() & (0x1 << ELF_IsSignature_Shift);
     195             : }
     196             : 
     197     1246131 : void MCSymbolELF::setIsBindingSet() const {
     198     2492262 :   uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_BindingSet_Shift);
     199     2492262 :   setFlags(OtherFlags | (1 << ELF_BindingSet_Shift));
     200     1246131 : }
     201             : 
     202     3101784 : bool MCSymbolELF::isBindingSet() const {
     203     6203568 :   return getFlags() & (0x1 << ELF_BindingSet_Shift);
     204             : }
     205             : }

Generated by: LCOV version 1.13