contrib/binutils-2.20/gold/incremental.h

   1 // inremental.h -- incremental linking support for gold   -*- C++ -*-
   2
   3 // Copyright 2009 Free Software Foundation, Inc.
   4 // Written by Mikolaj Zalewski <mikolajz@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_INCREMENTAL_H
  24 #define GOLD_INCREMENTAL_H
  25
  26 #include <map>
  27 #include <vector>
  28
  29 #include "elfcpp_file.h"
  30 #include "stringpool.h"
  31 #include "workqueue.h"
  32 #include "fileread.h"
  33 #include "output.h"
  34
  35 namespace gold
  36 {
  37
  38 class Archive;
  39 class Input_argument;
  40 class Incremental_inputs_checker;
  41 class Object;
  42 class Output_section_data;
  43
  44 // Incremental input type as stored in .gnu_incremental_inputs.
  45
  46 enum Incremental_input_type
  47 {
  48   INCREMENTAL_INPUT_INVALID = 0,
  49   INCREMENTAL_INPUT_OBJECT = 1,
  50   INCREMENTAL_INPUT_ARCHIVE = 2,
  51   INCREMENTAL_INPUT_SHARED_LIBRARY = 3,
  52   INCREMENTAL_INPUT_SCRIPT = 4
  53 };
  54
  55 // An object representing the ELF file we edit during an incremental build.
  56 // Similar to Object or Dynobj, but operates on Output_file and contains
  57 // method specific to file edition (TBD). This is the abstract parent class
  58 // implemented in Sized_incremental_binary<size, big_endian> for a specific
  59 // endianness and size.
  60
  61 class Incremental_binary
  62 {
  63  public:
  64   Incremental_binary(Output_file* output, Target* target)
  65     : output_(output), target_(target)
  66   { }
  67
  68   virtual
  69   ~Incremental_binary()
  70   { }
  71
  72   // Functions and types for the elfcpp::Elf_file interface.  This
  73   // permit us to use Incremental_binary as the File template parameter for
  74   // elfcpp::Elf_file.
  75
  76   // The View class is returned by view.  It must support a single
  77   // method, data().  This is trivial, because Output_file::get_output_view
  78   // does what we need.
  79   class View
  80   {
  81    public:
  82     View(const unsigned char* p)
  83       : p_(p)
  84     { }
  85
  86     const unsigned char*
  87     data() const
  88     { return this->p_; }
  89
  90    private:
  91     const unsigned char* p_;
  92   };
  93
  94   // Return a View.
  95   View
  96   view(off_t file_offset, section_size_type data_size)
  97   { return View(this->output_->get_input_view(file_offset, data_size)); }
  98
  99   // A location in the file.
 100   struct Location
 101   {
 102     off_t file_offset;
 103     off_t data_size;
 104
 105     Location(off_t fo, section_size_type ds)
 106       : file_offset(fo), data_size(ds)
 107     { }
 108
 109     Location()
 110       : file_offset(0), data_size(0)
 111     { }
 112   };
 113
 114   // Get a View given a Location.
 115   View view(Location loc)
 116   { return View(this->view(loc.file_offset, loc.data_size)); }
 117
 118   // Report an error.
 119   void
 120   error(const char* format, ...) const ATTRIBUTE_PRINTF_2;
 121
 122   // Find the .gnu_incremental_inputs section.  It selects the first section
 123   // of type SHT_GNU_INCREMENTAL_INPUTS.  Returns false if such a section
 124   // is not found.
 125   bool
 126   find_incremental_inputs_section(Location* location,
 127                                   unsigned int* strtab_shndx)
 128   { return do_find_incremental_inputs_section(location, strtab_shndx); }
 129
 130   // Check the .gnu_incremental_inputs section to see whether an incremental
 131   // build is possible.
 132   // TODO: on success, should report what files needs to be rebuilt.
 133   // INCREMENTAL_INPUTS is used to read the canonical form of the command line
 134   // and read the input arguments.  TODO: for items that don't need to be
 135   // rebuilt, we should also copy the incremental input information.
 136   virtual bool
 137   check_inputs(Incremental_inputs* incremental_inputs)
 138   { return do_check_inputs(incremental_inputs); }
 139
 140  protected:
 141   // Find incremental inputs section.
 142   virtual bool
 143   do_find_incremental_inputs_section(Location* location,
 144                                      unsigned int* strtab_shndx) = 0;
 145
 146   // Check the .gnu_incremental_inputs section to see whether an incremental
 147   // build is possible.
 148   virtual bool
 149   do_check_inputs(Incremental_inputs* incremental_inputs) = 0;
 150
 151  private:
 152   // Edited output file object.
 153   Output_file* output_;
 154   // Target of the output file.
 155   Target* target_;
 156 };
 157
 158 template<int size, bool big_endian>
 159 class Sized_incremental_binary : public Incremental_binary
 160 {
 161  public:
 162   Sized_incremental_binary(Output_file* output,
 163                            const elfcpp::Ehdr<size, big_endian>& ehdr,
 164                            Target* target)
 165     : Incremental_binary(output, target), elf_file_(this, ehdr)
 166   { }
 167
 168  protected:
 169   virtual bool
 170   do_find_incremental_inputs_section(Location* location,
 171                                      unsigned int* strtab_shndx);
 172
 173   virtual bool
 174   do_check_inputs(Incremental_inputs* incremental_inputs);
 175
 176  private:
 177   // Output as an ELF file.
 178   elfcpp::Elf_file<size, big_endian, Incremental_binary> elf_file_;
 179 };
 180
 181 // Create an Incremental_binary object for FILE. Returns NULL is this is not
 182 // possible, e.g. FILE is not an ELF file or has an unsupported target.
 183 Incremental_binary*
 184 open_incremental_binary(Output_file* file);
 185
 186 // Code invoked early during an incremental link that checks what files need
 187 // to be relinked.
 188 class Incremental_checker
 189 {
 190  public:
 191   // Check if the file named OUTPUT_NAME can be linked incrementally.
 192   // INCREMENTAL_INPUTS must have the canonical form of the command line
 193   // and input arguments filled - at this point of linking other fields are
 194   // probably not filled yet.  TODO: for inputs that don't need to be
 195   // rebuilt, this function should fill the incremental input information.
 196   Incremental_checker(const char* output_name,
 197                       Incremental_inputs* incremental_inputs)
 198     : output_name_(output_name), incremental_inputs_(incremental_inputs)
 199   { }
 200
 201   // Analyzes the output file to check if incremental linking is possible and
 202   // what files needs to be relinked.
 203   bool
 204   can_incrementally_link_output_file();
 205
 206  private:
 207   // Name of the output file to analyze.
 208   const char* output_name_;
 209
 210   // The Incremental_inputs object. At this stage of link, only the command
 211   // line and inputs are filled.
 212   Incremental_inputs* incremental_inputs_;
 213 };
 214
 215 // This class contains the information needed during an incremental
 216 // build about the inputs necessary to build the .gnu_incremental_inputs.
 217 class Incremental_inputs
 218 {
 219  public:
 220   Incremental_inputs()
 221     : lock_(new Lock()), inputs_(NULL), command_line_key_(0),
 222       strtab_(new Stringpool())
 223   { }
 224   ~Incremental_inputs() { delete this->strtab_; }
 225
 226   // Record the command line.
 227   void
 228   report_command_line(int argc, const char* const* argv);
 229
 230   // Record the input arguments obtained from parsing the command line.
 231   void
 232   report_inputs(const Input_arguments& inputs)
 233   { this->inputs_ = &inputs; }
 234
 235   // Record that the input argument INPUT is an archive ARCHIVE.
 236   void
 237   report_archive(const Input_argument* input, Archive* archive);
 238
 239   // Record that the input argument INPUT is to an object OBJ.
 240   void
 241   report_object(const Input_argument* input, Object* obj);
 242
 243   // Record that the input argument INPUT is to an script SCRIPT.
 244   void
 245   report_script(const Input_argument* input, Timespec mtime,
 246                 Script_info* script);
 247
 248   // Prepare for layout.  Called from Layout::finalize.
 249   void
 250   finalize();
 251
 252   // Create the content of the .gnu_incremental_inputs section.
 253   Output_section_data*
 254   create_incremental_inputs_section_data();
 255
 256   // Return the .gnu_incremental_strtab stringpool.
 257   Stringpool*
 258   get_stringpool()
 259   { return this->strtab_; }
 260
 261   // Return the canonical form of the command line, as will be stored in
 262   // .gnu_incremental_strtab.
 263   const std::string&
 264   command_line()
 265   { return this->command_line_; }
 266
 267   // Return the input files found in the command line.
 268   const Input_arguments*
 269   inputs()
 270   { return this->inputs_; }
 271
 272  private:
 273   // Code for each of the four possible variants of create_inputs_section_data.
 274   template<int size, bool big_endian>
 275   Output_section_data*
 276   sized_create_inputs_section_data();
 277
 278   // Compute indexes in the order in which the inputs should appear in
 279   // .gnu_incremental_inputs and put file names to the stringtable.
 280   // This needs to be done after all the scripts are parsed.
 281
 282   void
 283   finalize_inputs(Input_argument_list::const_iterator begin,
 284                   Input_argument_list::const_iterator end,
 285                   unsigned int* index);
 286
 287   // Additional data about an input needed for an incremental link.
 288   // None of these pointers is owned by the structure.
 289   struct Input_info
 290   {
 291     Input_info()
 292       : type(INCREMENTAL_INPUT_INVALID), archive(NULL), filename_key(0),
 293         index(0)
 294     { }
 295
 296     // Type of the file pointed by this argument.
 297     Incremental_input_type type;
 298
 299     union
 300     {
 301       // Present if type == INCREMENTAL_INPUT_ARCHIVE.
 302       Archive* archive;
 303
 304       // Present if type == INCREMENTAL_INPUT_OBJECT or
 305       // INCREMENTAL_INPUT_SHARED_LIBRARY.
 306       Object* object;
 307
 308       // Present if type == INCREMENTAL_INPUT_SCRIPT.
 309       Script_info* script;
 310     };
 311
 312     // Key of the filename string in the section stringtable.
 313     Stringpool::Key filename_key;
 314
 315     // Position of the entry information in the output section.
 316     unsigned int index;
 317
 318     // Last modification time of the file.
 319     Timespec mtime;
 320   };
 321
 322   typedef std::map<const Input_argument*, Input_info> Inputs_info_map;
 323
 324   // A lock guarding access to inputs_ during the first phase of linking, when
 325   // report_ function may be called from multiple threads.
 326   Lock* lock_;
 327
 328   // The list of input arguments obtained from parsing the command line.
 329   const Input_arguments* inputs_;
 330
 331   // A map containing additional information about the input elements.
 332   Inputs_info_map inputs_map_;
 333
 334   // Canonical form of the command line, as will be stored in
 335   // .gnu_incremental_strtab.
 336   std::string command_line_;
 337
 338   // The key of the command line string in the string pool.
 339   Stringpool::Key command_line_key_;
 340
 341   // The .gnu_incremental_strtab string pool associated with the
 342   // .gnu_incremental_inputs.
 343   Stringpool* strtab_;
 344 };
 345
 346 } // End namespace gold.
 347
 348 #endif // !defined(GOLD_INCREMENTAL_H)