Merge branch 'vendor/GCC50'
[dragonfly.git] / contrib / binutils-2.24 / gold / arm.cc
1 // arm.cc -- arm target support for gold.
2
3 // Copyright 2009, 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
4 // Written by Doug Kwan <dougkwan@google.com> based on the i386 code
5 // by Ian Lance Taylor <iant@google.com>.
6 // This file also contains borrowed and adapted code from
7 // bfd/elf32-arm.c.
8
9 // This file is part of gold.
10
11 // This program is free software; you can redistribute it and/or modify
12 // it under the terms of the GNU General Public License as published by
13 // the Free Software Foundation; either version 3 of the License, or
14 // (at your option) any later version.
15
16 // This program is distributed in the hope that it will be useful,
17 // but WITHOUT ANY WARRANTY; without even the implied warranty of
18 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19 // GNU General Public License for more details.
20
21 // You should have received a copy of the GNU General Public License
22 // along with this program; if not, write to the Free Software
23 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
24 // MA 02110-1301, USA.
25
26 #include "gold.h"
27
28 #include <cstring>
29 #include <limits>
30 #include <cstdio>
31 #include <string>
32 #include <algorithm>
33 #include <map>
34 #include <utility>
35 #include <set>
36
37 #include "elfcpp.h"
38 #include "parameters.h"
39 #include "reloc.h"
40 #include "arm.h"
41 #include "object.h"
42 #include "symtab.h"
43 #include "layout.h"
44 #include "output.h"
45 #include "copy-relocs.h"
46 #include "target.h"
47 #include "target-reloc.h"
48 #include "target-select.h"
49 #include "tls.h"
50 #include "defstd.h"
51 #include "gc.h"
52 #include "attributes.h"
53 #include "arm-reloc-property.h"
54 #include "nacl.h"
55
56 namespace
57 {
58
59 using namespace gold;
60
61 template<bool big_endian>
62 class Output_data_plt_arm;
63
64 template<bool big_endian>
65 class Output_data_plt_arm_standard;
66
67 template<bool big_endian>
68 class Stub_table;
69
70 template<bool big_endian>
71 class Arm_input_section;
72
73 class Arm_exidx_cantunwind;
74
75 class Arm_exidx_merged_section;
76
77 class Arm_exidx_fixup;
78
79 template<bool big_endian>
80 class Arm_output_section;
81
82 class Arm_exidx_input_section;
83
84 template<bool big_endian>
85 class Arm_relobj;
86
87 template<bool big_endian>
88 class Arm_relocate_functions;
89
90 template<bool big_endian>
91 class Arm_output_data_got;
92
93 template<bool big_endian>
94 class Target_arm;
95
96 // For convenience.
97 typedef elfcpp::Elf_types<32>::Elf_Addr Arm_address;
98
99 // Maximum branch offsets for ARM, THUMB and THUMB2.
100 const int32_t ARM_MAX_FWD_BRANCH_OFFSET = ((((1 << 23) - 1) << 2) + 8);
101 const int32_t ARM_MAX_BWD_BRANCH_OFFSET = ((-((1 << 23) << 2)) + 8);
102 const int32_t THM_MAX_FWD_BRANCH_OFFSET = ((1 << 22) -2 + 4);
103 const int32_t THM_MAX_BWD_BRANCH_OFFSET = (-(1 << 22) + 4);
104 const int32_t THM2_MAX_FWD_BRANCH_OFFSET = (((1 << 24) - 2) + 4);
105 const int32_t THM2_MAX_BWD_BRANCH_OFFSET = (-(1 << 24) + 4);
106
107 // Thread Control Block size.
108 const size_t ARM_TCB_SIZE = 8;
109
110 // The arm target class.
111 //
112 // This is a very simple port of gold for ARM-EABI.  It is intended for
113 // supporting Android only for the time being.
114 //
115 // TODOs:
116 // - Implement all static relocation types documented in arm-reloc.def.
117 // - Make PLTs more flexible for different architecture features like
118 //   Thumb-2 and BE8.
119 // There are probably a lot more.
120
121 // Ideally we would like to avoid using global variables but this is used
122 // very in many places and sometimes in loops.  If we use a function
123 // returning a static instance of Arm_reloc_property_table, it will be very
124 // slow in an threaded environment since the static instance needs to be
125 // locked.  The pointer is below initialized in the
126 // Target::do_select_as_default_target() hook so that we do not spend time
127 // building the table if we are not linking ARM objects.
128 //
129 // An alternative is to to process the information in arm-reloc.def in
130 // compilation time and generate a representation of it in PODs only.  That
131 // way we can avoid initialization when the linker starts.
132
133 Arm_reloc_property_table* arm_reloc_property_table = NULL;
134
135 // Instruction template class.  This class is similar to the insn_sequence
136 // struct in bfd/elf32-arm.c.
137
138 class Insn_template
139 {
140  public:
141   // Types of instruction templates.
142   enum Type
143     {
144       THUMB16_TYPE = 1,
145       // THUMB16_SPECIAL_TYPE is used by sub-classes of Stub for instruction
146       // templates with class-specific semantics.  Currently this is used
147       // only by the Cortex_a8_stub class for handling condition codes in
148       // conditional branches.
149       THUMB16_SPECIAL_TYPE,
150       THUMB32_TYPE,
151       ARM_TYPE,
152       DATA_TYPE
153     };
154
155   // Factory methods to create instruction templates in different formats.
156
157   static const Insn_template
158   thumb16_insn(uint32_t data)
159   { return Insn_template(data, THUMB16_TYPE, elfcpp::R_ARM_NONE, 0); }
160
161   // A Thumb conditional branch, in which the proper condition is inserted
162   // when we build the stub.
163   static const Insn_template
164   thumb16_bcond_insn(uint32_t data)
165   { return Insn_template(data, THUMB16_SPECIAL_TYPE, elfcpp::R_ARM_NONE, 1); }
166
167   static const Insn_template
168   thumb32_insn(uint32_t data)
169   { return Insn_template(data, THUMB32_TYPE, elfcpp::R_ARM_NONE, 0); }
170
171   static const Insn_template
172   thumb32_b_insn(uint32_t data, int reloc_addend)
173   {
174     return Insn_template(data, THUMB32_TYPE, elfcpp::R_ARM_THM_JUMP24,
175                          reloc_addend);
176   }
177
178   static const Insn_template
179   arm_insn(uint32_t data)
180   { return Insn_template(data, ARM_TYPE, elfcpp::R_ARM_NONE, 0); }
181
182   static const Insn_template
183   arm_rel_insn(unsigned data, int reloc_addend)
184   { return Insn_template(data, ARM_TYPE, elfcpp::R_ARM_JUMP24, reloc_addend); }
185
186   static const Insn_template
187   data_word(unsigned data, unsigned int r_type, int reloc_addend)
188   { return Insn_template(data, DATA_TYPE, r_type, reloc_addend); }
189
190   // Accessors.  This class is used for read-only objects so no modifiers
191   // are provided.
192
193   uint32_t
194   data() const
195   { return this->data_; }
196
197   // Return the instruction sequence type of this.
198   Type
199   type() const
200   { return this->type_; }
201
202   // Return the ARM relocation type of this.
203   unsigned int
204   r_type() const
205   { return this->r_type_; }
206
207   int32_t
208   reloc_addend() const
209   { return this->reloc_addend_; }
210
211   // Return size of instruction template in bytes.
212   size_t
213   size() const;
214
215   // Return byte-alignment of instruction template.
216   unsigned
217   alignment() const;
218
219  private:
220   // We make the constructor private to ensure that only the factory
221   // methods are used.
222   inline
223   Insn_template(unsigned data, Type type, unsigned int r_type, int reloc_addend)
224     : data_(data), type_(type), r_type_(r_type), reloc_addend_(reloc_addend)
225   { }
226
227   // Instruction specific data.  This is used to store information like
228   // some of the instruction bits.
229   uint32_t data_;
230   // Instruction template type.
231   Type type_;
232   // Relocation type if there is a relocation or R_ARM_NONE otherwise.
233   unsigned int r_type_;
234   // Relocation addend.
235   int32_t reloc_addend_;
236 };
237
238 // Macro for generating code to stub types. One entry per long/short
239 // branch stub
240
241 #define DEF_STUBS \
242   DEF_STUB(long_branch_any_any) \
243   DEF_STUB(long_branch_v4t_arm_thumb) \
244   DEF_STUB(long_branch_thumb_only) \
245   DEF_STUB(long_branch_v4t_thumb_thumb) \
246   DEF_STUB(long_branch_v4t_thumb_arm) \
247   DEF_STUB(short_branch_v4t_thumb_arm) \
248   DEF_STUB(long_branch_any_arm_pic) \
249   DEF_STUB(long_branch_any_thumb_pic) \
250   DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
251   DEF_STUB(long_branch_v4t_arm_thumb_pic) \
252   DEF_STUB(long_branch_v4t_thumb_arm_pic) \
253   DEF_STUB(long_branch_thumb_only_pic) \
254   DEF_STUB(a8_veneer_b_cond) \
255   DEF_STUB(a8_veneer_b) \
256   DEF_STUB(a8_veneer_bl) \
257   DEF_STUB(a8_veneer_blx) \
258   DEF_STUB(v4_veneer_bx)
259
260 // Stub types.
261
262 #define DEF_STUB(x) arm_stub_##x,
263 typedef enum
264   {
265     arm_stub_none,
266     DEF_STUBS
267
268     // First reloc stub type.
269     arm_stub_reloc_first = arm_stub_long_branch_any_any,
270     // Last  reloc stub type.
271     arm_stub_reloc_last = arm_stub_long_branch_thumb_only_pic,
272
273     // First Cortex-A8 stub type.
274     arm_stub_cortex_a8_first = arm_stub_a8_veneer_b_cond,
275     // Last Cortex-A8 stub type.
276     arm_stub_cortex_a8_last = arm_stub_a8_veneer_blx,
277
278     // Last stub type.
279     arm_stub_type_last = arm_stub_v4_veneer_bx
280   } Stub_type;
281 #undef DEF_STUB
282
283 // Stub template class.  Templates are meant to be read-only objects.
284 // A stub template for a stub type contains all read-only attributes
285 // common to all stubs of the same type.
286
287 class Stub_template
288 {
289  public:
290   Stub_template(Stub_type, const Insn_template*, size_t);
291
292   ~Stub_template()
293   { }
294
295   // Return stub type.
296   Stub_type
297   type() const
298   { return this->type_; }
299
300   // Return an array of instruction templates.
301   const Insn_template*
302   insns() const
303   { return this->insns_; }
304
305   // Return size of template in number of instructions.
306   size_t
307   insn_count() const
308   { return this->insn_count_; }
309
310   // Return size of template in bytes.
311   size_t
312   size() const
313   { return this->size_; }
314
315   // Return alignment of the stub template.
316   unsigned
317   alignment() const
318   { return this->alignment_; }
319
320   // Return whether entry point is in thumb mode.
321   bool
322   entry_in_thumb_mode() const
323   { return this->entry_in_thumb_mode_; }
324
325   // Return number of relocations in this template.
326   size_t
327   reloc_count() const
328   { return this->relocs_.size(); }
329
330   // Return index of the I-th instruction with relocation.
331   size_t
332   reloc_insn_index(size_t i) const
333   {
334     gold_assert(i < this->relocs_.size());
335     return this->relocs_[i].first;
336   }
337
338   // Return the offset of the I-th instruction with relocation from the
339   // beginning of the stub.
340   section_size_type
341   reloc_offset(size_t i) const
342   {
343     gold_assert(i < this->relocs_.size());
344     return this->relocs_[i].second;
345   }
346
347  private:
348   // This contains information about an instruction template with a relocation
349   // and its offset from start of stub.
350   typedef std::pair<size_t, section_size_type> Reloc;
351
352   // A Stub_template may not be copied.  We want to share templates as much
353   // as possible.
354   Stub_template(const Stub_template&);
355   Stub_template& operator=(const Stub_template&);
356
357   // Stub type.
358   Stub_type type_;
359   // Points to an array of Insn_templates.
360   const Insn_template* insns_;
361   // Number of Insn_templates in insns_[].
362   size_t insn_count_;
363   // Size of templated instructions in bytes.
364   size_t size_;
365   // Alignment of templated instructions.
366   unsigned alignment_;
367   // Flag to indicate if entry is in thumb mode.
368   bool entry_in_thumb_mode_;
369   // A table of reloc instruction indices and offsets.  We can find these by
370   // looking at the instruction templates but we pre-compute and then stash
371   // them here for speed.
372   std::vector<Reloc> relocs_;
373 };
374
375 //
376 // A class for code stubs.  This is a base class for different type of
377 // stubs used in the ARM target.
378 //
379
380 class Stub
381 {
382  private:
383   static const section_offset_type invalid_offset =
384     static_cast<section_offset_type>(-1);
385
386  public:
387   Stub(const Stub_template* stub_template)
388     : stub_template_(stub_template), offset_(invalid_offset)
389   { }
390
391   virtual
392    ~Stub()
393   { }
394
395   // Return the stub template.
396   const Stub_template*
397   stub_template() const
398   { return this->stub_template_; }
399
400   // Return offset of code stub from beginning of its containing stub table.
401   section_offset_type
402   offset() const
403   {
404     gold_assert(this->offset_ != invalid_offset);
405     return this->offset_;
406   }
407
408   // Set offset of code stub from beginning of its containing stub table.
409   void
410   set_offset(section_offset_type offset)
411   { this->offset_ = offset; }
412
413   // Return the relocation target address of the i-th relocation in the
414   // stub.  This must be defined in a child class.
415   Arm_address
416   reloc_target(size_t i)
417   { return this->do_reloc_target(i); }
418
419   // Write a stub at output VIEW.  BIG_ENDIAN select how a stub is written.
420   void
421   write(unsigned char* view, section_size_type view_size, bool big_endian)
422   { this->do_write(view, view_size, big_endian); }
423
424   // Return the instruction for THUMB16_SPECIAL_TYPE instruction template
425   // for the i-th instruction.
426   uint16_t
427   thumb16_special(size_t i)
428   { return this->do_thumb16_special(i); }
429
430  protected:
431   // This must be defined in the child class.
432   virtual Arm_address
433   do_reloc_target(size_t) = 0;
434
435   // This may be overridden in the child class.
436   virtual void
437   do_write(unsigned char* view, section_size_type view_size, bool big_endian)
438   {
439     if (big_endian)
440       this->do_fixed_endian_write<true>(view, view_size);
441     else
442       this->do_fixed_endian_write<false>(view, view_size);
443   }
444
445   // This must be overridden if a child class uses the THUMB16_SPECIAL_TYPE
446   // instruction template.
447   virtual uint16_t
448   do_thumb16_special(size_t)
449   { gold_unreachable(); }
450
451  private:
452   // A template to implement do_write.
453   template<bool big_endian>
454   void inline
455   do_fixed_endian_write(unsigned char*, section_size_type);
456
457   // Its template.
458   const Stub_template* stub_template_;
459   // Offset within the section of containing this stub.
460   section_offset_type offset_;
461 };
462
463 // Reloc stub class.  These are stubs we use to fix up relocation because
464 // of limited branch ranges.
465
466 class Reloc_stub : public Stub
467 {
468  public:
469   static const unsigned int invalid_index = static_cast<unsigned int>(-1);
470   // We assume we never jump to this address.
471   static const Arm_address invalid_address = static_cast<Arm_address>(-1);
472
473   // Return destination address.
474   Arm_address
475   destination_address() const
476   {
477     gold_assert(this->destination_address_ != this->invalid_address);
478     return this->destination_address_;
479   }
480
481   // Set destination address.
482   void
483   set_destination_address(Arm_address address)
484   {
485     gold_assert(address != this->invalid_address);
486     this->destination_address_ = address;
487   }
488
489   // Reset destination address.
490   void
491   reset_destination_address()
492   { this->destination_address_ = this->invalid_address; }
493
494   // Determine stub type for a branch of a relocation of R_TYPE going
495   // from BRANCH_ADDRESS to BRANCH_TARGET.  If TARGET_IS_THUMB is set,
496   // the branch target is a thumb instruction.  TARGET is used for look
497   // up ARM-specific linker settings.
498   static Stub_type
499   stub_type_for_reloc(unsigned int r_type, Arm_address branch_address,
500                       Arm_address branch_target, bool target_is_thumb);
501
502   // Reloc_stub key.  A key is logically a triplet of a stub type, a symbol
503   // and an addend.  Since we treat global and local symbol differently, we
504   // use a Symbol object for a global symbol and a object-index pair for
505   // a local symbol.
506   class Key
507   {
508    public:
509     // If SYMBOL is not null, this is a global symbol, we ignore RELOBJ and
510     // R_SYM.  Otherwise, this is a local symbol and RELOBJ must non-NULL
511     // and R_SYM must not be invalid_index.
512     Key(Stub_type stub_type, const Symbol* symbol, const Relobj* relobj,
513         unsigned int r_sym, int32_t addend)
514       : stub_type_(stub_type), addend_(addend)
515     {
516       if (symbol != NULL)
517         {
518           this->r_sym_ = Reloc_stub::invalid_index;
519           this->u_.symbol = symbol;
520         }
521       else
522         {
523           gold_assert(relobj != NULL && r_sym != invalid_index);
524           this->r_sym_ = r_sym;
525           this->u_.relobj = relobj;
526         }
527     }
528
529     ~Key()
530     { }
531
532     // Accessors: Keys are meant to be read-only object so no modifiers are
533     // provided.
534
535     // Return stub type.
536     Stub_type
537     stub_type() const
538     { return this->stub_type_; }
539
540     // Return the local symbol index or invalid_index.
541     unsigned int
542     r_sym() const
543     { return this->r_sym_; }
544
545     // Return the symbol if there is one.
546     const Symbol*
547     symbol() const
548     { return this->r_sym_ == invalid_index ? this->u_.symbol : NULL; }
549
550     // Return the relobj if there is one.
551     const Relobj*
552     relobj() const
553     { return this->r_sym_ != invalid_index ? this->u_.relobj : NULL; }
554
555     // Whether this equals to another key k.
556     bool
557     eq(const Key& k) const
558     {
559       return ((this->stub_type_ == k.stub_type_)
560               && (this->r_sym_ == k.r_sym_)
561               && ((this->r_sym_ != Reloc_stub::invalid_index)
562                   ? (this->u_.relobj == k.u_.relobj)
563                   : (this->u_.symbol == k.u_.symbol))
564               && (this->addend_ == k.addend_));
565     }
566
567     // Return a hash value.
568     size_t
569     hash_value() const
570     {
571       return (this->stub_type_
572               ^ this->r_sym_
573               ^ gold::string_hash<char>(
574                     (this->r_sym_ != Reloc_stub::invalid_index)
575                     ? this->u_.relobj->name().c_str()
576                     : this->u_.symbol->name())
577               ^ this->addend_);
578     }
579
580     // Functors for STL associative containers.
581     struct hash
582     {
583       size_t
584       operator()(const Key& k) const
585       { return k.hash_value(); }
586     };
587
588     struct equal_to
589     {
590       bool
591       operator()(const Key& k1, const Key& k2) const
592       { return k1.eq(k2); }
593     };
594
595     // Name of key.  This is mainly for debugging.
596     std::string
597     name() const;
598
599    private:
600     // Stub type.
601     Stub_type stub_type_;
602     // If this is a local symbol, this is the index in the defining object.
603     // Otherwise, it is invalid_index for a global symbol.
604     unsigned int r_sym_;
605     // If r_sym_ is an invalid index, this points to a global symbol.
606     // Otherwise, it points to a relobj.  We used the unsized and target
607     // independent Symbol and Relobj classes instead of Sized_symbol<32> and
608     // Arm_relobj, in order to avoid making the stub class a template
609     // as most of the stub machinery is endianness-neutral.  However, it
610     // may require a bit of casting done by users of this class.
611     union
612     {
613       const Symbol* symbol;
614       const Relobj* relobj;
615     } u_;
616     // Addend associated with a reloc.
617     int32_t addend_;
618   };
619
620  protected:
621   // Reloc_stubs are created via a stub factory.  So these are protected.
622   Reloc_stub(const Stub_template* stub_template)
623     : Stub(stub_template), destination_address_(invalid_address)
624   { }
625
626   ~Reloc_stub()
627   { }
628
629   friend class Stub_factory;
630
631   // Return the relocation target address of the i-th relocation in the
632   // stub.
633   Arm_address
634   do_reloc_target(size_t i)
635   {
636     // All reloc stub have only one relocation.
637     gold_assert(i == 0);
638     return this->destination_address_;
639   }
640
641  private:
642   // Address of destination.
643   Arm_address destination_address_;
644 };
645
646 // Cortex-A8 stub class.  We need a Cortex-A8 stub to redirect any 32-bit
647 // THUMB branch that meets the following conditions:
648 //
649 // 1. The branch straddles across a page boundary. i.e. lower 12-bit of
650 //    branch address is 0xffe.
651 // 2. The branch target address is in the same page as the first word of the
652 //    branch.
653 // 3. The branch follows a 32-bit instruction which is not a branch.
654 //
655 // To do the fix up, we need to store the address of the branch instruction
656 // and its target at least.  We also need to store the original branch
657 // instruction bits for the condition code in a conditional branch.  The
658 // condition code is used in a special instruction template.  We also want
659 // to identify input sections needing Cortex-A8 workaround quickly.  We store
660 // extra information about object and section index of the code section
661 // containing a branch being fixed up.  The information is used to mark
662 // the code section when we finalize the Cortex-A8 stubs.
663 //
664
665 class Cortex_a8_stub : public Stub
666 {
667  public:
668   ~Cortex_a8_stub()
669   { }
670
671   // Return the object of the code section containing the branch being fixed
672   // up.
673   Relobj*
674   relobj() const
675   { return this->relobj_; }
676
677   // Return the section index of the code section containing the branch being
678   // fixed up.
679   unsigned int
680   shndx() const
681   { return this->shndx_; }
682
683   // Return the source address of stub.  This is the address of the original
684   // branch instruction.  LSB is 1 always set to indicate that it is a THUMB
685   // instruction.
686   Arm_address
687   source_address() const
688   { return this->source_address_; }
689
690   // Return the destination address of the stub.  This is the branch taken
691   // address of the original branch instruction.  LSB is 1 if it is a THUMB
692   // instruction address.
693   Arm_address
694   destination_address() const
695   { return this->destination_address_; }
696
697   // Return the instruction being fixed up.
698   uint32_t
699   original_insn() const
700   { return this->original_insn_; }
701
702  protected:
703   // Cortex_a8_stubs are created via a stub factory.  So these are protected.
704   Cortex_a8_stub(const Stub_template* stub_template, Relobj* relobj,
705                  unsigned int shndx, Arm_address source_address,
706                  Arm_address destination_address, uint32_t original_insn)
707     : Stub(stub_template), relobj_(relobj), shndx_(shndx),
708       source_address_(source_address | 1U),
709       destination_address_(destination_address),
710       original_insn_(original_insn)
711   { }
712
713   friend class Stub_factory;
714
715   // Return the relocation target address of the i-th relocation in the
716   // stub.
717   Arm_address
718   do_reloc_target(size_t i)
719   {
720     if (this->stub_template()->type() == arm_stub_a8_veneer_b_cond)
721       {
722         // The conditional branch veneer has two relocations.
723         gold_assert(i < 2);
724         return i == 0 ? this->source_address_ + 4 : this->destination_address_;
725       }
726     else
727       {
728         // All other Cortex-A8 stubs have only one relocation.
729         gold_assert(i == 0);
730         return this->destination_address_;
731       }
732   }
733
734   // Return an instruction for the THUMB16_SPECIAL_TYPE instruction template.
735   uint16_t
736   do_thumb16_special(size_t);
737
738  private:
739   // Object of the code section containing the branch being fixed up.
740   Relobj* relobj_;
741   // Section index of the code section containing the branch begin fixed up.
742   unsigned int shndx_;
743   // Source address of original branch.
744   Arm_address source_address_;
745   // Destination address of the original branch.
746   Arm_address destination_address_;
747   // Original branch instruction.  This is needed for copying the condition
748   // code from a condition branch to its stub.
749   uint32_t original_insn_;
750 };
751
752 // ARMv4 BX Rx branch relocation stub class.
753 class Arm_v4bx_stub : public Stub
754 {
755  public:
756   ~Arm_v4bx_stub()
757   { }
758
759   // Return the associated register.
760   uint32_t
761   reg() const
762   { return this->reg_; }
763
764  protected:
765   // Arm V4BX stubs are created via a stub factory.  So these are protected.
766   Arm_v4bx_stub(const Stub_template* stub_template, const uint32_t reg)
767     : Stub(stub_template), reg_(reg)
768   { }
769
770   friend class Stub_factory;
771
772   // Return the relocation target address of the i-th relocation in the
773   // stub.
774   Arm_address
775   do_reloc_target(size_t)
776   { gold_unreachable(); }
777
778   // This may be overridden in the child class.
779   virtual void
780   do_write(unsigned char* view, section_size_type view_size, bool big_endian)
781   {
782     if (big_endian)
783       this->do_fixed_endian_v4bx_write<true>(view, view_size);
784     else
785       this->do_fixed_endian_v4bx_write<false>(view, view_size);
786   }
787
788  private:
789   // A template to implement do_write.
790   template<bool big_endian>
791   void inline
792   do_fixed_endian_v4bx_write(unsigned char* view, section_size_type)
793   {
794     const Insn_template* insns = this->stub_template()->insns();
795     elfcpp::Swap<32, big_endian>::writeval(view,
796                                            (insns[0].data()
797                                            + (this->reg_ << 16)));
798     view += insns[0].size();
799     elfcpp::Swap<32, big_endian>::writeval(view,
800                                            (insns[1].data() + this->reg_));
801     view += insns[1].size();
802     elfcpp::Swap<32, big_endian>::writeval(view,
803                                            (insns[2].data() + this->reg_));
804   }
805
806   // A register index (r0-r14), which is associated with the stub.
807   uint32_t reg_;
808 };
809
810 // Stub factory class.
811
812 class Stub_factory
813 {
814  public:
815   // Return the unique instance of this class.
816   static const Stub_factory&
817   get_instance()
818   {
819     static Stub_factory singleton;
820     return singleton;
821   }
822
823   // Make a relocation stub.
824   Reloc_stub*
825   make_reloc_stub(Stub_type stub_type) const
826   {
827     gold_assert(stub_type >= arm_stub_reloc_first
828                 && stub_type <= arm_stub_reloc_last);
829     return new Reloc_stub(this->stub_templates_[stub_type]);
830   }
831
832   // Make a Cortex-A8 stub.
833   Cortex_a8_stub*
834   make_cortex_a8_stub(Stub_type stub_type, Relobj* relobj, unsigned int shndx,
835                       Arm_address source, Arm_address destination,
836                       uint32_t original_insn) const
837   {
838     gold_assert(stub_type >= arm_stub_cortex_a8_first
839                 && stub_type <= arm_stub_cortex_a8_last);
840     return new Cortex_a8_stub(this->stub_templates_[stub_type], relobj, shndx,
841                               source, destination, original_insn);
842   }
843
844   // Make an ARM V4BX relocation stub.
845   // This method creates a stub from the arm_stub_v4_veneer_bx template only.
846   Arm_v4bx_stub*
847   make_arm_v4bx_stub(uint32_t reg) const
848   {
849     gold_assert(reg < 0xf);
850     return new Arm_v4bx_stub(this->stub_templates_[arm_stub_v4_veneer_bx],
851                              reg);
852   }
853
854  private:
855   // Constructor and destructor are protected since we only return a single
856   // instance created in Stub_factory::get_instance().
857
858   Stub_factory();
859
860   // A Stub_factory may not be copied since it is a singleton.
861   Stub_factory(const Stub_factory&);
862   Stub_factory& operator=(Stub_factory&);
863
864   // Stub templates.  These are initialized in the constructor.
865   const Stub_template* stub_templates_[arm_stub_type_last+1];
866 };
867
868 // A class to hold stubs for the ARM target.
869
870 template<bool big_endian>
871 class Stub_table : public Output_data
872 {
873  public:
874   Stub_table(Arm_input_section<big_endian>* owner)
875     : Output_data(), owner_(owner), reloc_stubs_(), reloc_stubs_size_(0),
876       reloc_stubs_addralign_(1), cortex_a8_stubs_(), arm_v4bx_stubs_(0xf),
877       prev_data_size_(0), prev_addralign_(1)
878   { }
879
880   ~Stub_table()
881   { }
882
883   // Owner of this stub table.
884   Arm_input_section<big_endian>*
885   owner() const
886   { return this->owner_; }
887
888   // Whether this stub table is empty.
889   bool
890   empty() const
891   {
892     return (this->reloc_stubs_.empty()
893             && this->cortex_a8_stubs_.empty()
894             && this->arm_v4bx_stubs_.empty());
895   }
896
897   // Return the current data size.
898   off_t
899   current_data_size() const
900   { return this->current_data_size_for_child(); }
901
902   // Add a STUB using KEY.  The caller is responsible for avoiding addition
903   // if a STUB with the same key has already been added.
904   void
905   add_reloc_stub(Reloc_stub* stub, const Reloc_stub::Key& key)
906   {
907     const Stub_template* stub_template = stub->stub_template();
908     gold_assert(stub_template->type() == key.stub_type());
909     this->reloc_stubs_[key] = stub;
910
911     // Assign stub offset early.  We can do this because we never remove
912     // reloc stubs and they are in the beginning of the stub table.
913     uint64_t align = stub_template->alignment();
914     this->reloc_stubs_size_ = align_address(this->reloc_stubs_size_, align);
915     stub->set_offset(this->reloc_stubs_size_);
916     this->reloc_stubs_size_ += stub_template->size();
917     this->reloc_stubs_addralign_ =
918       std::max(this->reloc_stubs_addralign_, align);
919   }
920
921   // Add a Cortex-A8 STUB that fixes up a THUMB branch at ADDRESS.
922   // The caller is responsible for avoiding addition if a STUB with the same
923   // address has already been added.
924   void
925   add_cortex_a8_stub(Arm_address address, Cortex_a8_stub* stub)
926   {
927     std::pair<Arm_address, Cortex_a8_stub*> value(address, stub);
928     this->cortex_a8_stubs_.insert(value);
929   }
930
931   // Add an ARM V4BX relocation stub. A register index will be retrieved
932   // from the stub.
933   void
934   add_arm_v4bx_stub(Arm_v4bx_stub* stub)
935   {
936     gold_assert(stub != NULL && this->arm_v4bx_stubs_[stub->reg()] == NULL);
937     this->arm_v4bx_stubs_[stub->reg()] = stub;
938   }
939
940   // Remove all Cortex-A8 stubs.
941   void
942   remove_all_cortex_a8_stubs();
943
944   // Look up a relocation stub using KEY.  Return NULL if there is none.
945   Reloc_stub*
946   find_reloc_stub(const Reloc_stub::Key& key) const
947   {
948     typename Reloc_stub_map::const_iterator p = this->reloc_stubs_.find(key);
949     return (p != this->reloc_stubs_.end()) ? p->second : NULL;
950   }
951
952   // Look up an arm v4bx relocation stub using the register index.
953   // Return NULL if there is none.
954   Arm_v4bx_stub*
955   find_arm_v4bx_stub(const uint32_t reg) const
956   {
957     gold_assert(reg < 0xf);
958     return this->arm_v4bx_stubs_[reg];
959   }
960
961   // Relocate stubs in this stub table.
962   void
963   relocate_stubs(const Relocate_info<32, big_endian>*,
964                  Target_arm<big_endian>*, Output_section*,
965                  unsigned char*, Arm_address, section_size_type);
966
967   // Update data size and alignment at the end of a relaxation pass.  Return
968   // true if either data size or alignment is different from that of the
969   // previous relaxation pass.
970   bool
971   update_data_size_and_addralign();
972
973   // Finalize stubs.  Set the offsets of all stubs and mark input sections
974   // needing the Cortex-A8 workaround.
975   void
976   finalize_stubs();
977
978   // Apply Cortex-A8 workaround to an address range.
979   void
980   apply_cortex_a8_workaround_to_address_range(Target_arm<big_endian>*,
981                                               unsigned char*, Arm_address,
982                                               section_size_type);
983
984  protected:
985   // Write out section contents.
986   void
987   do_write(Output_file*);
988
989   // Return the required alignment.
990   uint64_t
991   do_addralign() const
992   { return this->prev_addralign_; }
993
994   // Reset address and file offset.
995   void
996   do_reset_address_and_file_offset()
997   { this->set_current_data_size_for_child(this->prev_data_size_); }
998
999   // Set final data size.
1000   void
1001   set_final_data_size()
1002   { this->set_data_size(this->current_data_size()); }
1003
1004  private:
1005   // Relocate one stub.
1006   void
1007   relocate_stub(Stub*, const Relocate_info<32, big_endian>*,
1008                 Target_arm<big_endian>*, Output_section*,
1009                 unsigned char*, Arm_address, section_size_type);
1010
1011   // Unordered map of relocation stubs.
1012   typedef
1013     Unordered_map<Reloc_stub::Key, Reloc_stub*, Reloc_stub::Key::hash,
1014                   Reloc_stub::Key::equal_to>
1015     Reloc_stub_map;
1016
1017   // List of Cortex-A8 stubs ordered by addresses of branches being
1018   // fixed up in output.
1019   typedef std::map<Arm_address, Cortex_a8_stub*> Cortex_a8_stub_list;
1020   // List of Arm V4BX relocation stubs ordered by associated registers.
1021   typedef std::vector<Arm_v4bx_stub*> Arm_v4bx_stub_list;
1022
1023   // Owner of this stub table.
1024   Arm_input_section<big_endian>* owner_;
1025   // The relocation stubs.
1026   Reloc_stub_map reloc_stubs_;
1027   // Size of reloc stubs.
1028   off_t reloc_stubs_size_;
1029   // Maximum address alignment of reloc stubs.
1030   uint64_t reloc_stubs_addralign_;
1031   // The cortex_a8_stubs.
1032   Cortex_a8_stub_list cortex_a8_stubs_;
1033   // The Arm V4BX relocation stubs.
1034   Arm_v4bx_stub_list arm_v4bx_stubs_;
1035   // data size of this in the previous pass.
1036   off_t prev_data_size_;
1037   // address alignment of this in the previous pass.
1038   uint64_t prev_addralign_;
1039 };
1040
1041 // Arm_exidx_cantunwind class.  This represents an EXIDX_CANTUNWIND entry
1042 // we add to the end of an EXIDX input section that goes into the output.
1043
1044 class Arm_exidx_cantunwind : public Output_section_data
1045 {
1046  public:
1047   Arm_exidx_cantunwind(Relobj* relobj, unsigned int shndx)
1048     : Output_section_data(8, 4, true), relobj_(relobj), shndx_(shndx)
1049   { }
1050
1051   // Return the object containing the section pointed by this.
1052   Relobj*
1053   relobj() const
1054   { return this->relobj_; }
1055
1056   // Return the section index of the section pointed by this.
1057   unsigned int
1058   shndx() const
1059   { return this->shndx_; }
1060
1061  protected:
1062   void
1063   do_write(Output_file* of)
1064   {
1065     if (parameters->target().is_big_endian())
1066       this->do_fixed_endian_write<true>(of);
1067     else
1068       this->do_fixed_endian_write<false>(of);
1069   }
1070
1071   // Write to a map file.
1072   void
1073   do_print_to_mapfile(Mapfile* mapfile) const
1074   { mapfile->print_output_data(this, _("** ARM cantunwind")); }
1075
1076  private:
1077   // Implement do_write for a given endianness.
1078   template<bool big_endian>
1079   void inline
1080   do_fixed_endian_write(Output_file*);
1081
1082   // The object containing the section pointed by this.
1083   Relobj* relobj_;
1084   // The section index of the section pointed by this.
1085   unsigned int shndx_;
1086 };
1087
1088 // During EXIDX coverage fix-up, we compact an EXIDX section.  The
1089 // Offset map is used to map input section offset within the EXIDX section
1090 // to the output offset from the start of this EXIDX section.
1091
1092 typedef std::map<section_offset_type, section_offset_type>
1093         Arm_exidx_section_offset_map;
1094
1095 // Arm_exidx_merged_section class.  This represents an EXIDX input section
1096 // with some of its entries merged.
1097
1098 class Arm_exidx_merged_section : public Output_relaxed_input_section
1099 {
1100  public:
1101   // Constructor for Arm_exidx_merged_section.
1102   // EXIDX_INPUT_SECTION points to the unmodified EXIDX input section.
1103   // SECTION_OFFSET_MAP points to a section offset map describing how
1104   // parts of the input section are mapped to output.  DELETED_BYTES is
1105   // the number of bytes deleted from the EXIDX input section.
1106   Arm_exidx_merged_section(
1107       const Arm_exidx_input_section& exidx_input_section,
1108       const Arm_exidx_section_offset_map& section_offset_map,
1109       uint32_t deleted_bytes);
1110
1111   // Build output contents.
1112   void
1113   build_contents(const unsigned char*, section_size_type);
1114
1115   // Return the original EXIDX input section.
1116   const Arm_exidx_input_section&
1117   exidx_input_section() const
1118   { return this->exidx_input_section_; }
1119
1120   // Return the section offset map.
1121   const Arm_exidx_section_offset_map&
1122   section_offset_map() const
1123   { return this->section_offset_map_; }
1124
1125  protected:
1126   // Write merged section into file OF.
1127   void
1128   do_write(Output_file* of);
1129
1130   bool
1131   do_output_offset(const Relobj*, unsigned int, section_offset_type,
1132                   section_offset_type*) const;
1133
1134  private:
1135   // Original EXIDX input section.
1136   const Arm_exidx_input_section& exidx_input_section_;
1137   // Section offset map.
1138   const Arm_exidx_section_offset_map& section_offset_map_;
1139   // Merged section contents.  We need to keep build the merged section
1140   // and save it here to avoid accessing the original EXIDX section when
1141   // we cannot lock the sections' object.
1142   unsigned char* section_contents_;
1143 };
1144
1145 // A class to wrap an ordinary input section containing executable code.
1146
1147 template<bool big_endian>
1148 class Arm_input_section : public Output_relaxed_input_section
1149 {
1150  public:
1151   Arm_input_section(Relobj* relobj, unsigned int shndx)
1152     : Output_relaxed_input_section(relobj, shndx, 1),
1153       original_addralign_(1), original_size_(0), stub_table_(NULL),
1154       original_contents_(NULL)
1155   { }
1156
1157   ~Arm_input_section()
1158   { delete[] this->original_contents_; }
1159
1160   // Initialize.
1161   void
1162   init();
1163
1164   // Whether this is a stub table owner.
1165   bool
1166   is_stub_table_owner() const
1167   { return this->stub_table_ != NULL && this->stub_table_->owner() == this; }
1168
1169   // Return the stub table.
1170   Stub_table<big_endian>*
1171   stub_table() const
1172   { return this->stub_table_; }
1173
1174   // Set the stub_table.
1175   void
1176   set_stub_table(Stub_table<big_endian>* stub_table)
1177   { this->stub_table_ = stub_table; }
1178
1179   // Downcast a base pointer to an Arm_input_section pointer.  This is
1180   // not type-safe but we only use Arm_input_section not the base class.
1181   static Arm_input_section<big_endian>*
1182   as_arm_input_section(Output_relaxed_input_section* poris)
1183   { return static_cast<Arm_input_section<big_endian>*>(poris); }
1184
1185   // Return the original size of the section.
1186   uint32_t
1187   original_size() const
1188   { return this->original_size_; }
1189
1190  protected:
1191   // Write data to output file.
1192   void
1193   do_write(Output_file*);
1194
1195   // Return required alignment of this.
1196   uint64_t
1197   do_addralign() const
1198   {
1199     if (this->is_stub_table_owner())
1200       return std::max(this->stub_table_->addralign(),
1201                       static_cast<uint64_t>(this->original_addralign_));
1202     else
1203       return this->original_addralign_;
1204   }
1205
1206   // Finalize data size.
1207   void
1208   set_final_data_size();
1209
1210   // Reset address and file offset.
1211   void
1212   do_reset_address_and_file_offset();
1213
1214   // Output offset.
1215   bool
1216   do_output_offset(const Relobj* object, unsigned int shndx,
1217                    section_offset_type offset,
1218                    section_offset_type* poutput) const
1219   {
1220     if ((object == this->relobj())
1221         && (shndx == this->shndx())
1222         && (offset >= 0)
1223         && (offset <=
1224             convert_types<section_offset_type, uint32_t>(this->original_size_)))
1225       {
1226         *poutput = offset;
1227         return true;
1228       }
1229     else
1230       return false;
1231   }
1232
1233  private:
1234   // Copying is not allowed.
1235   Arm_input_section(const Arm_input_section&);
1236   Arm_input_section& operator=(const Arm_input_section&);
1237
1238   // Address alignment of the original input section.
1239   uint32_t original_addralign_;
1240   // Section size of the original input section.
1241   uint32_t original_size_;
1242   // Stub table.
1243   Stub_table<big_endian>* stub_table_;
1244   // Original section contents.  We have to make a copy here since the file
1245   // containing the original section may not be locked when we need to access
1246   // the contents.
1247   unsigned char* original_contents_;
1248 };
1249
1250 // Arm_exidx_fixup class.  This is used to define a number of methods
1251 // and keep states for fixing up EXIDX coverage.
1252
1253 class Arm_exidx_fixup
1254 {
1255  public:
1256   Arm_exidx_fixup(Output_section* exidx_output_section,
1257                   bool merge_exidx_entries = true)
1258     : exidx_output_section_(exidx_output_section), last_unwind_type_(UT_NONE),
1259       last_inlined_entry_(0), last_input_section_(NULL),
1260       section_offset_map_(NULL), first_output_text_section_(NULL),
1261       merge_exidx_entries_(merge_exidx_entries)
1262   { }
1263
1264   ~Arm_exidx_fixup()
1265   { delete this->section_offset_map_; }
1266
1267   // Process an EXIDX section for entry merging.  SECTION_CONTENTS points
1268   // to the EXIDX contents and SECTION_SIZE is the size of the contents. Return
1269   // number of bytes to be deleted in output.  If parts of the input EXIDX
1270   // section are merged a heap allocated Arm_exidx_section_offset_map is store
1271   // in the located PSECTION_OFFSET_MAP.   The caller owns the map and is
1272   // responsible for releasing it.
1273   template<bool big_endian>
1274   uint32_t
1275   process_exidx_section(const Arm_exidx_input_section* exidx_input_section,
1276                         const unsigned char* section_contents,
1277                         section_size_type section_size,
1278                         Arm_exidx_section_offset_map** psection_offset_map);
1279
1280   // Append an EXIDX_CANTUNWIND entry pointing at the end of the last
1281   // input section, if there is not one already.
1282   void
1283   add_exidx_cantunwind_as_needed();
1284
1285   // Return the output section for the text section which is linked to the
1286   // first exidx input in output.
1287   Output_section*
1288   first_output_text_section() const
1289   { return this->first_output_text_section_; }
1290
1291  private:
1292   // Copying is not allowed.
1293   Arm_exidx_fixup(const Arm_exidx_fixup&);
1294   Arm_exidx_fixup& operator=(const Arm_exidx_fixup&);
1295
1296   // Type of EXIDX unwind entry.
1297   enum Unwind_type
1298   {
1299     // No type.
1300     UT_NONE,
1301     // EXIDX_CANTUNWIND.
1302     UT_EXIDX_CANTUNWIND,
1303     // Inlined entry.
1304     UT_INLINED_ENTRY,
1305     // Normal entry.
1306     UT_NORMAL_ENTRY,
1307   };
1308
1309   // Process an EXIDX entry.  We only care about the second word of the
1310   // entry.  Return true if the entry can be deleted.
1311   bool
1312   process_exidx_entry(uint32_t second_word);
1313
1314   // Update the current section offset map during EXIDX section fix-up.
1315   // If there is no map, create one.  INPUT_OFFSET is the offset of a
1316   // reference point, DELETED_BYTES is the number of deleted by in the
1317   // section so far.  If DELETE_ENTRY is true, the reference point and
1318   // all offsets after the previous reference point are discarded.
1319   void
1320   update_offset_map(section_offset_type input_offset,
1321                     section_size_type deleted_bytes, bool delete_entry);
1322
1323   // EXIDX output section.
1324   Output_section* exidx_output_section_;
1325   // Unwind type of the last EXIDX entry processed.
1326   Unwind_type last_unwind_type_;
1327   // Last seen inlined EXIDX entry.
1328   uint32_t last_inlined_entry_;
1329   // Last processed EXIDX input section.
1330   const Arm_exidx_input_section* last_input_section_;
1331   // Section offset map created in process_exidx_section.
1332   Arm_exidx_section_offset_map* section_offset_map_;
1333   // Output section for the text section which is linked to the first exidx
1334   // input in output.
1335   Output_section* first_output_text_section_;
1336
1337   bool merge_exidx_entries_;
1338 };
1339
1340 // Arm output section class.  This is defined mainly to add a number of
1341 // stub generation methods.
1342
1343 template<bool big_endian>
1344 class Arm_output_section : public Output_section
1345 {
1346  public:
1347   typedef std::vector<std::pair<Relobj*, unsigned int> > Text_section_list;
1348
1349   // We need to force SHF_LINK_ORDER in a SHT_ARM_EXIDX section.
1350   Arm_output_section(const char* name, elfcpp::Elf_Word type,
1351                      elfcpp::Elf_Xword flags)
1352     : Output_section(name, type,
1353                      (type == elfcpp::SHT_ARM_EXIDX
1354                       ? flags | elfcpp::SHF_LINK_ORDER
1355                       : flags))
1356   {
1357     if (type == elfcpp::SHT_ARM_EXIDX)
1358       this->set_always_keeps_input_sections();
1359   }
1360
1361   ~Arm_output_section()
1362   { }
1363
1364   // Group input sections for stub generation.
1365   void
1366   group_sections(section_size_type, bool, Target_arm<big_endian>*, const Task*);
1367
1368   // Downcast a base pointer to an Arm_output_section pointer.  This is
1369   // not type-safe but we only use Arm_output_section not the base class.
1370   static Arm_output_section<big_endian>*
1371   as_arm_output_section(Output_section* os)
1372   { return static_cast<Arm_output_section<big_endian>*>(os); }
1373
1374   // Append all input text sections in this into LIST.
1375   void
1376   append_text_sections_to_list(Text_section_list* list);
1377
1378   // Fix EXIDX coverage of this EXIDX output section.  SORTED_TEXT_SECTION
1379   // is a list of text input sections sorted in ascending order of their
1380   // output addresses.
1381   void
1382   fix_exidx_coverage(Layout* layout,
1383                      const Text_section_list& sorted_text_section,
1384                      Symbol_table* symtab,
1385                      bool merge_exidx_entries,
1386                      const Task* task);
1387
1388   // Link an EXIDX section into its corresponding text section.
1389   void
1390   set_exidx_section_link();
1391
1392  private:
1393   // For convenience.
1394   typedef Output_section::Input_section Input_section;
1395   typedef Output_section::Input_section_list Input_section_list;
1396
1397   // Create a stub group.
1398   void create_stub_group(Input_section_list::const_iterator,
1399                          Input_section_list::const_iterator,
1400                          Input_section_list::const_iterator,
1401                          Target_arm<big_endian>*,
1402                          std::vector<Output_relaxed_input_section*>*,
1403                          const Task* task);
1404 };
1405
1406 // Arm_exidx_input_section class.  This represents an EXIDX input section.
1407
1408 class Arm_exidx_input_section
1409 {
1410  public:
1411   static const section_offset_type invalid_offset =
1412     static_cast<section_offset_type>(-1);
1413
1414   Arm_exidx_input_section(Relobj* relobj, unsigned int shndx,
1415                           unsigned int link, uint32_t size,
1416                           uint32_t addralign, uint32_t text_size)
1417     : relobj_(relobj), shndx_(shndx), link_(link), size_(size),
1418       addralign_(addralign), text_size_(text_size), has_errors_(false)
1419   { }
1420
1421   ~Arm_exidx_input_section()
1422   { }
1423
1424   // Accessors:  This is a read-only class.
1425
1426   // Return the object containing this EXIDX input section.
1427   Relobj*
1428   relobj() const
1429   { return this->relobj_; }
1430
1431   // Return the section index of this EXIDX input section.
1432   unsigned int
1433   shndx() const
1434   { return this->shndx_; }
1435
1436   // Return the section index of linked text section in the same object.
1437   unsigned int
1438   link() const
1439   { return this->link_; }
1440
1441   // Return size of the EXIDX input section.
1442   uint32_t
1443   size() const
1444   { return this->size_; }
1445
1446   // Return address alignment of EXIDX input section.
1447   uint32_t
1448   addralign() const
1449   { return this->addralign_; }
1450
1451   // Return size of the associated text input section.
1452   uint32_t
1453   text_size() const
1454   { return this->text_size_; }
1455
1456   // Whether there are any errors in the EXIDX input section.
1457   bool
1458   has_errors() const
1459   { return this->has_errors_; }
1460
1461   // Set has-errors flag.
1462   void
1463   set_has_errors()
1464   { this->has_errors_ = true; }
1465
1466  private:
1467   // Object containing this.
1468   Relobj* relobj_;
1469   // Section index of this.
1470   unsigned int shndx_;
1471   // text section linked to this in the same object.
1472   unsigned int link_;
1473   // Size of this.  For ARM 32-bit is sufficient.
1474   uint32_t size_;
1475   // Address alignment of this.  For ARM 32-bit is sufficient.
1476   uint32_t addralign_;
1477   // Size of associated text section.
1478   uint32_t text_size_;
1479   // Whether this has any errors.
1480   bool has_errors_;
1481 };
1482
1483 // Arm_relobj class.
1484
1485 template<bool big_endian>
1486 class Arm_relobj : public Sized_relobj_file<32, big_endian>
1487 {
1488  public:
1489   static const Arm_address invalid_address = static_cast<Arm_address>(-1);
1490
1491   Arm_relobj(const std::string& name, Input_file* input_file, off_t offset,
1492              const typename elfcpp::Ehdr<32, big_endian>& ehdr)
1493     : Sized_relobj_file<32, big_endian>(name, input_file, offset, ehdr),
1494       stub_tables_(), local_symbol_is_thumb_function_(),
1495       attributes_section_data_(NULL), mapping_symbols_info_(),
1496       section_has_cortex_a8_workaround_(NULL), exidx_section_map_(),
1497       output_local_symbol_count_needs_update_(false),
1498       merge_flags_and_attributes_(true)
1499   { }
1500
1501   ~Arm_relobj()
1502   { delete this->attributes_section_data_; }
1503
1504   // Return the stub table of the SHNDX-th section if there is one.
1505   Stub_table<big_endian>*
1506   stub_table(unsigned int shndx) const
1507   {
1508     gold_assert(shndx < this->stub_tables_.size());
1509     return this->stub_tables_[shndx];
1510   }
1511
1512   // Set STUB_TABLE to be the stub_table of the SHNDX-th section.
1513   void
1514   set_stub_table(unsigned int shndx, Stub_table<big_endian>* stub_table)
1515   {
1516     gold_assert(shndx < this->stub_tables_.size());
1517     this->stub_tables_[shndx] = stub_table;
1518   }
1519
1520   // Whether a local symbol is a THUMB function.  R_SYM is the symbol table
1521   // index.  This is only valid after do_count_local_symbol is called.
1522   bool
1523   local_symbol_is_thumb_function(unsigned int r_sym) const
1524   {
1525     gold_assert(r_sym < this->local_symbol_is_thumb_function_.size());
1526     return this->local_symbol_is_thumb_function_[r_sym];
1527   }
1528
1529   // Scan all relocation sections for stub generation.
1530   void
1531   scan_sections_for_stubs(Target_arm<big_endian>*, const Symbol_table*,
1532                           const Layout*);
1533
1534   // Convert regular input section with index SHNDX to a relaxed section.
1535   void
1536   convert_input_section_to_relaxed_section(unsigned shndx)
1537   {
1538     // The stubs have relocations and we need to process them after writing
1539     // out the stubs.  So relocation now must follow section write.
1540     this->set_section_offset(shndx, -1ULL);
1541     this->set_relocs_must_follow_section_writes();
1542   }
1543
1544   // Downcast a base pointer to an Arm_relobj pointer.  This is
1545   // not type-safe but we only use Arm_relobj not the base class.
1546   static Arm_relobj<big_endian>*
1547   as_arm_relobj(Relobj* relobj)
1548   { return static_cast<Arm_relobj<big_endian>*>(relobj); }
1549
1550   // Processor-specific flags in ELF file header.  This is valid only after
1551   // reading symbols.
1552   elfcpp::Elf_Word
1553   processor_specific_flags() const
1554   { return this->processor_specific_flags_; }
1555
1556   // Attribute section data  This is the contents of the .ARM.attribute section
1557   // if there is one.
1558   const Attributes_section_data*
1559   attributes_section_data() const
1560   { return this->attributes_section_data_; }
1561
1562   // Mapping symbol location.
1563   typedef std::pair<unsigned int, Arm_address> Mapping_symbol_position;
1564
1565   // Functor for STL container.
1566   struct Mapping_symbol_position_less
1567   {
1568     bool
1569     operator()(const Mapping_symbol_position& p1,
1570                const Mapping_symbol_position& p2) const
1571     {
1572       return (p1.first < p2.first
1573               || (p1.first == p2.first && p1.second < p2.second));
1574     }
1575   };
1576
1577   // We only care about the first character of a mapping symbol, so
1578   // we only store that instead of the whole symbol name.
1579   typedef std::map<Mapping_symbol_position, char,
1580                    Mapping_symbol_position_less> Mapping_symbols_info;
1581
1582   // Whether a section contains any Cortex-A8 workaround.
1583   bool
1584   section_has_cortex_a8_workaround(unsigned int shndx) const
1585   {
1586     return (this->section_has_cortex_a8_workaround_ != NULL
1587             && (*this->section_has_cortex_a8_workaround_)[shndx]);
1588   }
1589
1590   // Mark a section that has Cortex-A8 workaround.
1591   void
1592   mark_section_for_cortex_a8_workaround(unsigned int shndx)
1593   {
1594     if (this->section_has_cortex_a8_workaround_ == NULL)
1595       this->section_has_cortex_a8_workaround_ =
1596         new std::vector<bool>(this->shnum(), false);
1597     (*this->section_has_cortex_a8_workaround_)[shndx] = true;
1598   }
1599
1600   // Return the EXIDX section of an text section with index SHNDX or NULL
1601   // if the text section has no associated EXIDX section.
1602   const Arm_exidx_input_section*
1603   exidx_input_section_by_link(unsigned int shndx) const
1604   {
1605     Exidx_section_map::const_iterator p = this->exidx_section_map_.find(shndx);
1606     return ((p != this->exidx_section_map_.end()
1607              && p->second->link() == shndx)
1608             ? p->second
1609             : NULL);
1610   }
1611
1612   // Return the EXIDX section with index SHNDX or NULL if there is none.
1613   const Arm_exidx_input_section*
1614   exidx_input_section_by_shndx(unsigned shndx) const
1615   {
1616     Exidx_section_map::const_iterator p = this->exidx_section_map_.find(shndx);
1617     return ((p != this->exidx_section_map_.end()
1618              && p->second->shndx() == shndx)
1619             ? p->second
1620             : NULL);
1621   }
1622
1623   // Whether output local symbol count needs updating.
1624   bool
1625   output_local_symbol_count_needs_update() const
1626   { return this->output_local_symbol_count_needs_update_; }
1627
1628   // Set output_local_symbol_count_needs_update flag to be true.
1629   void
1630   set_output_local_symbol_count_needs_update()
1631   { this->output_local_symbol_count_needs_update_ = true; }
1632
1633   // Update output local symbol count at the end of relaxation.
1634   void
1635   update_output_local_symbol_count();
1636
1637   // Whether we want to merge processor-specific flags and attributes.
1638   bool
1639   merge_flags_and_attributes() const
1640   { return this->merge_flags_and_attributes_; }
1641
1642   // Export list of EXIDX section indices.
1643   void
1644   get_exidx_shndx_list(std::vector<unsigned int>* list) const
1645   {
1646     list->clear();
1647     for (Exidx_section_map::const_iterator p = this->exidx_section_map_.begin();
1648          p != this->exidx_section_map_.end();
1649          ++p)
1650       {
1651         if (p->second->shndx() == p->first)
1652           list->push_back(p->first);
1653       }
1654     // Sort list to make result independent of implementation of map.
1655     std::sort(list->begin(), list->end());
1656   }
1657
1658  protected:
1659   // Post constructor setup.
1660   void
1661   do_setup()
1662   {
1663     // Call parent's setup method.
1664     Sized_relobj_file<32, big_endian>::do_setup();
1665
1666     // Initialize look-up tables.
1667     Stub_table_list empty_stub_table_list(this->shnum(), NULL);
1668     this->stub_tables_.swap(empty_stub_table_list);
1669   }
1670
1671   // Count the local symbols.
1672   void
1673   do_count_local_symbols(Stringpool_template<char>*,
1674                          Stringpool_template<char>*);
1675
1676   void
1677   do_relocate_sections(
1678       const Symbol_table* symtab, const Layout* layout,
1679       const unsigned char* pshdrs, Output_file* of,
1680       typename Sized_relobj_file<32, big_endian>::Views* pivews);
1681
1682   // Read the symbol information.
1683   void
1684   do_read_symbols(Read_symbols_data* sd);
1685
1686   // Process relocs for garbage collection.
1687   void
1688   do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*);
1689
1690  private:
1691
1692   // Whether a section needs to be scanned for relocation stubs.
1693   bool
1694   section_needs_reloc_stub_scanning(const elfcpp::Shdr<32, big_endian>&,
1695                                     const Relobj::Output_sections&,
1696                                     const Symbol_table*, const unsigned char*);
1697
1698   // Whether a section is a scannable text section.
1699   bool
1700   section_is_scannable(const elfcpp::Shdr<32, big_endian>&, unsigned int,
1701                        const Output_section*, const Symbol_table*);
1702
1703   // Whether a section needs to be scanned for the Cortex-A8 erratum.
1704   bool
1705   section_needs_cortex_a8_stub_scanning(const elfcpp::Shdr<32, big_endian>&,
1706                                         unsigned int, Output_section*,
1707                                         const Symbol_table*);
1708
1709   // Scan a section for the Cortex-A8 erratum.
1710   void
1711   scan_section_for_cortex_a8_erratum(const elfcpp::Shdr<32, big_endian>&,
1712                                      unsigned int, Output_section*,
1713                                      Target_arm<big_endian>*);
1714
1715   // Find the linked text section of an EXIDX section by looking at the
1716   // first relocation of the EXIDX section.  PSHDR points to the section
1717   // headers of a relocation section and PSYMS points to the local symbols.
1718   // PSHNDX points to a location storing the text section index if found.
1719   // Return whether we can find the linked section.
1720   bool
1721   find_linked_text_section(const unsigned char* pshdr,
1722                            const unsigned char* psyms, unsigned int* pshndx);
1723
1724   //
1725   // Make a new Arm_exidx_input_section object for EXIDX section with
1726   // index SHNDX and section header SHDR.  TEXT_SHNDX is the section
1727   // index of the linked text section.
1728   void
1729   make_exidx_input_section(unsigned int shndx,
1730                            const elfcpp::Shdr<32, big_endian>& shdr,
1731                            unsigned int text_shndx,
1732                            const elfcpp::Shdr<32, big_endian>& text_shdr);
1733
1734   // Return the output address of either a plain input section or a
1735   // relaxed input section.  SHNDX is the section index.
1736   Arm_address
1737   simple_input_section_output_address(unsigned int, Output_section*);
1738
1739   typedef std::vector<Stub_table<big_endian>*> Stub_table_list;
1740   typedef Unordered_map<unsigned int, const Arm_exidx_input_section*>
1741     Exidx_section_map;
1742
1743   // List of stub tables.
1744   Stub_table_list stub_tables_;
1745   // Bit vector to tell if a local symbol is a thumb function or not.
1746   // This is only valid after do_count_local_symbol is called.
1747   std::vector<bool> local_symbol_is_thumb_function_;
1748   // processor-specific flags in ELF file header.
1749   elfcpp::Elf_Word processor_specific_flags_;
1750   // Object attributes if there is an .ARM.attributes section or NULL.
1751   Attributes_section_data* attributes_section_data_;
1752   // Mapping symbols information.
1753   Mapping_symbols_info mapping_symbols_info_;
1754   // Bitmap to indicate sections with Cortex-A8 workaround or NULL.
1755   std::vector<bool>* section_has_cortex_a8_workaround_;
1756   // Map a text section to its associated .ARM.exidx section, if there is one.
1757   Exidx_section_map exidx_section_map_;
1758   // Whether output local symbol count needs updating.
1759   bool output_local_symbol_count_needs_update_;
1760   // Whether we merge processor flags and attributes of this object to
1761   // output.
1762   bool merge_flags_and_attributes_;
1763 };
1764
1765 // Arm_dynobj class.
1766
1767 template<bool big_endian>
1768 class Arm_dynobj : public Sized_dynobj<32, big_endian>
1769 {
1770  public:
1771   Arm_dynobj(const std::string& name, Input_file* input_file, off_t offset,
1772              const elfcpp::Ehdr<32, big_endian>& ehdr)
1773     : Sized_dynobj<32, big_endian>(name, input_file, offset, ehdr),
1774       processor_specific_flags_(0), attributes_section_data_(NULL)
1775   { }
1776
1777   ~Arm_dynobj()
1778   { delete this->attributes_section_data_; }
1779
1780   // Downcast a base pointer to an Arm_relobj pointer.  This is
1781   // not type-safe but we only use Arm_relobj not the base class.
1782   static Arm_dynobj<big_endian>*
1783   as_arm_dynobj(Dynobj* dynobj)
1784   { return static_cast<Arm_dynobj<big_endian>*>(dynobj); }
1785
1786   // Processor-specific flags in ELF file header.  This is valid only after
1787   // reading symbols.
1788   elfcpp::Elf_Word
1789   processor_specific_flags() const
1790   { return this->processor_specific_flags_; }
1791
1792   // Attributes section data.
1793   const Attributes_section_data*
1794   attributes_section_data() const
1795   { return this->attributes_section_data_; }
1796
1797  protected:
1798   // Read the symbol information.
1799   void
1800   do_read_symbols(Read_symbols_data* sd);
1801
1802  private:
1803   // processor-specific flags in ELF file header.
1804   elfcpp::Elf_Word processor_specific_flags_;
1805   // Object attributes if there is an .ARM.attributes section or NULL.
1806   Attributes_section_data* attributes_section_data_;
1807 };
1808
1809 // Functor to read reloc addends during stub generation.
1810
1811 template<int sh_type, bool big_endian>
1812 struct Stub_addend_reader
1813 {
1814   // Return the addend for a relocation of a particular type.  Depending
1815   // on whether this is a REL or RELA relocation, read the addend from a
1816   // view or from a Reloc object.
1817   elfcpp::Elf_types<32>::Elf_Swxword
1818   operator()(
1819     unsigned int /* r_type */,
1820     const unsigned char* /* view */,
1821     const typename Reloc_types<sh_type,
1822                                32, big_endian>::Reloc& /* reloc */) const;
1823 };
1824
1825 // Specialized Stub_addend_reader for SHT_REL type relocation sections.
1826
1827 template<bool big_endian>
1828 struct Stub_addend_reader<elfcpp::SHT_REL, big_endian>
1829 {
1830   elfcpp::Elf_types<32>::Elf_Swxword
1831   operator()(
1832     unsigned int,
1833     const unsigned char*,
1834     const typename Reloc_types<elfcpp::SHT_REL, 32, big_endian>::Reloc&) const;
1835 };
1836
1837 // Specialized Stub_addend_reader for RELA type relocation sections.
1838 // We currently do not handle RELA type relocation sections but it is trivial
1839 // to implement the addend reader.  This is provided for completeness and to
1840 // make it easier to add support for RELA relocation sections in the future.
1841
1842 template<bool big_endian>
1843 struct Stub_addend_reader<elfcpp::SHT_RELA, big_endian>
1844 {
1845   elfcpp::Elf_types<32>::Elf_Swxword
1846   operator()(
1847     unsigned int,
1848     const unsigned char*,
1849     const typename Reloc_types<elfcpp::SHT_RELA, 32,
1850                                big_endian>::Reloc& reloc) const
1851   { return reloc.get_r_addend(); }
1852 };
1853
1854 // Cortex_a8_reloc class.  We keep record of relocation that may need
1855 // the Cortex-A8 erratum workaround.
1856
1857 class Cortex_a8_reloc
1858 {
1859  public:
1860   Cortex_a8_reloc(Reloc_stub* reloc_stub, unsigned r_type,
1861                   Arm_address destination)
1862     : reloc_stub_(reloc_stub), r_type_(r_type), destination_(destination)
1863   { }
1864
1865   ~Cortex_a8_reloc()
1866   { }
1867
1868   // Accessors:  This is a read-only class.
1869
1870   // Return the relocation stub associated with this relocation if there is
1871   // one.
1872   const Reloc_stub*
1873   reloc_stub() const
1874   { return this->reloc_stub_; }
1875
1876   // Return the relocation type.
1877   unsigned int
1878   r_type() const
1879   { return this->r_type_; }
1880
1881   // Return the destination address of the relocation.  LSB stores the THUMB
1882   // bit.
1883   Arm_address
1884   destination() const
1885   { return this->destination_; }
1886
1887  private:
1888   // Associated relocation stub if there is one, or NULL.
1889   const Reloc_stub* reloc_stub_;
1890   // Relocation type.
1891   unsigned int r_type_;
1892   // Destination address of this relocation.  LSB is used to distinguish
1893   // ARM/THUMB mode.
1894   Arm_address destination_;
1895 };
1896
1897 // Arm_output_data_got class.  We derive this from Output_data_got to add
1898 // extra methods to handle TLS relocations in a static link.
1899
1900 template<bool big_endian>
1901 class Arm_output_data_got : public Output_data_got<32, big_endian>
1902 {
1903  public:
1904   Arm_output_data_got(Symbol_table* symtab, Layout* layout)
1905     : Output_data_got<32, big_endian>(), symbol_table_(symtab), layout_(layout)
1906   { }
1907
1908   // Add a static entry for the GOT entry at OFFSET.  GSYM is a global
1909   // symbol and R_TYPE is the code of a dynamic relocation that needs to be
1910   // applied in a static link.
1911   void
1912   add_static_reloc(unsigned int got_offset, unsigned int r_type, Symbol* gsym)
1913   { this->static_relocs_.push_back(Static_reloc(got_offset, r_type, gsym)); }
1914
1915   // Add a static reloc for the GOT entry at OFFSET.  RELOBJ is an object
1916   // defining a local symbol with INDEX.  R_TYPE is the code of a dynamic
1917   // relocation that needs to be applied in a static link.
1918   void
1919   add_static_reloc(unsigned int got_offset, unsigned int r_type,
1920                    Sized_relobj_file<32, big_endian>* relobj,
1921                    unsigned int index)
1922   {
1923     this->static_relocs_.push_back(Static_reloc(got_offset, r_type, relobj,
1924                                                 index));
1925   }
1926
1927   // Add a GOT pair for R_ARM_TLS_GD32.  The creates a pair of GOT entries.
1928   // The first one is initialized to be 1, which is the module index for
1929   // the main executable and the second one 0.  A reloc of the type
1930   // R_ARM_TLS_DTPOFF32 will be created for the second GOT entry and will
1931   // be applied by gold.  GSYM is a global symbol.
1932   void
1933   add_tls_gd32_with_static_reloc(unsigned int got_type, Symbol* gsym);
1934
1935   // Same as the above but for a local symbol in OBJECT with INDEX.
1936   void
1937   add_tls_gd32_with_static_reloc(unsigned int got_type,
1938                                  Sized_relobj_file<32, big_endian>* object,
1939                                  unsigned int index);
1940
1941  protected:
1942   // Write out the GOT table.
1943   void
1944   do_write(Output_file*);
1945
1946  private:
1947   // This class represent dynamic relocations that need to be applied by
1948   // gold because we are using TLS relocations in a static link.
1949   class Static_reloc
1950   {
1951    public:
1952     Static_reloc(unsigned int got_offset, unsigned int r_type, Symbol* gsym)
1953       : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(true)
1954     { this->u_.global.symbol = gsym; }
1955
1956     Static_reloc(unsigned int got_offset, unsigned int r_type,
1957           Sized_relobj_file<32, big_endian>* relobj, unsigned int index)
1958       : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(false)
1959     {
1960       this->u_.local.relobj = relobj;
1961       this->u_.local.index = index;
1962     }
1963
1964     // Return the GOT offset.
1965     unsigned int
1966     got_offset() const
1967     { return this->got_offset_; }
1968
1969     // Relocation type.
1970     unsigned int
1971     r_type() const
1972     { return this->r_type_; }
1973
1974     // Whether the symbol is global or not.
1975     bool
1976     symbol_is_global() const
1977     { return this->symbol_is_global_; }
1978
1979     // For a relocation against a global symbol, the global symbol.
1980     Symbol*
1981     symbol() const
1982     {
1983       gold_assert(this->symbol_is_global_);
1984       return this->u_.global.symbol;
1985     }
1986
1987     // For a relocation against a local symbol, the defining object.
1988     Sized_relobj_file<32, big_endian>*
1989     relobj() const
1990     {
1991       gold_assert(!this->symbol_is_global_);
1992       return this->u_.local.relobj;
1993     }
1994
1995     // For a relocation against a local symbol, the local symbol index.
1996     unsigned int
1997     index() const
1998     {
1999       gold_assert(!this->symbol_is_global_);
2000       return this->u_.local.index;
2001     }
2002
2003    private:
2004     // GOT offset of the entry to which this relocation is applied.
2005     unsigned int got_offset_;
2006     // Type of relocation.
2007     unsigned int r_type_;
2008     // Whether this relocation is against a global symbol.
2009     bool symbol_is_global_;
2010     // A global or local symbol.
2011     union
2012     {
2013       struct
2014       {
2015         // For a global symbol, the symbol itself.
2016         Symbol* symbol;
2017       } global;
2018       struct
2019       {
2020         // For a local symbol, the object defining object.
2021         Sized_relobj_file<32, big_endian>* relobj;
2022         // For a local symbol, the symbol index.
2023         unsigned int index;
2024       } local;
2025     } u_;
2026   };
2027
2028   // Symbol table of the output object.
2029   Symbol_table* symbol_table_;
2030   // Layout of the output object.
2031   Layout* layout_;
2032   // Static relocs to be applied to the GOT.
2033   std::vector<Static_reloc> static_relocs_;
2034 };
2035
2036 // The ARM target has many relocation types with odd-sizes or noncontiguous
2037 // bits.  The default handling of relocatable relocation cannot process these
2038 // relocations.  So we have to extend the default code.
2039
2040 template<bool big_endian, int sh_type, typename Classify_reloc>
2041 class Arm_scan_relocatable_relocs :
2042   public Default_scan_relocatable_relocs<sh_type, Classify_reloc>
2043 {
2044  public:
2045   // Return the strategy to use for a local symbol which is a section
2046   // symbol, given the relocation type.
2047   inline Relocatable_relocs::Reloc_strategy
2048   local_section_strategy(unsigned int r_type, Relobj*)
2049   {
2050     if (sh_type == elfcpp::SHT_RELA)
2051       return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
2052     else
2053       {
2054         if (r_type == elfcpp::R_ARM_TARGET1
2055             || r_type == elfcpp::R_ARM_TARGET2)
2056           {
2057             const Target_arm<big_endian>* arm_target =
2058               Target_arm<big_endian>::default_target();
2059             r_type = arm_target->get_real_reloc_type(r_type);
2060           }
2061
2062         switch(r_type)
2063           {
2064           // Relocations that write nothing.  These exclude R_ARM_TARGET1
2065           // and R_ARM_TARGET2.
2066           case elfcpp::R_ARM_NONE:
2067           case elfcpp::R_ARM_V4BX:
2068           case elfcpp::R_ARM_TLS_GOTDESC:
2069           case elfcpp::R_ARM_TLS_CALL:
2070           case elfcpp::R_ARM_TLS_DESCSEQ:
2071           case elfcpp::R_ARM_THM_TLS_CALL:
2072           case elfcpp::R_ARM_GOTRELAX:
2073           case elfcpp::R_ARM_GNU_VTENTRY:
2074           case elfcpp::R_ARM_GNU_VTINHERIT:
2075           case elfcpp::R_ARM_THM_TLS_DESCSEQ16:
2076           case elfcpp::R_ARM_THM_TLS_DESCSEQ32:
2077             return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_0;
2078           // These should have been converted to something else above.
2079           case elfcpp::R_ARM_TARGET1:
2080           case elfcpp::R_ARM_TARGET2:
2081             gold_unreachable();
2082           // Relocations that write full 32 bits and
2083           // have alignment of 1.
2084           case elfcpp::R_ARM_ABS32:
2085           case elfcpp::R_ARM_REL32:
2086           case elfcpp::R_ARM_SBREL32:
2087           case elfcpp::R_ARM_GOTOFF32:
2088           case elfcpp::R_ARM_BASE_PREL:
2089           case elfcpp::R_ARM_GOT_BREL:
2090           case elfcpp::R_ARM_BASE_ABS:
2091           case elfcpp::R_ARM_ABS32_NOI:
2092           case elfcpp::R_ARM_REL32_NOI:
2093           case elfcpp::R_ARM_PLT32_ABS:
2094           case elfcpp::R_ARM_GOT_ABS:
2095           case elfcpp::R_ARM_GOT_PREL:
2096           case elfcpp::R_ARM_TLS_GD32:
2097           case elfcpp::R_ARM_TLS_LDM32:
2098           case elfcpp::R_ARM_TLS_LDO32:
2099           case elfcpp::R_ARM_TLS_IE32:
2100           case elfcpp::R_ARM_TLS_LE32:
2101             return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_4_UNALIGNED;
2102           default:
2103             // For all other static relocations, return RELOC_SPECIAL.
2104             return Relocatable_relocs::RELOC_SPECIAL;
2105           }
2106       }
2107   }
2108 };
2109
2110 template<bool big_endian>
2111 class Target_arm : public Sized_target<32, big_endian>
2112 {
2113  public:
2114   typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, big_endian>
2115     Reloc_section;
2116
2117   // When were are relocating a stub, we pass this as the relocation number.
2118   static const size_t fake_relnum_for_stubs = static_cast<size_t>(-1);
2119
2120   Target_arm(const Target::Target_info* info = &arm_info)
2121     : Sized_target<32, big_endian>(info),
2122       got_(NULL), plt_(NULL), got_plt_(NULL), rel_dyn_(NULL),
2123       copy_relocs_(elfcpp::R_ARM_COPY),
2124       got_mod_index_offset_(-1U), tls_base_symbol_defined_(false),
2125       stub_tables_(), stub_factory_(Stub_factory::get_instance()),
2126       should_force_pic_veneer_(false),
2127       arm_input_section_map_(), attributes_section_data_(NULL),
2128       fix_cortex_a8_(false), cortex_a8_relocs_info_()
2129   { }
2130
2131   // Whether we force PCI branch veneers.
2132   bool
2133   should_force_pic_veneer() const
2134   { return this->should_force_pic_veneer_; }
2135
2136   // Set PIC veneer flag.
2137   void
2138   set_should_force_pic_veneer(bool value)
2139   { this->should_force_pic_veneer_ = value; }
2140
2141   // Whether we use THUMB-2 instructions.
2142   bool
2143   using_thumb2() const
2144   {
2145     Object_attribute* attr =
2146       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2147     int arch = attr->int_value();
2148     return arch == elfcpp::TAG_CPU_ARCH_V6T2 || arch >= elfcpp::TAG_CPU_ARCH_V7;
2149   }
2150
2151   // Whether we use THUMB/THUMB-2 instructions only.
2152   bool
2153   using_thumb_only() const
2154   {
2155     Object_attribute* attr =
2156       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2157
2158     if (attr->int_value() == elfcpp::TAG_CPU_ARCH_V6_M
2159         || attr->int_value() == elfcpp::TAG_CPU_ARCH_V6S_M)
2160       return true;
2161     if (attr->int_value() != elfcpp::TAG_CPU_ARCH_V7
2162         && attr->int_value() != elfcpp::TAG_CPU_ARCH_V7E_M)
2163       return false;
2164     attr = this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch_profile);
2165     return attr->int_value() == 'M';
2166   }
2167
2168   // Whether we have an NOP instruction.  If not, use mov r0, r0 instead.
2169   bool
2170   may_use_arm_nop() const
2171   {
2172     Object_attribute* attr =
2173       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2174     int arch = attr->int_value();
2175     return (arch == elfcpp::TAG_CPU_ARCH_V6T2
2176             || arch == elfcpp::TAG_CPU_ARCH_V6K
2177             || arch == elfcpp::TAG_CPU_ARCH_V7
2178             || arch == elfcpp::TAG_CPU_ARCH_V7E_M);
2179   }
2180
2181   // Whether we have THUMB-2 NOP.W instruction.
2182   bool
2183   may_use_thumb2_nop() const
2184   {
2185     Object_attribute* attr =
2186       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2187     int arch = attr->int_value();
2188     return (arch == elfcpp::TAG_CPU_ARCH_V6T2
2189             || arch == elfcpp::TAG_CPU_ARCH_V7
2190             || arch == elfcpp::TAG_CPU_ARCH_V7E_M);
2191   }
2192
2193   // Whether we have v4T interworking instructions available.
2194   bool
2195   may_use_v4t_interworking() const
2196   {
2197     Object_attribute* attr =
2198       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2199     int arch = attr->int_value();
2200     return (arch != elfcpp::TAG_CPU_ARCH_PRE_V4
2201             && arch != elfcpp::TAG_CPU_ARCH_V4);
2202   }
2203
2204   // Whether we have v5T interworking instructions available.
2205   bool
2206   may_use_v5t_interworking() const
2207   {
2208     Object_attribute* attr =
2209       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2210     int arch = attr->int_value();
2211     if (parameters->options().fix_arm1176())
2212       return (arch == elfcpp::TAG_CPU_ARCH_V6T2
2213               || arch == elfcpp::TAG_CPU_ARCH_V7
2214               || arch == elfcpp::TAG_CPU_ARCH_V6_M
2215               || arch == elfcpp::TAG_CPU_ARCH_V6S_M
2216               || arch == elfcpp::TAG_CPU_ARCH_V7E_M);
2217     else
2218       return (arch != elfcpp::TAG_CPU_ARCH_PRE_V4
2219               && arch != elfcpp::TAG_CPU_ARCH_V4
2220               && arch != elfcpp::TAG_CPU_ARCH_V4T);
2221   }
2222
2223   // Process the relocations to determine unreferenced sections for
2224   // garbage collection.
2225   void
2226   gc_process_relocs(Symbol_table* symtab,
2227                     Layout* layout,
2228                     Sized_relobj_file<32, big_endian>* object,
2229                     unsigned int data_shndx,
2230                     unsigned int sh_type,
2231                     const unsigned char* prelocs,
2232                     size_t reloc_count,
2233                     Output_section* output_section,
2234                     bool needs_special_offset_handling,
2235                     size_t local_symbol_count,
2236                     const unsigned char* plocal_symbols);
2237
2238   // Scan the relocations to look for symbol adjustments.
2239   void
2240   scan_relocs(Symbol_table* symtab,
2241               Layout* layout,
2242               Sized_relobj_file<32, big_endian>* object,
2243               unsigned int data_shndx,
2244               unsigned int sh_type,
2245               const unsigned char* prelocs,
2246               size_t reloc_count,
2247               Output_section* output_section,
2248               bool needs_special_offset_handling,
2249               size_t local_symbol_count,
2250               const unsigned char* plocal_symbols);
2251
2252   // Finalize the sections.
2253   void
2254   do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
2255
2256   // Return the value to use for a dynamic symbol which requires special
2257   // treatment.
2258   uint64_t
2259   do_dynsym_value(const Symbol*) const;
2260
2261   // Relocate a section.
2262   void
2263   relocate_section(const Relocate_info<32, big_endian>*,
2264                    unsigned int sh_type,
2265                    const unsigned char* prelocs,
2266                    size_t reloc_count,
2267                    Output_section* output_section,
2268                    bool needs_special_offset_handling,
2269                    unsigned char* view,
2270                    Arm_address view_address,
2271                    section_size_type view_size,
2272                    const Reloc_symbol_changes*);
2273
2274   // Scan the relocs during a relocatable link.
2275   void
2276   scan_relocatable_relocs(Symbol_table* symtab,
2277                           Layout* layout,
2278                           Sized_relobj_file<32, big_endian>* object,
2279                           unsigned int data_shndx,
2280                           unsigned int sh_type,
2281                           const unsigned char* prelocs,
2282                           size_t reloc_count,
2283                           Output_section* output_section,
2284                           bool needs_special_offset_handling,
2285                           size_t local_symbol_count,
2286                           const unsigned char* plocal_symbols,
2287                           Relocatable_relocs*);
2288
2289   // Emit relocations for a section.
2290   void
2291   relocate_relocs(const Relocate_info<32, big_endian>*,
2292                   unsigned int sh_type,
2293                   const unsigned char* prelocs,
2294                   size_t reloc_count,
2295                   Output_section* output_section,
2296                   typename elfcpp::Elf_types<32>::Elf_Off
2297                     offset_in_output_section,
2298                   const Relocatable_relocs*,
2299                   unsigned char* view,
2300                   Arm_address view_address,
2301                   section_size_type view_size,
2302                   unsigned char* reloc_view,
2303                   section_size_type reloc_view_size);
2304
2305   // Perform target-specific processing in a relocatable link.  This is
2306   // only used if we use the relocation strategy RELOC_SPECIAL.
2307   void
2308   relocate_special_relocatable(const Relocate_info<32, big_endian>* relinfo,
2309                                unsigned int sh_type,
2310                                const unsigned char* preloc_in,
2311                                size_t relnum,
2312                                Output_section* output_section,
2313                                typename elfcpp::Elf_types<32>::Elf_Off
2314                                  offset_in_output_section,
2315                                unsigned char* view,
2316                                typename elfcpp::Elf_types<32>::Elf_Addr
2317                                  view_address,
2318                                section_size_type view_size,
2319                                unsigned char* preloc_out);
2320
2321   // Return whether SYM is defined by the ABI.
2322   bool
2323   do_is_defined_by_abi(const Symbol* sym) const
2324   { return strcmp(sym->name(), "__tls_get_addr") == 0; }
2325
2326   // Return whether there is a GOT section.
2327   bool
2328   has_got_section() const
2329   { return this->got_ != NULL; }
2330
2331   // Return the size of the GOT section.
2332   section_size_type
2333   got_size() const
2334   {
2335     gold_assert(this->got_ != NULL);
2336     return this->got_->data_size();
2337   }
2338
2339   // Return the number of entries in the GOT.
2340   unsigned int
2341   got_entry_count() const
2342   {
2343     if (!this->has_got_section())
2344       return 0;
2345     return this->got_size() / 4;
2346   }
2347
2348   // Return the number of entries in the PLT.
2349   unsigned int
2350   plt_entry_count() const;
2351
2352   // Return the offset of the first non-reserved PLT entry.
2353   unsigned int
2354   first_plt_entry_offset() const;
2355
2356   // Return the size of each PLT entry.
2357   unsigned int
2358   plt_entry_size() const;
2359
2360   // Map platform-specific reloc types
2361   static unsigned int
2362   get_real_reloc_type(unsigned int r_type);
2363
2364   //
2365   // Methods to support stub-generations.
2366   //
2367
2368   // Return the stub factory
2369   const Stub_factory&
2370   stub_factory() const
2371   { return this->stub_factory_; }
2372
2373   // Make a new Arm_input_section object.
2374   Arm_input_section<big_endian>*
2375   new_arm_input_section(Relobj*, unsigned int);
2376
2377   // Find the Arm_input_section object corresponding to the SHNDX-th input
2378   // section of RELOBJ.
2379   Arm_input_section<big_endian>*
2380   find_arm_input_section(Relobj* relobj, unsigned int shndx) const;
2381
2382   // Make a new Stub_table
2383   Stub_table<big_endian>*
2384   new_stub_table(Arm_input_section<big_endian>*);
2385
2386   // Scan a section for stub generation.
2387   void
2388   scan_section_for_stubs(const Relocate_info<32, big_endian>*, unsigned int,
2389                          const unsigned char*, size_t, Output_section*,
2390                          bool, const unsigned char*, Arm_address,
2391                          section_size_type);
2392
2393   // Relocate a stub.
2394   void
2395   relocate_stub(Stub*, const Relocate_info<32, big_endian>*,
2396                 Output_section*, unsigned char*, Arm_address,
2397                 section_size_type);
2398
2399   // Get the default ARM target.
2400   static Target_arm<big_endian>*
2401   default_target()
2402   {
2403     gold_assert(parameters->target().machine_code() == elfcpp::EM_ARM
2404                 && parameters->target().is_big_endian() == big_endian);
2405     return static_cast<Target_arm<big_endian>*>(
2406              parameters->sized_target<32, big_endian>());
2407   }
2408
2409   // Whether NAME belongs to a mapping symbol.
2410   static bool
2411   is_mapping_symbol_name(const char* name)
2412   {
2413     return (name
2414             && name[0] == '$'
2415             && (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
2416             && (name[2] == '\0' || name[2] == '.'));
2417   }
2418
2419   // Whether we work around the Cortex-A8 erratum.
2420   bool
2421   fix_cortex_a8() const
2422   { return this->fix_cortex_a8_; }
2423
2424   // Whether we merge exidx entries in debuginfo.
2425   bool
2426   merge_exidx_entries() const
2427   { return parameters->options().merge_exidx_entries(); }
2428
2429   // Whether we fix R_ARM_V4BX relocation.
2430   // 0 - do not fix
2431   // 1 - replace with MOV instruction (armv4 target)
2432   // 2 - make interworking veneer (>= armv4t targets only)
2433   General_options::Fix_v4bx
2434   fix_v4bx() const
2435   { return parameters->options().fix_v4bx(); }
2436
2437   // Scan a span of THUMB code section for Cortex-A8 erratum.
2438   void
2439   scan_span_for_cortex_a8_erratum(Arm_relobj<big_endian>*, unsigned int,
2440                                   section_size_type, section_size_type,
2441                                   const unsigned char*, Arm_address);
2442
2443   // Apply Cortex-A8 workaround to a branch.
2444   void
2445   apply_cortex_a8_workaround(const Cortex_a8_stub*, Arm_address,
2446                              unsigned char*, Arm_address);
2447
2448  protected:
2449   // Make the PLT-generator object.
2450   Output_data_plt_arm<big_endian>*
2451   make_data_plt(Layout* layout, Output_data_space* got_plt)
2452   { return this->do_make_data_plt(layout, got_plt); }
2453
2454   // Make an ELF object.
2455   Object*
2456   do_make_elf_object(const std::string&, Input_file*, off_t,
2457                      const elfcpp::Ehdr<32, big_endian>& ehdr);
2458
2459   Object*
2460   do_make_elf_object(const std::string&, Input_file*, off_t,
2461                      const elfcpp::Ehdr<32, !big_endian>&)
2462   { gold_unreachable(); }
2463
2464   Object*
2465   do_make_elf_object(const std::string&, Input_file*, off_t,
2466                       const elfcpp::Ehdr<64, false>&)
2467   { gold_unreachable(); }
2468
2469   Object*
2470   do_make_elf_object(const std::string&, Input_file*, off_t,
2471                      const elfcpp::Ehdr<64, true>&)
2472   { gold_unreachable(); }
2473
2474   // Make an output section.
2475   Output_section*
2476   do_make_output_section(const char* name, elfcpp::Elf_Word type,
2477                          elfcpp::Elf_Xword flags)
2478   { return new Arm_output_section<big_endian>(name, type, flags); }
2479
2480   void
2481   do_adjust_elf_header(unsigned char* view, int len);
2482
2483   // We only need to generate stubs, and hence perform relaxation if we are
2484   // not doing relocatable linking.
2485   bool
2486   do_may_relax() const
2487   { return !parameters->options().relocatable(); }
2488
2489   bool
2490   do_relax(int, const Input_objects*, Symbol_table*, Layout*, const Task*);
2491
2492   // Determine whether an object attribute tag takes an integer, a
2493   // string or both.
2494   int
2495   do_attribute_arg_type(int tag) const;
2496
2497   // Reorder tags during output.
2498   int
2499   do_attributes_order(int num) const;
2500
2501   // This is called when the target is selected as the default.
2502   void
2503   do_select_as_default_target()
2504   {
2505     // No locking is required since there should only be one default target.
2506     // We cannot have both the big-endian and little-endian ARM targets
2507     // as the default.
2508     gold_assert(arm_reloc_property_table == NULL);
2509     arm_reloc_property_table = new Arm_reloc_property_table();
2510   }
2511
2512   // Virtual function which is set to return true by a target if
2513   // it can use relocation types to determine if a function's
2514   // pointer is taken.
2515   virtual bool
2516   do_can_check_for_function_pointers() const
2517   { return true; }
2518
2519   // Whether a section called SECTION_NAME may have function pointers to
2520   // sections not eligible for safe ICF folding.
2521   virtual bool
2522   do_section_may_have_icf_unsafe_pointers(const char* section_name) const
2523   {
2524     return (!is_prefix_of(".ARM.exidx", section_name)
2525             && !is_prefix_of(".ARM.extab", section_name)
2526             && Target::do_section_may_have_icf_unsafe_pointers(section_name));
2527   }
2528
2529   virtual void
2530   do_define_standard_symbols(Symbol_table*, Layout*);
2531
2532   virtual Output_data_plt_arm<big_endian>*
2533   do_make_data_plt(Layout* layout, Output_data_space* got_plt)
2534   {
2535     return new Output_data_plt_arm_standard<big_endian>(layout, got_plt);
2536   }
2537
2538  private:
2539   // The class which scans relocations.
2540   class Scan
2541   {
2542    public:
2543     Scan()
2544       : issued_non_pic_error_(false)
2545     { }
2546
2547     static inline int
2548     get_reference_flags(unsigned int r_type);
2549
2550     inline void
2551     local(Symbol_table* symtab, Layout* layout, Target_arm* target,
2552           Sized_relobj_file<32, big_endian>* object,
2553           unsigned int data_shndx,
2554           Output_section* output_section,
2555           const elfcpp::Rel<32, big_endian>& reloc, unsigned int r_type,
2556           const elfcpp::Sym<32, big_endian>& lsym,
2557           bool is_discarded);
2558
2559     inline void
2560     global(Symbol_table* symtab, Layout* layout, Target_arm* target,
2561            Sized_relobj_file<32, big_endian>* object,
2562            unsigned int data_shndx,
2563            Output_section* output_section,
2564            const elfcpp::Rel<32, big_endian>& reloc, unsigned int r_type,
2565            Symbol* gsym);
2566
2567     inline bool
2568     local_reloc_may_be_function_pointer(Symbol_table* , Layout* , Target_arm* ,
2569                                         Sized_relobj_file<32, big_endian>* ,
2570                                         unsigned int ,
2571                                         Output_section* ,
2572                                         const elfcpp::Rel<32, big_endian>& ,
2573                                         unsigned int ,
2574                                         const elfcpp::Sym<32, big_endian>&);
2575
2576     inline bool
2577     global_reloc_may_be_function_pointer(Symbol_table* , Layout* , Target_arm* ,
2578                                          Sized_relobj_file<32, big_endian>* ,
2579                                          unsigned int ,
2580                                          Output_section* ,
2581                                          const elfcpp::Rel<32, big_endian>& ,
2582                                          unsigned int , Symbol*);
2583
2584    private:
2585     static void
2586     unsupported_reloc_local(Sized_relobj_file<32, big_endian>*,
2587                             unsigned int r_type);
2588
2589     static void
2590     unsupported_reloc_global(Sized_relobj_file<32, big_endian>*,
2591                              unsigned int r_type, Symbol*);
2592
2593     void
2594     check_non_pic(Relobj*, unsigned int r_type);
2595
2596     // Almost identical to Symbol::needs_plt_entry except that it also
2597     // handles STT_ARM_TFUNC.
2598     static bool
2599     symbol_needs_plt_entry(const Symbol* sym)
2600     {
2601       // An undefined symbol from an executable does not need a PLT entry.
2602       if (sym->is_undefined() && !parameters->options().shared())
2603         return false;
2604
2605       return (!parameters->doing_static_link()
2606               && (sym->type() == elfcpp::STT_FUNC
2607                   || sym->type() == elfcpp::STT_ARM_TFUNC)
2608               && (sym->is_from_dynobj()
2609                   || sym->is_undefined()
2610                   || sym->is_preemptible()));
2611     }
2612
2613     inline bool
2614     possible_function_pointer_reloc(unsigned int r_type);
2615
2616     // Whether we have issued an error about a non-PIC compilation.
2617     bool issued_non_pic_error_;
2618   };
2619
2620   // The class which implements relocation.
2621   class Relocate
2622   {
2623    public:
2624     Relocate()
2625     { }
2626
2627     ~Relocate()
2628     { }
2629
2630     // Return whether the static relocation needs to be applied.
2631     inline bool
2632     should_apply_static_reloc(const Sized_symbol<32>* gsym,
2633                               unsigned int r_type,
2634                               bool is_32bit,
2635                               Output_section* output_section);
2636
2637     // Do a relocation.  Return false if the caller should not issue
2638     // any warnings about this relocation.
2639     inline bool
2640     relocate(const Relocate_info<32, big_endian>*, Target_arm*,
2641              Output_section*,  size_t relnum,
2642              const elfcpp::Rel<32, big_endian>&,
2643              unsigned int r_type, const Sized_symbol<32>*,
2644              const Symbol_value<32>*,
2645              unsigned char*, Arm_address,
2646              section_size_type);
2647
2648     // Return whether we want to pass flag NON_PIC_REF for this
2649     // reloc.  This means the relocation type accesses a symbol not via
2650     // GOT or PLT.
2651     static inline bool
2652     reloc_is_non_pic(unsigned int r_type)
2653     {
2654       switch (r_type)
2655         {
2656         // These relocation types reference GOT or PLT entries explicitly.
2657         case elfcpp::R_ARM_GOT_BREL:
2658         case elfcpp::R_ARM_GOT_ABS:
2659         case elfcpp::R_ARM_GOT_PREL:
2660         case elfcpp::R_ARM_GOT_BREL12:
2661         case elfcpp::R_ARM_PLT32_ABS:
2662         case elfcpp::R_ARM_TLS_GD32:
2663         case elfcpp::R_ARM_TLS_LDM32:
2664         case elfcpp::R_ARM_TLS_IE32:
2665         case elfcpp::R_ARM_TLS_IE12GP:
2666
2667         // These relocate types may use PLT entries.
2668         case elfcpp::R_ARM_CALL:
2669         case elfcpp::R_ARM_THM_CALL:
2670         case elfcpp::R_ARM_JUMP24:
2671         case elfcpp::R_ARM_THM_JUMP24:
2672         case elfcpp::R_ARM_THM_JUMP19:
2673         case elfcpp::R_ARM_PLT32:
2674         case elfcpp::R_ARM_THM_XPC22:
2675         case elfcpp::R_ARM_PREL31:
2676         case elfcpp::R_ARM_SBREL31:
2677           return false;
2678
2679         default:
2680           return true;
2681         }
2682     }
2683
2684    private:
2685     // Do a TLS relocation.
2686     inline typename Arm_relocate_functions<big_endian>::Status
2687     relocate_tls(const Relocate_info<32, big_endian>*, Target_arm<big_endian>*,
2688                  size_t, const elfcpp::Rel<32, big_endian>&, unsigned int,
2689                  const Sized_symbol<32>*, const Symbol_value<32>*,
2690                  unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,
2691                  section_size_type);
2692
2693   };
2694
2695   // A class which returns the size required for a relocation type,
2696   // used while scanning relocs during a relocatable link.
2697   class Relocatable_size_for_reloc
2698   {
2699    public:
2700     unsigned int
2701     get_size_for_reloc(unsigned int, Relobj*);
2702   };
2703
2704   // Adjust TLS relocation type based on the options and whether this
2705   // is a local symbol.
2706   static tls::Tls_optimization
2707   optimize_tls_reloc(bool is_final, int r_type);
2708
2709   // Get the GOT section, creating it if necessary.
2710   Arm_output_data_got<big_endian>*
2711   got_section(Symbol_table*, Layout*);
2712
2713   // Get the GOT PLT section.
2714   Output_data_space*
2715   got_plt_section() const
2716   {
2717     gold_assert(this->got_plt_ != NULL);
2718     return this->got_plt_;
2719   }
2720
2721   // Create a PLT entry for a global symbol.
2722   void
2723   make_plt_entry(Symbol_table*, Layout*, Symbol*);
2724
2725   // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
2726   void
2727   define_tls_base_symbol(Symbol_table*, Layout*);
2728
2729   // Create a GOT entry for the TLS module index.
2730   unsigned int
2731   got_mod_index_entry(Symbol_table* symtab, Layout* layout,
2732                       Sized_relobj_file<32, big_endian>* object);
2733
2734   // Get the PLT section.
2735   const Output_data_plt_arm<big_endian>*
2736   plt_section() const
2737   {
2738     gold_assert(this->plt_ != NULL);
2739     return this->plt_;
2740   }
2741
2742   // Get the dynamic reloc section, creating it if necessary.
2743   Reloc_section*
2744   rel_dyn_section(Layout*);
2745
2746   // Get the section to use for TLS_DESC relocations.
2747   Reloc_section*
2748   rel_tls_desc_section(Layout*) const;
2749
2750   // Return true if the symbol may need a COPY relocation.
2751   // References from an executable object to non-function symbols
2752   // defined in a dynamic object may need a COPY relocation.
2753   bool
2754   may_need_copy_reloc(Symbol* gsym)
2755   {
2756     return (gsym->type() != elfcpp::STT_ARM_TFUNC
2757             && gsym->may_need_copy_reloc());
2758   }
2759
2760   // Add a potential copy relocation.
2761   void
2762   copy_reloc(Symbol_table* symtab, Layout* layout,
2763              Sized_relobj_file<32, big_endian>* object,
2764              unsigned int shndx, Output_section* output_section,
2765              Symbol* sym, const elfcpp::Rel<32, big_endian>& reloc)
2766   {
2767     this->copy_relocs_.copy_reloc(symtab, layout,
2768                                   symtab->get_sized_symbol<32>(sym),
2769                                   object, shndx, output_section, reloc,
2770                                   this->rel_dyn_section(layout));
2771   }
2772
2773   // Whether two EABI versions are compatible.
2774   static bool
2775   are_eabi_versions_compatible(elfcpp::Elf_Word v1, elfcpp::Elf_Word v2);
2776
2777   // Merge processor-specific flags from input object and those in the ELF
2778   // header of the output.
2779   void
2780   merge_processor_specific_flags(const std::string&, elfcpp::Elf_Word);
2781
2782   // Get the secondary compatible architecture.
2783   static int
2784   get_secondary_compatible_arch(const Attributes_section_data*);
2785
2786   // Set the secondary compatible architecture.
2787   static void
2788   set_secondary_compatible_arch(Attributes_section_data*, int);
2789
2790   static int
2791   tag_cpu_arch_combine(const char*, int, int*, int, int);
2792
2793   // Helper to print AEABI enum tag value.
2794   static std::string
2795   aeabi_enum_name(unsigned int);
2796
2797   // Return string value for TAG_CPU_name.
2798   static std::string
2799   tag_cpu_name_value(unsigned int);
2800
2801   // Query attributes object to see if integer divide instructions may be
2802   // present in an object.
2803   static bool
2804   attributes_accept_div(int arch, int profile,
2805                         const Object_attribute* div_attr);
2806
2807   // Query attributes object to see if integer divide instructions are
2808   // forbidden to be in the object.  This is not the inverse of
2809   // attributes_accept_div.
2810   static bool
2811   attributes_forbid_div(const Object_attribute* div_attr);
2812
2813   // Merge object attributes from input object and those in the output.
2814   void
2815   merge_object_attributes(const char*, const Attributes_section_data*);
2816
2817   // Helper to get an AEABI object attribute
2818   Object_attribute*
2819   get_aeabi_object_attribute(int tag) const
2820   {
2821     Attributes_section_data* pasd = this->attributes_section_data_;
2822     gold_assert(pasd != NULL);
2823     Object_attribute* attr =
2824       pasd->get_attribute(Object_attribute::OBJ_ATTR_PROC, tag);
2825     gold_assert(attr != NULL);
2826     return attr;
2827   }
2828
2829   //
2830   // Methods to support stub-generations.
2831   //
2832
2833   // Group input sections for stub generation.
2834   void
2835   group_sections(Layout*, section_size_type, bool, const Task*);
2836
2837   // Scan a relocation for stub generation.
2838   void
2839   scan_reloc_for_stub(const Relocate_info<32, big_endian>*, unsigned int,
2840                       const Sized_symbol<32>*, unsigned int,
2841                       const Symbol_value<32>*,
2842                       elfcpp::Elf_types<32>::Elf_Swxword, Arm_address);
2843
2844   // Scan a relocation section for stub.
2845   template<int sh_type>
2846   void
2847   scan_reloc_section_for_stubs(
2848       const Relocate_info<32, big_endian>* relinfo,
2849       const unsigned char* prelocs,
2850       size_t reloc_count,
2851       Output_section* output_section,
2852       bool needs_special_offset_handling,
2853       const unsigned char* view,
2854       elfcpp::Elf_types<32>::Elf_Addr view_address,
2855       section_size_type);
2856
2857   // Fix .ARM.exidx section coverage.
2858   void
2859   fix_exidx_coverage(Layout*, const Input_objects*,
2860                      Arm_output_section<big_endian>*, Symbol_table*,
2861                      const Task*);
2862
2863   // Functors for STL set.
2864   struct output_section_address_less_than
2865   {
2866     bool
2867     operator()(const Output_section* s1, const Output_section* s2) const
2868     { return s1->address() < s2->address(); }
2869   };
2870
2871   // Information about this specific target which we pass to the
2872   // general Target structure.
2873   static const Target::Target_info arm_info;
2874
2875   // The types of GOT entries needed for this platform.
2876   // These values are exposed to the ABI in an incremental link.
2877   // Do not renumber existing values without changing the version
2878   // number of the .gnu_incremental_inputs section.
2879   enum Got_type
2880   {
2881     GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
2882     GOT_TYPE_TLS_NOFFSET = 1,   // GOT entry for negative TLS offset
2883     GOT_TYPE_TLS_OFFSET = 2,    // GOT entry for positive TLS offset
2884     GOT_TYPE_TLS_PAIR = 3,      // GOT entry for TLS module/offset pair
2885     GOT_TYPE_TLS_DESC = 4       // GOT entry for TLS_DESC pair
2886   };
2887
2888   typedef typename std::vector<Stub_table<big_endian>*> Stub_table_list;
2889
2890   // Map input section to Arm_input_section.
2891   typedef Unordered_map<Section_id,
2892                         Arm_input_section<big_endian>*,
2893                         Section_id_hash>
2894           Arm_input_section_map;
2895
2896   // Map output addresses to relocs for Cortex-A8 erratum.
2897   typedef Unordered_map<Arm_address, const Cortex_a8_reloc*>
2898           Cortex_a8_relocs_info;
2899
2900   // The GOT section.
2901   Arm_output_data_got<big_endian>* got_;
2902   // The PLT section.
2903   Output_data_plt_arm<big_endian>* plt_;
2904   // The GOT PLT section.
2905   Output_data_space* got_plt_;
2906   // The dynamic reloc section.
2907   Reloc_section* rel_dyn_;
2908   // Relocs saved to avoid a COPY reloc.
2909   Copy_relocs<elfcpp::SHT_REL, 32, big_endian> copy_relocs_;
2910   // Offset of the GOT entry for the TLS module index.
2911   unsigned int got_mod_index_offset_;
2912   // True if the _TLS_MODULE_BASE_ symbol has been defined.
2913   bool tls_base_symbol_defined_;
2914   // Vector of Stub_tables created.
2915   Stub_table_list stub_tables_;
2916   // Stub factory.
2917   const Stub_factory &stub_factory_;
2918   // Whether we force PIC branch veneers.
2919   bool should_force_pic_veneer_;
2920   // Map for locating Arm_input_sections.
2921   Arm_input_section_map arm_input_section_map_;
2922   // Attributes section data in output.
2923   Attributes_section_data* attributes_section_data_;
2924   // Whether we want to fix code for Cortex-A8 erratum.
2925   bool fix_cortex_a8_;
2926   // Map addresses to relocs for Cortex-A8 erratum.
2927   Cortex_a8_relocs_info cortex_a8_relocs_info_;
2928 };
2929
2930 template<bool big_endian>
2931 const Target::Target_info Target_arm<big_endian>::arm_info =
2932 {
2933   32,                   // size
2934   big_endian,           // is_big_endian
2935   elfcpp::EM_ARM,       // machine_code
2936   false,                // has_make_symbol
2937   false,                // has_resolve
2938   false,                // has_code_fill
2939   true,                 // is_default_stack_executable
2940   false,                // can_icf_inline_merge_sections
2941   '\0',                 // wrap_char
2942   "/usr/lib/libc.so.1", // dynamic_linker
2943   0x8000,               // default_text_segment_address
2944   0x1000,               // abi_pagesize (overridable by -z max-page-size)
2945   0x1000,               // common_pagesize (overridable by -z common-page-size)
2946   false,                // isolate_execinstr
2947   0,                    // rosegment_gap
2948   elfcpp::SHN_UNDEF,    // small_common_shndx
2949   elfcpp::SHN_UNDEF,    // large_common_shndx
2950   0,                    // small_common_section_flags
2951   0,                    // large_common_section_flags
2952   ".ARM.attributes",    // attributes_section
2953   "aeabi",              // attributes_vendor
2954   "_start"              // entry_symbol_name
2955 };
2956
2957 // Arm relocate functions class
2958 //
2959
2960 template<bool big_endian>
2961 class Arm_relocate_functions : public Relocate_functions<32, big_endian>
2962 {
2963  public:
2964   typedef enum
2965   {
2966     STATUS_OKAY,        // No error during relocation.
2967     STATUS_OVERFLOW,    // Relocation overflow.
2968     STATUS_BAD_RELOC    // Relocation cannot be applied.
2969   } Status;
2970
2971  private:
2972   typedef Relocate_functions<32, big_endian> Base;
2973   typedef Arm_relocate_functions<big_endian> This;
2974
2975   // Encoding of imm16 argument for movt and movw ARM instructions
2976   // from ARM ARM:
2977   //
2978   //     imm16 := imm4 | imm12
2979   //
2980   //  f e d c b a 9 8 7 6 5 4 3 2 1 0 f e d c b a 9 8 7 6 5 4 3 2 1 0
2981   // +-------+---------------+-------+-------+-----------------------+
2982   // |       |               |imm4   |       |imm12                  |
2983   // +-------+---------------+-------+-------+-----------------------+
2984
2985   // Extract the relocation addend from VAL based on the ARM
2986   // instruction encoding described above.
2987   static inline typename elfcpp::Swap<32, big_endian>::Valtype
2988   extract_arm_movw_movt_addend(
2989       typename elfcpp::Swap<32, big_endian>::Valtype val)
2990   {
2991     // According to the Elf ABI for ARM Architecture the immediate
2992     // field is sign-extended to form the addend.
2993     return Bits<16>::sign_extend32(((val >> 4) & 0xf000) | (val & 0xfff));
2994   }
2995
2996   // Insert X into VAL based on the ARM instruction encoding described
2997   // above.
2998   static inline typename elfcpp::Swap<32, big_endian>::Valtype
2999   insert_val_arm_movw_movt(
3000       typename elfcpp::Swap<32, big_endian>::Valtype val,
3001       typename elfcpp::Swap<32, big_endian>::Valtype x)
3002   {
3003     val &= 0xfff0f000;
3004     val |= x & 0x0fff;
3005     val |= (x & 0xf000) << 4;
3006     return val;
3007   }
3008
3009   // Encoding of imm16 argument for movt and movw Thumb2 instructions
3010   // from ARM ARM:
3011   //
3012   //     imm16 := imm4 | i | imm3 | imm8
3013   //
3014   //  f e d c b a 9 8 7 6 5 4 3 2 1 0  f e d c b a 9 8 7 6 5 4 3 2 1 0
3015   // +---------+-+-----------+-------++-+-----+-------+---------------+
3016   // |         |i|           |imm4   || |imm3 |       |imm8           |
3017   // +---------+-+-----------+-------++-+-----+-------+---------------+
3018
3019   // Extract the relocation addend from VAL based on the Thumb2
3020   // instruction encoding described above.
3021   static inline typename elfcpp::Swap<32, big_endian>::Valtype
3022   extract_thumb_movw_movt_addend(
3023       typename elfcpp::Swap<32, big_endian>::Valtype val)
3024   {
3025     // According to the Elf ABI for ARM Architecture the immediate
3026     // field is sign-extended to form the addend.
3027     return Bits<16>::sign_extend32(((val >> 4) & 0xf000)
3028                                    | ((val >> 15) & 0x0800)
3029                                    | ((val >> 4) & 0x0700)
3030                                    | (val & 0x00ff));
3031   }
3032
3033   // Insert X into VAL based on the Thumb2 instruction encoding
3034   // described above.
3035   static inline typename elfcpp::Swap<32, big_endian>::Valtype
3036   insert_val_thumb_movw_movt(
3037       typename elfcpp::Swap<32, big_endian>::Valtype val,
3038       typename elfcpp::Swap<32, big_endian>::Valtype x)
3039   {
3040     val &= 0xfbf08f00;
3041     val |= (x & 0xf000) << 4;
3042     val |= (x & 0x0800) << 15;
3043     val |= (x & 0x0700) << 4;
3044     val |= (x & 0x00ff);
3045     return val;
3046   }
3047
3048   // Calculate the smallest constant Kn for the specified residual.
3049   // (see (AAELF 4.6.1.4 Static ARM relocations, Group Relocations, p.32)
3050   static uint32_t
3051   calc_grp_kn(typename elfcpp::Swap<32, big_endian>::Valtype residual)
3052   {
3053     int32_t msb;
3054
3055     if (residual == 0)
3056       return 0;
3057     // Determine the most significant bit in the residual and
3058     // align the resulting value to a 2-bit boundary.
3059     for (msb = 30; (msb >= 0) && !(residual & (3 << msb)); msb -= 2)
3060       ;
3061     // The desired shift is now (msb - 6), or zero, whichever
3062     // is the greater.
3063     return (((msb - 6) < 0) ? 0 : (msb - 6));
3064   }
3065
3066   // Calculate the final residual for the specified group index.
3067   // If the passed group index is less than zero, the method will return
3068   // the value of the specified residual without any change.
3069   // (see (AAELF 4.6.1.4 Static ARM relocations, Group Relocations, p.32)
3070   static typename elfcpp::Swap<32, big_endian>::Valtype
3071   calc_grp_residual(typename elfcpp::Swap<32, big_endian>::Valtype residual,
3072                     const int group)
3073   {
3074     for (int n = 0; n <= group; n++)
3075       {
3076         // Calculate which part of the value to mask.
3077         uint32_t shift = calc_grp_kn(residual);
3078         // Calculate the residual for the next time around.
3079         residual &= ~(residual & (0xff << shift));
3080       }
3081
3082     return residual;
3083   }
3084
3085   // Calculate the value of Gn for the specified group index.
3086   // We return it in the form of an encoded constant-and-rotation.
3087   // (see (AAELF 4.6.1.4 Static ARM relocations, Group Relocations, p.32)
3088   static typename elfcpp::Swap<32, big_endian>::Valtype
3089   calc_grp_gn(typename elfcpp::Swap<32, big_endian>::Valtype residual,
3090               const int group)
3091   {
3092     typename elfcpp::Swap<32, big_endian>::Valtype gn = 0;
3093     uint32_t shift = 0;
3094
3095     for (int n = 0; n <= group; n++)
3096       {
3097         // Calculate which part of the value to mask.
3098         shift = calc_grp_kn(residual);
3099         // Calculate Gn in 32-bit as well as encoded constant-and-rotation form.
3100         gn = residual & (0xff << shift);
3101         // Calculate the residual for the next time around.
3102         residual &= ~gn;
3103       }
3104     // Return Gn in the form of an encoded constant-and-rotation.
3105     return ((gn >> shift) | ((gn <= 0xff ? 0 : (32 - shift) / 2) << 8));
3106   }
3107
3108  public:
3109   // Handle ARM long branches.
3110   static typename This::Status
3111   arm_branch_common(unsigned int, const Relocate_info<32, big_endian>*,
3112                     unsigned char*, const Sized_symbol<32>*,
3113                     const Arm_relobj<big_endian>*, unsigned int,
3114                     const Symbol_value<32>*, Arm_address, Arm_address, bool);
3115
3116   // Handle THUMB long branches.
3117   static typename This::Status
3118   thumb_branch_common(unsigned int, const Relocate_info<32, big_endian>*,
3119                       unsigned char*, const Sized_symbol<32>*,
3120                       const Arm_relobj<big_endian>*, unsigned int,
3121                       const Symbol_value<32>*, Arm_address, Arm_address, bool);
3122
3123
3124   // Return the branch offset of a 32-bit THUMB branch.
3125   static inline int32_t
3126   thumb32_branch_offset(uint16_t upper_insn, uint16_t lower_insn)
3127   {
3128     // We use the Thumb-2 encoding (backwards compatible with Thumb-1)
3129     // involving the J1 and J2 bits.
3130     uint32_t s = (upper_insn & (1U << 10)) >> 10;
3131     uint32_t upper = upper_insn & 0x3ffU;
3132     uint32_t lower = lower_insn & 0x7ffU;
3133     uint32_t j1 = (lower_insn & (1U << 13)) >> 13;
3134     uint32_t j2 = (lower_insn & (1U << 11)) >> 11;
3135     uint32_t i1 = j1 ^ s ? 0 : 1;
3136     uint32_t i2 = j2 ^ s ? 0 : 1;
3137
3138     return Bits<25>::sign_extend32((s << 24) | (i1 << 23) | (i2 << 22)
3139                                    | (upper << 12) | (lower << 1));
3140   }
3141
3142   // Insert OFFSET to a 32-bit THUMB branch and return the upper instruction.
3143   // UPPER_INSN is the original upper instruction of the branch.  Caller is
3144   // responsible for overflow checking and BLX offset adjustment.
3145   static inline uint16_t
3146   thumb32_branch_upper(uint16_t upper_insn, int32_t offset)
3147   {
3148     uint32_t s = offset < 0 ? 1 : 0;
3149     uint32_t bits = static_cast<uint32_t>(offset);
3150     return (upper_insn & ~0x7ffU) | ((bits >> 12) & 0x3ffU) | (s << 10);
3151   }
3152
3153   // Insert OFFSET to a 32-bit THUMB branch and return the lower instruction.
3154   // LOWER_INSN is the original lower instruction of the branch.  Caller is
3155   // responsible for overflow checking and BLX offset adjustment.
3156   static inline uint16_t
3157   thumb32_branch_lower(uint16_t lower_insn, int32_t offset)
3158   {
3159     uint32_t s = offset < 0 ? 1 : 0;
3160     uint32_t bits = static_cast<uint32_t>(offset);
3161     return ((lower_insn & ~0x2fffU)
3162             | ((((bits >> 23) & 1) ^ !s) << 13)
3163             | ((((bits >> 22) & 1) ^ !s) << 11)
3164             | ((bits >> 1) & 0x7ffU));
3165   }
3166
3167   // Return the branch offset of a 32-bit THUMB conditional branch.
3168   static inline int32_t
3169   thumb32_cond_branch_offset(uint16_t upper_insn, uint16_t lower_insn)
3170   {
3171     uint32_t s = (upper_insn & 0x0400U) >> 10;
3172     uint32_t j1 = (lower_insn & 0x2000U) >> 13;
3173     uint32_t j2 = (lower_insn & 0x0800U) >> 11;
3174     uint32_t lower = (lower_insn & 0x07ffU);
3175     uint32_t upper = (s << 8) | (j2 << 7) | (j1 << 6) | (upper_insn & 0x003fU);
3176
3177     return Bits<21>::sign_extend32((upper << 12) | (lower << 1));
3178   }
3179
3180   // Insert OFFSET to a 32-bit THUMB conditional branch and return the upper
3181   // instruction.  UPPER_INSN is the original upper instruction of the branch.
3182   // Caller is responsible for overflow checking.
3183   static inline uint16_t
3184   thumb32_cond_branch_upper(uint16_t upper_insn, int32_t offset)
3185   {
3186     uint32_t s = offset < 0 ? 1 : 0;
3187     uint32_t bits = static_cast<uint32_t>(offset);
3188     return (upper_insn & 0xfbc0U) | (s << 10) | ((bits & 0x0003f000U) >> 12);
3189   }
3190
3191   // Insert OFFSET to a 32-bit THUMB conditional branch and return the lower
3192   // instruction.  LOWER_INSN is the original lower instruction of the branch.
3193   // The caller is responsible for overflow checking.
3194   static inline uint16_t
3195   thumb32_cond_branch_lower(uint16_t lower_insn, int32_t offset)
3196   {
3197     uint32_t bits = static_cast<uint32_t>(offset);
3198     uint32_t j2 = (bits & 0x00080000U) >> 19;
3199     uint32_t j1 = (bits & 0x00040000U) >> 18;
3200     uint32_t lo = (bits & 0x00000ffeU) >> 1;
3201
3202     return (lower_insn & 0xd000U) | (j1 << 13) | (j2 << 11) | lo;
3203   }
3204
3205   // R_ARM_ABS8: S + A
3206   static inline typename This::Status
3207   abs8(unsigned char* view,
3208        const Sized_relobj_file<32, big_endian>* object,
3209        const Symbol_value<32>* psymval)
3210   {
3211     typedef typename elfcpp::Swap<8, big_endian>::Valtype Valtype;
3212     Valtype* wv = reinterpret_cast<Valtype*>(view);
3213     Valtype val = elfcpp::Swap<8, big_endian>::readval(wv);
3214     int32_t addend = Bits<8>::sign_extend32(val);
3215     Arm_address x = psymval->value(object, addend);
3216     val = Bits<32>::bit_select32(val, x, 0xffU);
3217     elfcpp::Swap<8, big_endian>::writeval(wv, val);
3218
3219     // R_ARM_ABS8 permits signed or unsigned results.
3220     return (Bits<8>::has_signed_unsigned_overflow32(x)
3221             ? This::STATUS_OVERFLOW
3222             : This::STATUS_OKAY);
3223   }
3224
3225   // R_ARM_THM_ABS5: S + A
3226   static inline typename This::Status
3227   thm_abs5(unsigned char* view,
3228        const Sized_relobj_file<32, big_endian>* object,
3229        const Symbol_value<32>* psymval)
3230   {
3231     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3232     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3233     Valtype* wv = reinterpret_cast<Valtype*>(view);
3234     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3235     Reltype addend = (val & 0x7e0U) >> 6;
3236     Reltype x = psymval->value(object, addend);
3237     val = Bits<32>::bit_select32(val, x << 6, 0x7e0U);
3238     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3239     return (Bits<5>::has_overflow32(x)
3240             ? This::STATUS_OVERFLOW
3241             : This::STATUS_OKAY);
3242   }
3243
3244   // R_ARM_ABS12: S + A
3245   static inline typename This::Status
3246   abs12(unsigned char* view,
3247         const Sized_relobj_file<32, big_endian>* object,
3248         const Symbol_value<32>* psymval)
3249   {
3250     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3251     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3252     Valtype* wv = reinterpret_cast<Valtype*>(view);
3253     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3254     Reltype addend = val & 0x0fffU;
3255     Reltype x = psymval->value(object, addend);
3256     val = Bits<32>::bit_select32(val, x, 0x0fffU);
3257     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3258     return (Bits<12>::has_overflow32(x)
3259             ? This::STATUS_OVERFLOW
3260             : This::STATUS_OKAY);
3261   }
3262
3263   // R_ARM_ABS16: S + A
3264   static inline typename This::Status
3265   abs16(unsigned char* view,
3266         const Sized_relobj_file<32, big_endian>* object,
3267         const Symbol_value<32>* psymval)
3268   {
3269     typedef typename elfcpp::Swap_unaligned<16, big_endian>::Valtype Valtype;
3270     Valtype val = elfcpp::Swap_unaligned<16, big_endian>::readval(view);
3271     int32_t addend = Bits<16>::sign_extend32(val);
3272     Arm_address x = psymval->value(object, addend);
3273     val = Bits<32>::bit_select32(val, x, 0xffffU);
3274     elfcpp::Swap_unaligned<16, big_endian>::writeval(view, val);
3275
3276     // R_ARM_ABS16 permits signed or unsigned results.
3277     return (Bits<16>::has_signed_unsigned_overflow32(x)
3278             ? This::STATUS_OVERFLOW
3279             : This::STATUS_OKAY);
3280   }
3281
3282   // R_ARM_ABS32: (S + A) | T
3283   static inline typename This::Status
3284   abs32(unsigned char* view,
3285         const Sized_relobj_file<32, big_endian>* object,
3286         const Symbol_value<32>* psymval,
3287         Arm_address thumb_bit)
3288   {
3289     typedef typename elfcpp::Swap_unaligned<32, big_endian>::Valtype Valtype;
3290     Valtype addend = elfcpp::Swap_unaligned<32, big_endian>::readval(view);
3291     Valtype x = psymval->value(object, addend) | thumb_bit;
3292     elfcpp::Swap_unaligned<32, big_endian>::writeval(view, x);
3293     return This::STATUS_OKAY;
3294   }
3295
3296   // R_ARM_REL32: (S + A) | T - P
3297   static inline typename This::Status
3298   rel32(unsigned char* view,
3299         const Sized_relobj_file<32, big_endian>* object,
3300         const Symbol_value<32>* psymval,
3301         Arm_address address,
3302         Arm_address thumb_bit)
3303   {
3304     typedef typename elfcpp::Swap_unaligned<32, big_endian>::Valtype Valtype;
3305     Valtype addend = elfcpp::Swap_unaligned<32, big_endian>::readval(view);
3306     Valtype x = (psymval->value(object, addend) | thumb_bit) - address;
3307     elfcpp::Swap_unaligned<32, big_endian>::writeval(view, x);
3308     return This::STATUS_OKAY;
3309   }
3310
3311   // R_ARM_THM_JUMP24: (S + A) | T - P
3312   static typename This::Status
3313   thm_jump19(unsigned char* view, const Arm_relobj<big_endian>* object,
3314              const Symbol_value<32>* psymval, Arm_address address,
3315              Arm_address thumb_bit);
3316
3317   // R_ARM_THM_JUMP6: S + A – P
3318   static inline typename This::Status
3319   thm_jump6(unsigned char* view,
3320             const Sized_relobj_file<32, big_endian>* object,
3321             const Symbol_value<32>* psymval,
3322             Arm_address address)
3323   {
3324     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3325     typedef typename elfcpp::Swap<16, big_endian>::Valtype Reltype;
3326     Valtype* wv = reinterpret_cast<Valtype*>(view);
3327     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3328     // bit[9]:bit[7:3]:’0’ (mask: 0x02f8)
3329     Reltype addend = (((val & 0x0200) >> 3) | ((val & 0x00f8) >> 2));
3330     Reltype x = (psymval->value(object, addend) - address);
3331     val = (val & 0xfd07) | ((x  & 0x0040) << 3) | ((val & 0x003e) << 2);
3332     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3333     // CZB does only forward jumps.
3334     return ((x > 0x007e)
3335             ? This::STATUS_OVERFLOW
3336             : This::STATUS_OKAY);
3337   }
3338
3339   // R_ARM_THM_JUMP8: S + A – P
3340   static inline typename This::Status
3341   thm_jump8(unsigned char* view,
3342             const Sized_relobj_file<32, big_endian>* object,
3343             const Symbol_value<32>* psymval,
3344             Arm_address address)
3345   {
3346     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3347     Valtype* wv = reinterpret_cast<Valtype*>(view);
3348     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3349     int32_t addend = Bits<8>::sign_extend32((val & 0x00ff) << 1);
3350     int32_t x = (psymval->value(object, addend) - address);
3351     elfcpp::Swap<16, big_endian>::writeval(wv, ((val & 0xff00)
3352                                                 | ((x & 0x01fe) >> 1)));
3353     // We do a 9-bit overflow check because x is right-shifted by 1 bit.
3354     return (Bits<9>::has_overflow32(x)
3355             ? This::STATUS_OVERFLOW
3356             : This::STATUS_OKAY);
3357   }
3358
3359   // R_ARM_THM_JUMP11: S + A – P
3360   static inline typename This::Status
3361   thm_jump11(unsigned char* view,
3362             const Sized_relobj_file<32, big_endian>* object,
3363             const Symbol_value<32>* psymval,
3364             Arm_address address)
3365   {
3366     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3367     Valtype* wv = reinterpret_cast<Valtype*>(view);
3368     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3369     int32_t addend = Bits<11>::sign_extend32((val & 0x07ff) << 1);
3370     int32_t x = (psymval->value(object, addend) - address);
3371     elfcpp::Swap<16, big_endian>::writeval(wv, ((val & 0xf800)
3372                                                 | ((x & 0x0ffe) >> 1)));
3373     // We do a 12-bit overflow check because x is right-shifted by 1 bit.
3374     return (Bits<12>::has_overflow32(x)
3375             ? This::STATUS_OVERFLOW
3376             : This::STATUS_OKAY);
3377   }
3378
3379   // R_ARM_BASE_PREL: B(S) + A - P
3380   static inline typename This::Status
3381   base_prel(unsigned char* view,
3382             Arm_address origin,
3383             Arm_address address)
3384   {
3385     Base::rel32(view, origin - address);
3386     return STATUS_OKAY;
3387   }
3388
3389   // R_ARM_BASE_ABS: B(S) + A
3390   static inline typename This::Status
3391   base_abs(unsigned char* view,
3392            Arm_address origin)
3393   {
3394     Base::rel32(view, origin);
3395     return STATUS_OKAY;
3396   }
3397
3398   // R_ARM_GOT_BREL: GOT(S) + A - GOT_ORG
3399   static inline typename This::Status
3400   got_brel(unsigned char* view,
3401            typename elfcpp::Swap<32, big_endian>::Valtype got_offset)
3402   {
3403     Base::rel32(view, got_offset);
3404     return This::STATUS_OKAY;
3405   }
3406
3407   // R_ARM_GOT_PREL: GOT(S) + A - P
3408   static inline typename This::Status
3409   got_prel(unsigned char* view,
3410            Arm_address got_entry,
3411            Arm_address address)
3412   {
3413     Base::rel32(view, got_entry - address);
3414     return This::STATUS_OKAY;
3415   }
3416
3417   // R_ARM_PREL: (S + A) | T - P
3418   static inline typename This::Status
3419   prel31(unsigned char* view,
3420          const Sized_relobj_file<32, big_endian>* object,
3421          const Symbol_value<32>* psymval,
3422          Arm_address address,
3423          Arm_address thumb_bit)
3424   {
3425     typedef typename elfcpp::Swap_unaligned<32, big_endian>::Valtype Valtype;
3426     Valtype val = elfcpp::Swap_unaligned<32, big_endian>::readval(view);
3427     Valtype addend = Bits<31>::sign_extend32(val);
3428     Valtype x = (psymval->value(object, addend) | thumb_bit) - address;
3429     val = Bits<32>::bit_select32(val, x, 0x7fffffffU);
3430     elfcpp::Swap_unaligned<32, big_endian>::writeval(view, val);
3431     return (Bits<31>::has_overflow32(x)
3432             ? This::STATUS_OVERFLOW
3433             : This::STATUS_OKAY);
3434   }
3435
3436   // R_ARM_MOVW_ABS_NC: (S + A) | T     (relative address base is )
3437   // R_ARM_MOVW_PREL_NC: (S + A) | T - P
3438   // R_ARM_MOVW_BREL_NC: ((S + A) | T) - B(S)
3439   // R_ARM_MOVW_BREL: ((S + A) | T) - B(S)
3440   static inline typename This::Status
3441   movw(unsigned char* view,
3442        const Sized_relobj_file<32, big_endian>* object,
3443        const Symbol_value<32>* psymval,
3444        Arm_address relative_address_base,
3445        Arm_address thumb_bit,
3446        bool check_overflow)
3447   {
3448     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3449     Valtype* wv = reinterpret_cast<Valtype*>(view);
3450     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3451     Valtype addend = This::extract_arm_movw_movt_addend(val);
3452     Valtype x = ((psymval->value(object, addend) | thumb_bit)
3453                  - relative_address_base);
3454     val = This::insert_val_arm_movw_movt(val, x);
3455     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3456     return ((check_overflow && Bits<16>::has_overflow32(x))
3457             ? This::STATUS_OVERFLOW
3458             : This::STATUS_OKAY);
3459   }
3460
3461   // R_ARM_MOVT_ABS: S + A      (relative address base is 0)
3462   // R_ARM_MOVT_PREL: S + A - P
3463   // R_ARM_MOVT_BREL: S + A - B(S)
3464   static inline typename This::Status
3465   movt(unsigned char* view,
3466        const Sized_relobj_file<32, big_endian>* object,
3467        const Symbol_value<32>* psymval,
3468        Arm_address relative_address_base)
3469   {
3470     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3471     Valtype* wv = reinterpret_cast<Valtype*>(view);
3472     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3473     Valtype addend = This::extract_arm_movw_movt_addend(val);
3474     Valtype x = (psymval->value(object, addend) - relative_address_base) >> 16;
3475     val = This::insert_val_arm_movw_movt(val, x);
3476     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3477     // FIXME: IHI0044D says that we should check for overflow.
3478     return This::STATUS_OKAY;
3479   }
3480
3481   // R_ARM_THM_MOVW_ABS_NC: S + A | T           (relative_address_base is 0)
3482   // R_ARM_THM_MOVW_PREL_NC: (S + A) | T - P
3483   // R_ARM_THM_MOVW_BREL_NC: ((S + A) | T) - B(S)
3484   // R_ARM_THM_MOVW_BREL: ((S + A) | T) - B(S)
3485   static inline typename This::Status
3486   thm_movw(unsigned char* view,
3487            const Sized_relobj_file<32, big_endian>* object,
3488            const Symbol_value<32>* psymval,
3489            Arm_address relative_address_base,
3490            Arm_address thumb_bit,
3491            bool check_overflow)
3492   {
3493     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3494     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3495     Valtype* wv = reinterpret_cast<Valtype*>(view);
3496     Reltype val = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3497                   | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3498     Reltype addend = This::extract_thumb_movw_movt_addend(val);
3499     Reltype x =
3500       (psymval->value(object, addend) | thumb_bit) - relative_address_base;
3501     val = This::insert_val_thumb_movw_movt(val, x);
3502     elfcpp::Swap<16, big_endian>::writeval(wv, val >> 16);
3503     elfcpp::Swap<16, big_endian>::writeval(wv + 1, val & 0xffff);
3504     return ((check_overflow && Bits<16>::has_overflow32(x))
3505             ? This::STATUS_OVERFLOW
3506             : This::STATUS_OKAY);
3507   }
3508
3509   // R_ARM_THM_MOVT_ABS: S + A          (relative address base is 0)
3510   // R_ARM_THM_MOVT_PREL: S + A - P
3511   // R_ARM_THM_MOVT_BREL: S + A - B(S)
3512   static inline typename This::Status
3513   thm_movt(unsigned char* view,
3514            const Sized_relobj_file<32, big_endian>* object,
3515            const Symbol_value<32>* psymval,
3516            Arm_address relative_address_base)
3517   {
3518     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3519     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3520     Valtype* wv = reinterpret_cast<Valtype*>(view);
3521     Reltype val = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3522                   | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3523     Reltype addend = This::extract_thumb_movw_movt_addend(val);
3524     Reltype x = (psymval->value(object, addend) - relative_address_base) >> 16;
3525     val = This::insert_val_thumb_movw_movt(val, x);
3526     elfcpp::Swap<16, big_endian>::writeval(wv, val >> 16);
3527     elfcpp::Swap<16, big_endian>::writeval(wv + 1, val & 0xffff);
3528     return This::STATUS_OKAY;
3529   }
3530
3531   // R_ARM_THM_ALU_PREL_11_0: ((S + A) | T) - Pa (Thumb32)
3532   static inline typename This::Status
3533   thm_alu11(unsigned char* view,
3534             const Sized_relobj_file<32, big_endian>* object,
3535             const Symbol_value<32>* psymval,
3536             Arm_address address,
3537             Arm_address thumb_bit)
3538   {
3539     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3540     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3541     Valtype* wv = reinterpret_cast<Valtype*>(view);
3542     Reltype insn = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3543                    | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3544
3545     //        f e d c b|a|9|8 7 6 5|4|3 2 1 0||f|e d c|b a 9 8|7 6 5 4 3 2 1 0
3546     // -----------------------------------------------------------------------
3547     // ADD{S} 1 1 1 1 0|i|0|1 0 0 0|S|1 1 0 1||0|imm3 |Rd     |imm8
3548     // ADDW   1 1 1 1 0|i|1|0 0 0 0|0|1 1 0 1||0|imm3 |Rd     |imm8
3549     // ADR[+] 1 1 1 1 0|i|1|0 0 0 0|0|1 1 1 1||0|imm3 |Rd     |imm8
3550     // SUB{S} 1 1 1 1 0|i|0|1 1 0 1|S|1 1 0 1||0|imm3 |Rd     |imm8
3551     // SUBW   1 1 1 1 0|i|1|0 1 0 1|0|1 1 0 1||0|imm3 |Rd     |imm8
3552     // ADR[-] 1 1 1 1 0|i|1|0 1 0 1|0|1 1 1 1||0|imm3 |Rd     |imm8
3553
3554     // Determine a sign for the addend.
3555     const int sign = ((insn & 0xf8ef0000) == 0xf0ad0000
3556                       || (insn & 0xf8ef0000) == 0xf0af0000) ? -1 : 1;
3557     // Thumb2 addend encoding:
3558     // imm12 := i | imm3 | imm8
3559     int32_t addend = (insn & 0xff)
3560                      | ((insn & 0x00007000) >> 4)
3561                      | ((insn & 0x04000000) >> 15);
3562     // Apply a sign to the added.
3563     addend *= sign;
3564
3565     int32_t x = (psymval->value(object, addend) | thumb_bit)
3566                 - (address & 0xfffffffc);
3567     Reltype val = abs(x);
3568     // Mask out the value and a distinct part of the ADD/SUB opcode
3569     // (bits 7:5 of opword).
3570     insn = (insn & 0xfb0f8f00)
3571            | (val & 0xff)
3572            | ((val & 0x700) << 4)
3573            | ((val & 0x800) << 15);
3574     // Set the opcode according to whether the value to go in the
3575     // place is negative.
3576     if (x < 0)
3577       insn |= 0x00a00000;
3578
3579     elfcpp::Swap<16, big_endian>::writeval(wv, insn >> 16);
3580     elfcpp::Swap<16, big_endian>::writeval(wv + 1, insn & 0xffff);
3581     return ((val > 0xfff) ?
3582             This::STATUS_OVERFLOW : This::STATUS_OKAY);
3583   }
3584
3585   // R_ARM_THM_PC8: S + A - Pa (Thumb)
3586   static inline typename This::Status
3587   thm_pc8(unsigned char* view,
3588           const Sized_relobj_file<32, big_endian>* object,
3589           const Symbol_value<32>* psymval,
3590           Arm_address address)
3591   {
3592     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3593     typedef typename elfcpp::Swap<16, big_endian>::Valtype Reltype;
3594     Valtype* wv = reinterpret_cast<Valtype*>(view);
3595     Valtype insn = elfcpp::Swap<16, big_endian>::readval(wv);
3596     Reltype addend = ((insn & 0x00ff) << 2);
3597     int32_t x = (psymval->value(object, addend) - (address & 0xfffffffc));
3598     Reltype val = abs(x);
3599     insn = (insn & 0xff00) | ((val & 0x03fc) >> 2);
3600
3601     elfcpp::Swap<16, big_endian>::writeval(wv, insn);
3602     return ((val > 0x03fc)
3603             ? This::STATUS_OVERFLOW
3604             : This::STATUS_OKAY);
3605   }
3606
3607   // R_ARM_THM_PC12: S + A - Pa (Thumb32)
3608   static inline typename This::Status
3609   thm_pc12(unsigned char* view,
3610            const Sized_relobj_file<32, big_endian>* object,
3611            const Symbol_value<32>* psymval,
3612            Arm_address address)
3613   {
3614     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3615     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3616     Valtype* wv = reinterpret_cast<Valtype*>(view);
3617     Reltype insn = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3618                    | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3619     // Determine a sign for the addend (positive if the U bit is 1).
3620     const int sign = (insn & 0x00800000) ? 1 : -1;
3621     int32_t addend = (insn & 0xfff);
3622     // Apply a sign to the added.
3623     addend *= sign;
3624
3625     int32_t x = (psymval->value(object, addend) - (address & 0xfffffffc));
3626     Reltype val = abs(x);
3627     // Mask out and apply the value and the U bit.
3628     insn = (insn & 0xff7ff000) | (val & 0xfff);
3629     // Set the U bit according to whether the value to go in the
3630     // place is positive.
3631     if (x >= 0)
3632       insn |= 0x00800000;
3633
3634     elfcpp::Swap<16, big_endian>::writeval(wv, insn >> 16);
3635     elfcpp::Swap<16, big_endian>::writeval(wv + 1, insn & 0xffff);
3636     return ((val > 0xfff) ?
3637             This::STATUS_OVERFLOW : This::STATUS_OKAY);
3638   }
3639
3640   // R_ARM_V4BX
3641   static inline typename This::Status
3642   v4bx(const Relocate_info<32, big_endian>* relinfo,
3643        unsigned char* view,
3644        const Arm_relobj<big_endian>* object,
3645        const Arm_address address,
3646        const bool is_interworking)
3647   {
3648
3649     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3650     Valtype* wv = reinterpret_cast<Valtype*>(view);
3651     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3652
3653     // Ensure that we have a BX instruction.
3654     gold_assert((val & 0x0ffffff0) == 0x012fff10);
3655     const uint32_t reg = (val & 0xf);
3656     if (is_interworking && reg != 0xf)
3657       {
3658         Stub_table<big_endian>* stub_table =
3659             object->stub_table(relinfo->data_shndx);
3660         gold_assert(stub_table != NULL);
3661
3662         Arm_v4bx_stub* stub = stub_table->find_arm_v4bx_stub(reg);
3663         gold_assert(stub != NULL);
3664
3665         int32_t veneer_address =
3666             stub_table->address() + stub->offset() - 8 - address;
3667         gold_assert((veneer_address <= ARM_MAX_FWD_BRANCH_OFFSET)
3668                     && (veneer_address >= ARM_MAX_BWD_BRANCH_OFFSET));
3669         // Replace with a branch to veneer (B <addr>)
3670         val = (val & 0xf0000000) | 0x0a000000
3671               | ((veneer_address >> 2) & 0x00ffffff);
3672       }
3673     else
3674       {
3675         // Preserve Rm (lowest four bits) and the condition code
3676         // (highest four bits). Other bits encode MOV PC,Rm.
3677         val = (val & 0xf000000f) | 0x01a0f000;
3678       }
3679     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3680     return This::STATUS_OKAY;
3681   }
3682
3683   // R_ARM_ALU_PC_G0_NC: ((S + A) | T) - P
3684   // R_ARM_ALU_PC_G0:    ((S + A) | T) - P
3685   // R_ARM_ALU_PC_G1_NC: ((S + A) | T) - P
3686   // R_ARM_ALU_PC_G1:    ((S + A) | T) - P
3687   // R_ARM_ALU_PC_G2:    ((S + A) | T) - P
3688   // R_ARM_ALU_SB_G0_NC: ((S + A) | T) - B(S)
3689   // R_ARM_ALU_SB_G0:    ((S + A) | T) - B(S)
3690   // R_ARM_ALU_SB_G1_NC: ((S + A) | T) - B(S)
3691   // R_ARM_ALU_SB_G1:    ((S + A) | T) - B(S)
3692   // R_ARM_ALU_SB_G2:    ((S + A) | T) - B(S)
3693   static inline typename This::Status
3694   arm_grp_alu(unsigned char* view,
3695         const Sized_relobj_file<32, big_endian>* object,
3696         const Symbol_value<32>* psymval,
3697         const int group,
3698         Arm_address address,
3699         Arm_address thumb_bit,
3700         bool check_overflow)
3701   {
3702     gold_assert(group >= 0 && group < 3);
3703     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3704     Valtype* wv = reinterpret_cast<Valtype*>(view);
3705     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3706
3707     // ALU group relocations are allowed only for the ADD/SUB instructions.
3708     // (0x00800000 - ADD, 0x00400000 - SUB)
3709     const Valtype opcode = insn & 0x01e00000;
3710     if (opcode != 0x00800000 && opcode != 0x00400000)
3711       return This::STATUS_BAD_RELOC;
3712
3713     // Determine a sign for the addend.
3714     const int sign = (opcode == 0x00800000) ? 1 : -1;
3715     // shifter = rotate_imm * 2
3716     const uint32_t shifter = (insn & 0xf00) >> 7;
3717     // Initial addend value.
3718     int32_t addend = insn & 0xff;
3719     // Rotate addend right by shifter.
3720     addend = (addend >> shifter) | (addend << (32 - shifter));
3721     // Apply a sign to the added.
3722     addend *= sign;
3723
3724     int32_t x = ((psymval->value(object, addend) | thumb_bit) - address);
3725     Valtype gn = Arm_relocate_functions::calc_grp_gn(abs(x), group);
3726     // Check for overflow if required
3727     if (check_overflow
3728         && (Arm_relocate_functions::calc_grp_residual(abs(x), group) != 0))
3729       return This::STATUS_OVERFLOW;
3730
3731     // Mask out the value and the ADD/SUB part of the opcode; take care
3732     // not to destroy the S bit.
3733     insn &= 0xff1ff000;
3734     // Set the opcode according to whether the value to go in the
3735     // place is negative.
3736     insn |= ((x < 0) ? 0x00400000 : 0x00800000);
3737     // Encode the offset (encoded Gn).
3738     insn |= gn;
3739
3740     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3741     return This::STATUS_OKAY;
3742   }
3743
3744   // R_ARM_LDR_PC_G0: S + A - P
3745   // R_ARM_LDR_PC_G1: S + A - P
3746   // R_ARM_LDR_PC_G2: S + A - P
3747   // R_ARM_LDR_SB_G0: S + A - B(S)
3748   // R_ARM_LDR_SB_G1: S + A - B(S)
3749   // R_ARM_LDR_SB_G2: S + A - B(S)
3750   static inline typename This::Status
3751   arm_grp_ldr(unsigned char* view,
3752         const Sized_relobj_file<32, big_endian>* object,
3753         const Symbol_value<32>* psymval,
3754         const int group,
3755         Arm_address address)
3756   {
3757     gold_assert(group >= 0 && group < 3);
3758     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3759     Valtype* wv = reinterpret_cast<Valtype*>(view);
3760     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3761
3762     const int sign = (insn & 0x00800000) ? 1 : -1;
3763     int32_t addend = (insn & 0xfff) * sign;
3764     int32_t x = (psymval->value(object, addend) - address);
3765     // Calculate the relevant G(n-1) value to obtain this stage residual.
3766     Valtype residual =
3767         Arm_relocate_functions::calc_grp_residual(abs(x), group - 1);
3768     if (residual >= 0x1000)
3769       return This::STATUS_OVERFLOW;
3770
3771     // Mask out the value and U bit.
3772     insn &= 0xff7ff000;
3773     // Set the U bit for non-negative values.
3774     if (x >= 0)
3775       insn |= 0x00800000;
3776     insn |= residual;
3777
3778     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3779     return This::STATUS_OKAY;
3780   }
3781
3782   // R_ARM_LDRS_PC_G0: S + A - P
3783   // R_ARM_LDRS_PC_G1: S + A - P
3784   // R_ARM_LDRS_PC_G2: S + A - P
3785   // R_ARM_LDRS_SB_G0: S + A - B(S)
3786   // R_ARM_LDRS_SB_G1: S + A - B(S)
3787   // R_ARM_LDRS_SB_G2: S + A - B(S)
3788   static inline typename This::Status
3789   arm_grp_ldrs(unsigned char* view,
3790         const Sized_relobj_file<32, big_endian>* object,
3791         const Symbol_value<32>* psymval,
3792         const int group,
3793         Arm_address address)
3794   {
3795     gold_assert(group >= 0 && group < 3);
3796     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3797     Valtype* wv = reinterpret_cast<Valtype*>(view);
3798     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3799
3800     const int sign = (insn & 0x00800000) ? 1 : -1;
3801     int32_t addend = (((insn & 0xf00) >> 4) + (insn & 0xf)) * sign;
3802     int32_t x = (psymval->value(object, addend) - address);
3803     // Calculate the relevant G(n-1) value to obtain this stage residual.
3804     Valtype residual =
3805         Arm_relocate_functions::calc_grp_residual(abs(x), group - 1);
3806    if (residual >= 0x100)
3807       return This::STATUS_OVERFLOW;
3808
3809     // Mask out the value and U bit.
3810     insn &= 0xff7ff0f0;
3811     // Set the U bit for non-negative values.
3812     if (x >= 0)
3813       insn |= 0x00800000;
3814     insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
3815
3816     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3817     return This::STATUS_OKAY;
3818   }
3819
3820   // R_ARM_LDC_PC_G0: S + A - P
3821   // R_ARM_LDC_PC_G1: S + A - P
3822   // R_ARM_LDC_PC_G2: S + A - P
3823   // R_ARM_LDC_SB_G0: S + A - B(S)
3824   // R_ARM_LDC_SB_G1: S + A - B(S)
3825   // R_ARM_LDC_SB_G2: S + A - B(S)
3826   static inline typename This::Status
3827   arm_grp_ldc(unsigned char* view,
3828       const Sized_relobj_file<32, big_endian>* object,
3829       const Symbol_value<32>* psymval,
3830       const int group,
3831       Arm_address address)
3832   {
3833     gold_assert(group >= 0 && group < 3);
3834     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3835     Valtype* wv = reinterpret_cast<Valtype*>(view);
3836     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3837
3838     const int sign = (insn & 0x00800000) ? 1 : -1;
3839     int32_t addend = ((insn & 0xff) << 2) * sign;
3840     int32_t x = (psymval->value(object, addend) - address);
3841     // Calculate the relevant G(n-1) value to obtain this stage residual.
3842     Valtype residual =
3843       Arm_relocate_functions::calc_grp_residual(abs(x), group - 1);
3844     if ((residual & 0x3) != 0 || residual >= 0x400)
3845       return This::STATUS_OVERFLOW;
3846
3847     // Mask out the value and U bit.
3848     insn &= 0xff7fff00;
3849     // Set the U bit for non-negative values.
3850     if (x >= 0)
3851       insn |= 0x00800000;
3852     insn |= (residual >> 2);
3853
3854     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3855     return This::STATUS_OKAY;
3856   }
3857 };
3858
3859 // Relocate ARM long branches.  This handles relocation types
3860 // R_ARM_CALL, R_ARM_JUMP24, R_ARM_PLT32 and R_ARM_XPC25.
3861 // If IS_WEAK_UNDEFINED_WITH_PLT is true.  The target symbol is weakly
3862 // undefined and we do not use PLT in this relocation.  In such a case,
3863 // the branch is converted into an NOP.
3864
3865 template<bool big_endian>
3866 typename Arm_relocate_functions<big_endian>::Status
3867 Arm_relocate_functions<big_endian>::arm_branch_common(
3868     unsigned int r_type,
3869     const Relocate_info<32, big_endian>* relinfo,
3870     unsigned char* view,
3871     const Sized_symbol<32>* gsym,
3872     const Arm_relobj<big_endian>* object,
3873     unsigned int r_sym,
3874     const Symbol_value<32>* psymval,
3875     Arm_address address,
3876     Arm_address thumb_bit,
3877     bool is_weakly_undefined_without_plt)
3878 {
3879   typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3880   Valtype* wv = reinterpret_cast<Valtype*>(view);
3881   Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3882
3883   bool insn_is_b = (((val >> 28) & 0xf) <= 0xe)
3884                     && ((val & 0x0f000000UL) == 0x0a000000UL);
3885   bool insn_is_uncond_bl = (val & 0xff000000UL) == 0xeb000000UL;
3886   bool insn_is_cond_bl = (((val >> 28) & 0xf) < 0xe)
3887                           && ((val & 0x0f000000UL) == 0x0b000000UL);
3888   bool insn_is_blx = (val & 0xfe000000UL) == 0xfa000000UL;
3889   bool insn_is_any_branch = (val & 0x0e000000UL) == 0x0a000000UL;
3890
3891   // Check that the instruction is valid.
3892   if (r_type == elfcpp::R_ARM_CALL)
3893     {
3894       if (!insn_is_uncond_bl && !insn_is_blx)
3895         return This::STATUS_BAD_RELOC;
3896     }
3897   else if (r_type == elfcpp::R_ARM_JUMP24)
3898     {
3899       if (!insn_is_b && !insn_is_cond_bl)
3900         return This::STATUS_BAD_RELOC;
3901     }
3902   else if (r_type == elfcpp::R_ARM_PLT32)
3903     {
3904       if (!insn_is_any_branch)
3905         return This::STATUS_BAD_RELOC;
3906     }
3907   else if (r_type == elfcpp::R_ARM_XPC25)
3908     {
3909       // FIXME: AAELF document IH0044C does not say much about it other
3910       // than it being obsolete.
3911       if (!insn_is_any_branch)
3912         return This::STATUS_BAD_RELOC;
3913     }
3914   else
3915     gold_unreachable();
3916
3917   // A branch to an undefined weak symbol is turned into a jump to
3918   // the next instruction unless a PLT entry will be created.
3919   // Do the same for local undefined symbols.
3920   // The jump to the next instruction is optimized as a NOP depending
3921   // on the architecture.
3922   const Target_arm<big_endian>* arm_target =
3923     Target_arm<big_endian>::default_target();
3924   if (is_weakly_undefined_without_plt)
3925     {
3926       gold_assert(!parameters->options().relocatable());
3927       Valtype cond = val & 0xf0000000U;
3928       if (arm_target->may_use_arm_nop())
3929         val = cond | 0x0320f000;
3930       else
3931         val = cond | 0x01a00000;        // Using pre-UAL nop: mov r0, r0.
3932       elfcpp::Swap<32, big_endian>::writeval(wv, val);
3933       return This::STATUS_OKAY;
3934     }
3935
3936   Valtype addend = Bits<26>::sign_extend32(val << 2);
3937   Valtype branch_target = psymval->value(object, addend);
3938   int32_t branch_offset = branch_target - address;
3939
3940   // We need a stub if the branch offset is too large or if we need
3941   // to switch mode.
3942   bool may_use_blx = arm_target->may_use_v5t_interworking();
3943   Reloc_stub* stub = NULL;
3944
3945   if (!parameters->options().relocatable()
3946       && (Bits<26>::has_overflow32(branch_offset)
3947           || ((thumb_bit != 0)
3948               && !(may_use_blx && r_type == elfcpp::R_ARM_CALL))))
3949     {
3950       Valtype unadjusted_branch_target = psymval->value(object, 0);
3951
3952       Stub_type stub_type =
3953         Reloc_stub::stub_type_for_reloc(r_type, address,
3954                                         unadjusted_branch_target,
3955                                         (thumb_bit != 0));
3956       if (stub_type != arm_stub_none)
3957         {
3958           Stub_table<big_endian>* stub_table =
3959             object->stub_table(relinfo->data_shndx);
3960           gold_assert(stub_table != NULL);
3961
3962           Reloc_stub::Key stub_key(stub_type, gsym, object, r_sym, addend);
3963           stub = stub_table->find_reloc_stub(stub_key);
3964           gold_assert(stub != NULL);
3965           thumb_bit = stub->stub_template()->entry_in_thumb_mode() ? 1 : 0;
3966           branch_target = stub_table->address() + stub->offset() + addend;
3967           branch_offset = branch_target - address;
3968           gold_assert(!Bits<26>::has_overflow32(branch_offset));
3969         }
3970     }
3971
3972   // At this point, if we still need to switch mode, the instruction
3973   // must either be a BLX or a BL that can be converted to a BLX.
3974   if (thumb_bit != 0)
3975     {
3976       // Turn BL to BLX.
3977       gold_assert(may_use_blx && r_type == elfcpp::R_ARM_CALL);
3978       val = (val & 0xffffff) | 0xfa000000 | ((branch_offset & 2) << 23);
3979     }
3980
3981   val = Bits<32>::bit_select32(val, (branch_offset >> 2), 0xffffffUL);
3982   elfcpp::Swap<32, big_endian>::writeval(wv, val);
3983   return (Bits<26>::has_overflow32(branch_offset)
3984           ? This::STATUS_OVERFLOW
3985           : This::STATUS_OKAY);
3986 }
3987
3988 // Relocate THUMB long branches.  This handles relocation types
3989 // R_ARM_THM_CALL, R_ARM_THM_JUMP24 and R_ARM_THM_XPC22.
3990 // If IS_WEAK_UNDEFINED_WITH_PLT is true.  The target symbol is weakly
3991 // undefined and we do not use PLT in this relocation.  In such a case,
3992 // the branch is converted into an NOP.
3993
3994 template<bool big_endian>
3995 typename Arm_relocate_functions<big_endian>::Status
3996 Arm_relocate_functions<big_endian>::thumb_branch_common(
3997     unsigned int r_type,
3998     const Relocate_info<32, big_endian>* relinfo,
3999     unsigned char* view,
4000     const Sized_symbol<32>* gsym,
4001     const Arm_relobj<big_endian>* object,
4002     unsigned int r_sym,
4003     const Symbol_value<32>* psymval,
4004     Arm_address address,
4005     Arm_address thumb_bit,
4006     bool is_weakly_undefined_without_plt)
4007 {
4008   typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
4009   Valtype* wv = reinterpret_cast<Valtype*>(view);
4010   uint32_t upper_insn = elfcpp::Swap<16, big_endian>::readval(wv);
4011   uint32_t lower_insn = elfcpp::Swap<16, big_endian>::readval(wv + 1);
4012
4013   // FIXME: These tests are too loose and do not take THUMB/THUMB-2 difference
4014   // into account.
4015   bool is_bl_insn = (lower_insn & 0x1000U) == 0x1000U;
4016   bool is_blx_insn = (lower_insn & 0x1000U) == 0x0000U;
4017
4018   // Check that the instruction is valid.
4019   if (r_type == elfcpp::R_ARM_THM_CALL)
4020     {
4021       if (!is_bl_insn && !is_blx_insn)
4022         return This::STATUS_BAD_RELOC;
4023     }
4024   else if (r_type == elfcpp::R_ARM_THM_JUMP24)
4025     {
4026       // This cannot be a BLX.
4027       if (!is_bl_insn)
4028         return This::STATUS_BAD_RELOC;
4029     }
4030   else if (r_type == elfcpp::R_ARM_THM_XPC22)
4031     {
4032       // Check for Thumb to Thumb call.
4033       if (!is_blx_insn)
4034         return This::STATUS_BAD_RELOC;
4035       if (thumb_bit != 0)
4036         {
4037           gold_warning(_("%s: Thumb BLX instruction targets "
4038                          "thumb function '%s'."),
4039                          object->name().c_str(),
4040                          (gsym ? gsym->name() : "(local)"));
4041           // Convert BLX to BL.
4042           lower_insn |= 0x1000U;
4043         }
4044     }
4045   else
4046     gold_unreachable();
4047
4048   // A branch to an undefined weak symbol is turned into a jump to
4049   // the next instruction unless a PLT entry will be created.
4050   // The jump to the next instruction is optimized as a NOP.W for
4051   // Thumb-2 enabled architectures.
4052   const Target_arm<big_endian>* arm_target =
4053     Target_arm<big_endian>::default_target();
4054   if (is_weakly_undefined_without_plt)
4055     {
4056       gold_assert(!parameters->options().relocatable());
4057       if (arm_target->may_use_thumb2_nop())
4058         {
4059           elfcpp::Swap<16, big_endian>::writeval(wv, 0xf3af);
4060           elfcpp::Swap<16, big_endian>::writeval(wv + 1, 0x8000);
4061         }
4062       else
4063         {
4064           elfcpp::Swap<16, big_endian>::writeval(wv, 0xe000);
4065           elfcpp::Swap<16, big_endian>::writeval(wv + 1, 0xbf00);
4066         }
4067       return This::STATUS_OKAY;
4068     }
4069
4070   int32_t addend = This::thumb32_branch_offset(upper_insn, lower_insn);
4071   Arm_address branch_target = psymval->value(object, addend);
4072
4073   // For BLX, bit 1 of target address comes from bit 1 of base address.
4074   bool may_use_blx = arm_target->may_use_v5t_interworking();
4075   if (thumb_bit == 0 && may_use_blx)
4076     branch_target = Bits<32>::bit_select32(branch_target, address, 0x2);
4077
4078   int32_t branch_offset = branch_target - address;
4079
4080   // We need a stub if the branch offset is too large or if we need
4081   // to switch mode.
4082   bool thumb2 = arm_target->using_thumb2();
4083   if (!parameters->options().relocatable()
4084       && ((!thumb2 && Bits<23>::has_overflow32(branch_offset))
4085           || (thumb2 && Bits<25>::has_overflow32(branch_offset))
4086           || ((thumb_bit == 0)
4087               && (((r_type == elfcpp::R_ARM_THM_CALL) && !may_use_blx)
4088                   || r_type == elfcpp::R_ARM_THM_JUMP24))))
4089     {
4090       Arm_address unadjusted_branch_target = psymval->value(object, 0);
4091
4092       Stub_type stub_type =
4093         Reloc_stub::stub_type_for_reloc(r_type, address,
4094                                         unadjusted_branch_target,
4095                                         (thumb_bit != 0));
4096
4097       if (stub_type != arm_stub_none)
4098         {
4099           Stub_table<big_endian>* stub_table =
4100             object->stub_table(relinfo->data_shndx);
4101           gold_assert(stub_table != NULL);
4102
4103           Reloc_stub::Key stub_key(stub_type, gsym, object, r_sym, addend);
4104           Reloc_stub* stub = stub_table->find_reloc_stub(stub_key);
4105           gold_assert(stub != NULL);
4106           thumb_bit = stub->stub_template()->entry_in_thumb_mode() ? 1 : 0;
4107           branch_target = stub_table->address() + stub->offset() + addend;
4108           if (thumb_bit == 0 && may_use_blx)
4109             branch_target = Bits<32>::bit_select32(branch_target, address, 0x2);
4110           branch_offset = branch_target - address;
4111         }
4112     }
4113
4114   // At this point, if we still need to switch mode, the instruction
4115   // must either be a BLX or a BL that can be converted to a BLX.
4116   if (thumb_bit == 0)
4117     {
4118       gold_assert(may_use_blx
4119                   && (r_type == elfcpp::R_ARM_THM_CALL
4120                       || r_type == elfcpp::R_ARM_THM_XPC22));
4121       // Make sure this is a BLX.
4122       lower_insn &= ~0x1000U;
4123     }
4124   else
4125     {
4126       // Make sure this is a BL.
4127       lower_insn |= 0x1000U;
4128     }
4129
4130   // For a BLX instruction, make sure that the relocation is rounded up
4131   // to a word boundary.  This follows the semantics of the instruction
4132   // which specifies that bit 1 of the target address will come from bit
4133   // 1 of the base address.
4134   if ((lower_insn & 0x5000U) == 0x4000U)
4135     gold_assert((branch_offset & 3) == 0);
4136
4137   // Put BRANCH_OFFSET back into the insn.  Assumes two's complement.
4138   // We use the Thumb-2 encoding, which is safe even if dealing with
4139   // a Thumb-1 instruction by virtue of our overflow check above.  */
4140   upper_insn = This::thumb32_branch_upper(upper_insn, branch_offset);
4141   lower_insn = This::thumb32_branch_lower(lower_insn, branch_offset);
4142
4143   elfcpp::Swap<16, big_endian>::writeval(wv, upper_insn);
4144   elfcpp::Swap<16, big_endian>::writeval(wv + 1, lower_insn);
4145
4146   gold_assert(!Bits<25>::has_overflow32(branch_offset));
4147
4148   return ((thumb2
4149            ? Bits<25>::has_overflow32(branch_offset)
4150            : Bits<23>::has_overflow32(branch_offset))
4151           ? This::STATUS_OVERFLOW
4152           : This::STATUS_OKAY);
4153 }
4154
4155 // Relocate THUMB-2 long conditional branches.
4156 // If IS_WEAK_UNDEFINED_WITH_PLT is true.  The target symbol is weakly
4157 // undefined and we do not use PLT in this relocation.  In such a case,
4158 // the branch is converted into an NOP.
4159
4160 template<bool big_endian>
4161 typename Arm_relocate_functions<big_endian>::Status
4162 Arm_relocate_functions<big_endian>::thm_jump19(
4163     unsigned char* view,
4164     const Arm_relobj<big_endian>* object,
4165     const Symbol_value<32>* psymval,
4166     Arm_address address,
4167     Arm_address thumb_bit)
4168 {
4169   typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
4170   Valtype* wv = reinterpret_cast<Valtype*>(view);
4171   uint32_t upper_insn = elfcpp::Swap<16, big_endian>::readval(wv);
4172   uint32_t lower_insn = elfcpp::Swap<16, big_endian>::readval(wv + 1);
4173   int32_t addend = This::thumb32_cond_branch_offset(upper_insn, lower_insn);
4174
4175   Arm_address branch_target = psymval->value(object, addend);
4176   int32_t branch_offset = branch_target - address;
4177
4178   // ??? Should handle interworking?  GCC might someday try to
4179   // use this for tail calls.
4180   // FIXME: We do support thumb entry to PLT yet.
4181   if (thumb_bit == 0)
4182     {
4183       gold_error(_("conditional branch to PLT in THUMB-2 not supported yet."));
4184       return This::STATUS_BAD_RELOC;
4185     }
4186
4187   // Put RELOCATION back into the insn.
4188   upper_insn = This::thumb32_cond_branch_upper(upper_insn, branch_offset);
4189   lower_insn = This::thumb32_cond_branch_lower(lower_insn, branch_offset);
4190
4191   // Put the relocated value back in the object file:
4192   elfcpp::Swap<16, big_endian>::writeval(wv, upper_insn);