gold/target-select.cc

   1 // target-select.cc -- select a target for an object file
   2
   3 // Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012
   4 // Free Software Foundation, Inc.
   5 // Written by Ian Lance Taylor <iant@google.com>.
   6
   7 // This file is part of gold.
   8
   9 // This program is free software; you can redistribute it and/or modify
  10 // it under the terms of the GNU General Public License as published by
  11 // the Free Software Foundation; either version 3 of the License, or
  12 // (at your option) any later version.
  13
  14 // This program is distributed in the hope that it will be useful,
  15 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 // GNU General Public License for more details.
  18
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  22 // MA 02110-1301, USA.
  23
  24 #include "gold.h"
  25
  26 #include <cstdio>
  27 #include <cstring>
  28
  29 #include "elfcpp.h"
  30 #include "options.h"
  31 #include "parameters.h"
  32 #include "target-select.h"
  33
  34 namespace
  35 {
  36
  37 // The start of the list of target selectors.
  38
  39 gold::Target_selector* target_selectors;
  40
  41 } // End anonymous namespace.
  42
  43 namespace gold
  44 {
  45
  46 // Class Set_target_once.
  47
  48 void
  49 Set_target_once::do_run_once(void*)
  50 {
  51   this->target_selector_->set_target();
  52 }
  53
  54 // Construct a Target_selector, which means adding it to the linked
  55 // list.  This runs at global constructor time, so we want it to be
  56 // fast.
  57
  58 Target_selector::Target_selector(int machine, int size, bool is_big_endian,
  59                                  const char* bfd_name, const char* emulation)
  60   : machine_(machine), size_(size), is_big_endian_(is_big_endian),
  61     bfd_name_(bfd_name), emulation_(emulation), instantiated_target_(NULL),
  62     set_target_once_(this)
  63 {
  64   this->next_ = target_selectors;
  65   target_selectors = this;
  66 }
  67
  68 // Instantiate the target and return it.  Use SET_TARGET_ONCE_ to
  69 // avoid instantiating two instances of the same target.
  70
  71 Target*
  72 Target_selector::instantiate_target()
  73 {
  74   this->set_target_once_.run_once(NULL);
  75   return this->instantiated_target_;
  76 }
  77
  78 // Instantiate the target.  This is called at most once.
  79
  80 void
  81 Target_selector::set_target()
  82 {
  83   gold_assert(this->instantiated_target_ == NULL);
  84   this->instantiated_target_ = this->do_instantiate_target();
  85 }
  86
  87 // If we instantiated TARGET, return the corresponding BFD name.
  88
  89 const char*
  90 Target_selector::do_target_bfd_name(const Target* target)
  91 {
  92   if (!this->is_our_target(target))
  93     return NULL;
  94   const char* my_bfd_name = this->bfd_name();
  95   gold_assert(my_bfd_name != NULL);
  96   return my_bfd_name;
  97 }
  98
  99 // Find the target for an ELF file.
 100
 101 Target*
 102 select_target(Input_file* input_file, off_t offset,
 103               int machine, int size, bool is_big_endian,
 104               int osabi, int abiversion)
 105 {
 106   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
 107     {
 108       int pmach = p->machine();
 109       if ((pmach == machine || pmach == elfcpp::EM_NONE)
 110           && p->get_size() == size
 111           && (p->is_big_endian() ? is_big_endian : !is_big_endian))
 112         {
 113           Target* ret = p->recognize(input_file, offset,
 114                                      machine, osabi, abiversion);
 115           if (ret != NULL)
 116             return ret;
 117         }
 118     }
 119   return NULL;
 120 }
 121
 122 // Find a target using a BFD name.  This is used to support the
 123 // --oformat option.
 124
 125 Target*
 126 select_target_by_bfd_name(const char* name)
 127 {
 128   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
 129     {
 130       const char* pname = p->bfd_name();
 131       if (pname == NULL || strcmp(pname, name) == 0)
 132         {
 133           Target* ret = p->recognize_by_bfd_name(name);
 134           if (ret != NULL)
 135             return ret;
 136         }
 137     }
 138   return NULL;
 139 }
 140
 141 // Find a target using a GNU linker emulation.  This is used to
 142 // support the -m option.
 143
 144 Target*
 145 select_target_by_emulation(const char* name)
 146 {
 147   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
 148     {
 149       const char* pname = p->emulation();
 150       if (pname == NULL || strcmp(pname, name) == 0)
 151         {
 152           Target* ret = p->recognize_by_emulation(name);
 153           if (ret != NULL)
 154             return ret;
 155         }
 156     }
 157   return NULL;
 158 }
 159
 160 // Push all the supported BFD names onto a vector.
 161
 162 void
 163 supported_target_names(std::vector<const char*>* names)
 164 {
 165   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
 166     p->supported_bfd_names(names);
 167 }
 168
 169 // Push all the supported emulations onto a vector.
 170
 171 void
 172 supported_emulation_names(std::vector<const char*>* names)
 173 {
 174   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
 175     p->supported_emulations(names);
 176 }
 177
 178 // Implement the --print-output-format option.
 179
 180 void
 181 print_output_format()
 182 {
 183   if (!parameters->target_valid())
 184     {
 185       // This case arises when --print-output-format is used with no
 186       // input files.  We need to come up with the right string to
 187       // print based on the other options.  If the user specified the
 188       // format using a --oformat option, use that.  That saves each
 189       // target from having to remember the name that was used to
 190       // select it.  In other cases, we will just have to ask the
 191       // target.
 192       if (parameters->options().user_set_oformat())
 193         {
 194           const char* bfd_name = parameters->options().oformat();
 195           Target* target = select_target_by_bfd_name(bfd_name);
 196           if (target != NULL)
 197             printf("%s\n", bfd_name);
 198           else
 199             gold_error(_("unrecognized output format %s"), bfd_name);
 200           return;
 201         }
 202
 203       parameters_force_valid_target();
 204     }
 205
 206   const Target* target = &parameters->target();
 207   for (Target_selector* p = target_selectors; p != NULL; p = p->next())
 208     {
 209       const char* bfd_name = p->target_bfd_name(target);
 210       if (bfd_name != NULL)
 211         {
 212           printf("%s\n", bfd_name);
 213           return;
 214         }
 215     }
 216
 217   gold_unreachable();
 218 }
 219
 220 } // End namespace gold.