gold/
authorRoland McGrath <roland@gnu.org>
Tue, 27 Aug 2013 21:49:48 +0000 (21:49 +0000)
committerRoland McGrath <roland@gnu.org>
Tue, 27 Aug 2013 21:49:48 +0000 (21:49 +0000)
* output.cc (Output_segment::set_section_addresses): Take new
Target* argument.  If target->isolate_execinstr() and the segment
is executable and starts at a target->abi_pagesize() boundary,
pad its end out to a target->abi_pagesize() boundary with code fill.
* output.h (Output_segment::set_section_addresses): Update decl.
* layout.h (Layout::check_output_data_for_reset_values): Take new
argument RELAX_OUTPUTS.
(Layout): New member relax_output_list_.
(Layout::add_relax_output): New method.
* layout.cc (Layout::Layout): Update constructor.
(Layout::reset_relax_output): New method.
(Layout::clean_up_after_relaxation): Call it.
(Layout::prepare_for_relaxation): Update caller.
(Layout::set_segment_offsets): Update callers of set_section_addresses.
Call reset_relax_output before re-processing segments for
isolate_execinstr case.
(Layout::write_data): Handle relax_output_list_.
(Layout::Relaxation_debug_check::check_output_data_for_reset_values):
Take new argument RELAX_OUTPUTS.  Assert it's an empty collection.

gold/ChangeLog
gold/layout.cc
gold/layout.h
gold/output.cc
gold/output.h

index 324d8bc..df61e9c 100644 (file)
@@ -1,3 +1,25 @@
+2013-08-27  Roland McGrath  <mcgrathr@google.com>
+
+       * output.cc (Output_segment::set_section_addresses): Take new
+       Target* argument.  If target->isolate_execinstr() and the segment
+       is executable and starts at a target->abi_pagesize() boundary,
+       pad its end out to a target->abi_pagesize() boundary with code fill.
+       * output.h (Output_segment::set_section_addresses): Update decl.
+       * layout.h (Layout::check_output_data_for_reset_values): Take new
+       argument RELAX_OUTPUTS.
+       (Layout): New member relax_output_list_.
+       (Layout::add_relax_output): New method.
+       * layout.cc (Layout::Layout): Update constructor.
+       (Layout::reset_relax_output): New method.
+       (Layout::clean_up_after_relaxation): Call it.
+       (Layout::prepare_for_relaxation): Update caller.
+       (Layout::set_segment_offsets): Update callers of set_section_addresses.
+       Call reset_relax_output before re-processing segments for
+       isolate_execinstr case.
+       (Layout::write_data): Handle relax_output_list_.
+       (Layout::Relaxation_debug_check::check_output_data_for_reset_values):
+       Take new argument RELAX_OUTPUTS.  Assert it's an empty collection.
+
 2013-08-23  Yuri Chornoivan  <yurchor@ukr.net>
 
        PR binutils/15834
index 07dbc9b..38fd272 100644 (file)
@@ -293,7 +293,8 @@ Hash_task::is_runnable()
 void
 Layout::Relaxation_debug_check::check_output_data_for_reset_values(
     const Layout::Section_list& sections,
-    const Layout::Data_list& special_outputs)
+    const Layout::Data_list& special_outputs,
+    const Layout::Data_list& relax_outputs)
 {
   for(Layout::Section_list::const_iterator p = sections.begin();
       p != sections.end();
@@ -304,6 +305,8 @@ Layout::Relaxation_debug_check::check_output_data_for_reset_values(
       p != special_outputs.end();
       ++p)
     gold_assert((*p)->address_and_file_offset_have_reset_values());
+
+  gold_assert(relax_outputs.empty());
 }
 
 // Save information of SECTIONS for checking later.
@@ -428,6 +431,7 @@ Layout::Layout(int number_of_input_files, Script_options* script_options)
     section_list_(),
     unattached_section_list_(),
     special_output_list_(),
+    relax_output_list_(),
     section_headers_(NULL),
     tls_segment_(NULL),
     relro_segment_(NULL),
@@ -2341,6 +2345,20 @@ Layout::clean_up_after_relaxation()
        ++p)
     delete *p;
   this->script_output_section_data_list_.clear();
+
+  // Special-case fill output objects are recreated each time through
+  // the relaxation loop.
+  this->reset_relax_output();
+}
+
+void
+Layout::reset_relax_output()
+{
+  for (Data_list::const_iterator p = this->relax_output_list_.begin();
+       p != this->relax_output_list_.end();
+       ++p)
+    delete *p;
+  this->relax_output_list_.clear();
 }
 
 // Prepare for relaxation.
@@ -2363,7 +2381,8 @@ Layout::prepare_for_relaxation()
 
   if (is_debugging_enabled(DEBUG_RELAXATION))
     this->relaxation_debug_check_->check_output_data_for_reset_values(
-       this->section_list_, this->special_output_list_);
+       this->section_list_, this->special_output_list_,
+       this->relax_output_list_);
 
   // Also enable recording of output section data from scripts.
   this->record_output_section_data_from_script_ = true;
@@ -3540,7 +3559,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
 
          unsigned int shndx_hold = *pshndx;
          bool has_relro = false;
-         uint64_t new_addr = (*p)->set_section_addresses(this, false, addr,
+         uint64_t new_addr = (*p)->set_section_addresses(target, this,
+                                                         false, addr,
                                                          &increase_relro,
                                                          &has_relro,
                                                          &off, pshndx);
@@ -3581,7 +3601,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
                    increase_relro = 0;
                  has_relro = false;
 
-                 new_addr = (*p)->set_section_addresses(this, true, addr,
+                 new_addr = (*p)->set_section_addresses(target, this,
+                                                        true, addr,
                                                         &increase_relro,
                                                         &has_relro,
                                                         &off, pshndx);
@@ -3617,6 +3638,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
       // so they land after the segments starting at LOAD_SEG.
       off = align_file_offset(off, 0, target->abi_pagesize());
 
+      this->reset_relax_output();
+
       for (Segment_list::iterator p = this->segment_list_.begin();
           *p != load_seg;
           ++p)
@@ -3630,8 +3653,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
              bool has_relro = false;
              const uint64_t old_addr = (*p)->vaddr();
              const uint64_t old_end = old_addr + (*p)->memsz();
-             uint64_t new_addr = (*p)->set_section_addresses(this, true,
-                                                             old_addr,
+             uint64_t new_addr = (*p)->set_section_addresses(target, this,
+                                                             true, old_addr,
                                                              &increase_relro,
                                                              &has_relro,
                                                              &off,
@@ -5268,6 +5291,13 @@ Layout::write_data(const Symbol_table* symtab, Output_file* of) const
        p != this->special_output_list_.end();
        ++p)
     (*p)->write(of);
+
+  // Write out the Output_data which are not in an Output_section
+  // and are regenerated in each iteration of relaxation.
+  for (Data_list::const_iterator p = this->relax_output_list_.begin();
+       p != this->relax_output_list_.end();
+       ++p)
+    (*p)->write(of);
 }
 
 // Write out the Output_sections which can only be written after the
index 1743869..f49ae24 100644 (file)
@@ -1,6 +1,6 @@
 // layout.h -- lay out output file sections for gold  -*- C++ -*-
 
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
 // Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
@@ -897,7 +897,7 @@ class Layout
   // they finish.  Otherwise return BUILD_ID_BLOCKER.
   Task_token*
   queue_build_id_tasks(Workqueue* workqueue, Task_token* build_id_blocker,
-                       Output_file* of);
+                      Output_file* of);
 
   // Compute and write out the build ID if needed.
   void
@@ -976,7 +976,17 @@ class Layout
   // be mapped to an output section that should be KEPT.
   bool
   keep_input_section(const Relobj*, const char*);
-  
+
+  // Add a special output object that will be recreated afresh
+  // if there is another relaxation iteration.
+  void
+  add_relax_output(Output_data* data)
+  { this->relax_output_list_.push_back(data); }
+
+  // Clear out (and free) everything added by add_relax_output.
+  void
+  reset_relax_output();
+
  private:
   Layout(const Layout&);
   Layout& operator=(const Layout&);
@@ -1272,7 +1282,8 @@ class Layout
     // Check that sections and special data are in reset states.
     void
     check_output_data_for_reset_values(const Layout::Section_list&,
-                                      const Layout::Data_list&);
+                                      const Layout::Data_list& special_outputs,
+                                      const Layout::Data_list& relax_outputs);
 
     // Record information of a section list.
     void
@@ -1324,6 +1335,9 @@ class Layout
   // The list of unattached Output_data objects which require special
   // handling because they are not Output_sections.
   Data_list special_output_list_;
+  // Like special_output_list_, but cleared and recreated on each
+  // iteration of relaxation.
+  Data_list relax_output_list_;
   // The section headers.
   Output_section_headers* section_headers_;
   // A pointer to the PT_TLS segment if there is one.
index 583c020..a5ff988 100644 (file)
@@ -1,6 +1,6 @@
 // output.cc -- manage the output file for gold
 
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
 // Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
@@ -590,7 +590,7 @@ Output_file_header::entry()
 {
   const bool should_issue_warning = (parameters->options().entry() != NULL
                                     && !parameters->options().relocatable()
-                                     && !parameters->options().shared());
+                                    && !parameters->options().shared());
   const char* entry = parameters->entry();
   Symbol* sym = this->symtab_->lookup(entry);
 
@@ -769,7 +769,7 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
     shndx_(INVALID_CODE)
 {
   gold_assert(local_sym_index != GSYM_CODE
-              && local_sym_index != INVALID_CODE);
+             && local_sym_index != INVALID_CODE);
   // this->type_ is a bitfield; make sure TYPE fits.
   gold_assert(this->type_ == type);
   this->u1_.relobj = relobj;
@@ -795,7 +795,7 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::Output_reloc(
     shndx_(shndx)
 {
   gold_assert(local_sym_index != GSYM_CODE
-              && local_sym_index != INVALID_CODE);
+             && local_sym_index != INVALID_CODE);
   gold_assert(shndx != INVALID_CODE);
   // this->type_ is a bitfield; make sure TYPE fits.
   gold_assert(this->type_ == type);
@@ -954,14 +954,14 @@ set_needs_dynsym_index()
 
     default:
       {
-        const unsigned int lsi = this->local_sym_index_;
+       const unsigned int lsi = this->local_sym_index_;
        Sized_relobj_file<size, big_endian>* relobj =
            this->u1_.relobj->sized_relobj();
        gold_assert(relobj != NULL);
-        if (!this->is_section_symbol_)
-          relobj->set_needs_output_dynsym_entry(lsi);
-        else
-          relobj->output_section(lsi)->set_needs_dynsym_index();
+       if (!this->is_section_symbol_)
+         relobj->set_needs_output_dynsym_entry(lsi);
+       else
+         relobj->output_section(lsi)->set_needs_dynsym_index();
       }
       break;
     }
@@ -1010,26 +1010,26 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 
     default:
       {
-        const unsigned int lsi = this->local_sym_index_;
+       const unsigned int lsi = this->local_sym_index_;
        Sized_relobj_file<size, big_endian>* relobj =
            this->u1_.relobj->sized_relobj();
        gold_assert(relobj != NULL);
-        if (!this->is_section_symbol_)
-          {
-            if (dynamic)
-              index = relobj->dynsym_index(lsi);
-            else
-              index = relobj->symtab_index(lsi);
-          }
-        else
-          {
-            Output_section* os = relobj->output_section(lsi);
-            gold_assert(os != NULL);
-            if (dynamic)
-              index = os->dynsym_index();
-            else
-              index = os->symtab_index();
-          }
+       if (!this->is_section_symbol_)
+         {
+           if (dynamic)
+             index = relobj->dynsym_index(lsi);
+           else
+             index = relobj->symtab_index(lsi);
+         }
+       else
+         {
+           Output_section* os = relobj->output_section(lsi);
+           gold_assert(os != NULL);
+           if (dynamic)
+             index = os->dynsym_index();
+           else
+             index = os->symtab_index();
+         }
       }
       break;
     }
@@ -1046,11 +1046,11 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::
   local_section_offset(Addend addend) const
 {
   gold_assert(this->local_sym_index_ != GSYM_CODE
-              && this->local_sym_index_ != SECTION_CODE
+             && this->local_sym_index_ != SECTION_CODE
              && this->local_sym_index_ != TARGET_CODE
-              && this->local_sym_index_ != INVALID_CODE
+             && this->local_sym_index_ != INVALID_CODE
              && this->local_sym_index_ != 0
-              && this->is_section_symbol_);
+             && this->is_section_symbol_);
   const unsigned int lsi = this->local_sym_index_;
   Output_section* os = this->u1_.relobj->output_section(lsi);
   gold_assert(os != NULL);
@@ -1141,9 +1141,9 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::symbol_value(
       return this->u1_.os->address() + addend;
     }
   gold_assert(this->local_sym_index_ != TARGET_CODE
-              && this->local_sym_index_ != INVALID_CODE
+             && this->local_sym_index_ != INVALID_CODE
              && this->local_sym_index_ != 0
-              && !this->is_section_symbol_);
+             && !this->is_section_symbol_);
   const unsigned int lsi = this->local_sym_index_;
   Sized_relobj_file<size, big_endian>* relobj =
       this->u1_.relobj->sized_relobj();
@@ -1425,14 +1425,14 @@ Output_data_got<got_size, big_endian>::Got_entry::write(
     case RESERVED_CODE:
       // If we're doing an incremental update, don't touch this GOT entry.
       if (parameters->incremental_update())
-        return;
+       return;
       val = this->u_.constant;
       break;
 
     default:
       {
        const Relobj* object = this->u_.object;
-        const unsigned int lsi = this->local_sym_index_;
+       const unsigned int lsi = this->local_sym_index_;
        bool is_tls = object->local_is_tls(lsi);
        if (this->use_plt_or_tls_offset_ && !is_tls)
          val = parameters->target().plt_address_for_local(object, lsi);
@@ -2246,9 +2246,9 @@ Output_section::Input_section::print_to_mapfile(Mapfile* mapfile) const
 
     case RELAXED_INPUT_SECTION_CODE:
       {
-        Output_relaxed_input_section* relaxed_section =
+       Output_relaxed_input_section* relaxed_section =
          this->relaxed_input_section();
-        mapfile->print_input_section(relaxed_section->relobj(),
+       mapfile->print_input_section(relaxed_section->relobj(),
                                     relaxed_section->shndx());
       }
       break;
@@ -2429,7 +2429,7 @@ Output_section::add_input_section(Layout* layout,
       offset_in_section = this->free_list_.allocate(input_section_size,
                                                    addralign, 0);
       if (offset_in_section == -1)
-        gold_fallback(_("out of patch space in section %s; "
+       gold_fallback(_("out of patch space in section %s; "
                        "relink with --incremental-full"),
                      this->name());
       return offset_in_section;
@@ -2450,7 +2450,7 @@ Output_section::add_input_section(Layout* layout,
       && (sh_flags & elfcpp::SHF_EXECINSTR) != 0
       && parameters->target().has_code_fill()
       && (parameters->target().may_relax()
-          || layout->is_section_ordering_specified()))
+         || layout->is_section_ordering_specified()))
     {
       gold_assert(this->fills_.empty());
       this->generate_code_fills_at_write_ = true;
@@ -2467,13 +2467,13 @@ Output_section::add_input_section(Layout* layout,
       // sections without input sections.
       off_t fill_len = aligned_offset_in_section - offset_in_section;
       if (this->input_sections_.empty())
-        this->fills_.push_back(Fill(offset_in_section, fill_len));
+       this->fills_.push_back(Fill(offset_in_section, fill_len));
       else
-        {
-          std::string fill_data(parameters->target().code_fill(fill_len));
-          Output_data_const* odc = new Output_data_const(fill_data, 1);
-          this->input_sections_.push_back(Input_section(odc));
-        }
+       {
+         std::string fill_data(parameters->target().code_fill(fill_len));
+         Output_data_const* odc = new Output_data_const(fill_data, 1);
+         this->input_sections_.push_back(Input_section(odc));
+       }
     }
 
   // We need to keep track of this section if we are already keeping
@@ -2496,15 +2496,15 @@ Output_section::add_input_section(Layout* layout,
         using --section-ordering-file, match the section name with
         a pattern.  */
       if (parameters->options().section_ordering_file())
-        {
-          unsigned int section_order_index =
-            layout->find_section_order_index(std::string(secname));
+       {
+         unsigned int section_order_index =
+           layout->find_section_order_index(std::string(secname));
          if (section_order_index != 0)
-            {
-              isecn.set_section_order_index(section_order_index);
-              this->set_input_section_order_specified();
-            }
-        }
+           {
+             isecn.set_section_order_index(section_order_index);
+             this->set_input_section_order_specified();
+           }
+       }
       this->input_sections_.push_back(isecn);
     }
 
@@ -2573,12 +2573,12 @@ Output_section::add_relaxed_input_section(Layout* layout,
   if (layout->is_section_ordering_specified())
     {
       unsigned int section_order_index =
-        layout->find_section_order_index(name);
+       layout->find_section_order_index(name);
       if (section_order_index != 0)
-        {
-          inp.set_section_order_index(section_order_index);
-          this->set_input_section_order_specified();
-        }
+       {
+         inp.set_section_order_index(section_order_index);
+         this->set_input_section_order_specified();
+       }
     }
 
   this->add_output_section_data(&inp);
@@ -3127,7 +3127,7 @@ Output_section::set_final_data_size()
       double pct = parameters->options().incremental_patch();
       size_t extra = static_cast<size_t>(data_size * pct);
       if (this->free_space_fill_ != NULL
-          && this->free_space_fill_->minimum_hole_size() > extra)
+         && this->free_space_fill_->minimum_hole_size() > extra)
        extra = this->free_space_fill_->minimum_hole_size();
       off_t new_size = align_address(data_size + extra, this->addralign());
       this->patch_space_ = new_size - data_size;
@@ -3215,7 +3215,7 @@ class Output_section::Input_section_sort_entry
                        || input_section.is_relaxed_input_section())
   {
     if (this->section_has_name_
-        && must_sort_attached_input_sections)
+       && must_sort_attached_input_sections)
       {
        // This is only called single-threaded from Layout::finalize,
        // so it is OK to lock.  Unfortunately we have no way to pass
@@ -3323,10 +3323,10 @@ class Output_section::Input_section_sort_entry
     unsigned int s_secn_index = s.input_section().section_order_index();
     if (this_secn_index > 0 && s_secn_index > 0)
       {
-        if (this_secn_index < s_secn_index)
-          return 1;
-        else if (this_secn_index > s_secn_index)
-          return -1;
+       if (this_secn_index < s_secn_index)
+         return 1;
+       else if (this_secn_index > s_secn_index)
+         return -1;
       }
     return 0;
   }
@@ -3568,10 +3568,10 @@ Output_section::update_section_layout(
     {
       if (p->is_input_section()
          || p->is_relaxed_input_section())
-        {
+       {
          Object* obj = (p->is_input_section()
                         ? p->relobj()
-                        : p->relaxed_input_section()->relobj());
+                        : p->relaxed_input_section()->relobj());
          unsigned int shndx = p->shndx();
          Section_layout_order::const_iterator it
            = order_map->find(Section_id(obj, shndx));
@@ -3579,11 +3579,11 @@ Output_section::update_section_layout(
            continue;
          unsigned int section_order_index = it->second;
          if (section_order_index != 0)
-            {
-              p->set_section_order_index(section_order_index);
-              this->set_input_section_order_specified();
+           {
+             p->set_section_order_index(section_order_index);
+             this->set_input_section_order_specified();
            }
-        }
+       }
     }
 }
 
@@ -3613,16 +3613,16 @@ Output_section::sort_attached_input_sections()
        p != this->input_sections_.end();
        ++p, ++i)
       sort_list.push_back(Input_section_sort_entry(*p, i,
-                            this->must_sort_attached_input_sections()));
+                           this->must_sort_attached_input_sections()));
 
   // Sort the input sections.
   if (this->must_sort_attached_input_sections())
     {
       if (this->type() == elfcpp::SHT_PREINIT_ARRAY
-          || this->type() == elfcpp::SHT_INIT_ARRAY
-          || this->type() == elfcpp::SHT_FINI_ARRAY)
-        std::sort(sort_list.begin(), sort_list.end(),
-                 Input_section_sort_init_fini_compare());
+         || this->type() == elfcpp::SHT_INIT_ARRAY
+         || this->type() == elfcpp::SHT_FINI_ARRAY)
+       std::sort(sort_list.begin(), sort_list.end(),
+                 Input_section_sort_init_fini_compare());
       else if (strcmp(parameters->options().sort_section(), "name") == 0)
        std::sort(sort_list.begin(), sort_list.end(),
                  Input_section_sort_section_name_compare());
@@ -3630,14 +3630,14 @@ Output_section::sort_attached_input_sections()
        std::sort(sort_list.begin(), sort_list.end(),
                  Input_section_sort_section_prefix_special_ordering_compare());
       else
-        std::sort(sort_list.begin(), sort_list.end(),
-                 Input_section_sort_compare());
+       std::sort(sort_list.begin(), sort_list.end(),
+                 Input_section_sort_compare());
     }
   else
     {
       gold_assert(this->input_section_order_specified());
       std::sort(sort_list.begin(), sort_list.end(),
-               Input_section_sort_section_order_index_compare());
+               Input_section_sort_section_order_index_compare());
     }
 
   // Copy the sorted input sections back to our list.
@@ -4299,8 +4299,9 @@ Output_segment::has_dynamic_reloc_list(const Output_data_list* pdl) const
 // and *PSHNDX.
 
 uint64_t
-Output_segment::set_section_addresses(Layout* layout, bool reset,
-                                      uint64_t addr,
+Output_segment::set_section_addresses(const Target* target,
+                                     Layout* layout, bool reset,
+                                     uint64_t addr,
                                      unsigned int* increase_relro,
                                      bool* has_relro,
                                      off_t* poff,
@@ -4439,6 +4440,41 @@ Output_segment::set_section_addresses(Layout* layout, bool reset,
   // objects.
   *poff = off;
 
+  // If code segments must contain only code, and this code segment is
+  // page-aligned in the file, then fill it out to a whole page with
+  // code fill (the tail of the segment will not be within any section).
+  // Thus the entire code segment can be mapped from the file as whole
+  // pages and that mapping will contain only valid instructions.
+  if (target->isolate_execinstr() && (this->flags() & elfcpp::PF_X) != 0)
+    {
+      uint64_t abi_pagesize = target->abi_pagesize();
+      if (orig_off % abi_pagesize == 0 && off % abi_pagesize != 0)
+       {
+         size_t fill_size = abi_pagesize - (off % abi_pagesize);
+
+         std::string fill_data;
+         if (target->has_code_fill())
+           fill_data = target->code_fill(fill_size);
+         else
+           fill_data.resize(fill_size); // Zero fill.
+
+         Output_data_const* fill = new Output_data_const(fill_data, 0);
+         fill->set_address(this->vaddr_ + this->memsz_);
+         fill->set_file_offset(off);
+         layout->add_relax_output(fill);
+
+         off += fill_size;
+         gold_assert(off % abi_pagesize == 0);
+         ret += fill_size;
+         gold_assert(ret % abi_pagesize == 0);
+
+         gold_assert((uint64_t) this->filesz_ == this->memsz_);
+         this->memsz_ = this->filesz_ += fill_size;
+
+         *poff = off;
+       }
+    }
+
   return ret;
 }
 
@@ -4447,10 +4483,10 @@ Output_segment::set_section_addresses(Layout* layout, bool reset,
 
 uint64_t
 Output_segment::set_section_list_addresses(Layout* layout, bool reset,
-                                           Output_data_list* pdl,
+                                          Output_data_list* pdl,
                                           uint64_t addr, off_t* poff,
                                           unsigned int* pshndx,
-                                           bool* in_tls)
+                                          bool* in_tls)
 {
   off_t startoff = *poff;
   // For incremental updates, we may allocate non-fixed sections from
@@ -4469,40 +4505,40 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
       // the section will most likely already have an address.
       if (!(*p)->is_address_valid())
        {
-          uint64_t align = (*p)->addralign();
-
-          if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
-            {
-              // Give the first TLS section the alignment of the
-              // entire TLS segment.  Otherwise the TLS segment as a
-              // whole may be misaligned.
-              if (!*in_tls)
-                {
-                  Output_segment* tls_segment = layout->tls_segment();
-                  gold_assert(tls_segment != NULL);
-                  uint64_t segment_align = tls_segment->maximum_alignment();
-                  gold_assert(segment_align >= align);
-                  align = segment_align;
-
-                  *in_tls = true;
-                }
-            }
-          else
-            {
-              // If this is the first section after the TLS segment,
-              // align it to at least the alignment of the TLS
-              // segment, so that the size of the overall TLS segment
-              // is aligned.
-              if (*in_tls)
-                {
-                  uint64_t segment_align =
-                      layout->tls_segment()->maximum_alignment();
-                  if (segment_align > align)
-                    align = segment_align;
-
-                  *in_tls = false;
-                }
-            }
+         uint64_t align = (*p)->addralign();
+
+         if ((*p)->is_section_flag_set(elfcpp::SHF_TLS))
+           {
+             // Give the first TLS section the alignment of the
+             // entire TLS segment.  Otherwise the TLS segment as a
+             // whole may be misaligned.
+             if (!*in_tls)
+               {
+                 Output_segment* tls_segment = layout->tls_segment();
+                 gold_assert(tls_segment != NULL);
+                 uint64_t segment_align = tls_segment->maximum_alignment();
+                 gold_assert(segment_align >= align);
+                 align = segment_align;
+
+                 *in_tls = true;
+               }
+           }
+         else
+           {
+             // If this is the first section after the TLS segment,
+             // align it to at least the alignment of the TLS
+             // segment, so that the size of the overall TLS segment
+             // is aligned.
+             if (*in_tls)
+               {
+                 uint64_t segment_align =
+                     layout->tls_segment()->maximum_alignment();
+                 if (segment_align > align)
+                   align = segment_align;
+
+                 *in_tls = false;
+               }
+           }
 
          if (!parameters->incremental_update())
            {
@@ -4516,12 +4552,12 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
              off_t current_size = (*p)->current_data_size();
              off = layout->allocate(current_size, align, startoff);
              if (off == -1)
-               {
+               {
                  gold_assert((*p)->output_section() != NULL);
                  gold_fallback(_("out of patch space for section %s; "
                                  "relink with --incremental-full"),
                                (*p)->output_section()->name());
-               }
+               }
              (*p)->set_address_and_file_offset(addr + (off - startoff), off);
              if ((*p)->data_size() > current_size)
                {
@@ -4533,11 +4569,11 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
            }
        }
       else if (parameters->incremental_update())
-        {
-          // For incremental updates, use the fixed offset for the
-          // high-water mark computation.
-          off = (*p)->offset();
-        }
+       {
+         // For incremental updates, use the fixed offset for the
+         // high-water mark computation.
+         off = (*p)->offset();
+       }
       else
        {
          // The script may have inserted a skip forward, but it
@@ -4587,7 +4623,7 @@ Output_segment::set_section_list_addresses(Layout* layout, bool reset,
        off += (*p)->data_size();
 
       if (off > maxoff)
-        maxoff = off;
+       maxoff = off;
 
       if ((*p)->is_section())
        {
@@ -5184,8 +5220,8 @@ Output_file::map()
     return;
 
   gold_fatal(_("%s: mmap: failed to allocate %lu bytes for output file: %s"),
-             this->name_, static_cast<unsigned long>(this->file_size_),
-             strerror(errno));
+            this->name_, static_cast<unsigned long>(this->file_size_),
+            strerror(errno));
 }
 
 // Unmap the file from memory.
@@ -5217,19 +5253,19 @@ Output_file::close()
       size_t bytes_to_write = this->file_size_;
       size_t offset = 0;
       while (bytes_to_write > 0)
-        {
-          ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
-                                          bytes_to_write);
-          if (bytes_written == 0)
-            gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
-          else if (bytes_written < 0)
-            gold_error(_("%s: write: %s"), this->name_, strerror(errno));
-          else
-            {
-              bytes_to_write -= bytes_written;
-              offset += bytes_written;
-            }
-        }
+       {
+         ssize_t bytes_written = ::write(this->o_, this->base_ + offset,
+                                         bytes_to_write);
+         if (bytes_written == 0)
+           gold_error(_("%s: write: unexpected 0 return-value"), this->name_);
+         else if (bytes_written < 0)
+           gold_error(_("%s: write: %s"), this->name_, strerror(errno));
+         else
+           {
+             bytes_to_write -= bytes_written;
+             offset += bytes_written;
+           }
+       }
     }
   this->unmap();
 
index 1bcdfea..f5a7299 100644 (file)
@@ -1,6 +1,7 @@
 // output.h -- manage the output file for gold   -*- C++ -*-
 
-// Copyright 2006, 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2013
+// Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -4596,7 +4597,7 @@ class Output_segment
   // address of the immediately following segment.  Update *POFF and
   // *PSHNDX.  This should only be called for a PT_LOAD segment.
   uint64_t
-  set_section_addresses(Layout*, bool reset, uint64_t addr,
+  set_section_addresses(const Target*, Layout*, bool reset, uint64_t addr,
                        unsigned int* increase_relro, bool* has_relro,
                        off_t* poff, unsigned int* pshndx);