Merge branch 'vendor/GCC44'
[dragonfly.git] / contrib / binutils-2.21 / gold / arm.cc
1 // arm.cc -- arm target support for gold.
2
3 // Copyright 2009, 2010 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 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 invalid index.  This points to a global symbol.
602     // Otherwise, this points a relobj.  We used the unsized and target
603     // independent Symbol and Relobj classes instead of Sized_symbol<32> and  
604     // Arm_relobj.  This is done 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 with using KEY.  Caller is reponsible for avoid adding
899   // if already a STUB with the same key has 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   // Caller is reponsible for avoid adding if already a STUB with the same
919   // address has 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   // Return the original EXIDX input section.
1108   const Arm_exidx_input_section&
1109   exidx_input_section() const
1110   { return this->exidx_input_section_; }
1111
1112   // Return the section offset map.
1113   const Arm_exidx_section_offset_map&
1114   section_offset_map() const
1115   { return this->section_offset_map_; }
1116
1117  protected:
1118   // Write merged section into file OF.
1119   void
1120   do_write(Output_file* of);
1121
1122   bool
1123   do_output_offset(const Relobj*, unsigned int, section_offset_type,
1124                   section_offset_type*) const;
1125
1126  private:
1127   // Original EXIDX input section.
1128   const Arm_exidx_input_section& exidx_input_section_;
1129   // Section offset map.
1130   const Arm_exidx_section_offset_map& section_offset_map_;
1131 };
1132
1133 // A class to wrap an ordinary input section containing executable code.
1134
1135 template<bool big_endian>
1136 class Arm_input_section : public Output_relaxed_input_section
1137 {
1138  public:
1139   Arm_input_section(Relobj* relobj, unsigned int shndx)
1140     : Output_relaxed_input_section(relobj, shndx, 1),
1141       original_addralign_(1), original_size_(0), stub_table_(NULL)
1142   { }
1143
1144   ~Arm_input_section()
1145   { }
1146
1147   // Initialize.
1148   void
1149   init();
1150   
1151   // Whether this is a stub table owner.
1152   bool
1153   is_stub_table_owner() const
1154   { return this->stub_table_ != NULL && this->stub_table_->owner() == this; }
1155
1156   // Return the stub table.
1157   Stub_table<big_endian>*
1158   stub_table() const
1159   { return this->stub_table_; }
1160
1161   // Set the stub_table.
1162   void
1163   set_stub_table(Stub_table<big_endian>* stub_table)
1164   { this->stub_table_ = stub_table; }
1165
1166   // Downcast a base pointer to an Arm_input_section pointer.  This is
1167   // not type-safe but we only use Arm_input_section not the base class.
1168   static Arm_input_section<big_endian>*
1169   as_arm_input_section(Output_relaxed_input_section* poris)
1170   { return static_cast<Arm_input_section<big_endian>*>(poris); }
1171
1172   // Return the original size of the section.
1173   uint32_t
1174   original_size() const
1175   { return this->original_size_; }
1176
1177  protected:
1178   // Write data to output file.
1179   void
1180   do_write(Output_file*);
1181
1182   // Return required alignment of this.
1183   uint64_t
1184   do_addralign() const
1185   {
1186     if (this->is_stub_table_owner())
1187       return std::max(this->stub_table_->addralign(),
1188                       static_cast<uint64_t>(this->original_addralign_));
1189     else
1190       return this->original_addralign_;
1191   }
1192
1193   // Finalize data size.
1194   void
1195   set_final_data_size();
1196
1197   // Reset address and file offset.
1198   void
1199   do_reset_address_and_file_offset();
1200
1201   // Output offset.
1202   bool
1203   do_output_offset(const Relobj* object, unsigned int shndx,
1204                    section_offset_type offset,
1205                    section_offset_type* poutput) const
1206   {
1207     if ((object == this->relobj())
1208         && (shndx == this->shndx())
1209         && (offset >= 0)
1210         && (offset <=
1211             convert_types<section_offset_type, uint32_t>(this->original_size_)))
1212       {
1213         *poutput = offset;
1214         return true;
1215       }
1216     else
1217       return false;
1218   }
1219
1220  private:
1221   // Copying is not allowed.
1222   Arm_input_section(const Arm_input_section&);
1223   Arm_input_section& operator=(const Arm_input_section&);
1224
1225   // Address alignment of the original input section.
1226   uint32_t original_addralign_;
1227   // Section size of the original input section.
1228   uint32_t original_size_;
1229   // Stub table.
1230   Stub_table<big_endian>* stub_table_;
1231 };
1232
1233 // Arm_exidx_fixup class.  This is used to define a number of methods
1234 // and keep states for fixing up EXIDX coverage.
1235
1236 class Arm_exidx_fixup
1237 {
1238  public:
1239   Arm_exidx_fixup(Output_section* exidx_output_section,
1240                   bool merge_exidx_entries = true)
1241     : exidx_output_section_(exidx_output_section), last_unwind_type_(UT_NONE),
1242       last_inlined_entry_(0), last_input_section_(NULL),
1243       section_offset_map_(NULL), first_output_text_section_(NULL),
1244       merge_exidx_entries_(merge_exidx_entries)
1245   { }
1246
1247   ~Arm_exidx_fixup()
1248   { delete this->section_offset_map_; }
1249
1250   // Process an EXIDX section for entry merging.  Return  number of bytes to
1251   // be deleted in output.  If parts of the input EXIDX section are merged
1252   // a heap allocated Arm_exidx_section_offset_map is store in the located
1253   // PSECTION_OFFSET_MAP.  The caller owns the map and is reponsible for
1254   // releasing it.
1255   template<bool big_endian>
1256   uint32_t
1257   process_exidx_section(const Arm_exidx_input_section* exidx_input_section,
1258                         Arm_exidx_section_offset_map** psection_offset_map);
1259   
1260   // Append an EXIDX_CANTUNWIND entry pointing at the end of the last
1261   // input section, if there is not one already.
1262   void
1263   add_exidx_cantunwind_as_needed();
1264
1265   // Return the output section for the text section which is linked to the
1266   // first exidx input in output.
1267   Output_section*
1268   first_output_text_section() const
1269   { return this->first_output_text_section_; }
1270
1271  private:
1272   // Copying is not allowed.
1273   Arm_exidx_fixup(const Arm_exidx_fixup&);
1274   Arm_exidx_fixup& operator=(const Arm_exidx_fixup&);
1275
1276   // Type of EXIDX unwind entry.
1277   enum Unwind_type
1278   {
1279     // No type.
1280     UT_NONE,
1281     // EXIDX_CANTUNWIND.
1282     UT_EXIDX_CANTUNWIND,
1283     // Inlined entry.
1284     UT_INLINED_ENTRY,
1285     // Normal entry.
1286     UT_NORMAL_ENTRY,
1287   };
1288
1289   // Process an EXIDX entry.  We only care about the second word of the
1290   // entry.  Return true if the entry can be deleted.
1291   bool
1292   process_exidx_entry(uint32_t second_word);
1293
1294   // Update the current section offset map during EXIDX section fix-up.
1295   // If there is no map, create one.  INPUT_OFFSET is the offset of a
1296   // reference point, DELETED_BYTES is the number of deleted by in the
1297   // section so far.  If DELETE_ENTRY is true, the reference point and
1298   // all offsets after the previous reference point are discarded.
1299   void
1300   update_offset_map(section_offset_type input_offset,
1301                     section_size_type deleted_bytes, bool delete_entry);
1302
1303   // EXIDX output section.
1304   Output_section* exidx_output_section_;
1305   // Unwind type of the last EXIDX entry processed.
1306   Unwind_type last_unwind_type_;
1307   // Last seen inlined EXIDX entry.
1308   uint32_t last_inlined_entry_;
1309   // Last processed EXIDX input section.
1310   const Arm_exidx_input_section* last_input_section_;
1311   // Section offset map created in process_exidx_section.
1312   Arm_exidx_section_offset_map* section_offset_map_;
1313   // Output section for the text section which is linked to the first exidx
1314   // input in output.
1315   Output_section* first_output_text_section_;
1316
1317   bool merge_exidx_entries_;
1318 };
1319
1320 // Arm output section class.  This is defined mainly to add a number of
1321 // stub generation methods.
1322
1323 template<bool big_endian>
1324 class Arm_output_section : public Output_section
1325 {
1326  public:
1327   typedef std::vector<std::pair<Relobj*, unsigned int> > Text_section_list;
1328
1329   Arm_output_section(const char* name, elfcpp::Elf_Word type,
1330                      elfcpp::Elf_Xword flags)
1331     : Output_section(name, type, flags)
1332   {
1333     if (type == elfcpp::SHT_ARM_EXIDX)
1334       this->set_always_keeps_input_sections();
1335   }
1336
1337   ~Arm_output_section()
1338   { }
1339   
1340   // Group input sections for stub generation.
1341   void
1342   group_sections(section_size_type, bool, Target_arm<big_endian>*);
1343
1344   // Downcast a base pointer to an Arm_output_section pointer.  This is
1345   // not type-safe but we only use Arm_output_section not the base class.
1346   static Arm_output_section<big_endian>*
1347   as_arm_output_section(Output_section* os)
1348   { return static_cast<Arm_output_section<big_endian>*>(os); }
1349
1350   // Append all input text sections in this into LIST.
1351   void
1352   append_text_sections_to_list(Text_section_list* list);
1353
1354   // Fix EXIDX coverage of this EXIDX output section.  SORTED_TEXT_SECTION
1355   // is a list of text input sections sorted in ascending order of their
1356   // output addresses.
1357   void
1358   fix_exidx_coverage(Layout* layout,
1359                      const Text_section_list& sorted_text_section,
1360                      Symbol_table* symtab,
1361                      bool merge_exidx_entries);
1362
1363   // Link an EXIDX section into its corresponding text section.
1364   void
1365   set_exidx_section_link();
1366
1367  private:
1368   // For convenience.
1369   typedef Output_section::Input_section Input_section;
1370   typedef Output_section::Input_section_list Input_section_list;
1371
1372   // Create a stub group.
1373   void create_stub_group(Input_section_list::const_iterator,
1374                          Input_section_list::const_iterator,
1375                          Input_section_list::const_iterator,
1376                          Target_arm<big_endian>*,
1377                          std::vector<Output_relaxed_input_section*>*);
1378 };
1379
1380 // Arm_exidx_input_section class.  This represents an EXIDX input section.
1381
1382 class Arm_exidx_input_section
1383 {
1384  public:
1385   static const section_offset_type invalid_offset =
1386     static_cast<section_offset_type>(-1);
1387
1388   Arm_exidx_input_section(Relobj* relobj, unsigned int shndx,
1389                           unsigned int link, uint32_t size, uint32_t addralign)
1390     : relobj_(relobj), shndx_(shndx), link_(link), size_(size),
1391       addralign_(addralign), has_errors_(false)
1392   { }
1393
1394   ~Arm_exidx_input_section()
1395   { }
1396         
1397   // Accessors:  This is a read-only class.
1398
1399   // Return the object containing this EXIDX input section.
1400   Relobj*
1401   relobj() const
1402   { return this->relobj_; }
1403
1404   // Return the section index of this EXIDX input section.
1405   unsigned int
1406   shndx() const
1407   { return this->shndx_; }
1408
1409   // Return the section index of linked text section in the same object.
1410   unsigned int
1411   link() const
1412   { return this->link_; }
1413
1414   // Return size of the EXIDX input section.
1415   uint32_t
1416   size() const
1417   { return this->size_; }
1418
1419   // Reutnr address alignment of EXIDX input section.
1420   uint32_t
1421   addralign() const
1422   { return this->addralign_; }
1423
1424   // Whether there are any errors in the EXIDX input section.
1425   bool
1426   has_errors() const
1427   { return this->has_errors_; }
1428
1429   // Set has-errors flag.
1430   void
1431   set_has_errors()
1432   { this->has_errors_ = true; }
1433
1434  private:
1435   // Object containing this.
1436   Relobj* relobj_;
1437   // Section index of this.
1438   unsigned int shndx_;
1439   // text section linked to this in the same object.
1440   unsigned int link_;
1441   // Size of this.  For ARM 32-bit is sufficient.
1442   uint32_t size_;
1443   // Address alignment of this.  For ARM 32-bit is sufficient.
1444   uint32_t addralign_;
1445   // Whether this has any errors.
1446   bool has_errors_;
1447 };
1448
1449 // Arm_relobj class.
1450
1451 template<bool big_endian>
1452 class Arm_relobj : public Sized_relobj<32, big_endian>
1453 {
1454  public:
1455   static const Arm_address invalid_address = static_cast<Arm_address>(-1);
1456
1457   Arm_relobj(const std::string& name, Input_file* input_file, off_t offset,
1458              const typename elfcpp::Ehdr<32, big_endian>& ehdr)
1459     : Sized_relobj<32, big_endian>(name, input_file, offset, ehdr),
1460       stub_tables_(), local_symbol_is_thumb_function_(),
1461       attributes_section_data_(NULL), mapping_symbols_info_(),
1462       section_has_cortex_a8_workaround_(NULL), exidx_section_map_(),
1463       output_local_symbol_count_needs_update_(false),
1464       merge_flags_and_attributes_(true)
1465   { }
1466
1467   ~Arm_relobj()
1468   { delete this->attributes_section_data_; }
1469  
1470   // Return the stub table of the SHNDX-th section if there is one.
1471   Stub_table<big_endian>*
1472   stub_table(unsigned int shndx) const
1473   {
1474     gold_assert(shndx < this->stub_tables_.size());
1475     return this->stub_tables_[shndx];
1476   }
1477
1478   // Set STUB_TABLE to be the stub_table of the SHNDX-th section.
1479   void
1480   set_stub_table(unsigned int shndx, Stub_table<big_endian>* stub_table)
1481   {
1482     gold_assert(shndx < this->stub_tables_.size());
1483     this->stub_tables_[shndx] = stub_table;
1484   }
1485
1486   // Whether a local symbol is a THUMB function.  R_SYM is the symbol table
1487   // index.  This is only valid after do_count_local_symbol is called.
1488   bool
1489   local_symbol_is_thumb_function(unsigned int r_sym) const
1490   {
1491     gold_assert(r_sym < this->local_symbol_is_thumb_function_.size());
1492     return this->local_symbol_is_thumb_function_[r_sym];
1493   }
1494   
1495   // Scan all relocation sections for stub generation.
1496   void
1497   scan_sections_for_stubs(Target_arm<big_endian>*, const Symbol_table*,
1498                           const Layout*);
1499
1500   // Convert regular input section with index SHNDX to a relaxed section.
1501   void
1502   convert_input_section_to_relaxed_section(unsigned shndx)
1503   {
1504     // The stubs have relocations and we need to process them after writing
1505     // out the stubs.  So relocation now must follow section write.
1506     this->set_section_offset(shndx, -1ULL);
1507     this->set_relocs_must_follow_section_writes();
1508   }
1509
1510   // Downcast a base pointer to an Arm_relobj pointer.  This is
1511   // not type-safe but we only use Arm_relobj not the base class.
1512   static Arm_relobj<big_endian>*
1513   as_arm_relobj(Relobj* relobj)
1514   { return static_cast<Arm_relobj<big_endian>*>(relobj); }
1515
1516   // Processor-specific flags in ELF file header.  This is valid only after
1517   // reading symbols.
1518   elfcpp::Elf_Word
1519   processor_specific_flags() const
1520   { return this->processor_specific_flags_; }
1521
1522   // Attribute section data  This is the contents of the .ARM.attribute section
1523   // if there is one.
1524   const Attributes_section_data*
1525   attributes_section_data() const
1526   { return this->attributes_section_data_; }
1527
1528   // Mapping symbol location.
1529   typedef std::pair<unsigned int, Arm_address> Mapping_symbol_position;
1530
1531   // Functor for STL container.
1532   struct Mapping_symbol_position_less
1533   {
1534     bool
1535     operator()(const Mapping_symbol_position& p1,
1536                const Mapping_symbol_position& p2) const
1537     {
1538       return (p1.first < p2.first
1539               || (p1.first == p2.first && p1.second < p2.second));
1540     }
1541   };
1542   
1543   // We only care about the first character of a mapping symbol, so
1544   // we only store that instead of the whole symbol name.
1545   typedef std::map<Mapping_symbol_position, char,
1546                    Mapping_symbol_position_less> Mapping_symbols_info;
1547
1548   // Whether a section contains any Cortex-A8 workaround.
1549   bool
1550   section_has_cortex_a8_workaround(unsigned int shndx) const
1551   { 
1552     return (this->section_has_cortex_a8_workaround_ != NULL
1553             && (*this->section_has_cortex_a8_workaround_)[shndx]);
1554   }
1555   
1556   // Mark a section that has Cortex-A8 workaround.
1557   void
1558   mark_section_for_cortex_a8_workaround(unsigned int shndx)
1559   {
1560     if (this->section_has_cortex_a8_workaround_ == NULL)
1561       this->section_has_cortex_a8_workaround_ =
1562         new std::vector<bool>(this->shnum(), false);
1563     (*this->section_has_cortex_a8_workaround_)[shndx] = true;
1564   }
1565
1566   // Return the EXIDX section of an text section with index SHNDX or NULL
1567   // if the text section has no associated EXIDX section.
1568   const Arm_exidx_input_section*
1569   exidx_input_section_by_link(unsigned int shndx) const
1570   {
1571     Exidx_section_map::const_iterator p = this->exidx_section_map_.find(shndx);
1572     return ((p != this->exidx_section_map_.end()
1573              && p->second->link() == shndx)
1574             ? p->second
1575             : NULL);
1576   }
1577
1578   // Return the EXIDX section with index SHNDX or NULL if there is none.
1579   const Arm_exidx_input_section*
1580   exidx_input_section_by_shndx(unsigned shndx) const
1581   {
1582     Exidx_section_map::const_iterator p = this->exidx_section_map_.find(shndx);
1583     return ((p != this->exidx_section_map_.end()
1584              && p->second->shndx() == shndx)
1585             ? p->second
1586             : NULL);
1587   }
1588
1589   // Whether output local symbol count needs updating.
1590   bool
1591   output_local_symbol_count_needs_update() const
1592   { return this->output_local_symbol_count_needs_update_; }
1593
1594   // Set output_local_symbol_count_needs_update flag to be true.
1595   void
1596   set_output_local_symbol_count_needs_update()
1597   { this->output_local_symbol_count_needs_update_ = true; }
1598   
1599   // Update output local symbol count at the end of relaxation.
1600   void
1601   update_output_local_symbol_count();
1602
1603   // Whether we want to merge processor-specific flags and attributes.
1604   bool
1605   merge_flags_and_attributes() const
1606   { return this->merge_flags_and_attributes_; }
1607   
1608   // Export list of EXIDX section indices.
1609   void
1610   get_exidx_shndx_list(std::vector<unsigned int>* list) const
1611   {
1612     list->clear();
1613     for (Exidx_section_map::const_iterator p = this->exidx_section_map_.begin();
1614          p != this->exidx_section_map_.end();
1615          ++p)
1616       {
1617         if (p->second->shndx() == p->first)
1618           list->push_back(p->first);
1619       }
1620     // Sort list to make result independent of implementation of map. 
1621     std::sort(list->begin(), list->end());
1622   }
1623
1624  protected:
1625   // Post constructor setup.
1626   void
1627   do_setup()
1628   {
1629     // Call parent's setup method.
1630     Sized_relobj<32, big_endian>::do_setup();
1631
1632     // Initialize look-up tables.
1633     Stub_table_list empty_stub_table_list(this->shnum(), NULL);
1634     this->stub_tables_.swap(empty_stub_table_list);
1635   }
1636
1637   // Count the local symbols.
1638   void
1639   do_count_local_symbols(Stringpool_template<char>*,
1640                          Stringpool_template<char>*);
1641
1642   void
1643   do_relocate_sections(const Symbol_table* symtab, const Layout* layout,
1644                        const unsigned char* pshdrs, Output_file* of,
1645                        typename Sized_relobj<32, big_endian>::Views* pivews);
1646
1647   // Read the symbol information.
1648   void
1649   do_read_symbols(Read_symbols_data* sd);
1650
1651   // Process relocs for garbage collection.
1652   void
1653   do_gc_process_relocs(Symbol_table*, Layout*, Read_relocs_data*);
1654
1655  private:
1656
1657   // Whether a section needs to be scanned for relocation stubs.
1658   bool
1659   section_needs_reloc_stub_scanning(const elfcpp::Shdr<32, big_endian>&,
1660                                     const Relobj::Output_sections&,
1661                                     const Symbol_table*, const unsigned char*);
1662
1663   // Whether a section is a scannable text section.
1664   bool
1665   section_is_scannable(const elfcpp::Shdr<32, big_endian>&, unsigned int,
1666                        const Output_section*, const Symbol_table*);
1667
1668   // Whether a section needs to be scanned for the Cortex-A8 erratum.
1669   bool
1670   section_needs_cortex_a8_stub_scanning(const elfcpp::Shdr<32, big_endian>&,
1671                                         unsigned int, Output_section*,
1672                                         const Symbol_table*);
1673
1674   // Scan a section for the Cortex-A8 erratum.
1675   void
1676   scan_section_for_cortex_a8_erratum(const elfcpp::Shdr<32, big_endian>&,
1677                                      unsigned int, Output_section*,
1678                                      Target_arm<big_endian>*);
1679
1680   // Find the linked text section of an EXIDX section by looking at the
1681   // first reloction of the EXIDX section.  PSHDR points to the section
1682   // headers of a relocation section and PSYMS points to the local symbols.
1683   // PSHNDX points to a location storing the text section index if found.
1684   // Return whether we can find the linked section.
1685   bool
1686   find_linked_text_section(const unsigned char* pshdr,
1687                            const unsigned char* psyms, unsigned int* pshndx);
1688
1689   //
1690   // Make a new Arm_exidx_input_section object for EXIDX section with
1691   // index SHNDX and section header SHDR.  TEXT_SHNDX is the section
1692   // index of the linked text section.
1693   void
1694   make_exidx_input_section(unsigned int shndx,
1695                            const elfcpp::Shdr<32, big_endian>& shdr,
1696                            unsigned int text_shndx,
1697                            const elfcpp::Shdr<32, big_endian>& text_shdr);
1698
1699   // Return the output address of either a plain input section or a
1700   // relaxed input section.  SHNDX is the section index.
1701   Arm_address
1702   simple_input_section_output_address(unsigned int, Output_section*);
1703
1704   typedef std::vector<Stub_table<big_endian>*> Stub_table_list;
1705   typedef Unordered_map<unsigned int, const Arm_exidx_input_section*>
1706     Exidx_section_map;
1707
1708   // List of stub tables.
1709   Stub_table_list stub_tables_;
1710   // Bit vector to tell if a local symbol is a thumb function or not.
1711   // This is only valid after do_count_local_symbol is called.
1712   std::vector<bool> local_symbol_is_thumb_function_;
1713   // processor-specific flags in ELF file header.
1714   elfcpp::Elf_Word processor_specific_flags_;
1715   // Object attributes if there is an .ARM.attributes section or NULL.
1716   Attributes_section_data* attributes_section_data_;
1717   // Mapping symbols information.
1718   Mapping_symbols_info mapping_symbols_info_;
1719   // Bitmap to indicate sections with Cortex-A8 workaround or NULL.
1720   std::vector<bool>* section_has_cortex_a8_workaround_;
1721   // Map a text section to its associated .ARM.exidx section, if there is one.
1722   Exidx_section_map exidx_section_map_;
1723   // Whether output local symbol count needs updating.
1724   bool output_local_symbol_count_needs_update_;
1725   // Whether we merge processor flags and attributes of this object to
1726   // output.
1727   bool merge_flags_and_attributes_;
1728 };
1729
1730 // Arm_dynobj class.
1731
1732 template<bool big_endian>
1733 class Arm_dynobj : public Sized_dynobj<32, big_endian>
1734 {
1735  public:
1736   Arm_dynobj(const std::string& name, Input_file* input_file, off_t offset,
1737              const elfcpp::Ehdr<32, big_endian>& ehdr)
1738     : Sized_dynobj<32, big_endian>(name, input_file, offset, ehdr),
1739       processor_specific_flags_(0), attributes_section_data_(NULL)
1740   { }
1741  
1742   ~Arm_dynobj()
1743   { delete this->attributes_section_data_; }
1744
1745   // Downcast a base pointer to an Arm_relobj pointer.  This is
1746   // not type-safe but we only use Arm_relobj not the base class.
1747   static Arm_dynobj<big_endian>*
1748   as_arm_dynobj(Dynobj* dynobj)
1749   { return static_cast<Arm_dynobj<big_endian>*>(dynobj); }
1750
1751   // Processor-specific flags in ELF file header.  This is valid only after
1752   // reading symbols.
1753   elfcpp::Elf_Word
1754   processor_specific_flags() const
1755   { return this->processor_specific_flags_; }
1756
1757   // Attributes section data.
1758   const Attributes_section_data*
1759   attributes_section_data() const
1760   { return this->attributes_section_data_; }
1761
1762  protected:
1763   // Read the symbol information.
1764   void
1765   do_read_symbols(Read_symbols_data* sd);
1766
1767  private:
1768   // processor-specific flags in ELF file header.
1769   elfcpp::Elf_Word processor_specific_flags_;
1770   // Object attributes if there is an .ARM.attributes section or NULL.
1771   Attributes_section_data* attributes_section_data_;
1772 };
1773
1774 // Functor to read reloc addends during stub generation.
1775
1776 template<int sh_type, bool big_endian>
1777 struct Stub_addend_reader
1778 {
1779   // Return the addend for a relocation of a particular type.  Depending
1780   // on whether this is a REL or RELA relocation, read the addend from a
1781   // view or from a Reloc object.
1782   elfcpp::Elf_types<32>::Elf_Swxword
1783   operator()(
1784     unsigned int /* r_type */,
1785     const unsigned char* /* view */,
1786     const typename Reloc_types<sh_type,
1787                                32, big_endian>::Reloc& /* reloc */) const;
1788 };
1789
1790 // Specialized Stub_addend_reader for SHT_REL type relocation sections.
1791
1792 template<bool big_endian>
1793 struct Stub_addend_reader<elfcpp::SHT_REL, big_endian>
1794 {
1795   elfcpp::Elf_types<32>::Elf_Swxword
1796   operator()(
1797     unsigned int,
1798     const unsigned char*,
1799     const typename Reloc_types<elfcpp::SHT_REL, 32, big_endian>::Reloc&) const;
1800 };
1801
1802 // Specialized Stub_addend_reader for RELA type relocation sections.
1803 // We currently do not handle RELA type relocation sections but it is trivial
1804 // to implement the addend reader.  This is provided for completeness and to
1805 // make it easier to add support for RELA relocation sections in the future.
1806
1807 template<bool big_endian>
1808 struct Stub_addend_reader<elfcpp::SHT_RELA, big_endian>
1809 {
1810   elfcpp::Elf_types<32>::Elf_Swxword
1811   operator()(
1812     unsigned int,
1813     const unsigned char*,
1814     const typename Reloc_types<elfcpp::SHT_RELA, 32,
1815                                big_endian>::Reloc& reloc) const
1816   { return reloc.get_r_addend(); }
1817 };
1818
1819 // Cortex_a8_reloc class.  We keep record of relocation that may need
1820 // the Cortex-A8 erratum workaround.
1821
1822 class Cortex_a8_reloc
1823 {
1824  public:
1825   Cortex_a8_reloc(Reloc_stub* reloc_stub, unsigned r_type,
1826                   Arm_address destination)
1827     : reloc_stub_(reloc_stub), r_type_(r_type), destination_(destination)
1828   { }
1829
1830   ~Cortex_a8_reloc()
1831   { }
1832
1833   // Accessors:  This is a read-only class.
1834   
1835   // Return the relocation stub associated with this relocation if there is
1836   // one.
1837   const Reloc_stub*
1838   reloc_stub() const
1839   { return this->reloc_stub_; } 
1840   
1841   // Return the relocation type.
1842   unsigned int
1843   r_type() const
1844   { return this->r_type_; }
1845
1846   // Return the destination address of the relocation.  LSB stores the THUMB
1847   // bit.
1848   Arm_address
1849   destination() const
1850   { return this->destination_; }
1851
1852  private:
1853   // Associated relocation stub if there is one, or NULL.
1854   const Reloc_stub* reloc_stub_;
1855   // Relocation type.
1856   unsigned int r_type_;
1857   // Destination address of this relocation.  LSB is used to distinguish
1858   // ARM/THUMB mode.
1859   Arm_address destination_;
1860 };
1861
1862 // Arm_output_data_got class.  We derive this from Output_data_got to add
1863 // extra methods to handle TLS relocations in a static link.
1864
1865 template<bool big_endian>
1866 class Arm_output_data_got : public Output_data_got<32, big_endian>
1867 {
1868  public:
1869   Arm_output_data_got(Symbol_table* symtab, Layout* layout)
1870     : Output_data_got<32, big_endian>(), symbol_table_(symtab), layout_(layout)
1871   { }
1872
1873   // Add a static entry for the GOT entry at OFFSET.  GSYM is a global
1874   // symbol and R_TYPE is the code of a dynamic relocation that needs to be
1875   // applied in a static link.
1876   void
1877   add_static_reloc(unsigned int got_offset, unsigned int r_type, Symbol* gsym)
1878   { this->static_relocs_.push_back(Static_reloc(got_offset, r_type, gsym)); }
1879
1880   // Add a static reloc for the GOT entry at OFFSET.  RELOBJ is an object
1881   // defining a local symbol with INDEX.  R_TYPE is the code of a dynamic
1882   // relocation that needs to be applied in a static link.
1883   void
1884   add_static_reloc(unsigned int got_offset, unsigned int r_type,
1885                    Sized_relobj<32, big_endian>* relobj, unsigned int index)
1886   {
1887     this->static_relocs_.push_back(Static_reloc(got_offset, r_type, relobj,
1888                                                 index));
1889   }
1890
1891   // Add a GOT pair for R_ARM_TLS_GD32.  The creates a pair of GOT entries.
1892   // The first one is initialized to be 1, which is the module index for
1893   // the main executable and the second one 0.  A reloc of the type
1894   // R_ARM_TLS_DTPOFF32 will be created for the second GOT entry and will
1895   // be applied by gold.  GSYM is a global symbol.
1896   void
1897   add_tls_gd32_with_static_reloc(unsigned int got_type, Symbol* gsym);
1898
1899   // Same as the above but for a local symbol in OBJECT with INDEX.
1900   void
1901   add_tls_gd32_with_static_reloc(unsigned int got_type,
1902                                  Sized_relobj<32, big_endian>* object,
1903                                  unsigned int index);
1904
1905  protected:
1906   // Write out the GOT table.
1907   void
1908   do_write(Output_file*);
1909
1910  private:
1911   // This class represent dynamic relocations that need to be applied by
1912   // gold because we are using TLS relocations in a static link.
1913   class Static_reloc
1914   {
1915    public:
1916     Static_reloc(unsigned int got_offset, unsigned int r_type, Symbol* gsym)
1917       : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(true)
1918     { this->u_.global.symbol = gsym; }
1919
1920     Static_reloc(unsigned int got_offset, unsigned int r_type,
1921           Sized_relobj<32, big_endian>* relobj, unsigned int index)
1922       : got_offset_(got_offset), r_type_(r_type), symbol_is_global_(false)
1923     {
1924       this->u_.local.relobj = relobj;
1925       this->u_.local.index = index;
1926     }
1927
1928     // Return the GOT offset.
1929     unsigned int
1930     got_offset() const
1931     { return this->got_offset_; }
1932
1933     // Relocation type.
1934     unsigned int
1935     r_type() const
1936     { return this->r_type_; }
1937
1938     // Whether the symbol is global or not.
1939     bool
1940     symbol_is_global() const
1941     { return this->symbol_is_global_; }
1942
1943     // For a relocation against a global symbol, the global symbol.
1944     Symbol*
1945     symbol() const
1946     {
1947       gold_assert(this->symbol_is_global_);
1948       return this->u_.global.symbol;
1949     }
1950
1951     // For a relocation against a local symbol, the defining object.
1952     Sized_relobj<32, big_endian>*
1953     relobj() const
1954     {
1955       gold_assert(!this->symbol_is_global_);
1956       return this->u_.local.relobj;
1957     }
1958
1959     // For a relocation against a local symbol, the local symbol index.
1960     unsigned int
1961     index() const
1962     {
1963       gold_assert(!this->symbol_is_global_);
1964       return this->u_.local.index;
1965     }
1966
1967    private:
1968     // GOT offset of the entry to which this relocation is applied.
1969     unsigned int got_offset_;
1970     // Type of relocation.
1971     unsigned int r_type_;
1972     // Whether this relocation is against a global symbol.
1973     bool symbol_is_global_;
1974     // A global or local symbol.
1975     union
1976     {
1977       struct
1978       {
1979         // For a global symbol, the symbol itself.
1980         Symbol* symbol;
1981       } global;
1982       struct
1983       {
1984         // For a local symbol, the object defining object.
1985         Sized_relobj<32, big_endian>* relobj;
1986         // For a local symbol, the symbol index.
1987         unsigned int index;
1988       } local;
1989     } u_;
1990   };
1991
1992   // Symbol table of the output object.
1993   Symbol_table* symbol_table_;
1994   // Layout of the output object.
1995   Layout* layout_;
1996   // Static relocs to be applied to the GOT.
1997   std::vector<Static_reloc> static_relocs_;
1998 };
1999
2000 // The ARM target has many relocation types with odd-sizes or incontigious
2001 // bits.  The default handling of relocatable relocation cannot process these
2002 // relocations.  So we have to extend the default code.
2003
2004 template<bool big_endian, int sh_type, typename Classify_reloc>
2005 class Arm_scan_relocatable_relocs :
2006   public Default_scan_relocatable_relocs<sh_type, Classify_reloc>
2007 {
2008  public:
2009   // Return the strategy to use for a local symbol which is a section
2010   // symbol, given the relocation type.
2011   inline Relocatable_relocs::Reloc_strategy
2012   local_section_strategy(unsigned int r_type, Relobj*)
2013   {
2014     if (sh_type == elfcpp::SHT_RELA)
2015       return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_RELA;
2016     else
2017       {
2018         if (r_type == elfcpp::R_ARM_TARGET1
2019             || r_type == elfcpp::R_ARM_TARGET2)
2020           {
2021             const Target_arm<big_endian>* arm_target =
2022               Target_arm<big_endian>::default_target();
2023             r_type = arm_target->get_real_reloc_type(r_type);
2024           }
2025
2026         switch(r_type)
2027           {
2028           // Relocations that write nothing.  These exclude R_ARM_TARGET1
2029           // and R_ARM_TARGET2.
2030           case elfcpp::R_ARM_NONE:
2031           case elfcpp::R_ARM_V4BX:
2032           case elfcpp::R_ARM_TLS_GOTDESC:
2033           case elfcpp::R_ARM_TLS_CALL:
2034           case elfcpp::R_ARM_TLS_DESCSEQ:
2035           case elfcpp::R_ARM_THM_TLS_CALL:
2036           case elfcpp::R_ARM_GOTRELAX:
2037           case elfcpp::R_ARM_GNU_VTENTRY:
2038           case elfcpp::R_ARM_GNU_VTINHERIT:
2039           case elfcpp::R_ARM_THM_TLS_DESCSEQ16:
2040           case elfcpp::R_ARM_THM_TLS_DESCSEQ32:
2041             return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_0;
2042           // These should have been converted to something else above.
2043           case elfcpp::R_ARM_TARGET1:
2044           case elfcpp::R_ARM_TARGET2:
2045             gold_unreachable();
2046           // Relocations that write full 32 bits.
2047           case elfcpp::R_ARM_ABS32:
2048           case elfcpp::R_ARM_REL32:
2049           case elfcpp::R_ARM_SBREL32:
2050           case elfcpp::R_ARM_GOTOFF32:
2051           case elfcpp::R_ARM_BASE_PREL:
2052           case elfcpp::R_ARM_GOT_BREL:
2053           case elfcpp::R_ARM_BASE_ABS:
2054           case elfcpp::R_ARM_ABS32_NOI:
2055           case elfcpp::R_ARM_REL32_NOI:
2056           case elfcpp::R_ARM_PLT32_ABS:
2057           case elfcpp::R_ARM_GOT_ABS:
2058           case elfcpp::R_ARM_GOT_PREL:
2059           case elfcpp::R_ARM_TLS_GD32:
2060           case elfcpp::R_ARM_TLS_LDM32:
2061           case elfcpp::R_ARM_TLS_LDO32:
2062           case elfcpp::R_ARM_TLS_IE32:
2063           case elfcpp::R_ARM_TLS_LE32:
2064             return Relocatable_relocs::RELOC_ADJUST_FOR_SECTION_4;
2065           default:
2066             // For all other static relocations, return RELOC_SPECIAL.
2067             return Relocatable_relocs::RELOC_SPECIAL;
2068           }
2069       }
2070   }
2071 };
2072
2073 // Utilities for manipulating integers of up to 32-bits
2074
2075 namespace utils
2076 {
2077   // Sign extend an n-bit unsigned integer stored in an uint32_t into
2078   // an int32_t.  NO_BITS must be between 1 to 32.
2079   template<int no_bits>
2080   static inline int32_t
2081   sign_extend(uint32_t bits)
2082   {
2083     gold_assert(no_bits >= 0 && no_bits <= 32);
2084     if (no_bits == 32)
2085       return static_cast<int32_t>(bits);
2086     uint32_t mask = (~((uint32_t) 0)) >> (32 - no_bits);
2087     bits &= mask;
2088     uint32_t top_bit = 1U << (no_bits - 1);
2089     int32_t as_signed = static_cast<int32_t>(bits);
2090     return (bits & top_bit) ? as_signed + (-top_bit * 2) : as_signed;
2091   }
2092
2093   // Detects overflow of an NO_BITS integer stored in a uint32_t.
2094   template<int no_bits>
2095   static inline bool
2096   has_overflow(uint32_t bits)
2097   {
2098     gold_assert(no_bits >= 0 && no_bits <= 32);
2099     if (no_bits == 32)
2100       return false;
2101     int32_t max = (1 << (no_bits - 1)) - 1;
2102     int32_t min = -(1 << (no_bits - 1));
2103     int32_t as_signed = static_cast<int32_t>(bits);
2104     return as_signed > max || as_signed < min;
2105   }
2106
2107   // Detects overflow of an NO_BITS integer stored in a uint32_t when it
2108   // fits in the given number of bits as either a signed or unsigned value.
2109   // For example, has_signed_unsigned_overflow<8> would check
2110   // -128 <= bits <= 255
2111   template<int no_bits>
2112   static inline bool
2113   has_signed_unsigned_overflow(uint32_t bits)
2114   {
2115     gold_assert(no_bits >= 2 && no_bits <= 32);
2116     if (no_bits == 32)
2117       return false;
2118     int32_t max = static_cast<int32_t>((1U << no_bits) - 1);
2119     int32_t min = -(1 << (no_bits - 1));
2120     int32_t as_signed = static_cast<int32_t>(bits);
2121     return as_signed > max || as_signed < min;
2122   }
2123
2124   // Select bits from A and B using bits in MASK.  For each n in [0..31],
2125   // the n-th bit in the result is chosen from the n-th bits of A and B.
2126   // A zero selects A and a one selects B.
2127   static inline uint32_t
2128   bit_select(uint32_t a, uint32_t b, uint32_t mask)
2129   { return (a & ~mask) | (b & mask); }
2130 };
2131
2132 template<bool big_endian>
2133 class Target_arm : public Sized_target<32, big_endian>
2134 {
2135  public:
2136   typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, big_endian>
2137     Reloc_section;
2138
2139   // When were are relocating a stub, we pass this as the relocation number.
2140   static const size_t fake_relnum_for_stubs = static_cast<size_t>(-1);
2141
2142   Target_arm()
2143     : Sized_target<32, big_endian>(&arm_info),
2144       got_(NULL), plt_(NULL), got_plt_(NULL), rel_dyn_(NULL),
2145       copy_relocs_(elfcpp::R_ARM_COPY), dynbss_(NULL), 
2146       got_mod_index_offset_(-1U), tls_base_symbol_defined_(false),
2147       stub_tables_(), stub_factory_(Stub_factory::get_instance()),
2148       may_use_blx_(false), should_force_pic_veneer_(false),
2149       arm_input_section_map_(), attributes_section_data_(NULL),
2150       fix_cortex_a8_(false), cortex_a8_relocs_info_()
2151   { }
2152
2153   // Virtual function which is set to return true by a target if
2154   // it can use relocation types to determine if a function's
2155   // pointer is taken.
2156   virtual bool
2157   can_check_for_function_pointers() const
2158   { return true; }
2159
2160   // Whether a section called SECTION_NAME may have function pointers to
2161   // sections not eligible for safe ICF folding.
2162   virtual bool
2163   section_may_have_icf_unsafe_pointers(const char* section_name) const
2164   {
2165     return (!is_prefix_of(".ARM.exidx", section_name)
2166             && !is_prefix_of(".ARM.extab", section_name)
2167             && Target::section_may_have_icf_unsafe_pointers(section_name));
2168   }
2169   
2170   // Whether we can use BLX.
2171   bool
2172   may_use_blx() const
2173   { return this->may_use_blx_; }
2174
2175   // Set use-BLX flag.
2176   void
2177   set_may_use_blx(bool value)
2178   { this->may_use_blx_ = value; }
2179   
2180   // Whether we force PCI branch veneers.
2181   bool
2182   should_force_pic_veneer() const
2183   { return this->should_force_pic_veneer_; }
2184
2185   // Set PIC veneer flag.
2186   void
2187   set_should_force_pic_veneer(bool value)
2188   { this->should_force_pic_veneer_ = value; }
2189   
2190   // Whether we use THUMB-2 instructions.
2191   bool
2192   using_thumb2() const
2193   {
2194     Object_attribute* attr =
2195       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2196     int arch = attr->int_value();
2197     return arch == elfcpp::TAG_CPU_ARCH_V6T2 || arch >= elfcpp::TAG_CPU_ARCH_V7;
2198   }
2199
2200   // Whether we use THUMB/THUMB-2 instructions only.
2201   bool
2202   using_thumb_only() const
2203   {
2204     Object_attribute* attr =
2205       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2206
2207     if (attr->int_value() == elfcpp::TAG_CPU_ARCH_V6_M
2208         || attr->int_value() == elfcpp::TAG_CPU_ARCH_V6S_M)
2209       return true;
2210     if (attr->int_value() != elfcpp::TAG_CPU_ARCH_V7
2211         && attr->int_value() != elfcpp::TAG_CPU_ARCH_V7E_M)
2212       return false;
2213     attr = this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch_profile);
2214     return attr->int_value() == 'M';
2215   }
2216
2217   // Whether we have an NOP instruction.  If not, use mov r0, r0 instead.
2218   bool
2219   may_use_arm_nop() const
2220   {
2221     Object_attribute* attr =
2222       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2223     int arch = attr->int_value();
2224     return (arch == elfcpp::TAG_CPU_ARCH_V6T2
2225             || arch == elfcpp::TAG_CPU_ARCH_V6K
2226             || arch == elfcpp::TAG_CPU_ARCH_V7
2227             || arch == elfcpp::TAG_CPU_ARCH_V7E_M);
2228   }
2229
2230   // Whether we have THUMB-2 NOP.W instruction.
2231   bool
2232   may_use_thumb2_nop() const
2233   {
2234     Object_attribute* attr =
2235       this->get_aeabi_object_attribute(elfcpp::Tag_CPU_arch);
2236     int arch = attr->int_value();
2237     return (arch == elfcpp::TAG_CPU_ARCH_V6T2
2238             || arch == elfcpp::TAG_CPU_ARCH_V7
2239             || arch == elfcpp::TAG_CPU_ARCH_V7E_M);
2240   }
2241   
2242   // Process the relocations to determine unreferenced sections for 
2243   // garbage collection.
2244   void
2245   gc_process_relocs(Symbol_table* symtab,
2246                     Layout* layout,
2247                     Sized_relobj<32, big_endian>* object,
2248                     unsigned int data_shndx,
2249                     unsigned int sh_type,
2250                     const unsigned char* prelocs,
2251                     size_t reloc_count,
2252                     Output_section* output_section,
2253                     bool needs_special_offset_handling,
2254                     size_t local_symbol_count,
2255                     const unsigned char* plocal_symbols);
2256
2257   // Scan the relocations to look for symbol adjustments.
2258   void
2259   scan_relocs(Symbol_table* symtab,
2260               Layout* layout,
2261               Sized_relobj<32, big_endian>* object,
2262               unsigned int data_shndx,
2263               unsigned int sh_type,
2264               const unsigned char* prelocs,
2265               size_t reloc_count,
2266               Output_section* output_section,
2267               bool needs_special_offset_handling,
2268               size_t local_symbol_count,
2269               const unsigned char* plocal_symbols);
2270
2271   // Finalize the sections.
2272   void
2273   do_finalize_sections(Layout*, const Input_objects*, Symbol_table*);
2274
2275   // Return the value to use for a dynamic symbol which requires special
2276   // treatment.
2277   uint64_t
2278   do_dynsym_value(const Symbol*) const;
2279
2280   // Relocate a section.
2281   void
2282   relocate_section(const Relocate_info<32, big_endian>*,
2283                    unsigned int sh_type,
2284                    const unsigned char* prelocs,
2285                    size_t reloc_count,
2286                    Output_section* output_section,
2287                    bool needs_special_offset_handling,
2288                    unsigned char* view,
2289                    Arm_address view_address,
2290                    section_size_type view_size,
2291                    const Reloc_symbol_changes*);
2292
2293   // Scan the relocs during a relocatable link.
2294   void
2295   scan_relocatable_relocs(Symbol_table* symtab,
2296                           Layout* layout,
2297                           Sized_relobj<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                           Relocatable_relocs*);
2307
2308   // Relocate a section during a relocatable link.
2309   void
2310   relocate_for_relocatable(const Relocate_info<32, big_endian>*,
2311                            unsigned int sh_type,
2312                            const unsigned char* prelocs,
2313                            size_t reloc_count,
2314                            Output_section* output_section,
2315                            off_t offset_in_output_section,
2316                            const Relocatable_relocs*,
2317                            unsigned char* view,
2318                            Arm_address view_address,
2319                            section_size_type view_size,
2320                            unsigned char* reloc_view,
2321                            section_size_type reloc_view_size);
2322
2323   // Perform target-specific processing in a relocatable link.  This is
2324   // only used if we use the relocation strategy RELOC_SPECIAL.
2325   void
2326   relocate_special_relocatable(const Relocate_info<32, big_endian>* relinfo,
2327                                unsigned int sh_type,
2328                                const unsigned char* preloc_in,
2329                                size_t relnum,
2330                                Output_section* output_section,
2331                                off_t offset_in_output_section,
2332                                unsigned char* view,
2333                                typename elfcpp::Elf_types<32>::Elf_Addr
2334                                  view_address,
2335                                section_size_type view_size,
2336                                unsigned char* preloc_out);
2337  
2338   // Return whether SYM is defined by the ABI.
2339   bool
2340   do_is_defined_by_abi(Symbol* sym) const
2341   { return strcmp(sym->name(), "__tls_get_addr") == 0; }
2342
2343   // Return whether there is a GOT section.
2344   bool
2345   has_got_section() const
2346   { return this->got_ != NULL; }
2347
2348   // Return the size of the GOT section.
2349   section_size_type
2350   got_size() const
2351   {
2352     gold_assert(this->got_ != NULL);
2353     return this->got_->data_size();
2354   }
2355
2356   // Return the number of entries in the GOT.
2357   unsigned int
2358   got_entry_count() const
2359   {
2360     if (!this->has_got_section())
2361       return 0;
2362     return this->got_size() / 4;
2363   }
2364
2365   // Return the number of entries in the PLT.
2366   unsigned int
2367   plt_entry_count() const;
2368
2369   // Return the offset of the first non-reserved PLT entry.
2370   unsigned int
2371   first_plt_entry_offset() const;
2372
2373   // Return the size of each PLT entry.
2374   unsigned int
2375   plt_entry_size() const;
2376
2377   // Map platform-specific reloc types
2378   static unsigned int
2379   get_real_reloc_type(unsigned int r_type);
2380
2381   //
2382   // Methods to support stub-generations.
2383   //
2384   
2385   // Return the stub factory
2386   const Stub_factory&
2387   stub_factory() const
2388   { return this->stub_factory_; }
2389
2390   // Make a new Arm_input_section object.
2391   Arm_input_section<big_endian>*
2392   new_arm_input_section(Relobj*, unsigned int);
2393
2394   // Find the Arm_input_section object corresponding to the SHNDX-th input
2395   // section of RELOBJ.
2396   Arm_input_section<big_endian>*
2397   find_arm_input_section(Relobj* relobj, unsigned int shndx) const;
2398
2399   // Make a new Stub_table
2400   Stub_table<big_endian>*
2401   new_stub_table(Arm_input_section<big_endian>*);
2402
2403   // Scan a section for stub generation.
2404   void
2405   scan_section_for_stubs(const Relocate_info<32, big_endian>*, unsigned int,
2406                          const unsigned char*, size_t, Output_section*,
2407                          bool, const unsigned char*, Arm_address,
2408                          section_size_type);
2409
2410   // Relocate a stub. 
2411   void
2412   relocate_stub(Stub*, const Relocate_info<32, big_endian>*,
2413                 Output_section*, unsigned char*, Arm_address,
2414                 section_size_type);
2415  
2416   // Get the default ARM target.
2417   static Target_arm<big_endian>*
2418   default_target()
2419   {
2420     gold_assert(parameters->target().machine_code() == elfcpp::EM_ARM
2421                 && parameters->target().is_big_endian() == big_endian);
2422     return static_cast<Target_arm<big_endian>*>(
2423              parameters->sized_target<32, big_endian>());
2424   }
2425
2426   // Whether NAME belongs to a mapping symbol.
2427   static bool
2428   is_mapping_symbol_name(const char* name)
2429   {
2430     return (name
2431             && name[0] == '$'
2432             && (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
2433             && (name[2] == '\0' || name[2] == '.'));
2434   }
2435
2436   // Whether we work around the Cortex-A8 erratum.
2437   bool
2438   fix_cortex_a8() const
2439   { return this->fix_cortex_a8_; }
2440
2441   // Whether we merge exidx entries in debuginfo.
2442   bool
2443   merge_exidx_entries() const
2444   { return parameters->options().merge_exidx_entries(); }
2445
2446   // Whether we fix R_ARM_V4BX relocation.
2447   // 0 - do not fix
2448   // 1 - replace with MOV instruction (armv4 target)
2449   // 2 - make interworking veneer (>= armv4t targets only)
2450   General_options::Fix_v4bx
2451   fix_v4bx() const
2452   { return parameters->options().fix_v4bx(); }
2453
2454   // Scan a span of THUMB code section for Cortex-A8 erratum.
2455   void
2456   scan_span_for_cortex_a8_erratum(Arm_relobj<big_endian>*, unsigned int,
2457                                   section_size_type, section_size_type,
2458                                   const unsigned char*, Arm_address);
2459
2460   // Apply Cortex-A8 workaround to a branch.
2461   void
2462   apply_cortex_a8_workaround(const Cortex_a8_stub*, Arm_address,
2463                              unsigned char*, Arm_address);
2464
2465  protected:
2466   // Make an ELF object.
2467   Object*
2468   do_make_elf_object(const std::string&, Input_file*, off_t,
2469                      const elfcpp::Ehdr<32, big_endian>& ehdr);
2470
2471   Object*
2472   do_make_elf_object(const std::string&, Input_file*, off_t,
2473                      const elfcpp::Ehdr<32, !big_endian>&)
2474   { gold_unreachable(); }
2475
2476   Object*
2477   do_make_elf_object(const std::string&, Input_file*, off_t,
2478                       const elfcpp::Ehdr<64, false>&)
2479   { gold_unreachable(); }
2480
2481   Object*
2482   do_make_elf_object(const std::string&, Input_file*, off_t,
2483                      const elfcpp::Ehdr<64, true>&)
2484   { gold_unreachable(); }
2485
2486   // Make an output section.
2487   Output_section*
2488   do_make_output_section(const char* name, elfcpp::Elf_Word type,
2489                          elfcpp::Elf_Xword flags)
2490   { return new Arm_output_section<big_endian>(name, type, flags); }
2491
2492   void
2493   do_adjust_elf_header(unsigned char* view, int len) const;
2494
2495   // We only need to generate stubs, and hence perform relaxation if we are
2496   // not doing relocatable linking.
2497   bool
2498   do_may_relax() const
2499   { return !parameters->options().relocatable(); }
2500
2501   bool
2502   do_relax(int, const Input_objects*, Symbol_table*, Layout*);
2503
2504   // Determine whether an object attribute tag takes an integer, a
2505   // string or both.
2506   int
2507   do_attribute_arg_type(int tag) const;
2508
2509   // Reorder tags during output.
2510   int
2511   do_attributes_order(int num) const;
2512
2513   // This is called when the target is selected as the default.
2514   void
2515   do_select_as_default_target()
2516   {
2517     // No locking is required since there should only be one default target.
2518     // We cannot have both the big-endian and little-endian ARM targets
2519     // as the default.
2520     gold_assert(arm_reloc_property_table == NULL);
2521     arm_reloc_property_table = new Arm_reloc_property_table();
2522   }
2523
2524  private:
2525   // The class which scans relocations.
2526   class Scan
2527   {
2528    public:
2529     Scan()
2530       : issued_non_pic_error_(false)
2531     { }
2532
2533     inline void
2534     local(Symbol_table* symtab, Layout* layout, Target_arm* target,
2535           Sized_relobj<32, big_endian>* object,
2536           unsigned int data_shndx,
2537           Output_section* output_section,
2538           const elfcpp::Rel<32, big_endian>& reloc, unsigned int r_type,
2539           const elfcpp::Sym<32, big_endian>& lsym);
2540
2541     inline void
2542     global(Symbol_table* symtab, Layout* layout, Target_arm* target,
2543            Sized_relobj<32, big_endian>* object,
2544            unsigned int data_shndx,
2545            Output_section* output_section,
2546            const elfcpp::Rel<32, big_endian>& reloc, unsigned int r_type,
2547            Symbol* gsym);
2548
2549     inline bool
2550     local_reloc_may_be_function_pointer(Symbol_table* , Layout* , Target_arm* ,
2551                                         Sized_relobj<32, big_endian>* ,
2552                                         unsigned int ,
2553                                         Output_section* ,
2554                                         const elfcpp::Rel<32, big_endian>& ,
2555                                         unsigned int ,
2556                                         const elfcpp::Sym<32, big_endian>&);
2557
2558     inline bool
2559     global_reloc_may_be_function_pointer(Symbol_table* , Layout* , Target_arm* ,
2560                                          Sized_relobj<32, big_endian>* ,
2561                                          unsigned int ,
2562                                          Output_section* ,
2563                                          const elfcpp::Rel<32, big_endian>& ,
2564                                          unsigned int , Symbol*);
2565
2566    private:
2567     static void
2568     unsupported_reloc_local(Sized_relobj<32, big_endian>*,
2569                             unsigned int r_type);
2570
2571     static void
2572     unsupported_reloc_global(Sized_relobj<32, big_endian>*,
2573                              unsigned int r_type, Symbol*);
2574
2575     void
2576     check_non_pic(Relobj*, unsigned int r_type);
2577
2578     // Almost identical to Symbol::needs_plt_entry except that it also
2579     // handles STT_ARM_TFUNC.
2580     static bool
2581     symbol_needs_plt_entry(const Symbol* sym)
2582     {
2583       // An undefined symbol from an executable does not need a PLT entry.
2584       if (sym->is_undefined() && !parameters->options().shared())
2585         return false;
2586
2587       return (!parameters->doing_static_link()
2588               && (sym->type() == elfcpp::STT_FUNC
2589                   || sym->type() == elfcpp::STT_ARM_TFUNC)
2590               && (sym->is_from_dynobj()
2591                   || sym->is_undefined()
2592                   || sym->is_preemptible()));
2593     }
2594
2595     inline bool
2596     possible_function_pointer_reloc(unsigned int r_type);
2597
2598     // Whether we have issued an error about a non-PIC compilation.
2599     bool issued_non_pic_error_;
2600   };
2601
2602   // The class which implements relocation.
2603   class Relocate
2604   {
2605    public:
2606     Relocate()
2607     { }
2608
2609     ~Relocate()
2610     { }
2611
2612     // Return whether the static relocation needs to be applied.
2613     inline bool
2614     should_apply_static_reloc(const Sized_symbol<32>* gsym,
2615                               int ref_flags,
2616                               bool is_32bit,
2617                               Output_section* output_section);
2618
2619     // Do a relocation.  Return false if the caller should not issue
2620     // any warnings about this relocation.
2621     inline bool
2622     relocate(const Relocate_info<32, big_endian>*, Target_arm*,
2623              Output_section*,  size_t relnum,
2624              const elfcpp::Rel<32, big_endian>&,
2625              unsigned int r_type, const Sized_symbol<32>*,
2626              const Symbol_value<32>*,
2627              unsigned char*, Arm_address,
2628              section_size_type);
2629
2630     // Return whether we want to pass flag NON_PIC_REF for this
2631     // reloc.  This means the relocation type accesses a symbol not via
2632     // GOT or PLT.
2633     static inline bool
2634     reloc_is_non_pic(unsigned int r_type)
2635     {
2636       switch (r_type)
2637         {
2638         // These relocation types reference GOT or PLT entries explicitly.
2639         case elfcpp::R_ARM_GOT_BREL:
2640         case elfcpp::R_ARM_GOT_ABS:
2641         case elfcpp::R_ARM_GOT_PREL:
2642         case elfcpp::R_ARM_GOT_BREL12:
2643         case elfcpp::R_ARM_PLT32_ABS:
2644         case elfcpp::R_ARM_TLS_GD32:
2645         case elfcpp::R_ARM_TLS_LDM32:
2646         case elfcpp::R_ARM_TLS_IE32:
2647         case elfcpp::R_ARM_TLS_IE12GP:
2648
2649         // These relocate types may use PLT entries.
2650         case elfcpp::R_ARM_CALL:
2651         case elfcpp::R_ARM_THM_CALL:
2652         case elfcpp::R_ARM_JUMP24:
2653         case elfcpp::R_ARM_THM_JUMP24:
2654         case elfcpp::R_ARM_THM_JUMP19:
2655         case elfcpp::R_ARM_PLT32:
2656         case elfcpp::R_ARM_THM_XPC22:
2657         case elfcpp::R_ARM_PREL31:
2658         case elfcpp::R_ARM_SBREL31:
2659           return false;
2660
2661         default:
2662           return true;
2663         }
2664     }
2665
2666    private:
2667     // Do a TLS relocation.
2668     inline typename Arm_relocate_functions<big_endian>::Status
2669     relocate_tls(const Relocate_info<32, big_endian>*, Target_arm<big_endian>*,
2670                  size_t, const elfcpp::Rel<32, big_endian>&, unsigned int,
2671                  const Sized_symbol<32>*, const Symbol_value<32>*,
2672                  unsigned char*, elfcpp::Elf_types<32>::Elf_Addr,
2673                  section_size_type);
2674
2675   };
2676
2677   // A class which returns the size required for a relocation type,
2678   // used while scanning relocs during a relocatable link.
2679   class Relocatable_size_for_reloc
2680   {
2681    public:
2682     unsigned int
2683     get_size_for_reloc(unsigned int, Relobj*);
2684   };
2685
2686   // Adjust TLS relocation type based on the options and whether this
2687   // is a local symbol.
2688   static tls::Tls_optimization
2689   optimize_tls_reloc(bool is_final, int r_type);
2690
2691   // Get the GOT section, creating it if necessary.
2692   Arm_output_data_got<big_endian>*
2693   got_section(Symbol_table*, Layout*);
2694
2695   // Get the GOT PLT section.
2696   Output_data_space*
2697   got_plt_section() const
2698   {
2699     gold_assert(this->got_plt_ != NULL);
2700     return this->got_plt_;
2701   }
2702
2703   // Create a PLT entry for a global symbol.
2704   void
2705   make_plt_entry(Symbol_table*, Layout*, Symbol*);
2706
2707   // Define the _TLS_MODULE_BASE_ symbol in the TLS segment.
2708   void
2709   define_tls_base_symbol(Symbol_table*, Layout*);
2710
2711   // Create a GOT entry for the TLS module index.
2712   unsigned int
2713   got_mod_index_entry(Symbol_table* symtab, Layout* layout,
2714                       Sized_relobj<32, big_endian>* object);
2715
2716   // Get the PLT section.
2717   const Output_data_plt_arm<big_endian>*
2718   plt_section() const
2719   {
2720     gold_assert(this->plt_ != NULL);
2721     return this->plt_;
2722   }
2723
2724   // Get the dynamic reloc section, creating it if necessary.
2725   Reloc_section*
2726   rel_dyn_section(Layout*);
2727
2728   // Get the section to use for TLS_DESC relocations.
2729   Reloc_section*
2730   rel_tls_desc_section(Layout*) const;
2731
2732   // Return true if the symbol may need a COPY relocation.
2733   // References from an executable object to non-function symbols
2734   // defined in a dynamic object may need a COPY relocation.
2735   bool
2736   may_need_copy_reloc(Symbol* gsym)
2737   {
2738     return (gsym->type() != elfcpp::STT_ARM_TFUNC
2739             && gsym->may_need_copy_reloc());
2740   }
2741
2742   // Add a potential copy relocation.
2743   void
2744   copy_reloc(Symbol_table* symtab, Layout* layout,
2745              Sized_relobj<32, big_endian>* object,
2746              unsigned int shndx, Output_section* output_section,
2747              Symbol* sym, const elfcpp::Rel<32, big_endian>& reloc)
2748   {
2749     this->copy_relocs_.copy_reloc(symtab, layout,
2750                                   symtab->get_sized_symbol<32>(sym),
2751                                   object, shndx, output_section, reloc,
2752                                   this->rel_dyn_section(layout));
2753   }
2754
2755   // Whether two EABI versions are compatible.
2756   static bool
2757   are_eabi_versions_compatible(elfcpp::Elf_Word v1, elfcpp::Elf_Word v2);
2758
2759   // Merge processor-specific flags from input object and those in the ELF
2760   // header of the output.
2761   void
2762   merge_processor_specific_flags(const std::string&, elfcpp::Elf_Word);
2763
2764   // Get the secondary compatible architecture.
2765   static int
2766   get_secondary_compatible_arch(const Attributes_section_data*);
2767
2768   // Set the secondary compatible architecture.
2769   static void
2770   set_secondary_compatible_arch(Attributes_section_data*, int);
2771
2772   static int
2773   tag_cpu_arch_combine(const char*, int, int*, int, int);
2774
2775   // Helper to print AEABI enum tag value.
2776   static std::string
2777   aeabi_enum_name(unsigned int);
2778
2779   // Return string value for TAG_CPU_name.
2780   static std::string
2781   tag_cpu_name_value(unsigned int);
2782
2783   // Merge object attributes from input object and those in the output.
2784   void
2785   merge_object_attributes(const char*, const Attributes_section_data*);
2786
2787   // Helper to get an AEABI object attribute
2788   Object_attribute*
2789   get_aeabi_object_attribute(int tag) const
2790   {
2791     Attributes_section_data* pasd = this->attributes_section_data_;
2792     gold_assert(pasd != NULL);
2793     Object_attribute* attr =
2794       pasd->get_attribute(Object_attribute::OBJ_ATTR_PROC, tag);
2795     gold_assert(attr != NULL);
2796     return attr;
2797   }
2798
2799   //
2800   // Methods to support stub-generations.
2801   //
2802
2803   // Group input sections for stub generation.
2804   void
2805   group_sections(Layout*, section_size_type, bool);
2806
2807   // Scan a relocation for stub generation.
2808   void
2809   scan_reloc_for_stub(const Relocate_info<32, big_endian>*, unsigned int,
2810                       const Sized_symbol<32>*, unsigned int,
2811                       const Symbol_value<32>*,
2812                       elfcpp::Elf_types<32>::Elf_Swxword, Arm_address);
2813
2814   // Scan a relocation section for stub.
2815   template<int sh_type>
2816   void
2817   scan_reloc_section_for_stubs(
2818       const Relocate_info<32, big_endian>* relinfo,
2819       const unsigned char* prelocs,
2820       size_t reloc_count,
2821       Output_section* output_section,
2822       bool needs_special_offset_handling,
2823       const unsigned char* view,
2824       elfcpp::Elf_types<32>::Elf_Addr view_address,
2825       section_size_type);
2826
2827   // Fix .ARM.exidx section coverage.
2828   void
2829   fix_exidx_coverage(Layout*, const Input_objects*,
2830                      Arm_output_section<big_endian>*, Symbol_table*);
2831
2832   // Functors for STL set.
2833   struct output_section_address_less_than
2834   {
2835     bool
2836     operator()(const Output_section* s1, const Output_section* s2) const
2837     { return s1->address() < s2->address(); }
2838   };
2839
2840   // Information about this specific target which we pass to the
2841   // general Target structure.
2842   static const Target::Target_info arm_info;
2843
2844   // The types of GOT entries needed for this platform.
2845   // These values are exposed to the ABI in an incremental link.
2846   // Do not renumber existing values without changing the version
2847   // number of the .gnu_incremental_inputs section.
2848   enum Got_type
2849   {
2850     GOT_TYPE_STANDARD = 0,      // GOT entry for a regular symbol
2851     GOT_TYPE_TLS_NOFFSET = 1,   // GOT entry for negative TLS offset
2852     GOT_TYPE_TLS_OFFSET = 2,    // GOT entry for positive TLS offset
2853     GOT_TYPE_TLS_PAIR = 3,      // GOT entry for TLS module/offset pair
2854     GOT_TYPE_TLS_DESC = 4       // GOT entry for TLS_DESC pair
2855   };
2856
2857   typedef typename std::vector<Stub_table<big_endian>*> Stub_table_list;
2858
2859   // Map input section to Arm_input_section.
2860   typedef Unordered_map<Section_id,
2861                         Arm_input_section<big_endian>*,
2862                         Section_id_hash>
2863           Arm_input_section_map;
2864     
2865   // Map output addresses to relocs for Cortex-A8 erratum.
2866   typedef Unordered_map<Arm_address, const Cortex_a8_reloc*>
2867           Cortex_a8_relocs_info;
2868
2869   // The GOT section.
2870   Arm_output_data_got<big_endian>* got_;
2871   // The PLT section.
2872   Output_data_plt_arm<big_endian>* plt_;
2873   // The GOT PLT section.
2874   Output_data_space* got_plt_;
2875   // The dynamic reloc section.
2876   Reloc_section* rel_dyn_;
2877   // Relocs saved to avoid a COPY reloc.
2878   Copy_relocs<elfcpp::SHT_REL, 32, big_endian> copy_relocs_;
2879   // Space for variables copied with a COPY reloc.
2880   Output_data_space* dynbss_;
2881   // Offset of the GOT entry for the TLS module index.
2882   unsigned int got_mod_index_offset_;
2883   // True if the _TLS_MODULE_BASE_ symbol has been defined.
2884   bool tls_base_symbol_defined_;
2885   // Vector of Stub_tables created.
2886   Stub_table_list stub_tables_;
2887   // Stub factory.
2888   const Stub_factory &stub_factory_;
2889   // Whether we can use BLX.
2890   bool may_use_blx_;
2891   // Whether we force PIC branch veneers.
2892   bool should_force_pic_veneer_;
2893   // Map for locating Arm_input_sections.
2894   Arm_input_section_map arm_input_section_map_;
2895   // Attributes section data in output.
2896   Attributes_section_data* attributes_section_data_;
2897   // Whether we want to fix code for Cortex-A8 erratum.
2898   bool fix_cortex_a8_;
2899   // Map addresses to relocs for Cortex-A8 erratum.
2900   Cortex_a8_relocs_info cortex_a8_relocs_info_;
2901 };
2902
2903 template<bool big_endian>
2904 const Target::Target_info Target_arm<big_endian>::arm_info =
2905 {
2906   32,                   // size
2907   big_endian,           // is_big_endian
2908   elfcpp::EM_ARM,       // machine_code
2909   false,                // has_make_symbol
2910   false,                // has_resolve
2911   false,                // has_code_fill
2912   true,                 // is_default_stack_executable
2913   '\0',                 // wrap_char
2914   "/usr/lib/libc.so.1", // dynamic_linker
2915   0x8000,               // default_text_segment_address
2916   0x1000,               // abi_pagesize (overridable by -z max-page-size)
2917   0x1000,               // common_pagesize (overridable by -z common-page-size)
2918   elfcpp::SHN_UNDEF,    // small_common_shndx
2919   elfcpp::SHN_UNDEF,    // large_common_shndx
2920   0,                    // small_common_section_flags
2921   0,                    // large_common_section_flags
2922   ".ARM.attributes",    // attributes_section
2923   "aeabi"               // attributes_vendor
2924 };
2925
2926 // Arm relocate functions class
2927 //
2928
2929 template<bool big_endian>
2930 class Arm_relocate_functions : public Relocate_functions<32, big_endian>
2931 {
2932  public:
2933   typedef enum
2934   {
2935     STATUS_OKAY,        // No error during relocation.
2936     STATUS_OVERFLOW,    // Relocation oveflow.
2937     STATUS_BAD_RELOC    // Relocation cannot be applied.
2938   } Status;
2939
2940  private:
2941   typedef Relocate_functions<32, big_endian> Base;
2942   typedef Arm_relocate_functions<big_endian> This;
2943
2944   // Encoding of imm16 argument for movt and movw ARM instructions
2945   // from ARM ARM:
2946   //     
2947   //     imm16 := imm4 | imm12
2948   //
2949   //  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 
2950   // +-------+---------------+-------+-------+-----------------------+
2951   // |       |               |imm4   |       |imm12                  |
2952   // +-------+---------------+-------+-------+-----------------------+
2953
2954   // Extract the relocation addend from VAL based on the ARM
2955   // instruction encoding described above.
2956   static inline typename elfcpp::Swap<32, big_endian>::Valtype
2957   extract_arm_movw_movt_addend(
2958       typename elfcpp::Swap<32, big_endian>::Valtype val)
2959   {
2960     // According to the Elf ABI for ARM Architecture the immediate
2961     // field is sign-extended to form the addend.
2962     return utils::sign_extend<16>(((val >> 4) & 0xf000) | (val & 0xfff));
2963   }
2964
2965   // Insert X into VAL based on the ARM instruction encoding described
2966   // above.
2967   static inline typename elfcpp::Swap<32, big_endian>::Valtype
2968   insert_val_arm_movw_movt(
2969       typename elfcpp::Swap<32, big_endian>::Valtype val,
2970       typename elfcpp::Swap<32, big_endian>::Valtype x)
2971   {
2972     val &= 0xfff0f000;
2973     val |= x & 0x0fff;
2974     val |= (x & 0xf000) << 4;
2975     return val;
2976   }
2977
2978   // Encoding of imm16 argument for movt and movw Thumb2 instructions
2979   // from ARM ARM:
2980   //     
2981   //     imm16 := imm4 | i | imm3 | imm8
2982   //
2983   //  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 
2984   // +---------+-+-----------+-------++-+-----+-------+---------------+
2985   // |         |i|           |imm4   || |imm3 |       |imm8           |
2986   // +---------+-+-----------+-------++-+-----+-------+---------------+
2987
2988   // Extract the relocation addend from VAL based on the Thumb2
2989   // instruction encoding described above.
2990   static inline typename elfcpp::Swap<32, big_endian>::Valtype
2991   extract_thumb_movw_movt_addend(
2992       typename elfcpp::Swap<32, big_endian>::Valtype val)
2993   {
2994     // According to the Elf ABI for ARM Architecture the immediate
2995     // field is sign-extended to form the addend.
2996     return utils::sign_extend<16>(((val >> 4) & 0xf000)
2997                                   | ((val >> 15) & 0x0800)
2998                                   | ((val >> 4) & 0x0700)
2999                                   | (val & 0x00ff));
3000   }
3001
3002   // Insert X into VAL based on the Thumb2 instruction encoding
3003   // described above.
3004   static inline typename elfcpp::Swap<32, big_endian>::Valtype
3005   insert_val_thumb_movw_movt(
3006       typename elfcpp::Swap<32, big_endian>::Valtype val,
3007       typename elfcpp::Swap<32, big_endian>::Valtype x)
3008   {
3009     val &= 0xfbf08f00;
3010     val |= (x & 0xf000) << 4;
3011     val |= (x & 0x0800) << 15;
3012     val |= (x & 0x0700) << 4;
3013     val |= (x & 0x00ff);
3014     return val;
3015   }
3016
3017   // Calculate the smallest constant Kn for the specified residual.
3018   // (see (AAELF 4.6.1.4 Static ARM relocations, Group Relocations, p.32)
3019   static uint32_t
3020   calc_grp_kn(typename elfcpp::Swap<32, big_endian>::Valtype residual)
3021   {
3022     int32_t msb;
3023
3024     if (residual == 0)
3025       return 0;
3026     // Determine the most significant bit in the residual and
3027     // align the resulting value to a 2-bit boundary.
3028     for (msb = 30; (msb >= 0) && !(residual & (3 << msb)); msb -= 2)
3029       ;
3030     // The desired shift is now (msb - 6), or zero, whichever
3031     // is the greater.
3032     return (((msb - 6) < 0) ? 0 : (msb - 6));
3033   }
3034
3035   // Calculate the final residual for the specified group index.
3036   // If the passed group index is less than zero, the method will return
3037   // the value of the specified residual without any change.
3038   // (see (AAELF 4.6.1.4 Static ARM relocations, Group Relocations, p.32)
3039   static typename elfcpp::Swap<32, big_endian>::Valtype
3040   calc_grp_residual(typename elfcpp::Swap<32, big_endian>::Valtype residual,
3041                     const int group)
3042   {
3043     for (int n = 0; n <= group; n++)
3044       {
3045         // Calculate which part of the value to mask.
3046         uint32_t shift = calc_grp_kn(residual);
3047         // Calculate the residual for the next time around.
3048         residual &= ~(residual & (0xff << shift));
3049       }
3050
3051     return residual;
3052   }
3053
3054   // Calculate the value of Gn for the specified group index.
3055   // We return it in the form of an encoded constant-and-rotation.
3056   // (see (AAELF 4.6.1.4 Static ARM relocations, Group Relocations, p.32)
3057   static typename elfcpp::Swap<32, big_endian>::Valtype
3058   calc_grp_gn(typename elfcpp::Swap<32, big_endian>::Valtype residual,
3059               const int group)
3060   {
3061     typename elfcpp::Swap<32, big_endian>::Valtype gn = 0;
3062     uint32_t shift = 0;
3063
3064     for (int n = 0; n <= group; n++)
3065       {
3066         // Calculate which part of the value to mask.
3067         shift = calc_grp_kn(residual);
3068         // Calculate Gn in 32-bit as well as encoded constant-and-rotation form.
3069         gn = residual & (0xff << shift);
3070         // Calculate the residual for the next time around.
3071         residual &= ~gn;
3072       }
3073     // Return Gn in the form of an encoded constant-and-rotation.
3074     return ((gn >> shift) | ((gn <= 0xff ? 0 : (32 - shift) / 2) << 8));
3075   }
3076
3077  public:
3078   // Handle ARM long branches.
3079   static typename This::Status
3080   arm_branch_common(unsigned int, const Relocate_info<32, big_endian>*,
3081                     unsigned char*, const Sized_symbol<32>*,
3082                     const Arm_relobj<big_endian>*, unsigned int,
3083                     const Symbol_value<32>*, Arm_address, Arm_address, bool);
3084
3085   // Handle THUMB long branches.
3086   static typename This::Status
3087   thumb_branch_common(unsigned int, const Relocate_info<32, big_endian>*,
3088                       unsigned char*, const Sized_symbol<32>*,
3089                       const Arm_relobj<big_endian>*, unsigned int,
3090                       const Symbol_value<32>*, Arm_address, Arm_address, bool);
3091
3092
3093   // Return the branch offset of a 32-bit THUMB branch.
3094   static inline int32_t
3095   thumb32_branch_offset(uint16_t upper_insn, uint16_t lower_insn)
3096   {
3097     // We use the Thumb-2 encoding (backwards compatible with Thumb-1)
3098     // involving the J1 and J2 bits.
3099     uint32_t s = (upper_insn & (1U << 10)) >> 10;
3100     uint32_t upper = upper_insn & 0x3ffU;
3101     uint32_t lower = lower_insn & 0x7ffU;
3102     uint32_t j1 = (lower_insn & (1U << 13)) >> 13;
3103     uint32_t j2 = (lower_insn & (1U << 11)) >> 11;
3104     uint32_t i1 = j1 ^ s ? 0 : 1;
3105     uint32_t i2 = j2 ^ s ? 0 : 1;
3106
3107     return utils::sign_extend<25>((s << 24) | (i1 << 23) | (i2 << 22)
3108                                   | (upper << 12) | (lower << 1));
3109   }
3110
3111   // Insert OFFSET to a 32-bit THUMB branch and return the upper instruction.
3112   // UPPER_INSN is the original upper instruction of the branch.  Caller is
3113   // responsible for overflow checking and BLX offset adjustment.
3114   static inline uint16_t
3115   thumb32_branch_upper(uint16_t upper_insn, int32_t offset)
3116   {
3117     uint32_t s = offset < 0 ? 1 : 0;
3118     uint32_t bits = static_cast<uint32_t>(offset);
3119     return (upper_insn & ~0x7ffU) | ((bits >> 12) & 0x3ffU) | (s << 10);
3120   }
3121
3122   // Insert OFFSET to a 32-bit THUMB branch and return the lower instruction.
3123   // LOWER_INSN is the original lower instruction of the branch.  Caller is
3124   // responsible for overflow checking and BLX offset adjustment.
3125   static inline uint16_t
3126   thumb32_branch_lower(uint16_t lower_insn, int32_t offset)
3127   {
3128     uint32_t s = offset < 0 ? 1 : 0;
3129     uint32_t bits = static_cast<uint32_t>(offset);
3130     return ((lower_insn & ~0x2fffU)
3131             | ((((bits >> 23) & 1) ^ !s) << 13)
3132             | ((((bits >> 22) & 1) ^ !s) << 11)
3133             | ((bits >> 1) & 0x7ffU));
3134   }
3135
3136   // Return the branch offset of a 32-bit THUMB conditional branch.
3137   static inline int32_t
3138   thumb32_cond_branch_offset(uint16_t upper_insn, uint16_t lower_insn)
3139   {
3140     uint32_t s = (upper_insn & 0x0400U) >> 10;
3141     uint32_t j1 = (lower_insn & 0x2000U) >> 13;
3142     uint32_t j2 = (lower_insn & 0x0800U) >> 11;
3143     uint32_t lower = (lower_insn & 0x07ffU);
3144     uint32_t upper = (s << 8) | (j2 << 7) | (j1 << 6) | (upper_insn & 0x003fU);
3145
3146     return utils::sign_extend<21>((upper << 12) | (lower << 1));
3147   }
3148
3149   // Insert OFFSET to a 32-bit THUMB conditional branch and return the upper
3150   // instruction.  UPPER_INSN is the original upper instruction of the branch.
3151   // Caller is responsible for overflow checking.
3152   static inline uint16_t
3153   thumb32_cond_branch_upper(uint16_t upper_insn, int32_t offset)
3154   {
3155     uint32_t s = offset < 0 ? 1 : 0;
3156     uint32_t bits = static_cast<uint32_t>(offset);
3157     return (upper_insn & 0xfbc0U) | (s << 10) | ((bits & 0x0003f000U) >> 12);
3158   }
3159
3160   // Insert OFFSET to a 32-bit THUMB conditional branch and return the lower
3161   // instruction.  LOWER_INSN is the original lower instruction of the branch.
3162   // Caller is reponsible for overflow checking.
3163   static inline uint16_t
3164   thumb32_cond_branch_lower(uint16_t lower_insn, int32_t offset)
3165   {
3166     uint32_t bits = static_cast<uint32_t>(offset);
3167     uint32_t j2 = (bits & 0x00080000U) >> 19;
3168     uint32_t j1 = (bits & 0x00040000U) >> 18;
3169     uint32_t lo = (bits & 0x00000ffeU) >> 1;
3170
3171     return (lower_insn & 0xd000U) | (j1 << 13) | (j2 << 11) | lo;
3172   }
3173
3174   // R_ARM_ABS8: S + A
3175   static inline typename This::Status
3176   abs8(unsigned char* view,
3177        const Sized_relobj<32, big_endian>* object,
3178        const Symbol_value<32>* psymval)
3179   {
3180     typedef typename elfcpp::Swap<8, big_endian>::Valtype Valtype;
3181     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3182     Valtype* wv = reinterpret_cast<Valtype*>(view);
3183     Valtype val = elfcpp::Swap<8, big_endian>::readval(wv);
3184     Reltype addend = utils::sign_extend<8>(val);
3185     Reltype x = psymval->value(object, addend);
3186     val = utils::bit_select(val, x, 0xffU);
3187     elfcpp::Swap<8, big_endian>::writeval(wv, val);
3188
3189     // R_ARM_ABS8 permits signed or unsigned results.
3190     int signed_x = static_cast<int32_t>(x);
3191     return ((signed_x < -128 || signed_x > 255)
3192             ? This::STATUS_OVERFLOW
3193             : This::STATUS_OKAY);
3194   }
3195
3196   // R_ARM_THM_ABS5: S + A
3197   static inline typename This::Status
3198   thm_abs5(unsigned char* view,
3199        const Sized_relobj<32, big_endian>* object,
3200        const Symbol_value<32>* psymval)
3201   {
3202     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3203     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3204     Valtype* wv = reinterpret_cast<Valtype*>(view);
3205     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3206     Reltype addend = (val & 0x7e0U) >> 6;
3207     Reltype x = psymval->value(object, addend);
3208     val = utils::bit_select(val, x << 6, 0x7e0U);
3209     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3210
3211     // R_ARM_ABS16 permits signed or unsigned results.
3212     int signed_x = static_cast<int32_t>(x);
3213     return ((signed_x < -32768 || signed_x > 65535)
3214             ? This::STATUS_OVERFLOW
3215             : This::STATUS_OKAY);
3216   }
3217
3218   // R_ARM_ABS12: S + A
3219   static inline typename This::Status
3220   abs12(unsigned char* view,
3221         const Sized_relobj<32, big_endian>* object,
3222         const Symbol_value<32>* psymval)
3223   {
3224     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3225     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3226     Valtype* wv = reinterpret_cast<Valtype*>(view);
3227     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3228     Reltype addend = val & 0x0fffU;
3229     Reltype x = psymval->value(object, addend);
3230     val = utils::bit_select(val, x, 0x0fffU);
3231     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3232     return (utils::has_overflow<12>(x)
3233             ? This::STATUS_OVERFLOW
3234             : This::STATUS_OKAY);
3235   }
3236
3237   // R_ARM_ABS16: S + A
3238   static inline typename This::Status
3239   abs16(unsigned char* view,
3240         const Sized_relobj<32, big_endian>* object,
3241         const Symbol_value<32>* psymval)
3242   {
3243     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3244     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3245     Valtype* wv = reinterpret_cast<Valtype*>(view);
3246     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3247     Reltype addend = utils::sign_extend<16>(val);
3248     Reltype x = psymval->value(object, addend);
3249     val = utils::bit_select(val, x, 0xffffU);
3250     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3251     return (utils::has_signed_unsigned_overflow<16>(x)
3252             ? This::STATUS_OVERFLOW
3253             : This::STATUS_OKAY);
3254   }
3255
3256   // R_ARM_ABS32: (S + A) | T
3257   static inline typename This::Status
3258   abs32(unsigned char* view,
3259         const Sized_relobj<32, big_endian>* object,
3260         const Symbol_value<32>* psymval,
3261         Arm_address thumb_bit)
3262   {
3263     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3264     Valtype* wv = reinterpret_cast<Valtype*>(view);
3265     Valtype addend = elfcpp::Swap<32, big_endian>::readval(wv);
3266     Valtype x = psymval->value(object, addend) | thumb_bit;
3267     elfcpp::Swap<32, big_endian>::writeval(wv, x);
3268     return This::STATUS_OKAY;
3269   }
3270
3271   // R_ARM_REL32: (S + A) | T - P
3272   static inline typename This::Status
3273   rel32(unsigned char* view,
3274         const Sized_relobj<32, big_endian>* object,
3275         const Symbol_value<32>* psymval,
3276         Arm_address address,
3277         Arm_address thumb_bit)
3278   {
3279     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3280     Valtype* wv = reinterpret_cast<Valtype*>(view);
3281     Valtype addend = elfcpp::Swap<32, big_endian>::readval(wv);
3282     Valtype x = (psymval->value(object, addend) | thumb_bit) - address;
3283     elfcpp::Swap<32, big_endian>::writeval(wv, x);
3284     return This::STATUS_OKAY;
3285   }
3286
3287   // R_ARM_THM_JUMP24: (S + A) | T - P
3288   static typename This::Status
3289   thm_jump19(unsigned char* view, const Arm_relobj<big_endian>* object,
3290              const Symbol_value<32>* psymval, Arm_address address,
3291              Arm_address thumb_bit);
3292
3293   // R_ARM_THM_JUMP6: S + A – P
3294   static inline typename This::Status
3295   thm_jump6(unsigned char* view,
3296             const Sized_relobj<32, big_endian>* object,
3297             const Symbol_value<32>* psymval,
3298             Arm_address address)
3299   {
3300     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3301     typedef typename elfcpp::Swap<16, big_endian>::Valtype Reltype;
3302     Valtype* wv = reinterpret_cast<Valtype*>(view);
3303     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3304     // bit[9]:bit[7:3]:’0’ (mask: 0x02f8)
3305     Reltype addend = (((val & 0x0200) >> 3) | ((val & 0x00f8) >> 2));
3306     Reltype x = (psymval->value(object, addend) - address);
3307     val = (val & 0xfd07) | ((x  & 0x0040) << 3) | ((val & 0x003e) << 2);
3308     elfcpp::Swap<16, big_endian>::writeval(wv, val);
3309     // CZB does only forward jumps.
3310     return ((x > 0x007e)
3311             ? This::STATUS_OVERFLOW
3312             : This::STATUS_OKAY);
3313   }
3314
3315   // R_ARM_THM_JUMP8: S + A – P
3316   static inline typename This::Status
3317   thm_jump8(unsigned char* view,
3318             const Sized_relobj<32, big_endian>* object,
3319             const Symbol_value<32>* psymval,
3320             Arm_address address)
3321   {
3322     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3323     typedef typename elfcpp::Swap<16, big_endian>::Valtype Reltype;
3324     Valtype* wv = reinterpret_cast<Valtype*>(view);
3325     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3326     Reltype addend = utils::sign_extend<8>((val & 0x00ff) << 1);
3327     Reltype x = (psymval->value(object, addend) - address);
3328     elfcpp::Swap<16, big_endian>::writeval(wv, (val & 0xff00) | ((x & 0x01fe) >> 1));
3329     return (utils::has_overflow<8>(x)
3330             ? This::STATUS_OVERFLOW
3331             : This::STATUS_OKAY);
3332   }
3333
3334   // R_ARM_THM_JUMP11: S + A – P
3335   static inline typename This::Status
3336   thm_jump11(unsigned char* view,
3337             const Sized_relobj<32, big_endian>* object,
3338             const Symbol_value<32>* psymval,
3339             Arm_address address)
3340   {
3341     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3342     typedef typename elfcpp::Swap<16, big_endian>::Valtype Reltype;
3343     Valtype* wv = reinterpret_cast<Valtype*>(view);
3344     Valtype val = elfcpp::Swap<16, big_endian>::readval(wv);
3345     Reltype addend = utils::sign_extend<11>((val & 0x07ff) << 1);
3346     Reltype x = (psymval->value(object, addend) - address);
3347     elfcpp::Swap<16, big_endian>::writeval(wv, (val & 0xf800) | ((x & 0x0ffe) >> 1));
3348     return (utils::has_overflow<11>(x)
3349             ? This::STATUS_OVERFLOW
3350             : This::STATUS_OKAY);
3351   }
3352
3353   // R_ARM_BASE_PREL: B(S) + A - P
3354   static inline typename This::Status
3355   base_prel(unsigned char* view,
3356             Arm_address origin,
3357             Arm_address address)
3358   {
3359     Base::rel32(view, origin - address);
3360     return STATUS_OKAY;
3361   }
3362
3363   // R_ARM_BASE_ABS: B(S) + A
3364   static inline typename This::Status
3365   base_abs(unsigned char* view,
3366            Arm_address origin)
3367   {
3368     Base::rel32(view, origin);
3369     return STATUS_OKAY;
3370   }
3371
3372   // R_ARM_GOT_BREL: GOT(S) + A - GOT_ORG
3373   static inline typename This::Status
3374   got_brel(unsigned char* view,
3375            typename elfcpp::Swap<32, big_endian>::Valtype got_offset)
3376   {
3377     Base::rel32(view, got_offset);
3378     return This::STATUS_OKAY;
3379   }
3380
3381   // R_ARM_GOT_PREL: GOT(S) + A - P
3382   static inline typename This::Status
3383   got_prel(unsigned char* view,
3384            Arm_address got_entry,
3385            Arm_address address)
3386   {
3387     Base::rel32(view, got_entry - address);
3388     return This::STATUS_OKAY;
3389   }
3390
3391   // R_ARM_PREL: (S + A) | T - P
3392   static inline typename This::Status
3393   prel31(unsigned char* view,
3394          const Sized_relobj<32, big_endian>* object,
3395          const Symbol_value<32>* psymval,
3396          Arm_address address,
3397          Arm_address thumb_bit)
3398   {
3399     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3400     Valtype* wv = reinterpret_cast<Valtype*>(view);
3401     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3402     Valtype addend = utils::sign_extend<31>(val);
3403     Valtype x = (psymval->value(object, addend) | thumb_bit) - address;
3404     val = utils::bit_select(val, x, 0x7fffffffU);
3405     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3406     return (utils::has_overflow<31>(x) ?
3407             This::STATUS_OVERFLOW : This::STATUS_OKAY);
3408   }
3409
3410   // R_ARM_MOVW_ABS_NC: (S + A) | T     (relative address base is )
3411   // R_ARM_MOVW_PREL_NC: (S + A) | T - P
3412   // R_ARM_MOVW_BREL_NC: ((S + A) | T) - B(S)
3413   // R_ARM_MOVW_BREL: ((S + A) | T) - B(S)
3414   static inline typename This::Status
3415   movw(unsigned char* view,
3416        const Sized_relobj<32, big_endian>* object,
3417        const Symbol_value<32>* psymval,
3418        Arm_address relative_address_base,
3419        Arm_address thumb_bit,
3420        bool check_overflow)
3421   {
3422     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3423     Valtype* wv = reinterpret_cast<Valtype*>(view);
3424     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3425     Valtype addend = This::extract_arm_movw_movt_addend(val);
3426     Valtype x = ((psymval->value(object, addend) | thumb_bit)
3427                  - relative_address_base);
3428     val = This::insert_val_arm_movw_movt(val, x);
3429     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3430     return ((check_overflow && utils::has_overflow<16>(x))
3431             ? This::STATUS_OVERFLOW
3432             : This::STATUS_OKAY);
3433   }
3434
3435   // R_ARM_MOVT_ABS: S + A      (relative address base is 0)
3436   // R_ARM_MOVT_PREL: S + A - P
3437   // R_ARM_MOVT_BREL: S + A - B(S)
3438   static inline typename This::Status
3439   movt(unsigned char* view,
3440        const Sized_relobj<32, big_endian>* object,
3441        const Symbol_value<32>* psymval,
3442        Arm_address relative_address_base)
3443   {
3444     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3445     Valtype* wv = reinterpret_cast<Valtype*>(view);
3446     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3447     Valtype addend = This::extract_arm_movw_movt_addend(val);
3448     Valtype x = (psymval->value(object, addend) - relative_address_base) >> 16;
3449     val = This::insert_val_arm_movw_movt(val, x);
3450     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3451     // FIXME: IHI0044D says that we should check for overflow.
3452     return This::STATUS_OKAY;
3453   }
3454
3455   // R_ARM_THM_MOVW_ABS_NC: S + A | T           (relative_address_base is 0)
3456   // R_ARM_THM_MOVW_PREL_NC: (S + A) | T - P
3457   // R_ARM_THM_MOVW_BREL_NC: ((S + A) | T) - B(S)
3458   // R_ARM_THM_MOVW_BREL: ((S + A) | T) - B(S)
3459   static inline typename This::Status
3460   thm_movw(unsigned char* view,
3461            const Sized_relobj<32, big_endian>* object,
3462            const Symbol_value<32>* psymval,
3463            Arm_address relative_address_base,
3464            Arm_address thumb_bit,
3465            bool check_overflow)
3466   {
3467     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3468     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3469     Valtype* wv = reinterpret_cast<Valtype*>(view);
3470     Reltype val = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3471                   | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3472     Reltype addend = This::extract_thumb_movw_movt_addend(val);
3473     Reltype x =
3474       (psymval->value(object, addend) | thumb_bit) - relative_address_base;
3475     val = This::insert_val_thumb_movw_movt(val, x);
3476     elfcpp::Swap<16, big_endian>::writeval(wv, val >> 16);
3477     elfcpp::Swap<16, big_endian>::writeval(wv + 1, val & 0xffff);
3478     return ((check_overflow && utils::has_overflow<16>(x))
3479             ? This::STATUS_OVERFLOW
3480             : This::STATUS_OKAY);
3481   }
3482
3483   // R_ARM_THM_MOVT_ABS: S + A          (relative address base is 0)
3484   // R_ARM_THM_MOVT_PREL: S + A - P
3485   // R_ARM_THM_MOVT_BREL: S + A - B(S)
3486   static inline typename This::Status
3487   thm_movt(unsigned char* view,
3488            const Sized_relobj<32, big_endian>* object,
3489            const Symbol_value<32>* psymval,
3490            Arm_address relative_address_base)
3491   {
3492     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3493     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3494     Valtype* wv = reinterpret_cast<Valtype*>(view);
3495     Reltype val = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3496                   | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3497     Reltype addend = This::extract_thumb_movw_movt_addend(val);
3498     Reltype x = (psymval->value(object, addend) - relative_address_base) >> 16;
3499     val = This::insert_val_thumb_movw_movt(val, x);
3500     elfcpp::Swap<16, big_endian>::writeval(wv, val >> 16);
3501     elfcpp::Swap<16, big_endian>::writeval(wv + 1, val & 0xffff);
3502     return This::STATUS_OKAY;
3503   }
3504
3505   // R_ARM_THM_ALU_PREL_11_0: ((S + A) | T) - Pa (Thumb32)
3506   static inline typename This::Status
3507   thm_alu11(unsigned char* view,
3508             const Sized_relobj<32, big_endian>* object,
3509             const Symbol_value<32>* psymval,
3510             Arm_address address,
3511             Arm_address thumb_bit)
3512   {
3513     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3514     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3515     Valtype* wv = reinterpret_cast<Valtype*>(view);
3516     Reltype insn = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3517                    | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3518
3519     //        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
3520     // -----------------------------------------------------------------------
3521     // ADD{S} 1 1 1 1 0|i|0|1 0 0 0|S|1 1 0 1||0|imm3 |Rd     |imm8
3522     // ADDW   1 1 1 1 0|i|1|0 0 0 0|0|1 1 0 1||0|imm3 |Rd     |imm8
3523     // ADR[+] 1 1 1 1 0|i|1|0 0 0 0|0|1 1 1 1||0|imm3 |Rd     |imm8
3524     // SUB{S} 1 1 1 1 0|i|0|1 1 0 1|S|1 1 0 1||0|imm3 |Rd     |imm8
3525     // SUBW   1 1 1 1 0|i|1|0 1 0 1|0|1 1 0 1||0|imm3 |Rd     |imm8
3526     // ADR[-] 1 1 1 1 0|i|1|0 1 0 1|0|1 1 1 1||0|imm3 |Rd     |imm8
3527
3528     // Determine a sign for the addend.
3529     const int sign = ((insn & 0xf8ef0000) == 0xf0ad0000
3530                       || (insn & 0xf8ef0000) == 0xf0af0000) ? -1 : 1;
3531     // Thumb2 addend encoding:
3532     // imm12 := i | imm3 | imm8
3533     int32_t addend = (insn & 0xff)
3534                      | ((insn & 0x00007000) >> 4)
3535                      | ((insn & 0x04000000) >> 15);
3536     // Apply a sign to the added.
3537     addend *= sign;
3538
3539     int32_t x = (psymval->value(object, addend) | thumb_bit)
3540                 - (address & 0xfffffffc);
3541     Reltype val = abs(x);
3542     // Mask out the value and a distinct part of the ADD/SUB opcode
3543     // (bits 7:5 of opword).
3544     insn = (insn & 0xfb0f8f00)
3545            | (val & 0xff)
3546            | ((val & 0x700) << 4)
3547            | ((val & 0x800) << 15);
3548     // Set the opcode according to whether the value to go in the
3549     // place is negative.
3550     if (x < 0)
3551       insn |= 0x00a00000;
3552
3553     elfcpp::Swap<16, big_endian>::writeval(wv, insn >> 16);
3554     elfcpp::Swap<16, big_endian>::writeval(wv + 1, insn & 0xffff);
3555     return ((val > 0xfff) ?
3556             This::STATUS_OVERFLOW : This::STATUS_OKAY);
3557   }
3558
3559   // R_ARM_THM_PC8: S + A - Pa (Thumb)
3560   static inline typename This::Status
3561   thm_pc8(unsigned char* view,
3562           const Sized_relobj<32, big_endian>* object,
3563           const Symbol_value<32>* psymval,
3564           Arm_address address)
3565   {
3566     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3567     typedef typename elfcpp::Swap<16, big_endian>::Valtype Reltype;
3568     Valtype* wv = reinterpret_cast<Valtype*>(view);
3569     Valtype insn = elfcpp::Swap<16, big_endian>::readval(wv);
3570     Reltype addend = ((insn & 0x00ff) << 2);
3571     int32_t x = (psymval->value(object, addend) - (address & 0xfffffffc));
3572     Reltype val = abs(x);
3573     insn = (insn & 0xff00) | ((val & 0x03fc) >> 2);
3574
3575     elfcpp::Swap<16, big_endian>::writeval(wv, insn);
3576     return ((val > 0x03fc)
3577             ? This::STATUS_OVERFLOW
3578             : This::STATUS_OKAY);
3579   }
3580
3581   // R_ARM_THM_PC12: S + A - Pa (Thumb32)
3582   static inline typename This::Status
3583   thm_pc12(unsigned char* view,
3584            const Sized_relobj<32, big_endian>* object,
3585            const Symbol_value<32>* psymval,
3586            Arm_address address)
3587   {
3588     typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3589     typedef typename elfcpp::Swap<32, big_endian>::Valtype Reltype;
3590     Valtype* wv = reinterpret_cast<Valtype*>(view);
3591     Reltype insn = (elfcpp::Swap<16, big_endian>::readval(wv) << 16)
3592                    | elfcpp::Swap<16, big_endian>::readval(wv + 1);
3593     // Determine a sign for the addend (positive if the U bit is 1).
3594     const int sign = (insn & 0x00800000) ? 1 : -1;
3595     int32_t addend = (insn & 0xfff);
3596     // Apply a sign to the added.
3597     addend *= sign;
3598
3599     int32_t x = (psymval->value(object, addend) - (address & 0xfffffffc));
3600     Reltype val = abs(x);
3601     // Mask out and apply the value and the U bit.
3602     insn = (insn & 0xff7ff000) | (val & 0xfff);
3603     // Set the U bit according to whether the value to go in the
3604     // place is positive.
3605     if (x >= 0)
3606       insn |= 0x00800000;
3607
3608     elfcpp::Swap<16, big_endian>::writeval(wv, insn >> 16);
3609     elfcpp::Swap<16, big_endian>::writeval(wv + 1, insn & 0xffff);
3610     return ((val > 0xfff) ?
3611             This::STATUS_OVERFLOW : This::STATUS_OKAY);
3612   }
3613
3614   // R_ARM_V4BX
3615   static inline typename This::Status
3616   v4bx(const Relocate_info<32, big_endian>* relinfo,
3617        unsigned char* view,
3618        const Arm_relobj<big_endian>* object,
3619        const Arm_address address,
3620        const bool is_interworking)
3621   {
3622
3623     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3624     Valtype* wv = reinterpret_cast<Valtype*>(view);
3625     Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3626
3627     // Ensure that we have a BX instruction.
3628     gold_assert((val & 0x0ffffff0) == 0x012fff10);
3629     const uint32_t reg = (val & 0xf);
3630     if (is_interworking && reg != 0xf)
3631       {
3632         Stub_table<big_endian>* stub_table =
3633             object->stub_table(relinfo->data_shndx);
3634         gold_assert(stub_table != NULL);
3635
3636         Arm_v4bx_stub* stub = stub_table->find_arm_v4bx_stub(reg);
3637         gold_assert(stub != NULL);
3638
3639         int32_t veneer_address =
3640             stub_table->address() + stub->offset() - 8 - address;
3641         gold_assert((veneer_address <= ARM_MAX_FWD_BRANCH_OFFSET)
3642                     && (veneer_address >= ARM_MAX_BWD_BRANCH_OFFSET));
3643         // Replace with a branch to veneer (B <addr>)
3644         val = (val & 0xf0000000) | 0x0a000000
3645               | ((veneer_address >> 2) & 0x00ffffff);
3646       }
3647     else
3648       {
3649         // Preserve Rm (lowest four bits) and the condition code
3650         // (highest four bits). Other bits encode MOV PC,Rm.
3651         val = (val & 0xf000000f) | 0x01a0f000;
3652       }
3653     elfcpp::Swap<32, big_endian>::writeval(wv, val);
3654     return This::STATUS_OKAY;
3655   }
3656
3657   // R_ARM_ALU_PC_G0_NC: ((S + A) | T) - P
3658   // R_ARM_ALU_PC_G0:    ((S + A) | T) - P
3659   // R_ARM_ALU_PC_G1_NC: ((S + A) | T) - P
3660   // R_ARM_ALU_PC_G1:    ((S + A) | T) - P
3661   // R_ARM_ALU_PC_G2:    ((S + A) | T) - P
3662   // R_ARM_ALU_SB_G0_NC: ((S + A) | T) - B(S)
3663   // R_ARM_ALU_SB_G0:    ((S + A) | T) - B(S)
3664   // R_ARM_ALU_SB_G1_NC: ((S + A) | T) - B(S)
3665   // R_ARM_ALU_SB_G1:    ((S + A) | T) - B(S)
3666   // R_ARM_ALU_SB_G2:    ((S + A) | T) - B(S)
3667   static inline typename This::Status
3668   arm_grp_alu(unsigned char* view,
3669         const Sized_relobj<32, big_endian>* object,
3670         const Symbol_value<32>* psymval,
3671         const int group,
3672         Arm_address address,
3673         Arm_address thumb_bit,
3674         bool check_overflow)
3675   {
3676     gold_assert(group >= 0 && group < 3);
3677     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3678     Valtype* wv = reinterpret_cast<Valtype*>(view);
3679     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3680
3681     // ALU group relocations are allowed only for the ADD/SUB instructions.
3682     // (0x00800000 - ADD, 0x00400000 - SUB)
3683     const Valtype opcode = insn & 0x01e00000;
3684     if (opcode != 0x00800000 && opcode != 0x00400000)
3685       return This::STATUS_BAD_RELOC;
3686
3687     // Determine a sign for the addend.
3688     const int sign = (opcode == 0x00800000) ? 1 : -1;
3689     // shifter = rotate_imm * 2
3690     const uint32_t shifter = (insn & 0xf00) >> 7;
3691     // Initial addend value.
3692     int32_t addend = insn & 0xff;
3693     // Rotate addend right by shifter.
3694     addend = (addend >> shifter) | (addend << (32 - shifter));
3695     // Apply a sign to the added.
3696     addend *= sign;
3697
3698     int32_t x = ((psymval->value(object, addend) | thumb_bit) - address);
3699     Valtype gn = Arm_relocate_functions::calc_grp_gn(abs(x), group);
3700     // Check for overflow if required
3701     if (check_overflow
3702         && (Arm_relocate_functions::calc_grp_residual(abs(x), group) != 0))
3703       return This::STATUS_OVERFLOW;
3704
3705     // Mask out the value and the ADD/SUB part of the opcode; take care
3706     // not to destroy the S bit.
3707     insn &= 0xff1ff000;
3708     // Set the opcode according to whether the value to go in the
3709     // place is negative.
3710     insn |= ((x < 0) ? 0x00400000 : 0x00800000);
3711     // Encode the offset (encoded Gn).
3712     insn |= gn;
3713
3714     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3715     return This::STATUS_OKAY;
3716   }
3717
3718   // R_ARM_LDR_PC_G0: S + A - P
3719   // R_ARM_LDR_PC_G1: S + A - P
3720   // R_ARM_LDR_PC_G2: S + A - P
3721   // R_ARM_LDR_SB_G0: S + A - B(S)
3722   // R_ARM_LDR_SB_G1: S + A - B(S)
3723   // R_ARM_LDR_SB_G2: S + A - B(S)
3724   static inline typename This::Status
3725   arm_grp_ldr(unsigned char* view,
3726         const Sized_relobj<32, big_endian>* object,
3727         const Symbol_value<32>* psymval,
3728         const int group,
3729         Arm_address address)
3730   {
3731     gold_assert(group >= 0 && group < 3);
3732     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3733     Valtype* wv = reinterpret_cast<Valtype*>(view);
3734     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3735
3736     const int sign = (insn & 0x00800000) ? 1 : -1;
3737     int32_t addend = (insn & 0xfff) * sign;
3738     int32_t x = (psymval->value(object, addend) - address);
3739     // Calculate the relevant G(n-1) value to obtain this stage residual.
3740     Valtype residual =
3741         Arm_relocate_functions::calc_grp_residual(abs(x), group - 1);
3742     if (residual >= 0x1000)
3743       return This::STATUS_OVERFLOW;
3744
3745     // Mask out the value and U bit.
3746     insn &= 0xff7ff000;
3747     // Set the U bit for non-negative values.
3748     if (x >= 0)
3749       insn |= 0x00800000;
3750     insn |= residual;
3751
3752     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3753     return This::STATUS_OKAY;
3754   }
3755
3756   // R_ARM_LDRS_PC_G0: S + A - P
3757   // R_ARM_LDRS_PC_G1: S + A - P
3758   // R_ARM_LDRS_PC_G2: S + A - P
3759   // R_ARM_LDRS_SB_G0: S + A - B(S)
3760   // R_ARM_LDRS_SB_G1: S + A - B(S)
3761   // R_ARM_LDRS_SB_G2: S + A - B(S)
3762   static inline typename This::Status
3763   arm_grp_ldrs(unsigned char* view,
3764         const Sized_relobj<32, big_endian>* object,
3765         const Symbol_value<32>* psymval,
3766         const int group,
3767         Arm_address address)
3768   {
3769     gold_assert(group >= 0 && group < 3);
3770     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3771     Valtype* wv = reinterpret_cast<Valtype*>(view);
3772     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3773
3774     const int sign = (insn & 0x00800000) ? 1 : -1;
3775     int32_t addend = (((insn & 0xf00) >> 4) + (insn & 0xf)) * sign;
3776     int32_t x = (psymval->value(object, addend) - address);
3777     // Calculate the relevant G(n-1) value to obtain this stage residual.
3778     Valtype residual =
3779         Arm_relocate_functions::calc_grp_residual(abs(x), group - 1);
3780    if (residual >= 0x100)
3781       return This::STATUS_OVERFLOW;
3782
3783     // Mask out the value and U bit.
3784     insn &= 0xff7ff0f0;
3785     // Set the U bit for non-negative values.
3786     if (x >= 0)
3787       insn |= 0x00800000;
3788     insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
3789
3790     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3791     return This::STATUS_OKAY;
3792   }
3793
3794   // R_ARM_LDC_PC_G0: S + A - P
3795   // R_ARM_LDC_PC_G1: S + A - P
3796   // R_ARM_LDC_PC_G2: S + A - P
3797   // R_ARM_LDC_SB_G0: S + A - B(S)
3798   // R_ARM_LDC_SB_G1: S + A - B(S)
3799   // R_ARM_LDC_SB_G2: S + A - B(S)
3800   static inline typename This::Status
3801   arm_grp_ldc(unsigned char* view,
3802       const Sized_relobj<32, big_endian>* object,
3803       const Symbol_value<32>* psymval,
3804       const int group,
3805       Arm_address address)
3806   {
3807     gold_assert(group >= 0 && group < 3);
3808     typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3809     Valtype* wv = reinterpret_cast<Valtype*>(view);
3810     Valtype insn = elfcpp::Swap<32, big_endian>::readval(wv);
3811
3812     const int sign = (insn & 0x00800000) ? 1 : -1;
3813     int32_t addend = ((insn & 0xff) << 2) * sign;
3814     int32_t x = (psymval->value(object, addend) - address);
3815     // Calculate the relevant G(n-1) value to obtain this stage residual.
3816     Valtype residual =
3817       Arm_relocate_functions::calc_grp_residual(abs(x), group - 1);
3818     if ((residual & 0x3) != 0 || residual >= 0x400)
3819       return This::STATUS_OVERFLOW;
3820
3821     // Mask out the value and U bit.
3822     insn &= 0xff7fff00;
3823     // Set the U bit for non-negative values.
3824     if (x >= 0)
3825       insn |= 0x00800000;
3826     insn |= (residual >> 2);
3827
3828     elfcpp::Swap<32, big_endian>::writeval(wv, insn);
3829     return This::STATUS_OKAY;
3830   }
3831 };
3832
3833 // Relocate ARM long branches.  This handles relocation types
3834 // R_ARM_CALL, R_ARM_JUMP24, R_ARM_PLT32 and R_ARM_XPC25.
3835 // If IS_WEAK_UNDEFINED_WITH_PLT is true.  The target symbol is weakly
3836 // undefined and we do not use PLT in this relocation.  In such a case,
3837 // the branch is converted into an NOP.
3838
3839 template<bool big_endian>
3840 typename Arm_relocate_functions<big_endian>::Status
3841 Arm_relocate_functions<big_endian>::arm_branch_common(
3842     unsigned int r_type,
3843     const Relocate_info<32, big_endian>* relinfo,
3844     unsigned char* view,
3845     const Sized_symbol<32>* gsym,
3846     const Arm_relobj<big_endian>* object,
3847     unsigned int r_sym,
3848     const Symbol_value<32>* psymval,
3849     Arm_address address,
3850     Arm_address thumb_bit,
3851     bool is_weakly_undefined_without_plt)
3852 {
3853   typedef typename elfcpp::Swap<32, big_endian>::Valtype Valtype;
3854   Valtype* wv = reinterpret_cast<Valtype*>(view);
3855   Valtype val = elfcpp::Swap<32, big_endian>::readval(wv);
3856      
3857   bool insn_is_b = (((val >> 28) & 0xf) <= 0xe)
3858                     && ((val & 0x0f000000UL) == 0x0a000000UL);
3859   bool insn_is_uncond_bl = (val & 0xff000000UL) == 0xeb000000UL;
3860   bool insn_is_cond_bl = (((val >> 28) & 0xf) < 0xe)
3861                           && ((val & 0x0f000000UL) == 0x0b000000UL);
3862   bool insn_is_blx = (val & 0xfe000000UL) == 0xfa000000UL;
3863   bool insn_is_any_branch = (val & 0x0e000000UL) == 0x0a000000UL;
3864
3865   // Check that the instruction is valid.
3866   if (r_type == elfcpp::R_ARM_CALL)
3867     {
3868       if (!insn_is_uncond_bl && !insn_is_blx)
3869         return This::STATUS_BAD_RELOC;
3870     }
3871   else if (r_type == elfcpp::R_ARM_JUMP24)
3872     {
3873       if (!insn_is_b && !insn_is_cond_bl)
3874         return This::STATUS_BAD_RELOC;
3875     }
3876   else if (r_type == elfcpp::R_ARM_PLT32)
3877     {
3878       if (!insn_is_any_branch)
3879         return This::STATUS_BAD_RELOC;
3880     }
3881   else if (r_type == elfcpp::R_ARM_XPC25)
3882     {
3883       // FIXME: AAELF document IH0044C does not say much about it other
3884       // than it being obsolete.
3885       if (!insn_is_any_branch)
3886         return This::STATUS_BAD_RELOC;
3887     }
3888   else
3889     gold_unreachable();
3890
3891   // A branch to an undefined weak symbol is turned into a jump to
3892   // the next instruction unless a PLT entry will be created.
3893   // Do the same for local undefined symbols.
3894   // The jump to the next instruction is optimized as a NOP depending
3895   // on the architecture.
3896   const Target_arm<big_endian>* arm_target =
3897     Target_arm<big_endian>::default_target();
3898   if (is_weakly_undefined_without_plt)
3899     {
3900       gold_assert(!parameters->options().relocatable());
3901       Valtype cond = val & 0xf0000000U;
3902       if (arm_target->may_use_arm_nop())
3903         val = cond | 0x0320f000;
3904       else
3905         val = cond | 0x01a00000;        // Using pre-UAL nop: mov r0, r0.
3906       elfcpp::Swap<32, big_endian>::writeval(wv, val);
3907       return This::STATUS_OKAY;
3908     }
3909  
3910   Valtype addend = utils::sign_extend<26>(val << 2);
3911   Valtype branch_target = psymval->value(object, addend);
3912   int32_t branch_offset = branch_target - address;
3913
3914   // We need a stub if the branch offset is too large or if we need
3915   // to switch mode.
3916   bool may_use_blx = arm_target->may_use_blx();
3917   Reloc_stub* stub = NULL;
3918
3919   if (!parameters->options().relocatable()
3920       && (utils::has_overflow<26>(branch_offset)
3921           || ((thumb_bit != 0)
3922               && !(may_use_blx && r_type == elfcpp::R_ARM_CALL))))
3923     {
3924       Valtype unadjusted_branch_target = psymval->value(object, 0);
3925
3926       Stub_type stub_type =
3927         Reloc_stub::stub_type_for_reloc(r_type, address,
3928                                         unadjusted_branch_target,
3929                                         (thumb_bit != 0));
3930       if (stub_type != arm_stub_none)
3931         {
3932           Stub_table<big_endian>* stub_table =
3933             object->stub_table(relinfo->data_shndx);
3934           gold_assert(stub_table != NULL);
3935
3936           Reloc_stub::Key stub_key(stub_type, gsym, object, r_sym, addend);
3937           stub = stub_table->find_reloc_stub(stub_key);
3938           gold_assert(stub != NULL);
3939           thumb_bit = stub->stub_template()->entry_in_thumb_mode() ? 1 : 0;
3940           branch_target = stub_table->address() + stub->offset() + addend;
3941           branch_offset = branch_target - address;
3942           gold_assert(!utils::has_overflow<26>(branch_offset));
3943         }
3944     }
3945
3946   // At this point, if we still need to switch mode, the instruction
3947   // must either be a BLX or a BL that can be converted to a BLX.
3948   if (thumb_bit != 0)
3949     {
3950       // Turn BL to BLX.
3951       gold_assert(may_use_blx && r_type == elfcpp::R_ARM_CALL);
3952       val = (val & 0xffffff) | 0xfa000000 | ((branch_offset & 2) << 23);
3953     }
3954
3955   val = utils::bit_select(val, (branch_offset >> 2), 0xffffffUL);
3956   elfcpp::Swap<32, big_endian>::writeval(wv, val);
3957   return (utils::has_overflow<26>(branch_offset)
3958           ? This::STATUS_OVERFLOW : This::STATUS_OKAY);
3959 }
3960
3961 // Relocate THUMB long branches.  This handles relocation types
3962 // R_ARM_THM_CALL, R_ARM_THM_JUMP24 and R_ARM_THM_XPC22.
3963 // If IS_WEAK_UNDEFINED_WITH_PLT is true.  The target symbol is weakly
3964 // undefined and we do not use PLT in this relocation.  In such a case,
3965 // the branch is converted into an NOP.
3966
3967 template<bool big_endian>
3968 typename Arm_relocate_functions<big_endian>::Status
3969 Arm_relocate_functions<big_endian>::thumb_branch_common(
3970     unsigned int r_type,
3971     const Relocate_info<32, big_endian>* relinfo,
3972     unsigned char* view,
3973     const Sized_symbol<32>* gsym,
3974     const Arm_relobj<big_endian>* object,
3975     unsigned int r_sym,
3976     const Symbol_value<32>* psymval,
3977     Arm_address address,
3978     Arm_address thumb_bit,
3979     bool is_weakly_undefined_without_plt)
3980 {
3981   typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
3982   Valtype* wv = reinterpret_cast<Valtype*>(view);
3983   uint32_t upper_insn = elfcpp::Swap<16, big_endian>::readval(wv);
3984   uint32_t lower_insn = elfcpp::Swap<16, big_endian>::readval(wv + 1);
3985
3986   // FIXME: These tests are too loose and do not take THUMB/THUMB-2 difference
3987   // into account.
3988   bool is_bl_insn = (lower_insn & 0x1000U) == 0x1000U;
3989   bool is_blx_insn = (lower_insn & 0x1000U) == 0x0000U;
3990      
3991   // Check that the instruction is valid.
3992   if (r_type == elfcpp::R_ARM_THM_CALL)
3993     {
3994       if (!is_bl_insn && !is_blx_insn)
3995         return This::STATUS_BAD_RELOC;
3996     }
3997   else if (r_type == elfcpp::R_ARM_THM_JUMP24)
3998     {
3999       // This cannot be a BLX.
4000       if (!is_bl_insn)
4001         return This::STATUS_BAD_RELOC;
4002     }
4003   else if (r_type == elfcpp::R_ARM_THM_XPC22)
4004     {
4005       // Check for Thumb to Thumb call.
4006       if (!is_blx_insn)
4007         return This::STATUS_BAD_RELOC;
4008       if (thumb_bit != 0)
4009         {
4010           gold_warning(_("%s: Thumb BLX instruction targets "
4011                          "thumb function '%s'."),
4012                          object->name().c_str(),
4013                          (gsym ? gsym->name() : "(local)")); 
4014           // Convert BLX to BL.
4015           lower_insn |= 0x1000U;
4016         }
4017     }
4018   else
4019     gold_unreachable();
4020
4021   // A branch to an undefined weak symbol is turned into a jump to
4022   // the next instruction unless a PLT entry will be created.
4023   // The jump to the next instruction is optimized as a NOP.W for
4024   // Thumb-2 enabled architectures.
4025   const Target_arm<big_endian>* arm_target =
4026     Target_arm<big_endian>::default_target();
4027   if (is_weakly_undefined_without_plt)
4028     {
4029       gold_assert(!parameters->options().relocatable());
4030       if (arm_target->may_use_thumb2_nop())
4031         {
4032           elfcpp::Swap<16, big_endian>::writeval(wv, 0xf3af);
4033           elfcpp::Swap<16, big_endian>::writeval(wv + 1, 0x8000);
4034         }
4035       else
4036         {
4037           elfcpp::Swap<16, big_endian>::writeval(wv, 0xe000);
4038           elfcpp::Swap<16, big_endian>::writeval(wv + 1, 0xbf00);
4039         }
4040       return This::STATUS_OKAY;
4041     }
4042  
4043   int32_t addend = This::thumb32_branch_offset(upper_insn, lower_insn);
4044   Arm_address branch_target = psymval->value(object, addend);
4045
4046   // For BLX, bit 1 of target address comes from bit 1 of base address.
4047   bool may_use_blx = arm_target->may_use_blx();
4048   if (thumb_bit == 0 && may_use_blx)
4049     branch_target = utils::bit_select(branch_target, address, 0x2);
4050
4051   int32_t branch_offset = branch_target - address;
4052
4053   // We need a stub if the branch offset is too large or if we need
4054   // to switch mode.
4055   bool thumb2 = arm_target->using_thumb2();
4056   if (!parameters->options().relocatable()
4057       && ((!thumb2 && utils::has_overflow<23>(branch_offset))
4058           || (thumb2 && utils::has_overflow<25>(branch_offset))
4059           || ((thumb_bit == 0)
4060               && (((r_type == elfcpp::R_ARM_THM_CALL) && !may_use_blx)
4061                   || r_type == elfcpp::R_ARM_THM_JUMP24))))
4062     {
4063       Arm_address unadjusted_branch_target = psymval->value(object, 0);
4064
4065       Stub_type stub_type =
4066         Reloc_stub::stub_type_for_reloc(r_type, address,
4067                                         unadjusted_branch_target,
4068                                         (thumb_bit != 0));
4069
4070       if (stub_type != arm_stub_none)
4071         {
4072           Stub_table<big_endian>* stub_table =
4073             object->stub_table(relinfo->data_shndx);
4074           gold_assert(stub_table != NULL);
4075
4076           Reloc_stub::Key stub_key(stub_type, gsym, object, r_sym, addend);
4077           Reloc_stub* stub = stub_table->find_reloc_stub(stub_key);
4078           gold_assert(stub != NULL);
4079           thumb_bit = stub->stub_template()->entry_in_thumb_mode() ? 1 : 0;
4080           branch_target = stub_table->address() + stub->offset() + addend;
4081           if (thumb_bit == 0 && may_use_blx) 
4082             branch_target = utils::bit_select(branch_target, address, 0x2);
4083           branch_offset = branch_target - address;
4084         }
4085     }
4086
4087   // At this point, if we still need to switch mode, the instruction
4088   // must either be a BLX or a BL that can be converted to a BLX.
4089   if (thumb_bit == 0)
4090     {
4091       gold_assert(may_use_blx
4092                   && (r_type == elfcpp::R_ARM_THM_CALL
4093                       || r_type == elfcpp::R_ARM_THM_XPC22));
4094       // Make sure this is a BLX.
4095       lower_insn &= ~0x1000U;
4096     }
4097   else
4098     {
4099       // Make sure this is a BL.
4100       lower_insn |= 0x1000U;
4101     }
4102
4103   // For a BLX instruction, make sure that the relocation is rounded up
4104   // to a word boundary.  This follows the semantics of the instruction
4105   // which specifies that bit 1 of the target address will come from bit
4106   // 1 of the base address.
4107   if ((lower_insn & 0x5000U) == 0x4000U)
4108     gold_assert((branch_offset & 3) == 0);
4109
4110   // Put BRANCH_OFFSET back into the insn.  Assumes two's complement.
4111   // We use the Thumb-2 encoding, which is safe even if dealing with
4112   // a Thumb-1 instruction by virtue of our overflow check above.  */
4113   upper_insn = This::thumb32_branch_upper(upper_insn, branch_offset);
4114   lower_insn = This::thumb32_branch_lower(lower_insn, branch_offset);
4115
4116   elfcpp::Swap<16, big_endian>::writeval(wv, upper_insn);
4117   elfcpp::Swap<16, big_endian>::writeval(wv + 1, lower_insn);
4118
4119   gold_assert(!utils::has_overflow<25>(branch_offset));
4120
4121   return ((thumb2
4122            ? utils::has_overflow<25>(branch_offset)
4123            : utils::has_overflow<23>(branch_offset))
4124           ? This::STATUS_OVERFLOW
4125           : This::STATUS_OKAY);
4126 }
4127
4128 // Relocate THUMB-2 long conditional branches.
4129 // If IS_WEAK_UNDEFINED_WITH_PLT is true.  The target symbol is weakly
4130 // undefined and we do not use PLT in this relocation.  In such a case,
4131 // the branch is converted into an NOP.
4132
4133 template<bool big_endian>
4134 typename Arm_relocate_functions<big_endian>::Status
4135 Arm_relocate_functions<big_endian>::thm_jump19(
4136     unsigned char* view,
4137     const Arm_relobj<big_endian>* object,
4138     const Symbol_value<32>* psymval,
4139     Arm_address address,
4140     Arm_address thumb_bit)
4141 {
4142   typedef typename elfcpp::Swap<16, big_endian>::Valtype Valtype;
4143   Valtype* wv = reinterpret_cast<Valtype*>(view);
4144   uint32_t upper_insn = elfcpp::Swap<16, big_endian>::readval(wv);
4145   uint32_t lower_insn = elfcpp::Swap<16, big_endian>::readval(wv + 1);
4146   int32_t addend = This::thumb32_cond_branch_offset(upper_insn, lower_insn);
4147
4148   Arm_address branch_target = psymval->value(object, addend);
4149   int32_t branch_offset = branch_target - address;
4150
4151   // ??? Should handle interworking?  GCC might someday try to
4152   // use this for tail calls.
4153   // FIXME: We do support thumb entry to PLT yet.
4154   if (thumb_bit == 0)
4155     {
4156       gold_error(_("conditional branch to PLT in THUMB-2 not supported yet."));
4157       return This::STATUS_BAD_RELOC;
4158     }
4159
4160   // Put RELOCATION back into the insn.
4161   upper_insn = This::thumb32_cond_branch_upper(upper_insn, branch_offset);
4162   lower_insn = This::thumb32_cond_branch_lower(lower_insn, branch_offset);
4163
4164   // Put the relocated value back in the object file:
4165   elfcpp::Swap<16, big_endian>::writeval(wv, upper_insn);
4166   elfcpp::Swap<16, big_endian>::writeval(wv + 1, lower_insn);
4167
4168   return (utils::has_overflow<21>(branch_offset)
4169           ? This::STATUS_OVERFLOW
4170           : This::STATUS_OKAY);
4171 }
4172
4173 // Get the GOT section, creating it if necessary.
4174
4175 template<bool big_endian>
4176 Arm_output_data_got<big_endian>*
4177 Target_arm<big_endian>::got_section(Symbol_table* symtab, Layout* layout)
4178 {
4179   if (this->got_ == NULL)
4180     {
4181       gold_assert(symtab != NULL && layout != NULL);
4182
4183       this->got_ = new Arm_output_data_got<big_endian>(symtab, layout);
4184
4185       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
4186                                       (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE),
4187                                       this->got_, ORDER_DATA, false);
4188
4189       // The old GNU linker creates a .got.plt section.  We just
4190       // create another set of data in the .got section.  Note that we
4191       // always create a PLT if we create a GOT, although the PLT
4192       // might be empty.
4193       this->got_plt_ = new Output_data_space(4, "** GOT PLT");
4194       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
4195                                       (elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE),
4196                                       this->got_plt_, ORDER_DATA, false);
4197
4198       // The first three entries are reserved.
4199       this->got_plt_->set_current_data_size(3 * 4);
4200
4201       // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
4202       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
4203                                     Symbol_table::PREDEFINED,
4204                                     this->got_plt_,
4205                                     0, 0, elfcpp::STT_OBJECT,
4206                                     elfcpp::STB_LOCAL,
4207                                     elfcpp::STV_HIDDEN, 0,
4208                                     false, false);
4209     }
4210   return this->got_;
4211 }
4212
4213 // Get the dynamic reloc section, creating it if necessary.
4214
4215 template<bool big_endian>
4216 typename Target_arm<big_endian>::Reloc_section*
4217 Target_arm<big_endian>::rel_dyn_section(Layout* layout)
4218 {
4219   if (this->rel_dyn_ == NULL)
4220     {
4221       gold_assert(layout != NULL);
4222       this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
4223       layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
4224                                       elfcpp::SHF_ALLOC, this->rel_dyn_,
4225                                       ORDER_DYNAMIC_RELOCS, false);
4226     }
4227   return this->rel_dyn_;
4228 }
4229
4230 // Insn_template methods.
4231
4232 // Return byte size of an instruction template.
4233
4234 size_t
4235 Insn_template::size() const
4236 {
4237   switch (this->type())
4238     {
4239     case THUMB16_TYPE:
4240     case THUMB16_SPECIAL_TYPE:
4241       return 2;
4242     case ARM_TYPE:
4243     case THUMB32_TYPE:
4244     case DATA_TYPE:
4245       return 4;
4246     default:
4247       gold_unreachable();
4248     }
4249 }
4250
4251 // Return alignment of an instruction template.
4252
4253 unsigned
4254 Insn_template::alignment() const
4255 {
4256   switch (this->type())
4257     {
4258     case THUMB16_TYPE:
4259     case THUMB16_SPECIAL_TYPE:
4260     case THUMB32_TYPE:
4261       return 2;
4262     case ARM_TYPE:
4263     case DATA_TYPE:
4264       return 4;
4265     default:
4266       gold_unreachable();
4267     }
4268 }
4269
4270 // Stub_template methods.
4271
4272 Stub_template::Stub_template(
4273     Stub_type type, const Insn_template* insns,
4274      size_t insn_count)
4275   : type_(type), insns_(insns), insn_count_(insn_count), alignment_(1),
4276     entry_in_thumb_mode_(false), relocs_()
4277 {
4278   off_t offset = 0;
4279
4280   // Compute byte size and alignment of stub template.
4281   for (size_t i = 0; i < insn_count; i++)
4282     {
4283       unsigned insn_alignment = insns[i].alignment();
4284       size_t insn_size = insns[i].size();
4285       gold_assert((offset & (insn_alignment - 1)) == 0);
4286       this->alignment_ = std::max(this->alignment_, insn_alignment);
4287       switch (insns[i].type())
4288         {
4289         case Insn_template::THUMB16_TYPE:
4290         case Insn_template::THUMB16_SPECIAL_TYPE:
4291           if (i == 0)
4292             this->entry_in_thumb_mode_ = true;
4293           break;
4294
4295         case Insn_template::THUMB32_TYPE:
4296           if (insns[i].r_type() != elfcpp::R_ARM_NONE)
4297             this->relocs_.push_back(Reloc(i, offset));
4298           if (i == 0)
4299             this->entry_in_thumb_mode_ = true;
4300           break;
4301
4302         case Insn_template::ARM_TYPE:
4303           // Handle cases where the target is encoded within the
4304           // instruction.
4305           if (insns[i].r_type() == elfcpp::R_ARM_JUMP24)
4306             this->relocs_.push_back(Reloc(i, offset));
4307           break;
4308
4309         case Insn_template::DATA_TYPE:
4310           // Entry point cannot be data.
4311           gold_assert(i != 0);
4312           this->relocs_.push_back(Reloc(i, offset));
4313           break;
4314
4315         default:
4316           gold_unreachable();
4317         }
4318       offset += insn_size; 
4319     }
4320   this->size_ = offset;
4321 }
4322
4323 // Stub methods.
4324
4325 // Template to implement do_write for a specific target endianness.
4326
4327 template<bool big_endian>
4328 void inline
4329 Stub::do_fixed_endian_write(unsigned char* view, section_size_type view_size)
4330 {
4331   const Stub_template* stub_template = this->stub_template();
4332   const Insn_template* insns = stub_template->insns();
4333
4334   // FIXME:  We do not handle BE8 encoding yet.
4335   unsigned char* pov = view;
4336   for (size_t i = 0; i < stub_template->insn_count(); i++)
4337     {
4338       switch (insns[i].type())
4339         {
4340         case Insn_template::THUMB16_TYPE:
4341           elfcpp::Swap<16, big_endian>::writeval(pov, insns[i].data() & 0xffff);
4342           break;
4343         case Insn_template::THUMB16_SPECIAL_TYPE:
4344           elfcpp::Swap<16, big_endian>::writeval(
4345               pov,
4346               this->thumb16_special(i));
4347           break;
4348         case Insn_template::THUMB32_TYPE:
4349           {
4350             uint32_t hi = (insns[i].data() >> 16) & 0xffff;
4351             uint32_t lo = insns[i].data() & 0xffff;
4352             elfcpp::Swap<16, big_endian>::writeval(pov, hi);
4353