gold/target-select.h

   1 // target-select.h -- select a target for an object file  -*- C++ -*-
   2
   3 // Copyright (C) 2006-2019 Free Software Foundation, Inc.
   4 // Written by Ian Lance Taylor <iant@google.com>.
   5
   6 // This file is part of gold.
   7
   8 // This program is free software; you can redistribute it and/or modify
   9 // it under the terms of the GNU General Public License as published by
  10 // the Free Software Foundation; either version 3 of the License, or
  11 // (at your option) any later version.
  12
  13 // This program is distributed in the hope that it will be useful,
  14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 // GNU General Public License for more details.
  17
  18 // You should have received a copy of the GNU General Public License
  19 // along with this program; if not, write to the Free Software
  20 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21 // MA 02110-1301, USA.
  22
  23 #ifndef GOLD_TARGET_SELECT_H
  24 #define GOLD_TARGET_SELECT_H
  25
  26 #include <vector>
  27
  28 #include "gold-threads.h"
  29
  30 namespace gold
  31 {
  32
  33 class Input_file;
  34 class Target;
  35 class Target_selector;
  36
  37 // Used to set the target only once.
  38
  39 class Set_target_once : public Once
  40 {
  41  public:
  42   Set_target_once(Target_selector* target_selector)
  43     : target_selector_(target_selector)
  44   { }
  45
  46  protected:
  47   void
  48   do_run_once(void*);
  49
  50  private:
  51   Target_selector* target_selector_;
  52 };
  53
  54 // We want to avoid a master list of targets, which implies using a
  55 // global constructor.  And we also want the program to start up as
  56 // quickly as possible, which implies avoiding global constructors.
  57 // We compromise on a very simple global constructor.  We use a target
  58 // selector, which specifies an ELF machine number and a recognition
  59 // function.  We use global constructors to build a linked list of
  60 // target selectors--a simple pointer list, not a std::list.
  61
  62 class Target_selector
  63 {
  64  public:
  65   // Create a target selector for a specific machine number, size (32
  66   // or 64), and endianness.  The machine number can be EM_NONE to
  67   // test for any machine number.  BFD_NAME is the name of the target
  68   // used by the GNU linker, for backward compatibility; it may be
  69   // NULL.  EMULATION is the name of the emulation used by the GNU
  70   // linker; it is similar to BFD_NAME.
  71   Target_selector(int machine, int size, bool is_big_endian,
  72                   const char* bfd_name, const char* emulation);
  73
  74   virtual ~Target_selector()
  75   { }
  76
  77   // If we can handle this target, return a pointer to a target
  78   // structure.  The size and endianness are known.
  79   Target*
  80   recognize(Input_file* input_file, off_t offset,
  81             int machine, int osabi, int abiversion)
  82   { return this->do_recognize(input_file, offset, machine, osabi, abiversion); }
  83
  84   // If NAME matches the target, return a pointer to a target
  85   // structure.
  86   Target*
  87   recognize_by_bfd_name(const char* name)
  88   { return this->do_recognize_by_bfd_name(name); }
  89
  90   // Push all supported BFD names onto the vector.  This is only used
  91   // for help output.
  92   void
  93   supported_bfd_names(std::vector<const char*>* names)
  94   { this->do_supported_bfd_names(names); }
  95
  96   // If NAME matches the target emulation, return a pointer to a
  97   // target structure.
  98   Target*
  99   recognize_by_emulation(const char* name)
 100   { return this->do_recognize_by_emulation(name); }
 101
 102   // Push all supported emulations onto the vector.  This is only used
 103   // for help output.
 104   void
 105   supported_emulations(std::vector<const char*>* names)
 106   { this->do_supported_emulations(names); }
 107
 108   // Return the next Target_selector in the linked list.
 109   Target_selector*
 110   next() const
 111   { return this->next_; }
 112
 113   // Return the machine number this selector is looking for.  This can
 114   // be EM_NONE to match any machine number, in which case the
 115   // do_recognize hook will be responsible for matching the machine
 116   // number.
 117   int
 118   machine() const
 119   { return this->machine_; }
 120
 121   // Return the size this is looking for (32 or 64).
 122   int
 123   get_size() const
 124   { return this->size_; }
 125
 126   // Return the endianness this is looking for.
 127   bool
 128   is_big_endian() const
 129   { return this->is_big_endian_; }
 130
 131   // Return the BFD name.  This may return NULL, in which case the
 132   // do_recognize_by_bfd_name hook will be responsible for matching
 133   // the BFD name.
 134   const char*
 135   bfd_name() const
 136   { return this->bfd_name_; }
 137
 138   // Return the emulation.  This may return NULL, in which case the
 139   // do_recognize_by_emulation hook will be responsible for matching
 140   // the emulation.
 141   const char*
 142   emulation() const
 143   { return this->emulation_; }
 144
 145   // The reverse mapping, for --print-output-format: if we
 146   // instantiated TARGET, return our BFD_NAME.  If we did not
 147   // instantiate it, return NULL.
 148   const char*
 149   target_bfd_name(const Target* target)
 150   { return this->do_target_bfd_name(target); }
 151
 152  protected:
 153   // Return an instance of the real target.  This must be implemented
 154   // by the child class.
 155   virtual Target*
 156   do_instantiate_target() = 0;
 157
 158   // Recognize an object file given a machine code, OSABI code, and
 159   // ELF version value.  When this is called we already know that they
 160   // match the machine_, size_, and is_big_endian_ fields.  The child
 161   // class may implement a different version of this to do additional
 162   // checks, or to check for multiple machine codes if the machine_
 163   // field is EM_NONE.
 164   virtual Target*
 165   do_recognize(Input_file*, off_t, int, int, int)
 166   { return this->instantiate_target(); }
 167
 168   // Recognize a target by name.  When this is called we already know
 169   // that the name matches (or that the bfd_name_ field is NULL).  The
 170   // child class may implement a different version of this to
 171   // recognize more than one name.
 172   virtual Target*
 173   do_recognize_by_bfd_name(const char*)
 174   { return this->instantiate_target(); }
 175
 176   // Return a list of supported BFD names.  The child class may
 177   // implement a different version of this to handle more than one
 178   // name.
 179   virtual void
 180   do_supported_bfd_names(std::vector<const char*>* names)
 181   {
 182     gold_assert(this->bfd_name_ != NULL);
 183     names->push_back(this->bfd_name_);
 184   }
 185
 186   // Recognize a target by emulation.  When this is called we already
 187   // know that the name matches (or that the emulation_ field is
 188   // NULL).  The child class may implement a different version of this
 189   // to recognize more than one emulation.
 190   virtual Target*
 191   do_recognize_by_emulation(const char*)
 192   { return this->instantiate_target(); }
 193
 194   // Return a list of supported emulations.  The child class may
 195   // implement a different version of this to handle more than one
 196   // emulation.
 197   virtual void
 198   do_supported_emulations(std::vector<const char*>* emulations)
 199   {
 200     gold_assert(this->emulation_ != NULL);
 201     emulations->push_back(this->emulation_);
 202   }
 203
 204   // Map from target to BFD name.
 205   virtual const char*
 206   do_target_bfd_name(const Target*);
 207
 208   // Instantiate the target and return it.
 209   Target*
 210   instantiate_target();
 211
 212   // Return whether TARGET is the target we instantiated.
 213   bool
 214   is_our_target(const Target* target)
 215   { return target == this->instantiated_target_; }
 216
 217  private:
 218   // Set the target.
 219   void
 220   set_target();
 221
 222   friend class Set_target_once;
 223
 224   // ELF machine code.
 225   const int machine_;
 226   // Target size--32 or 64.
 227   const int size_;
 228   // Whether the target is big endian.
 229   const bool is_big_endian_;
 230   // BFD name of target, for compatibility.
 231   const char* const bfd_name_;
 232   // GNU linker emulation for this target, for compatibility.
 233   const char* const emulation_;
 234   // Next entry in list built at global constructor time.
 235   Target_selector* next_;
 236   // The singleton Target structure--this points to an instance of the
 237   // real implementation.
 238   Target* instantiated_target_;
 239   // Used to set the target only once.
 240   Set_target_once set_target_once_;
 241 };
 242
 243 // Select the target for an ELF file.
 244
 245 extern Target*
 246 select_target(Input_file*, off_t,
 247               int machine, int size, bool big_endian, int osabi,
 248               int abiversion);
 249
 250 // Select a target using a BFD name.
 251
 252 extern Target*
 253 select_target_by_bfd_name(const char* name);
 254
 255 // Select a target using a GNU linker emulation.
 256
 257 extern Target*
 258 select_target_by_emulation(const char* name);
 259
 260 // Fill in a vector with the list of supported targets.  This returns
 261 // a list of BFD names.
 262
 263 extern void
 264 supported_target_names(std::vector<const char*>*);
 265
 266 // Fill in a vector with the list of supported emulations.
 267
 268 extern void
 269 supported_emulation_names(std::vector<const char*>*);
 270
 271 // Print the output format, for the --print-output-format option.
 272
 273 extern void
 274 print_output_format();
 275
 276 } // End namespace gold.
 277
 278 #endif // !defined(GOLD_TARGET_SELECT_H)