1 |
27 |
khays |
// arm-reloc-property.cc -- ARM relocation property.
|
2 |
|
|
|
3 |
|
|
// Copyright 2010 Free Software Foundation, Inc.
|
4 |
|
|
// Written by Doug Kwan <dougkwan@google.com>.
|
5 |
|
|
|
6 |
|
|
// This file is part of gold.
|
7 |
|
|
|
8 |
|
|
// This program is free software; you can redistribute it and/or modify
|
9 |
|
|
// it under the terms of the GNU General Public License as published by
|
10 |
|
|
// the Free Software Foundation; either version 3 of the License, or
|
11 |
|
|
// (at your option) any later version.
|
12 |
|
|
|
13 |
|
|
// This program is distributed in the hope that it will be useful,
|
14 |
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
15 |
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
16 |
|
|
// GNU General Public License for more details.
|
17 |
|
|
|
18 |
|
|
// You should have received a copy of the GNU General Public License
|
19 |
|
|
// along with this program; if not, write to the Free Software
|
20 |
|
|
// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
|
21 |
|
|
// MA 02110-1301, USA.
|
22 |
|
|
|
23 |
|
|
#include "gold.h"
|
24 |
|
|
|
25 |
|
|
#include <cstdio>
|
26 |
|
|
#include <cstring>
|
27 |
|
|
#include <stack>
|
28 |
|
|
#include <string>
|
29 |
|
|
#include <vector>
|
30 |
|
|
|
31 |
|
|
#include "elfcpp.h"
|
32 |
|
|
#include "arm.h"
|
33 |
|
|
#include "arm-reloc-property.h"
|
34 |
|
|
|
35 |
|
|
namespace gold
|
36 |
|
|
{
|
37 |
|
|
|
38 |
|
|
// Arm_reloc_property::Tree_node methods.
|
39 |
|
|
|
40 |
|
|
// Parse an S-expression S and build a tree and return the root node.
|
41 |
|
|
// Caller is responsible for releasing tree after use.
|
42 |
|
|
|
43 |
|
|
Arm_reloc_property::Tree_node*
|
44 |
|
|
Arm_reloc_property::Tree_node::make_tree(const std::string& s)
|
45 |
|
|
{
|
46 |
|
|
std::stack<size_t> size_stack;
|
47 |
|
|
Tree_node_vector node_stack;
|
48 |
|
|
|
49 |
|
|
// strtok needs a non-const string pointer.
|
50 |
|
|
char* buffer = new char[s.size() + 1];
|
51 |
|
|
memcpy(buffer, s.data(), s.size());
|
52 |
|
|
buffer[s.size()] = '\0';
|
53 |
|
|
char* token = strtok(buffer, " ");
|
54 |
|
|
|
55 |
|
|
while (token != NULL)
|
56 |
|
|
{
|
57 |
|
|
if (strcmp(token, "(") == 0)
|
58 |
|
|
// Remember the node stack position for start of a new internal node.
|
59 |
|
|
size_stack.push(node_stack.size());
|
60 |
|
|
else if (strcmp(token, ")") == 0)
|
61 |
|
|
{
|
62 |
|
|
// Pop all tree nodes after the previous '(' and use them as
|
63 |
|
|
// children to build a new internal node. Push internal node back.
|
64 |
|
|
size_t current_size = node_stack.size();
|
65 |
|
|
size_t prev_size = size_stack.top();
|
66 |
|
|
size_stack.pop();
|
67 |
|
|
Tree_node* node =
|
68 |
|
|
new Tree_node(node_stack.begin() + prev_size,
|
69 |
|
|
node_stack.begin() + current_size);
|
70 |
|
|
node_stack.resize(prev_size);
|
71 |
|
|
node_stack.push_back(node);
|
72 |
|
|
}
|
73 |
|
|
else
|
74 |
|
|
// Just push a leaf node to node_stack.
|
75 |
|
|
node_stack.push_back(new Tree_node(token));
|
76 |
|
|
|
77 |
|
|
token = strtok(NULL, " ");
|
78 |
|
|
}
|
79 |
|
|
|
80 |
|
|
delete[] buffer;
|
81 |
|
|
|
82 |
|
|
// At this point, size_stack should be empty and node_stack should only
|
83 |
|
|
// contain the root node.
|
84 |
|
|
gold_assert(size_stack.empty() && node_stack.size() == 1);
|
85 |
|
|
return node_stack[0];
|
86 |
|
|
}
|
87 |
|
|
|
88 |
|
|
// Arm_reloc_property methods.
|
89 |
|
|
|
90 |
|
|
// Constructor.
|
91 |
|
|
|
92 |
|
|
Arm_reloc_property::Arm_reloc_property(
|
93 |
|
|
unsigned int code,
|
94 |
|
|
const char* name,
|
95 |
|
|
Reloc_type rtype,
|
96 |
|
|
bool is_deprecated,
|
97 |
|
|
Reloc_class rclass,
|
98 |
|
|
const std::string& operation,
|
99 |
|
|
bool is_implemented,
|
100 |
|
|
int group_index,
|
101 |
|
|
bool checks_overflow)
|
102 |
|
|
: code_(code), name_(name), reloc_type_(rtype), reloc_class_(rclass),
|
103 |
|
|
group_index_(group_index), size_(0), align_(1),
|
104 |
|
|
relative_address_base_(RAB_NONE), is_deprecated_(is_deprecated),
|
105 |
|
|
is_implemented_(is_implemented), checks_overflow_(checks_overflow),
|
106 |
|
|
uses_got_entry_(false), uses_got_origin_(false), uses_plt_entry_(false),
|
107 |
|
|
uses_thumb_bit_(false), uses_symbol_base_(false), uses_addend_(false),
|
108 |
|
|
uses_symbol_(false)
|
109 |
|
|
{
|
110 |
|
|
// Set size and alignment of static and dynamic relocations.
|
111 |
|
|
if (rtype == RT_STATIC)
|
112 |
|
|
{
|
113 |
|
|
switch (rclass)
|
114 |
|
|
{
|
115 |
|
|
case RC_DATA:
|
116 |
|
|
// Except for R_ARM_ABS16 and R_ARM_ABS8, all static data relocations
|
117 |
|
|
// have size 4. All static data relocations have alignment of 1.
|
118 |
|
|
if (code == elfcpp::R_ARM_ABS8)
|
119 |
|
|
this->size_ = 1;
|
120 |
|
|
else if (code == elfcpp::R_ARM_ABS16)
|
121 |
|
|
this->size_ = 2;
|
122 |
|
|
else
|
123 |
|
|
this->size_ = 4;
|
124 |
|
|
this->align_ = 1;
|
125 |
|
|
break;
|
126 |
|
|
case RC_MISC:
|
127 |
|
|
// R_ARM_V4BX should be treated as an ARM relocation. For all
|
128 |
|
|
// others, just use defaults.
|
129 |
|
|
if (code != elfcpp::R_ARM_V4BX)
|
130 |
|
|
break;
|
131 |
|
|
// Fall through.
|
132 |
|
|
case RC_ARM:
|
133 |
|
|
this->size_ = 4;
|
134 |
|
|
this->align_ = 4;
|
135 |
|
|
break;
|
136 |
|
|
case RC_THM16:
|
137 |
|
|
this->size_ = 2;
|
138 |
|
|
this->align_ = 2;
|
139 |
|
|
break;
|
140 |
|
|
case RC_THM32:
|
141 |
|
|
this->size_ = 4;
|
142 |
|
|
this->align_ = 2;
|
143 |
|
|
break;
|
144 |
|
|
default:
|
145 |
|
|
gold_unreachable();
|
146 |
|
|
}
|
147 |
|
|
}
|
148 |
|
|
else if (rtype == RT_DYNAMIC)
|
149 |
|
|
{
|
150 |
|
|
// With the exception of R_ARM_COPY, all dynamic relocations requires
|
151 |
|
|
// that the place being relocated is a word-aligned 32-bit object.
|
152 |
|
|
if (code != elfcpp::R_ARM_COPY)
|
153 |
|
|
{
|
154 |
|
|
this->size_ = 4;
|
155 |
|
|
this->align_ = 4;
|
156 |
|
|
}
|
157 |
|
|
}
|
158 |
|
|
|
159 |
|
|
// If no relocation operation is specified, we are done.
|
160 |
|
|
if (operation == "NONE")
|
161 |
|
|
return;
|
162 |
|
|
|
163 |
|
|
// Extract information from relocation operation.
|
164 |
|
|
Tree_node* root_node = Tree_node::make_tree(operation);
|
165 |
|
|
Tree_node* node = root_node;
|
166 |
|
|
|
167 |
|
|
// Check for an expression of the form XXX - YYY.
|
168 |
|
|
if (!node->is_leaf()
|
169 |
|
|
&& node->child(0)->is_leaf()
|
170 |
|
|
&& node->child(0)->name() == "-")
|
171 |
|
|
{
|
172 |
|
|
struct RAB_table_entry
|
173 |
|
|
{
|
174 |
|
|
Relative_address_base rab;
|
175 |
|
|
const char* name;
|
176 |
|
|
};
|
177 |
|
|
|
178 |
|
|
static const RAB_table_entry rab_table[] =
|
179 |
|
|
{
|
180 |
|
|
{ RAB_B_S, "( B S )" },
|
181 |
|
|
{ RAB_DELTA_B_S, "( DELTA_B ( S ) )" },
|
182 |
|
|
{ RAB_GOT_ORG, "GOT_ORG" },
|
183 |
|
|
{ RAB_P, "P" },
|
184 |
|
|
{ RAB_Pa, "Pa" },
|
185 |
|
|
{ RAB_TLS, "TLS" },
|
186 |
|
|
{ RAB_tp, "tp" }
|
187 |
|
|
};
|
188 |
|
|
|
189 |
|
|
static size_t rab_table_size = sizeof(rab_table) / sizeof(rab_table[0]);
|
190 |
|
|
const std::string rhs(node->child(2)->s_expression());
|
191 |
|
|
for (size_t i = 0; i < rab_table_size; ++i)
|
192 |
|
|
if (rhs == rab_table[i].name)
|
193 |
|
|
{
|
194 |
|
|
this->relative_address_base_ = rab_table[i].rab;
|
195 |
|
|
break;
|
196 |
|
|
}
|
197 |
|
|
|
198 |
|
|
gold_assert(this->relative_address_base_ != RAB_NONE);
|
199 |
|
|
if (this->relative_address_base_ == RAB_B_S)
|
200 |
|
|
this->uses_symbol_base_ = true;
|
201 |
|
|
node = node->child(1);
|
202 |
|
|
}
|
203 |
|
|
|
204 |
|
|
// Check for an expression of the form XXX | T.
|
205 |
|
|
if (!node->is_leaf()
|
206 |
|
|
&& node->child(0)->is_leaf()
|
207 |
|
|
&& node->child(0)->name() == "|")
|
208 |
|
|
{
|
209 |
|
|
gold_assert(node->number_of_children() == 3
|
210 |
|
|
&& node->child(2)->is_leaf()
|
211 |
|
|
&& node->child(2)->name() == "T");
|
212 |
|
|
this->uses_thumb_bit_ = true;
|
213 |
|
|
node = node->child(1);
|
214 |
|
|
}
|
215 |
|
|
|
216 |
|
|
// Check for an expression of the form XXX + A.
|
217 |
|
|
if (!node->is_leaf()
|
218 |
|
|
&& node->child(0)->is_leaf()
|
219 |
|
|
&& node->child(0)->name() == "+")
|
220 |
|
|
{
|
221 |
|
|
gold_assert(node->number_of_children() == 3
|
222 |
|
|
&& node->child(2)->is_leaf()
|
223 |
|
|
&& node->child(2)->name() == "A");
|
224 |
|
|
this->uses_addend_ = true;
|
225 |
|
|
node = node->child(1);
|
226 |
|
|
}
|
227 |
|
|
|
228 |
|
|
// Check for an expression of the form XXX(S).
|
229 |
|
|
if (!node->is_leaf() && node->child(0)->is_leaf())
|
230 |
|
|
{
|
231 |
|
|
gold_assert(node->number_of_children() == 2
|
232 |
|
|
&& node->child(1)->is_leaf()
|
233 |
|
|
&& node->child(1)->name() == "S");
|
234 |
|
|
const std::string func(node->child(0)->name());
|
235 |
|
|
if (func == "B")
|
236 |
|
|
this->uses_symbol_base_ = true;
|
237 |
|
|
else if (func == "GOT")
|
238 |
|
|
this->uses_got_entry_ = true;
|
239 |
|
|
else if (func == "PLT")
|
240 |
|
|
this->uses_plt_entry_ = true;
|
241 |
|
|
else if (func == "Module" || func == "DELTA_B")
|
242 |
|
|
// These are used in dynamic relocations.
|
243 |
|
|
;
|
244 |
|
|
else
|
245 |
|
|
gold_unreachable();
|
246 |
|
|
node = node->child(1);
|
247 |
|
|
}
|
248 |
|
|
|
249 |
|
|
gold_assert(node->is_leaf() && node->name() == "S");
|
250 |
|
|
this->uses_symbol_ = true;
|
251 |
|
|
|
252 |
|
|
delete root_node;
|
253 |
|
|
}
|
254 |
|
|
|
255 |
|
|
// Arm_reloc_property_table methods.
|
256 |
|
|
|
257 |
|
|
// Constructor. This processing informations in arm-reloc.def to
|
258 |
|
|
// initialize the table.
|
259 |
|
|
|
260 |
|
|
Arm_reloc_property_table::Arm_reloc_property_table()
|
261 |
|
|
{
|
262 |
|
|
// These appear in arm-reloc.def. Do not rename them.
|
263 |
|
|
Parse_expression A("A"), GOT_ORG("GOT_ORG"), NONE("NONE"), P("P"),
|
264 |
|
|
Pa("Pa"), S("S"), T("T"), TLS("TLS"), tp("tp");
|
265 |
|
|
const bool Y(true), N(false);
|
266 |
|
|
|
267 |
|
|
for (unsigned int i = 0; i < Property_table_size; ++i)
|
268 |
|
|
this->table_[i] = NULL;
|
269 |
|
|
|
270 |
|
|
#undef RD
|
271 |
|
|
#define RD(name, type, deprecated, class, operation, is_implemented, \
|
272 |
|
|
group_index, checks_oveflow) \
|
273 |
|
|
do \
|
274 |
|
|
{ \
|
275 |
|
|
unsigned int code = elfcpp::R_ARM_##name; \
|
276 |
|
|
gold_assert(code < Property_table_size); \
|
277 |
|
|
this->table_[code] = \
|
278 |
|
|
new Arm_reloc_property(elfcpp::R_ARM_##name, "R_ARM_" #name, \
|
279 |
|
|
Arm_reloc_property::RT_##type, deprecated, \
|
280 |
|
|
Arm_reloc_property::RC_##class, \
|
281 |
|
|
(operation).s_expression(), is_implemented, \
|
282 |
|
|
group_index, checks_oveflow); \
|
283 |
|
|
} \
|
284 |
|
|
while(0);
|
285 |
|
|
|
286 |
|
|
#include "arm-reloc.def"
|
287 |
|
|
#undef RD
|
288 |
|
|
}
|
289 |
|
|
|
290 |
|
|
// Return a string describing a relocation code that fails to get a
|
291 |
|
|
// relocation property in get_implemented_static_reloc_property().
|
292 |
|
|
|
293 |
|
|
std::string
|
294 |
|
|
Arm_reloc_property_table::reloc_name_in_error_message(unsigned int code)
|
295 |
|
|
{
|
296 |
|
|
gold_assert(code < Property_table_size);
|
297 |
|
|
|
298 |
|
|
const Arm_reloc_property* arp = this->table_[code];
|
299 |
|
|
|
300 |
|
|
if (arp == NULL)
|
301 |
|
|
{
|
302 |
|
|
char buffer[100];
|
303 |
|
|
sprintf(buffer, _("invalid reloc %u"), code);
|
304 |
|
|
return std::string(buffer);
|
305 |
|
|
}
|
306 |
|
|
|
307 |
|
|
// gold only implements static relocation codes.
|
308 |
|
|
Arm_reloc_property::Reloc_type reloc_type = arp->reloc_type();
|
309 |
|
|
gold_assert(reloc_type == Arm_reloc_property::RT_STATIC
|
310 |
|
|
|| !arp->is_implemented());
|
311 |
|
|
|
312 |
|
|
const char* prefix = NULL;
|
313 |
|
|
switch (reloc_type)
|
314 |
|
|
{
|
315 |
|
|
case Arm_reloc_property::RT_STATIC:
|
316 |
|
|
prefix = arp->is_implemented() ? _("reloc ") : _("unimplemented reloc ");
|
317 |
|
|
break;
|
318 |
|
|
case Arm_reloc_property::RT_DYNAMIC:
|
319 |
|
|
prefix = _("dynamic reloc ");
|
320 |
|
|
break;
|
321 |
|
|
case Arm_reloc_property::RT_PRIVATE:
|
322 |
|
|
prefix = _("private reloc ");
|
323 |
|
|
break;
|
324 |
|
|
case Arm_reloc_property::RT_OBSOLETE:
|
325 |
|
|
prefix = _("obsolete reloc ");
|
326 |
|
|
break;
|
327 |
|
|
default:
|
328 |
|
|
gold_unreachable();
|
329 |
|
|
}
|
330 |
|
|
return std::string(prefix) + arp->name();
|
331 |
|
|
}
|
332 |
|
|
|
333 |
|
|
} // End namespace gold.
|