[binutils] Bump binutils to 2.20.1

binutils/gold/layout.cc

 // layout.cc -- lay out output file sections for gold
 
-// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
 // Written 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
 // the Free Software Foundation; either version 3 of the License, or
 // (at your option) any later version.
 
 // This program is distributed in the hope that it will be useful,
@@ skipping 328 matching lines @@
             return false;
         }
       if (parameters->options().strip_lto_sections()
           && !parameters->options().relocatable()
           && (shdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0)
         {
           // Ignore LTO sections containing intermediate code.
           if (is_prefix_of(".gnu.lto_", name))
             return false;
         }
+      // The GNU linker strips .gnu_debuglink sections, so we do too.
+      // This is a feature used to keep debugging information in
+      // separate files.
+      if (strcmp(name, ".gnu_debuglink") == 0)
+        return false;
       return true;
 
     default:
       return true;
     }
 }
 
 // Return an output section named NAME, or NULL if there is none.
 
 Output_section*
@@ skipping 19 matching lines @@
        ++p)
     if (static_cast<elfcpp::PT>((*p)->type()) == type
         && ((*p)->flags() & set) == set
         && ((*p)->flags() & clear) == 0)
       return *p;
   return NULL;
 }
 
 // Return the output section to use for section NAME with type TYPE
 // and section flags FLAGS.  NAME must be canonicalized in the string
-// pool, and NAME_KEY is the key.
+// pool, and NAME_KEY is the key.  IS_INTERP is true if this is the
+// .interp section.  IS_DYNAMIC_LINKER_SECTION is true if this section
+// is used by the dynamic linker.
 
 Output_section*
 Layout::get_output_section(const char* name, Stringpool::Key name_key,
-                           elfcpp::Elf_Word type, elfcpp::Elf_Xword flags)
+                           elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
+                           bool is_interp, bool is_dynamic_linker_section)
 {
   elfcpp::Elf_Xword lookup_flags = flags;
 
   // Ignoring SHF_WRITE and SHF_EXECINSTR here means that we combine
   // read-write with read-only sections.  Some other ELF linkers do
   // not do this.  FIXME: Perhaps there should be an option
   // controlling this.
   lookup_flags &= ~(elfcpp::SHF_WRITE | elfcpp::SHF_EXECINSTR);
 
   const Key key(name_key, std::make_pair(type, lookup_flags));
@@ skipping 28 matching lines @@
               elfcpp::Elf_Xword zero_flags = 0;
               const Key zero_key(name_key, std::make_pair(type, zero_flags));
               Section_name_map::iterator p =
                   this->section_name_map_.find(zero_key);
               if (p != this->section_name_map_.end())
                 os = p->second;
             }
         }
 
       if (os == NULL)
-        os = this->make_output_section(name, type, flags);
+        os = this->make_output_section(name, type, flags, is_interp,
+                                       is_dynamic_linker_section);
       ins.first->second = os;
       return os;
     }
 }
 
 // Pick the output section to use for section NAME, in input file
 // RELOBJ, with type TYPE and flags FLAGS.  RELOBJ may be NULL for a
 // linker created section.  IS_INPUT_SECTION is true if we are
 // choosing an output section for an input section found in a input
-// file.  This will return NULL if the input section should be
-// discarded.
+// file.  IS_INTERP is true if this is the .interp section.
+// IS_DYNAMIC_LINKER_SECTION is true if this section is used by the
+// dynamic linker.  This will return NULL if the input section should
+// be discarded.
 
 Output_section*
 Layout::choose_output_section(const Relobj* relobj, const char* name,
                               elfcpp::Elf_Word type, elfcpp::Elf_Xword flags,
-                              bool is_input_section)
+                              bool is_input_section, bool is_interp,
+                              bool is_dynamic_linker_section)
 {
   // We should not see any input sections after we have attached
   // sections to segments.
   gold_assert(!is_input_section || !this->sections_are_attached_);
 
   // Some flags in the input section should not be automatically
   // copied to the output section.
   flags &= ~ (elfcpp::SHF_INFO_LINK
               | elfcpp::SHF_LINK_ORDER
               | elfcpp::SHF_GROUP
@@ skipping 27 matching lines @@
               return *output_section_slot;
             }
 
           // We don't put sections found in the linker script into
           // SECTION_NAME_MAP_.  That keeps us from getting confused
           // if an orphan section is mapped to a section with the same
           // name as one in the linker script.
 
           name = this->namepool_.add(name, false, NULL);
 
-          Output_section* os = this->make_output_section(name, type, flags);
+          Output_section* os =
+            this->make_output_section(name, type, flags, is_interp,
+                                      is_dynamic_linker_section);
           os->set_found_in_sections_clause();
           *output_section_slot = os;
           return os;
         }
     }
 
   // FIXME: Handle SHF_OS_NONCONFORMING somewhere.
 
   // Turn NAME from the name of the input section into the name of the
   // output section.
 
   size_t len = strlen(name);
   if (is_input_section
       && !this->script_options_->saw_sections_clause()
       && !parameters->options().relocatable())
     name = Layout::output_section_name(name, &len);
 
   Stringpool::Key name_key;
   name = this->namepool_.add_with_length(name, len, true, &name_key);
 
   // Find or make the output section.  The output section is selected
   // based on the section name, type, and flags.
-  return this->get_output_section(name, name_key, type, flags);
+  return this->get_output_section(name, name_key, type, flags, is_interp,
+                                  is_dynamic_linker_section);
 }
 
 // Return the output section to use for input section SHNDX, with name
 // NAME, with header HEADER, from object OBJECT.  RELOC_SHNDX is the
 // index of a relocation section which applies to this section, or 0
 // if none, or -1U if more than one.  RELOC_TYPE is the type of the
 // relocation section if there is one.  Set *OFF to the offset of this
 // input section without the output section.  Return NULL if the
 // section should be discarded.  Set *OFF to -1 if the section
 // contents should not be written directly to the output file, but
@@ skipping 12 matching lines @@
 
   Output_section* os;
 
   // In a relocatable link a grouped section must not be combined with
   // any other sections.
   if (parameters->options().relocatable()
       && (shdr.get_sh_flags() & elfcpp::SHF_GROUP) != 0)
     {
       name = this->namepool_.add(name, true, NULL);
       os = this->make_output_section(name, shdr.get_sh_type(),
-                                     shdr.get_sh_flags());
+                                     shdr.get_sh_flags(), false, false);
     }
   else
     {
       os = this->choose_output_section(object, name, shdr.get_sh_type(),
-                                       shdr.get_sh_flags(), true);
+                                       shdr.get_sh_flags(), true, false,
+                                       false);
       if (os == NULL)
         return NULL;
     }
 
   // By default the GNU linker sorts input sections whose names match
   // .ctor.*, .dtor.*, .init_array.*, or .fini_array.*.  The sections
   // are sorted by name.  This is used to implement constructor
   // priority ordering.  We are compatible.
   if (!this->script_options_->saw_sections_clause()
       && (is_prefix_of(".ctors.", name)
@@ skipping 30 matching lines @@
     name = ".rel";
   else if (sh_type == elfcpp::SHT_RELA)
     name = ".rela";
   else
     gold_unreachable();
   name += data_section->name();
 
   Output_section* os = this->choose_output_section(object, name.c_str(),
                                                    sh_type,
                                                    shdr.get_sh_flags(),
-                                                   false);
+                                                   false, false, false);
 
   os->set_should_link_to_symtab();
   os->set_info_section(data_section);
 
   Output_section_data* posd;
   if (sh_type == elfcpp::SHT_REL)
     {
       os->set_entsize(elfcpp::Elf_sizes<size>::rel_size);
       posd = new Output_relocatable_relocs<elfcpp::SHT_REL,
                                            size,
@@ skipping 26 matching lines @@
                      const char* signature,
                      const elfcpp::Shdr<size, big_endian>& shdr,
                      elfcpp::Elf_Word flags,
                      std::vector<unsigned int>* shndxes)
 {
   gold_assert(parameters->options().relocatable());
   gold_assert(shdr.get_sh_type() == elfcpp::SHT_GROUP);
   group_section_name = this->namepool_.add(group_section_name, true, NULL);
   Output_section* os = this->make_output_section(group_section_name,
                                                  elfcpp::SHT_GROUP,
-                                                 shdr.get_sh_flags());
+                                                 shdr.get_sh_flags(),
+                                                 false, false);
 
   // We need to find a symbol with the signature in the symbol table.
   // If we don't find one now, we need to look again later.
   Symbol* sym = symtab->lookup(signature, NULL);
   if (sym != NULL)
     os->set_info_symndx(sym);
   else
     {
       // Reserve some space to minimize reallocations.
       if (this->group_signatures_.empty())
@@ skipping 33 matching lines @@
                         off_t* off)
 {
   gold_assert(shdr.get_sh_type() == elfcpp::SHT_PROGBITS);
   gold_assert((shdr.get_sh_flags() & elfcpp::SHF_ALLOC) != 0);
 
   const char* const name = ".eh_frame";
   Output_section* os = this->choose_output_section(object,
                                                    name,
                                                    elfcpp::SHT_PROGBITS,
                                                    elfcpp::SHF_ALLOC,
-                                                   false);
+                                                   false, false, false);
   if (os == NULL)
     return NULL;
 
   if (this->eh_frame_section_ == NULL)
     {
       this->eh_frame_section_ = os;
       this->eh_frame_data_ = new Eh_frame();
 
       if (parameters->options().eh_frame_hdr())
         {
           Output_section* hdr_os =
             this->choose_output_section(NULL,
                                         ".eh_frame_hdr",
                                         elfcpp::SHT_PROGBITS,
                                         elfcpp::SHF_ALLOC,
-                                        false);
+                                        false, false, false);
 
           if (hdr_os != NULL)
             {
               Eh_frame_hdr* hdr_posd = new Eh_frame_hdr(os,
                                                         this->eh_frame_data_);
               hdr_os->add_output_section_data(hdr_posd);
 
               hdr_os->set_after_input_sections();
 
               if (!this->script_options_->saw_phdrs_clause())
                 {
                   Output_segment* hdr_oseg;
                   hdr_oseg = this->make_output_segment(elfcpp::PT_GNU_EH_FRAME,
                                                        elfcpp::PF_R);
-                  hdr_oseg->add_output_section(hdr_os, elfcpp::PF_R);
+                  hdr_oseg->add_output_section(hdr_os, elfcpp::PF_R, false);
                 }
 
               this->eh_frame_data_->set_eh_frame_hdr(hdr_posd);
             }
         }
     }
 
   gold_assert(this->eh_frame_section_ == os);
 
   if (this->eh_frame_data_->add_ehframe_input_section(object,
@@ skipping 30 matching lines @@
 
   return os;
 }
 
 // Add POSD to an output section using NAME, TYPE, and FLAGS.  Return
 // the output section.
 
 Output_section*
 Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type,
                                 elfcpp::Elf_Xword flags,
-                                Output_section_data* posd)
+                                Output_section_data* posd,
+                                bool is_dynamic_linker_section)
 {
   Output_section* os = this->choose_output_section(NULL, name, type, flags,
-                                                   false);
+                                                   false, false,
+                                                   is_dynamic_linker_section);
   if (os != NULL)
     os->add_output_section_data(posd);
   return os;
 }
 
 // Map section flags to segment flags.
 
 elfcpp::Elf_Word
 Layout::section_flags_to_segment(elfcpp::Elf_Xword flags)
 {
@@ skipping 14 matching lines @@
 // (The Output_compressed_section class decides whether to compress
 // a given section, and picks the name of the compressed section.)
 
 static bool
 is_compressible_debug_section(const char* secname)
 {
   return (strncmp(secname, ".debug", sizeof(".debug") - 1) == 0);
 }
 
 // Make a new Output_section, and attach it to segments as
-// appropriate.
+// appropriate.  IS_INTERP is true if this is the .interp section.
+// IS_DYNAMIC_LINKER_SECTION is true if this section is used by the
+// dynamic linker.
 
 Output_section*
 Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
-                            elfcpp::Elf_Xword flags)
+                            elfcpp::Elf_Xword flags, bool is_interp,
+                            bool is_dynamic_linker_section)
 {
   Output_section* os;
   if ((flags & elfcpp::SHF_ALLOC) == 0
       && strcmp(parameters->options().compress_debug_sections(), "none") != 0
       && is_compressible_debug_section(name))
     os = new Output_compressed_section(&parameters->options(), name, type,
                                        flags);
-
   else if ((flags & elfcpp::SHF_ALLOC) == 0
            && parameters->options().strip_debug_non_line()
            && strcmp(".debug_abbrev", name) == 0)
     {
       os = this->debug_abbrev_ = new Output_reduced_debug_abbrev_section(
           name, type, flags);
       if (this->debug_info_)
         this->debug_info_->set_abbreviations(this->debug_abbrev_);
     }
   else if ((flags & elfcpp::SHF_ALLOC) == 0
            && parameters->options().strip_debug_non_line()
            && strcmp(".debug_info", name) == 0)
     {
       os = this->debug_info_ = new Output_reduced_debug_info_section(
           name, type, flags);
       if (this->debug_abbrev_)
         this->debug_info_->set_abbreviations(this->debug_abbrev_);
     }
  else
     {
       // FIXME: const_cast is ugly.
       Target* target = const_cast<Target*>(&parameters->target());
       os = target->make_output_section(name, type, flags);
     }
 
+  if (is_interp)
+    os->set_is_interp();
+  if (is_dynamic_linker_section)
+    os->set_is_dynamic_linker_section();
+
   parameters->target().new_output_section(os);
 
   this->section_list_.push_back(os);
 
   // The GNU linker by default sorts some sections by priority, so we
   // do the same.  We need to know that this might happen before we
   // attach any input sections.
   if (!this->script_options_->saw_sections_clause()
       && (strcmp(name, ".ctors") == 0
           || strcmp(name, ".dtors") == 0
@@ skipping 75 matching lines @@
   // segments until after we've seen all the sections.
   if (this->script_options_->saw_sections_clause())
     return;
 
   gold_assert(!this->script_options_->saw_phdrs_clause());
 
   // This output section goes into a PT_LOAD segment.
 
   elfcpp::Elf_Word seg_flags = Layout::section_flags_to_segment(flags);
 
+  bool sort_sections = !this->script_options_->saw_sections_clause();
+
   // In general the only thing we really care about for PT_LOAD
   // segments is whether or not they are writable, so that is how we
   // search for them.  Large data sections also go into their own
   // PT_LOAD segment.  People who need segments sorted on some other
   // basis will have to use a linker script.
 
   Segment_list::const_iterator p;
   for (p = this->segment_list_.begin();
        p != this->segment_list_.end();
        ++p)
     {
       if ((*p)->type() != elfcpp::PT_LOAD)
         continue;
       if (!parameters->options().omagic()
           && ((*p)->flags() & elfcpp::PF_W) != (seg_flags & elfcpp::PF_W))
         continue;
       // If -Tbss was specified, we need to separate the data and BSS
       // segments.
       if (parameters->options().user_set_Tbss())
         {
           if ((os->type() == elfcpp::SHT_NOBITS)
               == (*p)->has_any_data_sections())
             continue;
         }
       if (os->is_large_data_section() && !(*p)->is_large_data_segment())
         continue;
 
-      (*p)->add_output_section(os, seg_flags);
+      (*p)->add_output_section(os, seg_flags, sort_sections);
       break;
     }
 
   if (p == this->segment_list_.end())
     {
       Output_segment* oseg = this->make_output_segment(elfcpp::PT_LOAD,
                                                        seg_flags);
       if (os->is_large_data_section())
         oseg->set_is_large_data_segment();
-      oseg->add_output_section(os, seg_flags);
+      oseg->add_output_section(os, seg_flags, sort_sections);
     }
 
   // If we see a loadable SHT_NOTE section, we create a PT_NOTE
   // segment.
   if (os->type() == elfcpp::SHT_NOTE)
     {
       // See if we already have an equivalent PT_NOTE segment.
       for (p = this->segment_list_.begin();
            p != segment_list_.end();
            ++p)
         {
           if ((*p)->type() == elfcpp::PT_NOTE
               && (((*p)->flags() & elfcpp::PF_W)
                   == (seg_flags & elfcpp::PF_W)))
             {
-              (*p)->add_output_section(os, seg_flags);
+              (*p)->add_output_section(os, seg_flags, false);
               break;
             }
         }
 
       if (p == this->segment_list_.end())
         {
           Output_segment* oseg = this->make_output_segment(elfcpp::PT_NOTE,
                                                            seg_flags);
-          oseg->add_output_section(os, seg_flags);
+          oseg->add_output_section(os, seg_flags, false);
         }
     }
 
   // If we see a loadable SHF_TLS section, we create a PT_TLS
   // segment.  There can only be one such segment.
   if ((flags & elfcpp::SHF_TLS) != 0)
     {
       if (this->tls_segment_ == NULL)
         this->make_output_segment(elfcpp::PT_TLS, seg_flags);
-      this->tls_segment_->add_output_section(os, seg_flags);
+      this->tls_segment_->add_output_section(os, seg_flags, false);
     }
 
   // If -z relro is in effect, and we see a relro section, we create a
   // PT_GNU_RELRO segment.  There can only be one such segment.
   if (os->is_relro() && parameters->options().relro())
     {
       gold_assert(seg_flags == (elfcpp::PF_R | elfcpp::PF_W));
       if (this->relro_segment_ == NULL)
         this->make_output_segment(elfcpp::PT_GNU_RELRO, seg_flags);
-      this->relro_segment_->add_output_section(os, seg_flags);
+      this->relro_segment_->add_output_section(os, seg_flags, false);
     }
 }
 
 // Make an output section for a script.
 
 Output_section*
 Layout::make_output_section_for_script(const char* name)
 {
   name = this->namepool_.add(name, false, NULL);
   Output_section* os = this->make_output_section(name, elfcpp::SHT_PROGBITS,
-                                                 elfcpp::SHF_ALLOC);
+                                                 elfcpp::SHF_ALLOC, false,
+                                                 false);
   os->set_found_in_sections_clause();
   return os;
 }
 
 // Return the number of segments we expect to see.
 
 size_t
 Layout::expected_segment_count() const
 {
   size_t ret = this->segment_list_.size();
@@ skipping 49 matching lines @@
 void
 Layout::create_initial_dynamic_sections(Symbol_table* symtab)
 {
   if (parameters->doing_static_link())
     return;
 
   this->dynamic_section_ = this->choose_output_section(NULL, ".dynamic",
                                                        elfcpp::SHT_DYNAMIC,
                                                        (elfcpp::SHF_ALLOC
                                                         | elfcpp::SHF_WRITE),
-                                                       false);
+                                                       false, false, true);
   this->dynamic_section_->set_is_relro();
 
   symtab->define_in_output_data("_DYNAMIC", NULL, this->dynamic_section_, 0, 0,
                                 elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
                                 elfcpp::STV_HIDDEN, 0, false, false);
 
   this->dynamic_data_ =  new Output_data_dynamic(&this->dynpool_);
 
   this->dynamic_section_->add_output_section_data(this->dynamic_data_);
 }
@@ skipping 577 matching lines @@
   else
     gold_unreachable();
 
   memcpy(buffer + 3 * (size / 8), name, namesz);
 
   elfcpp::Elf_Xword flags = 0;
   if (allocate)
     flags = elfcpp::SHF_ALLOC;
   Output_section* os = this->choose_output_section(NULL, section_name,
                                                    elfcpp::SHT_NOTE,
-                                                   flags, false);
+                                                   flags, false, false,
+                                                   false);
   if (os == NULL)
     return NULL;
 
   Output_section_data* posd = new Output_data_const_buffer(buffer, notehdrsz,
                                                            size / 8,
                                                            "** note header");
   os->add_output_section_data(posd);
 
   *trailing_padding = aligned_descsz - descsz;
 
@@ skipping 58 matching lines @@
       else
         is_stack_executable = false;
     }
 
   if (parameters->options().relocatable())
     {
       const char* name = this->namepool_.add(".note.GNU-stack", false, NULL);
       elfcpp::Elf_Xword flags = 0;
       if (is_stack_executable)
         flags |= elfcpp::SHF_EXECINSTR;
-      this->make_output_section(name, elfcpp::SHT_PROGBITS, flags);
+      this->make_output_section(name, elfcpp::SHT_PROGBITS, flags, false,
+                                false);
     }
   else
     {
       if (this->script_options_->saw_phdrs_clause())
         return;
       int flags = elfcpp::PF_R | elfcpp::PF_W;
       if (is_stack_executable)
         flags |= elfcpp::PF_X;
       this->make_output_segment(elfcpp::PT_GNU_STACK, flags);
     }
@@ skipping 139 matching lines @@
 void
 Layout::create_incremental_info_sections()
 {
   gold_assert(this->incremental_inputs_ != NULL);
 
   // Add the .gnu_incremental_inputs section.
   const char *incremental_inputs_name =
     this->namepool_.add(".gnu_incremental_inputs", false, NULL);
   Output_section* inputs_os =
     this->make_output_section(incremental_inputs_name,
-                              elfcpp::SHT_GNU_INCREMENTAL_INPUTS, 0);
+                              elfcpp::SHT_GNU_INCREMENTAL_INPUTS, 0,
+                              false, false);
   Output_section_data* posd =
       this->incremental_inputs_->create_incremental_inputs_section_data();
   inputs_os->add_output_section_data(posd);
   
   // Add the .gnu_incremental_strtab section.
   const char *incremental_strtab_name =
     this->namepool_.add(".gnu_incremental_strtab", false, NULL);
   Output_section* strtab_os = this->make_output_section(incremental_strtab_name,
                                                         elfcpp::SHT_STRTAB,
-                                                        0);
+                                                        0, false, false);
   Output_data_strtab* strtab_data =
     new Output_data_strtab(this->incremental_inputs_->get_stringpool());
   strtab_os->add_output_section_data(strtab_data);
   
   inputs_os->set_link_section(strtab_data);
 }
 
 // Return whether SEG1 should be before SEG2 in the output file.  This
 // is based entirely on the segment type and flags.  When this is
 // called the segment addresses has normally not yet been set.
@@ skipping 591 matching lines @@
   off = symtab->finalize(off, dynoff, dyn_global_index, dyncount,
                          &this->sympool_, &local_symcount);
 
   if (!parameters->options().strip_all())
     {
       this->sympool_.set_string_offsets();
 
       const char* symtab_name = this->namepool_.add(".symtab", false, NULL);
       Output_section* osymtab = this->make_output_section(symtab_name,
                                                           elfcpp::SHT_SYMTAB,
-                                                          0);
+                                                          0, false, false);
       this->symtab_section_ = osymtab;
 
       Output_section_data* pos = new Output_data_fixed_space(off - startoff,
                                                              align,
                                                              "** symtab");
       osymtab->add_output_section_data(pos);
 
       // We generate a .symtab_shndx section if we have more than
       // SHN_LORESERVE sections.  Technically it is possible that we
       // don't need one, because it is possible that there are no
       // symbols in any of sections with indexes larger than
       // SHN_LORESERVE.  That is probably unusual, though, and it is
       // easier to always create one than to compute section indexes
       // twice (once here, once when writing out the symbols).
       if (shnum >= elfcpp::SHN_LORESERVE)
         {
           const char* symtab_xindex_name = this->namepool_.add(".symtab_shndx",
                                                                false, NULL);
           Output_section* osymtab_xindex =
             this->make_output_section(symtab_xindex_name,
-                                      elfcpp::SHT_SYMTAB_SHNDX, 0);
+                                      elfcpp::SHT_SYMTAB_SHNDX, 0, false,
+                                      false);
 
           size_t symcount = (off - startoff) / symsize;
           this->symtab_xindex_ = new Output_symtab_xindex(symcount);
 
           osymtab_xindex->add_output_section_data(this->symtab_xindex_);
 
           osymtab_xindex->set_link_section(osymtab);
           osymtab_xindex->set_addralign(4);
           osymtab_xindex->set_entsize(4);
 
           osymtab_xindex->set_after_input_sections();
 
           // This tells the driver code to wait until the symbol table
           // has written out before writing out the postprocessing
           // sections, including the .symtab_shndx section.
           this->any_postprocessing_sections_ = true;
         }
 
       const char* strtab_name = this->namepool_.add(".strtab", false, NULL);
       Output_section* ostrtab = this->make_output_section(strtab_name,
                                                           elfcpp::SHT_STRTAB,
-                                                          0);
+                                                          0, false, false);
 
       Output_section_data* pstr = new Output_data_strtab(&this->sympool_);
       ostrtab->add_output_section_data(pstr);
 
       osymtab->set_file_offset(startoff);
       osymtab->finalize_data_size();
       osymtab->set_link_section(ostrtab);
       osymtab->set_info(local_symcount);
       osymtab->set_entsize(symsize);
 
       *poff = off;
     }
 }
 
 // Create the .shstrtab section, which holds the names of the
 // sections.  At the time this is called, we have created all the
 // output sections except .shstrtab itself.
 
 Output_section*
 Layout::create_shstrtab()
 {
   // FIXME: We don't need to create a .shstrtab section if we are
   // stripping everything.
 
   const char* name = this->namepool_.add(".shstrtab", false, NULL);
 
-  Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0);
+  Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0,
+                                                 false, false);
 
   // We can't write out this section until we've set all the section
   // names, and we don't set the names of compressed output sections
   // until relocations are complete.
   os->set_after_input_sections();
 
   Output_section_data* posd = new Output_data_strtab(&this->namepool_);
   os->add_output_section_data(posd);
 
   return os;
@@ skipping 92 matching lines @@
       align = 8;
     }
   else
     gold_unreachable();
 
   // Create the dynamic symbol table section.
 
   Output_section* dynsym = this->choose_output_section(NULL, ".dynsym",
                                                        elfcpp::SHT_DYNSYM,
                                                        elfcpp::SHF_ALLOC,
-                                                       false);
+                                                       false, false, true);
 
   Output_section_data* odata = new Output_data_fixed_space(index * symsize,
                                                            align,
                                                            "** dynsym");
   dynsym->add_output_section_data(odata);
 
   dynsym->set_info(local_symcount);
   dynsym->set_entsize(symsize);
   dynsym->set_addralign(align);
 
   this->dynsym_section_ = dynsym;
 
   Output_data_dynamic* const odyn = this->dynamic_data_;
   odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
   odyn->add_constant(elfcpp::DT_SYMENT, symsize);
 
   // If there are more than SHN_LORESERVE allocated sections, we
   // create a .dynsym_shndx section.  It is possible that we don't
   // need one, because it is possible that there are no dynamic
   // symbols in any of the sections with indexes larger than
   // SHN_LORESERVE.  This is probably unusual, though, and at this
   // time we don't know the actual section indexes so it is
   // inconvenient to check.
   if (this->allocated_output_section_count() >= elfcpp::SHN_LORESERVE)
     {
       Output_section* dynsym_xindex =
         this->choose_output_section(NULL, ".dynsym_shndx",
                                     elfcpp::SHT_SYMTAB_SHNDX,
                                     elfcpp::SHF_ALLOC,
-                                    false);
+                                    false, false, true);
 
       this->dynsym_xindex_ = new Output_symtab_xindex(index);
 
       dynsym_xindex->add_output_section_data(this->dynsym_xindex_);
 
       dynsym_xindex->set_link_section(dynsym);
       dynsym_xindex->set_addralign(4);
       dynsym_xindex->set_entsize(4);
 
       dynsym_xindex->set_after_input_sections();
 
       // This tells the driver code to wait until the symbol table has
       // written out before writing out the postprocessing sections,
       // including the .dynsym_shndx section.
       this->any_postprocessing_sections_ = true;
     }
 
   // Create the dynamic string table section.
 
   Output_section* dynstr = this->choose_output_section(NULL, ".dynstr",
                                                        elfcpp::SHT_STRTAB,
                                                        elfcpp::SHF_ALLOC,
-                                                       false);
+                                                       false, false, true);
 
   Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
   dynstr->add_output_section_data(strdata);
 
   dynsym->set_link_section(dynstr);
   this->dynamic_section_->set_link_section(dynstr);
 
   odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
   odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
 
   *pdynstr = dynstr;
 
   // Create the hash tables.
 
   if (strcmp(parameters->options().hash_style(), "sysv") == 0
       || strcmp(parameters->options().hash_style(), "both") == 0)
     {
       unsigned char* phash;
       unsigned int hashlen;
       Dynobj::create_elf_hash_table(*pdynamic_symbols, local_symcount,
                                     &phash, &hashlen);
 
       Output_section* hashsec = this->choose_output_section(NULL, ".hash",
                                                             elfcpp::SHT_HASH,
                                                             elfcpp::SHF_ALLOC,
-                                                            false);
+                                                            false, false, true);
 
       Output_section_data* hashdata = new Output_data_const_buffer(phash,
                                                                    hashlen,
                                                                    align,
                                                                    "** hash");
       hashsec->add_output_section_data(hashdata);
 
       hashsec->set_link_section(dynsym);
       hashsec->set_entsize(4);
 
       odyn->add_section_address(elfcpp::DT_HASH, hashsec);
     }
 
   if (strcmp(parameters->options().hash_style(), "gnu") == 0
       || strcmp(parameters->options().hash_style(), "both") == 0)
     {
       unsigned char* phash;
       unsigned int hashlen;
       Dynobj::create_gnu_hash_table(*pdynamic_symbols, local_symcount,
                                     &phash, &hashlen);
 
       Output_section* hashsec = this->choose_output_section(NULL, ".gnu.hash",
                                                             elfcpp::SHT_GNU_HASH,
                                                             elfcpp::SHF_ALLOC,
-                                                            false);
+                                                            false, false, true);
 
       Output_section_data* hashdata = new Output_data_const_buffer(phash,
                                                                    hashlen,
                                                                    align,
                                                                    "** hash");
       hashsec->add_output_section_data(hashdata);
 
       hashsec->set_link_section(dynsym);
       hashsec->set_entsize(4);
 
@@ skipping 77 matching lines @@
 Layout::sized_create_version_sections(
     const Versions* versions,
     const Symbol_table* symtab,
     unsigned int local_symcount,
     const std::vector<Symbol*>& dynamic_symbols,
     const Output_section* dynstr)
 {
   Output_section* vsec = this->choose_output_section(NULL, ".gnu.version",
                                                      elfcpp::SHT_GNU_versym,
                                                      elfcpp::SHF_ALLOC,
-                                                     false);
+                                                     false, false, true);
 
   unsigned char* vbuf;
   unsigned int vsize;
   versions->symbol_section_contents<size, big_endian>(symtab, &this->dynpool_,
                                                       local_symcount,
                                                       dynamic_symbols,
                                                       &vbuf, &vsize);
 
   Output_section_data* vdata = new Output_data_const_buffer(vbuf, vsize, 2,
                                                             "** versions");
 
   vsec->add_output_section_data(vdata);
   vsec->set_entsize(2);
   vsec->set_link_section(this->dynsym_section_);
 
   Output_data_dynamic* const odyn = this->dynamic_data_;
   odyn->add_section_address(elfcpp::DT_VERSYM, vsec);
 
   if (versions->any_defs())
     {
       Output_section* vdsec;
       vdsec= this->choose_output_section(NULL, ".gnu.version_d",
                                          elfcpp::SHT_GNU_verdef,
                                          elfcpp::SHF_ALLOC,
-                                         false);
+                                         false, false, true);
 
       unsigned char* vdbuf;
       unsigned int vdsize;
       unsigned int vdentries;
       versions->def_section_contents<size, big_endian>(&this->dynpool_, &vdbuf,
                                                        &vdsize, &vdentries);
 
       Output_section_data* vddata =
         new Output_data_const_buffer(vdbuf, vdsize, 4, "** version defs");
 
       vdsec->add_output_section_data(vddata);
       vdsec->set_link_section(dynstr);
       vdsec->set_info(vdentries);
 
       odyn->add_section_address(elfcpp::DT_VERDEF, vdsec);
       odyn->add_constant(elfcpp::DT_VERDEFNUM, vdentries);
     }
 
   if (versions->any_needs())
     {
       Output_section* vnsec;
       vnsec = this->choose_output_section(NULL, ".gnu.version_r",
                                           elfcpp::SHT_GNU_verneed,
                                           elfcpp::SHF_ALLOC,
-                                          false);
+                                          false, false, true);
 
       unsigned char* vnbuf;
       unsigned int vnsize;
       unsigned int vnentries;
       versions->need_section_contents<size, big_endian>(&this->dynpool_,
                                                         &vnbuf, &vnsize,
                                                         &vnentries);
 
       Output_section_data* vndata =
         new Output_data_const_buffer(vnbuf, vnsize, 4, "** version refs");
@@ skipping 19 matching lines @@
       gold_assert(interp != NULL);
     }
 
   size_t len = strlen(interp) + 1;
 
   Output_section_data* odata = new Output_data_const(interp, len, 1);
 
   Output_section* osec = this->choose_output_section(NULL, ".interp",
                                                      elfcpp::SHT_PROGBITS,
                                                      elfcpp::SHF_ALLOC,
-                                                     false);
+                                                     false, true, true);
   osec->add_output_section_data(odata);
 
   if (!this->script_options_->saw_phdrs_clause())
     {
       Output_segment* oseg = this->make_output_segment(elfcpp::PT_INTERP,
                                                        elfcpp::PF_R);
-      oseg->add_output_section(osec, elfcpp::PF_R);
+      oseg->add_output_section(osec, elfcpp::PF_R, false);
     }
 }
 
 // Finish the .dynamic section and PT_DYNAMIC segment.
 
 void
 Layout::finish_dynamic_section(const Input_objects* input_objects,
                                const Symbol_table* symtab)
 {
   if (!this->script_options_->saw_phdrs_clause())
     {
       Output_segment* oseg = this->make_output_segment(elfcpp::PT_DYNAMIC,
                                                        (elfcpp::PF_R
                                                         | elfcpp::PF_W));
       oseg->add_output_section(this->dynamic_section_,
-                               elfcpp::PF_R | elfcpp::PF_W);
+                               elfcpp::PF_R | elfcpp::PF_W,
+                               false);
     }
 
   Output_data_dynamic* const odyn = this->dynamic_data_;
 
   for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
        p != input_objects->dynobj_end();
        ++p)
     {
-      // FIXME: Handle --as-needed.
+      if (!(*p)->is_needed()
+          && (*p)->input_file()->options().as_needed())
+        {
+          // This dynamic object was linked with --as-needed, but it
+          // is not needed.
+          continue;
+        }
+
       odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname());
     }
 
   if (parameters->options().shared())
     {
       const char* soname = parameters->options().soname();
       if (soname != NULL)
         odyn->add_string(elfcpp::DT_SONAME, soname);
     }
 
@@ skipping 892 matching lines @@
                                   const unsigned char* symbol_names,
                                   off_t symbol_names_size,
                                   unsigned int shndx,
                                   const elfcpp::Shdr<64, true>& shdr,
                                   unsigned int reloc_shndx,
                                   unsigned int reloc_type,
                                   off_t* off);
 #endif
 
 } // End namespace gold.