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