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
setBinding(unsigned Binding) const41 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
getBinding() const64 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
setType(unsigned Type) const92 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
getType() const123 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
setVisibility(unsigned Visibility)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
getVisibility() const153 unsigned MCSymbolELF::getVisibility() const {
154 unsigned Visibility = (Flags >> ELF_STV_Shift) & 3;
155 return Visibility;
156 }
157
setOther(unsigned Other)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
getOther() const166 unsigned MCSymbolELF::getOther() const {
167 unsigned Other = (Flags >> ELF_STO_Shift) & 7;
168 return Other << 5;
169 }
170
setIsWeakrefUsedInReloc() const171 void MCSymbolELF::setIsWeakrefUsedInReloc() const {
172 uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_WeakrefUsedInReloc_Shift);
173 setFlags(OtherFlags | (1 << ELF_WeakrefUsedInReloc_Shift));
174 }
175
isWeakrefUsedInReloc() const176 bool MCSymbolELF::isWeakrefUsedInReloc() const {
177 return getFlags() & (0x1 << ELF_WeakrefUsedInReloc_Shift);
178 }
179
setIsSignature() const180 void MCSymbolELF::setIsSignature() const {
181 uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_IsSignature_Shift);
182 setFlags(OtherFlags | (1 << ELF_IsSignature_Shift));
183 }
184
isSignature() const185 bool MCSymbolELF::isSignature() const {
186 return getFlags() & (0x1 << ELF_IsSignature_Shift);
187 }
188
setIsBindingSet() const189 void MCSymbolELF::setIsBindingSet() const {
190 uint32_t OtherFlags = getFlags() & ~(0x1 << ELF_BindingSet_Shift);
191 setFlags(OtherFlags | (1 << ELF_BindingSet_Shift));
192 }
193
isBindingSet() const194 bool MCSymbolELF::isBindingSet() const {
195 return getFlags() & (0x1 << ELF_BindingSet_Shift);
196 }
197 }
198