llvm/lib/MC/MCSymbolELF.cpp

   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 }