[binutils] Bump binutils to 2.20.1

binutils/gold/powerpc.cc

 // powerpc.cc -- powerpc target support for gold.
 
 // Copyright 2008, 2009 Free Software Foundation, Inc.
 // Written by David S. Miller <davem@davemloft.net>
 //        and David Edelsohn <edelsohn@gnu.org>
 
 // 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 695 matching lines @@
                                               Layout* layout)
 {
   if (this->got_ == NULL)
     {
       gold_assert(symtab != NULL && layout != NULL);
 
       this->got_ = new Output_data_got<size, big_endian>();
 
       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
                                       elfcpp::SHF_ALLOC | elfcpp::SHF_WRITE,
-                                      this->got_);
+                                      this->got_, false);
 
       // Create the GOT2 or TOC in the .got section.
       if (size == 32)
         {
           this->got2_ = new Output_data_space(4, "** GOT2");
           layout->add_output_section_data(".got2", elfcpp::SHT_PROGBITS,
                                           elfcpp::SHF_ALLOC
                                           | elfcpp::SHF_WRITE,
-                                          this->got2_);
+                                          this->got2_, false);
         }
       else
         {
           this->toc_ = new Output_data_space(8, "** TOC");
           layout->add_output_section_data(".toc", elfcpp::SHT_PROGBITS,
                                           elfcpp::SHF_ALLOC
                                           | elfcpp::SHF_WRITE,
-                                          this->toc_);
+                                          this->toc_, false);
         }
 
       // Define _GLOBAL_OFFSET_TABLE_ at the start of the .got section.
       symtab->define_in_output_data("_GLOBAL_OFFSET_TABLE_", NULL,
                                     this->got_,
                                     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<int size, bool big_endian>
 typename Target_powerpc<size, big_endian>::Reloc_section*
 Target_powerpc<size, big_endian>::rela_dyn_section(Layout* layout)
 {
   if (this->rela_dyn_ == NULL)
     {
       gold_assert(layout != NULL);
       this->rela_dyn_ = new Reloc_section(parameters->options().combreloc());
       layout->add_output_section_data(".rela.dyn", elfcpp::SHT_RELA,
-                                      elfcpp::SHF_ALLOC, this->rela_dyn_);
+                                      elfcpp::SHF_ALLOC, this->rela_dyn_, true);
     }
   return this->rela_dyn_;
 }
 
 // A class to handle the PLT data.
 
 template<int size, bool big_endian>
 class Output_data_plt_powerpc : public Output_section_data
 {
  public:
@@ skipping 39 matching lines @@
 
 // Create the PLT section.  The ordinary .got section is an argument,
 // since we need to refer to the start.
 
 template<int size, bool big_endian>
 Output_data_plt_powerpc<size, big_endian>::Output_data_plt_powerpc(Layout* layout)
   : Output_section_data(size == 32 ? 4 : 8), count_(0)
 {
   this->rel_ = new Reloc_section(false);
   layout->add_output_section_data(".rela.plt", elfcpp::SHT_RELA,
-                                  elfcpp::SHF_ALLOC, this->rel_);
+                                  elfcpp::SHF_ALLOC, this->rel_, true);
 }
 
 template<int size, bool big_endian>
 void
 Output_data_plt_powerpc<size, big_endian>::do_adjust_output_section(Output_section* os)
 {
   os->set_entsize(0);
 }
 
 // Add an entry to the PLT.
@@ skipping 108 matching lines @@
   if (this->plt_ == NULL)
     {
       // Create the GOT section first.
       this->got_section(symtab, layout);
 
       this->plt_ = new Output_data_plt_powerpc<size, big_endian>(layout);
       layout->add_output_section_data(".plt", elfcpp::SHT_PROGBITS,
                                       (elfcpp::SHF_ALLOC
                                        | elfcpp::SHF_EXECINSTR
                                        | elfcpp::SHF_WRITE),
-                                      this->plt_);
+                                      this->plt_, false);
 
       // Define _PROCEDURE_LINKAGE_TABLE_ at the start of the .plt section.
       symtab->define_in_output_data("_PROCEDURE_LINKAGE_TABLE_", NULL,
                                     this->plt_,
                                     0, 0, elfcpp::STT_OBJECT,
                                     elfcpp::STB_LOCAL,
                                     elfcpp::STV_HIDDEN, 0,
                                     false, false);
     }
 
@@ skipping 546 matching lines @@
     }
 
   // Define _SDA_BASE_ at the start of the .sdata section.
   if (sdata == NULL)
   {
     // layout->find_output_section(".sdata") == NULL
     sdata = new Output_data_space(4, "** sdata");
     Output_section* os = layout->add_output_section_data(".sdata", 0,
                                                          elfcpp::SHF_ALLOC
                                                          | elfcpp::SHF_WRITE,
-                                                         sdata);
+                                                         sdata, false);
     symtab->define_in_output_data("_SDA_BASE_", NULL,
                                   os,
                                   32768, 0,
                                   elfcpp::STT_OBJECT,
                                   elfcpp::STB_LOCAL,
                                   elfcpp::STV_HIDDEN, 0,
                                   false, false);
   }
 
   gold::scan_relocs<size, big_endian, Powerpc, elfcpp::SHT_RELA, Scan>(
@@ skipping 14 matching lines @@
 // Finalize the sections.
 
 template<int size, bool big_endian>
 void
 Target_powerpc<size, 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->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_RELA);
 
           odyn->add_section_address(elfcpp::DT_PLTGOT, this->plt_);
         }
 
-      if (this->rela_dyn_ != NULL)
+      if (this->rela_dyn_ != NULL
+          && this->rela_dyn_->output_section() != NULL)
         {
           const Output_data* od = this->rela_dyn_;
           odyn->add_section_address(elfcpp::DT_RELA, od);
           odyn->add_section_size(elfcpp::DT_RELASZ, od);
           odyn->add_constant(elfcpp::DT_RELAENT,
                              elfcpp::Elf_sizes<size>::rela_size);
         }
 
       if (!parameters->options().shared())
         {
@@ skipping 445 matching lines @@
   Target* do_instantiate_target()
   { return new Target_powerpc<size, big_endian>(); }
 };
 
 Target_selector_powerpc<32, true> target_selector_ppc32;
 Target_selector_powerpc<32, false> target_selector_ppc32le;
 Target_selector_powerpc<64, true> target_selector_ppc64;
 Target_selector_powerpc<64, false> target_selector_ppc64le;
 
 } // End anonymous namespace.