1 // arm-reloc-property.cc -- ARM relocation property.
3 // Copyright 2010 Free Software Foundation, Inc.
4 // Written by Doug Kwan <dougkwan@google.com>.
6 // This file is part of gold.
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.
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.
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.
32 #include "arm-reloc-property.h"
37 // Arm_reloc_property::Tree_node methods.
39 // Parse an S-expression S and build a tree and return the root node.
40 // Caller is responsible for releasing tree after use.
42 Arm_reloc_property::Tree_node
*
43 Arm_reloc_property::Tree_node::make_tree(const std::string
& s
)
45 std::stack
<size_t> size_stack
;
46 Tree_node_vector node_stack
;
48 // strtok needs a non-const string pointer.
49 char* buffer
= new char[s
.size() + 1];
50 memcpy(buffer
, s
.data(), s
.size());
51 buffer
[s
.size()] = '\0';
52 char* token
= strtok(buffer
, " ");
56 if (strcmp(token
, "(") == 0)
57 // Remember the node stack position for start of a new internal node.
58 size_stack
.push(node_stack
.size());
59 else if (strcmp(token
, ")") == 0)
61 // Pop all tree nodes after the previous '(' and use them as
62 // children to build a new internal node. Push internal node back.
63 size_t current_size
= node_stack
.size();
64 size_t prev_size
= size_stack
.top();
67 new Tree_node(node_stack
.begin() + prev_size
,
68 node_stack
.begin() + current_size
);
69 node_stack
.resize(prev_size
);
70 node_stack
.push_back(node
);
73 // Just push a leaf node to node_stack.
74 node_stack
.push_back(new Tree_node(token
));
76 token
= strtok(NULL
, " ");
81 // At this point, size_stack should be empty and node_stack should only
82 // contain the root node.
83 gold_assert(size_stack
.empty() && node_stack
.size() == 1);
87 // Arm_reloc_property methods.
91 Arm_reloc_property::Arm_reloc_property(
97 const std::string
& operation
,
100 bool checks_overflow
)
101 : code_(code
), name_(name
), reloc_type_(rtype
), reloc_class_(rclass
),
102 group_index_(group_index
), size_(0), align_(1),
103 relative_address_base_(RAB_NONE
), is_deprecated_(is_deprecated
),
104 is_implemented_(is_implemented
), checks_overflow_(checks_overflow
),
105 uses_got_entry_(false), uses_got_origin_(false), uses_plt_entry_(false),
106 uses_thumb_bit_(false), uses_symbol_base_(false), uses_addend_(false)
108 // Set size and alignment of static and dynamic relocations.
109 if (rtype
== RT_STATIC
)
114 // Except for R_ARM_ABS16 and R_ARM_ABS8, all static data relocations
115 // have size 4. All static data relocations have alignment of 1.
116 if (code
== elfcpp::R_ARM_ABS8
)
118 else if (code
== elfcpp::R_ARM_ABS16
)
125 // R_ARM_V4BX should be treated as an ARM relocation. For all
126 // others, just use defaults.
127 if (code
!= elfcpp::R_ARM_V4BX
)
146 else if (rtype
== RT_DYNAMIC
)
148 // With the exception of R_ARM_COPY, all dynamic relocations requires
149 // that the place being relocated is a word-aligned 32-bit object.
150 if (code
!= elfcpp::R_ARM_COPY
)
157 // If no relocation operation is specified, we are done.
158 if (operation
== "NONE")
161 // Extract information from relocation operation.
162 Tree_node
* root_node
= Tree_node::make_tree(operation
);
163 Tree_node
* node
= root_node
;
165 // Check for an expression of the form XXX - YYY.
167 && node
->child(0)->is_leaf()
168 && node
->child(0)->name() == "-")
170 struct RAB_table_entry
172 Relative_address_base rab
;
176 static const RAB_table_entry rab_table
[] =
178 { RAB_B_S
, "( B S )" },
179 { RAB_DELTA_B_S
, "( DELTA_B ( S ) )" },
180 { RAB_GOT_ORG
, "GOT_ORG" },
187 static size_t rab_table_size
= sizeof(rab_table
) / sizeof(rab_table
[0]);
188 const std::string
rhs(node
->child(2)->s_expression());
189 for (size_t i
= 0; i
< rab_table_size
; ++i
)
190 if (rhs
== rab_table
[i
].name
)
192 this->relative_address_base_
= rab_table
[i
].rab
;
196 gold_assert(this->relative_address_base_
!= RAB_NONE
);
197 if (this->relative_address_base_
== RAB_B_S
)
198 this->uses_symbol_base_
= true;
199 node
= node
->child(1);
202 // Check for an expression of the form XXX | T.
204 && node
->child(0)->is_leaf()
205 && node
->child(0)->name() == "|")
207 gold_assert(node
->number_of_children() == 3
208 && node
->child(2)->is_leaf()
209 && node
->child(2)->name() == "T");
210 this->uses_thumb_bit_
= true;
211 node
= node
->child(1);
214 // Check for an expression of the form XXX + A.
216 && node
->child(0)->is_leaf()
217 && node
->child(0)->name() == "+")
219 gold_assert(node
->number_of_children() == 3
220 && node
->child(2)->is_leaf()
221 && node
->child(2)->name() == "A");
222 this->uses_addend_
= true;
223 node
= node
->child(1);
226 // Check for an expression of the form XXX(S).
227 if (!node
->is_leaf() && node
->child(0)->is_leaf())
229 gold_assert(node
->number_of_children() == 2
230 && node
->child(1)->is_leaf()
231 && node
->child(1)->name() == "S");
232 const std::string
func(node
->child(0)->name());
234 this->uses_symbol_base_
= true;
235 else if (func
== "GOT")
236 this->uses_got_entry_
= true;
237 else if (func
== "PLT")
238 this->uses_plt_entry_
= true;
239 else if (func
== "Module" || func
== "DELTA_B")
240 // These are used in dynamic relocations.
244 node
= node
->child(1);
247 gold_assert(node
->is_leaf() && node
->name() == "S");
252 // Arm_reloc_property_table methods.
254 // Constructor. This processing informations in arm-reloc.def to
255 // initialize the table.
257 Arm_reloc_property_table::Arm_reloc_property_table()
259 // These appers in arm-reloc.def. Do not rename them.
260 Parse_expression
A("A"), GOT_ORG("GOT_ORG"), NONE("NONE"), P("P"),
261 Pa("Pa"), S("S"), T("T"), TLS("TLS"), tp("tp");
262 const bool Y(true), N(false);
264 for (unsigned int i
= 0; i
< Property_table_size
; ++i
)
265 this->table_
[i
] = NULL
;
268 #define RD(name, type, deprecated, class, operation, is_implemented, \
269 group_index, checks_oveflow) \
272 unsigned int code = elfcpp::R_ARM_##name; \
273 gold_assert(code < Property_table_size); \
274 this->table_[code] = \
275 new Arm_reloc_property(elfcpp::R_ARM_##name, "R_ARM_" #name, \
276 Arm_reloc_property::RT_##type, deprecated, \
277 Arm_reloc_property::RC_##class, \
278 (operation).s_expression(), is_implemented, \
279 group_index, checks_oveflow); \
283 #include "arm-reloc.def"
287 // Return a string describing a relocation code that fails to get a
288 // relocation property in get_implemented_static_reloc_property().
291 Arm_reloc_property_table::reloc_name_in_error_message(unsigned int code
)
293 gold_assert(code
< Property_table_size
);
295 const Arm_reloc_property
* arp
= this->table_
[code
];
300 sprintf(buffer
, _("invalid reloc %u"), code
);
301 return std::string(buffer
);
304 // gold only implements static relocation codes.
305 Arm_reloc_property::Reloc_type reloc_type
= arp
->reloc_type();
306 gold_assert(reloc_type
== Arm_reloc_property::RT_STATIC
307 || !arp
->is_implemented());
309 const char* prefix
= NULL
;
312 case Arm_reloc_property::RT_STATIC
:
313 prefix
= arp
->is_implemented() ? _("reloc ") : _("unimplemented reloc ");
315 case Arm_reloc_property::RT_DYNAMIC
:
316 prefix
= _("dynamic reloc ");
318 case Arm_reloc_property::RT_PRIVATE
:
319 prefix
= _("private reloc ");
321 case Arm_reloc_property::RT_OBSOLETE
:
322 prefix
= _("obsolete reloc ");
327 return std::string(prefix
) + arp
->name();
330 } // End namespace gold.