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