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