gas/

[deliverable/binutils-gdb.git] / gold / symtab.h

diff --git a/gold/symtab.h b/gold/symtab.h
index 4e5b7b05ab95db4dc02fe3bb6a1cc811008f7d63..e355b2a75cd6b89d1a6e3c823b42259f7a1fb1b6 100644 (file)
--- a/gold/symtab.h
+++ b/gold/symtab.h
@@ -409,6 +409,11 @@ class Symbol
   set_got_offset(unsigned int got_type, unsigned int got_offset)
   { this->got_offsets_.set_offset(got_type, got_offset); }
 
+  // Return the GOT offset list.
+  const Got_offset_list*
+  got_offset_list() const
+  { return this->got_offsets_.get_list(); }
+
   // Return whether this symbol has an entry in the PLT section.
   bool
   has_plt_offset() const
@@ -577,9 +582,6 @@ class Symbol
   }
 
   // Return true if this symbol is a function that needs a PLT entry.
-  // If the symbol is defined in a dynamic object or if it is subject
-  // to pre-emption, we need to make a PLT entry. If we're doing a
-  // static link or a -pie link, we don't create PLT entries.
   bool
   needs_plt_entry() const
   {
@@ -587,12 +589,27 @@ class Symbol
     if (this->is_undefined() && !parameters->options().shared())
       return false;
 
-    return (!parameters->doing_static_link()
-           && !parameters->options().pie()
-            && this->is_func()
-            && (this->is_from_dynobj()
-                || this->is_undefined()
-                || this->is_preemptible()));
+    // An STT_GNU_IFUNC symbol always needs a PLT entry, even when
+    // doing a static link.
+    if (this->type() == elfcpp::STT_GNU_IFUNC)
+      return true;
+
+    // We only need a PLT entry for a function.
+    if (!this->is_func())
+      return false;
+
+    // If we're doing a static link or a -pie link, we don't create
+    // PLT entries.
+    if (parameters->doing_static_link()
+       || parameters->options().pie())
+      return false;
+
+    // We need a PLT entry if the function is defined in a dynamic
+    // object, or is undefined when building a shared object, or if it
+    // is subject to pre-emption.
+    return (this->is_from_dynobj()
+           || this->is_undefined()
+           || this->is_preemptible());
   }
 
   // When determining whether a reference to a symbol needs a dynamic
@@ -640,7 +657,8 @@ class Symbol
     // shared library cannot use a PLT entry.
     if ((flags & FUNCTION_CALL)
         && this->has_plt_offset()
-        && !((flags & NON_PIC_REF) && parameters->options().shared()))
+        && !((flags & NON_PIC_REF)
+             && parameters->options().output_is_position_independent()))
       return false;
 
     // A reference to any PLT entry in a non-position-independent executable
@@ -673,6 +691,10 @@ class Symbol
     if (!this->has_plt_offset())
       return false;
 
+    // For a STT_GNU_IFUNC symbol we always have to use the PLT entry.
+    if (this->type() == elfcpp::STT_GNU_IFUNC)
+      return true;
+
     // If we are going to generate a dynamic relocation, then we will
     // wind up using that, so no need to use the PLT entry.
     if (this->needs_dynamic_reloc(FUNCTION_CALL
@@ -777,7 +799,7 @@ class Symbol
   bool
   may_need_copy_reloc() const
   {
-    return (!parameters->options().shared()
+    return (!parameters->options().output_is_position_independent()
            && parameters->options().copyreloc()
            && this->is_from_dynobj()
            && !this->is_func());
@@ -800,7 +822,7 @@ class Symbol
   // index rather than a special code.
   template<int size, bool big_endian>
   void
-  init_base_object(const char *name, const char* version, Object* object,
+  init_base_object(const char* name, const char* version, Object* object,
                   const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
                   bool is_ordinary);
 
@@ -991,7 +1013,7 @@ class Sized_symbol : public Symbol
   // index rather than a special code.
   template<bool big_endian>
   void
-  init_object(const char *name, const char* version, Object* object,
+  init_object(const char* name, const char* version, Object* object,
              const elfcpp::Sym<size, big_endian>&, unsigned int st_shndx,
              bool is_ordinary);
 
@@ -1446,7 +1468,7 @@ class Symbol_table
   // local symbols.
   off_t
   finalize(off_t off, off_t dynoff, size_t dyn_global_index, size_t dyncount,
-          Stringpool* pool, unsigned int *plocal_symcount);
+          Stringpool* pool, unsigned int* plocal_symcount);
 
   // Status code of Symbol_table::compute_final_value.
   enum Compute_final_value_status
@@ -1489,6 +1511,20 @@ class Symbol_table
   write_section_symbol(const Output_section*, Output_symtab_xindex*,
                       Output_file*, off_t) const;
 
+  // Loop over all symbols, applying the function F to each.
+  template<int size, typename F>
+  void
+  for_all_symbols(F f) const
+  {
+    for (Symbol_table_type::const_iterator p = this->table_.begin();
+         p != this->table_.end();
+         ++p)
+      {
+       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
+       f(sym);
+      }
+  }
+
   // Dump statistical information to stderr.
   void
   print_stats() const;
@@ -1531,8 +1567,8 @@ class Symbol_table
   // Add a symbol.
   template<int size, bool big_endian>
   Sized_symbol<size>*
-  add_from_object(Object*, const char *name, Stringpool::Key name_key,
-                 const char *version, Stringpool::Key version_key,
+  add_from_object(Object*, const char* name, Stringpool::Key name_key,
+                 const char* version, Stringpool::Key version_key,
                  bool def, const elfcpp::Sym<size, big_endian>& sym,
                  unsigned int st_shndx, bool is_ordinary,
                  unsigned int orig_st_shndx);