[binutils] Bump binutils to 2.20.1

binutils/gold/arm.cc

 // arm.cc -- arm target support for gold.
 
 // Copyright 2009 Free Software Foundation, Inc.
 // Written by Doug Kwan <dougkwan@google.com> based on the i386 code
 // by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
 
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ skipping 1057 matching lines @@
   if (this->got_ == NULL)
     {
       gold_assert(symtab != NULL && layout != NULL);
 
       this->got_ = new Output_data_got<32, big_endian>();
 
       Output_section* os;
       os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
                                            (elfcpp::SHF_ALLOC
                                             | elfcpp::SHF_WRITE),
-                                           this->got_);
+                                           this->got_, false);
       os->set_is_relro();
 
       // The old GNU linker creates a .got.plt section.  We just
       // create another set of data in the .got section.  Note that we
       // always create a PLT if we create a GOT, although the PLT
       // might be empty.
       this->got_plt_ = new Output_data_space(4, "** GOT PLT");
       os = layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
                                            (elfcpp::SHF_ALLOC
                                             | elfcpp::SHF_WRITE),
-                                           this->got_plt_);
+                                           this->got_plt_, false);
       os->set_is_relro();
 
       // The first three entries are reserved.
       this->got_plt_->set_current_data_size(3 * 4);
 
       // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
                                     this->got_plt_,
                                     0, 0, elfcpp::STT_OBJECT,
                                     elfcpp::STB_LOCAL,
                                     elfcpp::STV_HIDDEN, 0,
                                     false, false);
     }
   return this->got_;
 }
 
 // Get the dynamic reloc section, creating it if necessary.
 
 template<bool big_endian>
 typename Target_arm<big_endian>::Reloc_section*
 Target_arm<big_endian>::rel_dyn_section(Layout* layout)
 {
   if (this->rel_dyn_ == NULL)
     {
       gold_assert(layout != NULL);
       this->rel_dyn_ = new Reloc_section(parameters->options().combreloc());
       layout->add_output_section_data(".rel.dyn", elfcpp::SHT_REL,
-                                      elfcpp::SHF_ALLOC, this->rel_dyn_);
+                                      elfcpp::SHF_ALLOC, this->rel_dyn_, true);
     }
   return this->rel_dyn_;
 }
 
 // A class to handle the PLT data.
 
 template<bool big_endian>
 class Output_data_plt_arm : public Output_section_data
 {
  public:
@@ skipping 51 matching lines @@
 // since we need to refer to the start.  We also create our own .got
 // section just for PLT entries.
 
 template<bool big_endian>
 Output_data_plt_arm<big_endian>::Output_data_plt_arm(Layout* layout,
                                                      Output_data_space* got_plt)
   : Output_section_data(4), got_plt_(got_plt), count_(0)
 {
   this->rel_ = new Reloc_section(false);
   layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
-                                  elfcpp::SHF_ALLOC, this->rel_);
+                                  elfcpp::SHF_ALLOC, this->rel_, true);
 }
 
 template<bool big_endian>
 void
 Output_data_plt_arm<big_endian>::do_adjust_output_section(Output_section* os)
 {
   os->set_entsize(0);
 }
 
 // Add an entry to the PLT.
@@ skipping 141 matching lines @@
 
   if (this->plt_ == NULL)
     {
       // Create the GOT sections first.
       this->got_section(symtab, layout);
 
       this->plt_ = new Output_data_plt_arm<big_endian>(layout, this->got_plt_);
       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
                                       (elfcpp::SHF_ALLOC
                                        | elfcpp::SHF_EXECINSTR),
-                                      this->plt_);
+                                      this->plt_, false);
     }
   this->plt_->add_entry(gsym);
 }
 
 // Report an unsupported relocation against a local symbol.
 
 template<bool big_endian>
 void
 Target_arm<big_endian>::Scan::unsupported_reloc_local(
     Sized_relobj<32, big_endian>* object,
@@ skipping 462 matching lines @@
 // Finalize the sections.
 
 template<bool big_endian>
 void
 Target_arm<big_endian>::do_finalize_sections(Layout* layout)
 {
   // Fill in some more dynamic tags.
   Output_data_dynamic* const odyn = layout->dynamic_data();
   if (odyn != NULL)
     {
-      if (this->got_plt_ != NULL)
+      if (this->got_plt_ != NULL
+          && this->got_plt_->output_section() != NULL)
         odyn->add_section_address(elfcpp::DT_PLTGOT, this->got_plt_);
 
-      if (this->plt_ != NULL)
+      if (this->plt_ != NULL
+          && this->plt_->output_section() != NULL)
         {
           const Output_data* od = this->plt_->rel_plt();
           odyn->add_section_size(elfcpp::DT_PLTRELSZ, od);
           odyn->add_section_address(elfcpp::DT_JMPREL, od);
           odyn->add_constant(elfcpp::DT_PLTREL, elfcpp::DT_REL);
         }
 
-      if (this->rel_dyn_ != NULL)
+      if (this->rel_dyn_ != NULL
+          && this->rel_dyn_->output_section() != NULL)
         {
           const Output_data* od = this->rel_dyn_;
           odyn->add_section_address(elfcpp::DT_REL, od);
           odyn->add_section_size(elfcpp::DT_RELSZ, od);
           odyn->add_constant(elfcpp::DT_RELENT,
                              elfcpp::Elf_sizes<32>::rel_size);
         }
 
       if (!parameters->options().shared())
         {
@@ skipping 16 matching lines @@
       Output_section* exidx_section =
         layout->find_output_section(".ARM.exidx");
 
       if (exidx_section != NULL
           && exidx_section->type() == elfcpp::SHT_ARM_EXIDX)
         {
           gold_assert(layout->find_output_segment(elfcpp::PT_ARM_EXIDX, 0, 0)
                       == NULL);
           Output_segment*  exidx_segment =
             layout->make_output_segment(elfcpp::PT_ARM_EXIDX, elfcpp::PF_R);
-          exidx_segment->add_output_section(exidx_section, elfcpp::PF_R);
+          exidx_segment->add_output_section(exidx_section, elfcpp::PF_R,
+                                            false);
         }
     }
 }
 
 // Return whether a direct absolute static relocation needs to be applied.
 // In cases where Scan::local() or Scan::global() has created
 // a dynamic relocation other than R_ARM_RELATIVE, the addend
 // of the relocation is carried in the data, and we must not
 // apply the static relocation.
 
@@ skipping 585 matching lines @@
 
   Target*
   do_instantiate_target()
   { return new Target_arm<big_endian>(); }
 };
 
 Target_selector_arm<false> target_selector_arm;
 Target_selector_arm<true> target_selector_armbe;
 
 } // End anonymous namespace.