Subversion Repositories open8_urisc

// target-select.h -- select a target for an object file  -*- C++ -*-

// Copyright 2006, 2007, 2008, 2009, 2010, 2011 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,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program; if not, write to the Free Software

// Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,

// MA 02110-1301, USA.

#ifndef GOLD_TARGET_SELECT_H

#define GOLD_TARGET_SELECT_H

#include <vector>

#include "gold-threads.h"

namespace gold

{

class Target;

class Target_selector;

// Used to set the target only once.

class Set_target_once : public Once

{

 public:

  Set_target_once(Target_selector* target_selector)

    : target_selector_(target_selector)

  { }

 protected:

  void

  do_run_once(void*);

 private:

  Target_selector* target_selector_;

};

// We want to avoid a master list of targets, which implies using a

// global constructor.  And we also want the program to start up as

// quickly as possible, which implies avoiding global constructors.

// We compromise on a very simple global constructor.  We use a target

// selector, which specifies an ELF machine number and a recognition

// function.  We use global constructors to build a linked list of

// target selectors--a simple pointer list, not a std::list.

class Target_selector

{

 public:

  // Create a target selector for a specific machine number, size (32

  // or 64), and endianness.  The machine number can be EM_NONE to

  // test for any machine number.  BFD_NAME is the name of the target

  // used by the GNU linker, for backward compatibility; it may be

  // NULL.  EMULATION is the name of the emulation used by the GNU

  // linker; it is similar to BFD_NAME.

  Target_selector(int machine, int size, bool is_big_endian,

                  const char* bfd_name, const char* emulation);

  virtual ~Target_selector()

  { }

  // If we can handle this target, return a pointer to a target

  // structure.  The size and endianness are known.

  Target*

  recognize(int machine, int osabi, int abiversion)

  { return this->do_recognize(machine, osabi, abiversion); }

  // If NAME matches the target, return a pointer to a target

  // structure.

  Target*

  recognize_by_bfd_name(const char* name)

  { return this->do_recognize_by_bfd_name(name); }

  // Push all supported BFD names onto the vector.  This is only used

  // for help output.

  void

  supported_bfd_names(std::vector<const char*>* names)

  { this->do_supported_bfd_names(names); }

  // If NAME matches the target emulation, return a pointer to a

  // target structure.

  Target*

  recognize_by_emulation(const char* name)

  { return this->do_recognize_by_emulation(name); }

  // Push all supported emulations onto the vector.  This is only used

  // for help output.

  void

  supported_emulations(std::vector<const char*>* names)

  { this->do_supported_emulations(names); }

  // Return the next Target_selector in the linked list.

  Target_selector*

  next() const

  { return this->next_; }

  // Return the machine number this selector is looking for.  This can

  // be EM_NONE to match any machine number, in which case the

  // do_recognize hook will be responsible for matching the machine

  // number.

  int

  machine() const

  { return this->machine_; }

  // Return the size this is looking for (32 or 64).

  int

  get_size() const

  { return this->size_; }

  // Return the endianness this is looking for.

  bool

  is_big_endian() const

  { return this->is_big_endian_; }

  // Return the BFD name.  This may return NULL, in which case the

  // do_recognize_by_bfd_name hook will be responsible for matching

  // the BFD name.

  const char*

  bfd_name() const

  { return this->bfd_name_; }

  // Return the emulation.  This may return NULL, in which case the

  // do_recognize_by_emulation hook will be responsible for matching

  // the emulation.

  const char*

  emulation() const

  { return this->emulation_; }

  // The reverse mapping, for --print-output-format: if we

  // instantiated TARGET, return our BFD_NAME.  If we did not

  // instantiate it, return NULL.

  const char*

  target_bfd_name(const Target* target)

  { return this->do_target_bfd_name(target); }

 protected:

  // Return an instance of the real target.  This must be implemented

  // by the child class.

  virtual Target*

  do_instantiate_target() = 0;

  // Recognize an object file given a machine code, OSABI code, and

  // ELF version value.  When this is called we already know that they

  // match the machine_, size_, and is_big_endian_ fields.  The child

  // class may implement a different version of this to do additional

  // checks, or to check for multiple machine codes if the machine_

  // field is EM_NONE.

  virtual Target*

  do_recognize(int, int, int)

  { return this->instantiate_target(); }

  // Recognize a target by name.  When this is called we already know

  // that the name matches (or that the bfd_name_ field is NULL).  The

  // child class may implement a different version of this to

  // recognize more than one name.

  virtual Target*

  do_recognize_by_bfd_name(const char*)

  { return this->instantiate_target(); }

  // Return a list of supported BFD names.  The child class may

  // implement a different version of this to handle more than one

  // name.

  virtual void

  do_supported_bfd_names(std::vector<const char*>* names)

  {

    gold_assert(this->bfd_name_ != NULL);

    names->push_back(this->bfd_name_);

  }

  // Recognize a target by emulation.  When this is called we already

  // know that the name matches (or that the emulation_ field is

  // NULL).  The child class may implement a different version of this

  // to recognize more than one emulation.

  virtual Target*

  do_recognize_by_emulation(const char*)

  { return this->instantiate_target(); }

  // Return a list of supported emulations.  The child class may

  // implement a different version of this to handle more than one

  // emulation.

  virtual void

  do_supported_emulations(std::vector<const char*>* emulations)

  {

    gold_assert(this->emulation_ != NULL);

    emulations->push_back(this->emulation_);

  }

  // Map from target to BFD name.

  virtual const char*

  do_target_bfd_name(const Target*);

  // Instantiate the target and return it.

  Target*

  instantiate_target();

  // Return whether TARGET is the target we instantiated.

  bool

  is_our_target(const Target* target)

  { return target == this->instantiated_target_; }

 private:

  // Set the target.

  void

  set_target();

  friend class Set_target_once;

  // ELF machine code.

  const int machine_;

  // Target size--32 or 64.

  const int size_;

  // Whether the target is big endian.

  const bool is_big_endian_;

  // BFD name of target, for compatibility.

  const char* const bfd_name_;

  // GNU linker emulation for this target, for compatibility.

  const char* const emulation_;

  // Next entry in list built at global constructor time.

  Target_selector* next_;

  // The singleton Target structure--this points to an instance of the

  // real implementation.

  Target* instantiated_target_;

  // Used to set the target only once.

  Set_target_once set_target_once_;

};

// Select the target for an ELF file.

extern Target*

select_target(int machine, int size, bool big_endian, int osabi,

              int abiversion);

// Select a target using a BFD name.

extern Target*

select_target_by_bfd_name(const char* name);

// Select a target using a GNU linker emulation.

extern Target*

select_target_by_emulation(const char* name);

// Fill in a vector with the list of supported targets.  This returns

// a list of BFD names.

extern void

supported_target_names(std::vector<const char*>*);

// Fill in a vector with the list of supported emulations.

extern void

supported_emulation_names(std::vector<const char*>*);

// Print the output format, for the --print-output-format option.

extern void

print_output_format();

} // End namespace gold.

#endif // !defined(GOLD_TARGET_SELECT_H)