Another snapshot of the current state of the sources. Gets to the

point of symbol resolution and can now issue a multiple definition
error.  Also added target selection infrastructure.

1 files changed, 90 insertions, 3 deletions

diff --git a/gold/target.h b/gold/target.h
index 1f1c575..236185b 100644
--- a/gold/target.h
+++ b/gold/target.h
@@ -1,4 +1,4 @@
-// target.h -- target support for gold
+// target.h -- target support for gold   -*- C++ -*-
 
 // The abstract class Target is the interface for target specific
 // support.  It defines abstract methods which each target must
@@ -13,16 +13,103 @@
 #ifndef GOLD_TARGET_H
 #define GOLD_TARGET_H
 
+#include "symtab.h"
+#include "elfcpp.h"
+
 namespace gold
 {
 
+class Object;
+
+// The abstract class for target specific handling.
+
 class Target
 {
  public:
+  virtual ~Target()
+  { }
+
+  // Return the bit size that this target implements.  This should
+  // return 32 or 64.
+  int
+  get_size() const
+  { return this->size_; }
+
+  // Return whether this target is big-endian.
+  bool
+  is_big_endian() const
+  { return this->is_big_endian_; }
+
+  // Whether this target has a specific make_symbol function.
+  bool
+  has_make_symbol() const
+  { return this->has_make_symbol_; }
+
+  // Whether this target has a specific resolve function.
+  bool
+  has_resolve() const
+  { return this->has_resolve_; }
+
+  // Resolve a symbol.  This is called when we see a symbol with a
+  // target specific binding (STB_LOOS through STB_HIOS or STB_LOPROC
+  // through STB_HIPROC).  TO is a pre-existing symbol.  SYM is the
+  // new symbol, seen in OBJECT.  This returns true on success, false
+  // if the symbol can not be resolved.
+  template<int size, bool big_endian>
+  bool
+  resolve(Sized_symbol<size>* to, const elfcpp::Sym<size, big_endian>& sym,
+	  Object* object);
+
+ protected:
+  Target(int size, bool is_big_endian, bool has_make_symbol, bool has_resolve)
+    : size_(size),
+      is_big_endian_(is_big_endian),
+      has_make_symbol_(has_make_symbol),
+      has_resolve_(has_resolve)
+  { }
+
+ private:
+  Target(const Target&);
+  Target& operator=(const Target&);
+
+  // The target size.
+  int size_;
+  // Whether this target is big endian.
+  bool is_big_endian_;
+  // Whether this target has a special make_symbol function.
+  bool has_make_symbol_;
+  // Whether this target has a special resolve function.
+  bool has_resolve_;
 };
 
-extern Target* select_target(int machine, int size, bool big_endian,
-			     int osabi, int abiversion);
+// The abstract class for a specific size and endianness of target.
+// Each actual target implementation class should derive from an
+// instantiation of Sized_target.
+
+template<int size, bool big_endian>
+class Sized_target : public Target
+{
+ public:
+  // Make a new symbol table entry for the target.  This should be
+  // overridden by a target which needs additional information in the
+  // symbol table.  This will only be called if has_make_symbol()
+  // returns true.
+  virtual Sized_symbol<size>*
+  make_symbol()
+  { abort(); }
+
+  // Resolve a symbol for the target.  This should be overridden by a
+  // target which needs to take special action.  TO is the
+  // pre-existing symbol.  SYM is the new symbol, seen in OBJECT.
+  virtual void
+  resolve(Symbol*, const elfcpp::Sym<size, big_endian>&, Object*)
+  { abort(); }
+
+ protected:
+  Sized_target(bool has_make_symbol, bool has_resolve)
+    : Target(size, big_endian, has_make_symbol, has_resolve)
+  { }
+};
 
 } // End namespace gold.