gold/ehframe.h

   1 // ehframe.h -- handle exception frame sections for gold  -*- C++ -*-
   2
   3 // Copyright (C) 2006-2020 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_EHFRAME_H
  24 #define GOLD_EHFRAME_H
  25
  26 #include <map>
  27 #include <set>
  28 #include <vector>
  29
  30 #include "output.h"
  31 #include "merge.h"
  32
  33 namespace gold
  34 {
  35
  36 template<int size, bool big_endian>
  37 class Track_relocs;
  38
  39 class Eh_frame;
  40
  41 // This class manages the .eh_frame_hdr section, which holds the data
  42 // for the PT_GNU_EH_FRAME segment.  gcc's unwind support code uses
  43 // the PT_GNU_EH_FRAME segment to find the list of FDEs.  This saves
  44 // the time required to register the exception handlers at startup
  45 // time and when a shared object is loaded, and the time required to
  46 // deregister the exception handlers when a shared object is unloaded.
  47
  48 class Eh_frame_hdr : public Output_section_data
  49 {
  50  public:
  51   Eh_frame_hdr(Output_section* eh_frame_section, const Eh_frame*);
  52
  53   // Record that we found an unrecognized .eh_frame section.
  54   void
  55   found_unrecognized_eh_frame_section()
  56   { this->any_unrecognized_eh_frame_sections_ = true; }
  57
  58   // Record an FDE.
  59   void
  60   record_fde(section_offset_type fde_offset, unsigned char fde_encoding)
  61   {
  62     if (!this->any_unrecognized_eh_frame_sections_)
  63       this->fde_offsets_.push_back(std::make_pair(fde_offset, fde_encoding));
  64   }
  65
  66  protected:
  67   // Set the final data size.
  68   void
  69   set_final_data_size();
  70
  71   // Write the data to the file.
  72   void
  73   do_write(Output_file*);
  74
  75   // Write to a map file.
  76   void
  77   do_print_to_mapfile(Mapfile* mapfile) const
  78   { mapfile->print_output_data(this, _("** eh_frame_hdr")); }
  79
  80  private:
  81   // Write the data to the file with the right endianness.
  82   template<int size, bool big_endian>
  83   void
  84   do_sized_write(Output_file*);
  85
  86   // The data we record for one FDE: the offset of the FDE within the
  87   // .eh_frame section, and the FDE encoding.
  88   typedef std::pair<section_offset_type, unsigned char> Fde_offset;
  89
  90   // The list of information we record for an FDE.
  91   typedef std::vector<Fde_offset> Fde_offsets;
  92
  93   // When writing out the header, we convert the FDE offsets into FDE
  94   // addresses.  This is a list of pairs of the offset from the header
  95   // to the FDE PC and to the FDE itself.
  96   template<int size>
  97   class Fde_addresses
  98   {
  99    public:
 100     typedef typename elfcpp::Elf_types<size>::Elf_Addr Address;
 101     typedef typename std::pair<Address, Address> Fde_address;
 102     typedef typename std::vector<Fde_address> Fde_address_list;
 103     typedef typename Fde_address_list::iterator iterator;
 104
 105     Fde_addresses(unsigned int reserve)
 106       : fde_addresses_()
 107     { this->fde_addresses_.reserve(reserve); }
 108
 109     void
 110     push_back(Address pc_address, Address fde_address)
 111     {
 112       this->fde_addresses_.push_back(std::make_pair(pc_address, fde_address));
 113     }
 114
 115     iterator
 116     begin()
 117     { return this->fde_addresses_.begin(); }
 118
 119     iterator
 120     end()
 121     { return this->fde_addresses_.end(); }
 122
 123    private:
 124     Fde_address_list fde_addresses_;
 125   };
 126
 127   // Compare Fde_address objects.
 128   template<int size>
 129   struct Fde_address_compare
 130   {
 131     bool
 132     operator()(const typename Fde_addresses<size>::Fde_address& f1,
 133                const typename Fde_addresses<size>::Fde_address& f2) const
 134     { return f1.first < f2.first; }
 135   };
 136
 137   // Return the PC to which an FDE refers.
 138   template<int size, bool big_endian>
 139   typename elfcpp::Elf_types<size>::Elf_Addr
 140   get_fde_pc(typename elfcpp::Elf_types<size>::Elf_Addr eh_frame_address,
 141              const unsigned char* eh_frame_contents,
 142              section_offset_type fde_offset, unsigned char fde_encoding);
 143
 144   // Convert Fde_offsets to Fde_addresses.
 145   template<int size, bool big_endian>
 146   void
 147   get_fde_addresses(Output_file* of,
 148                     const Fde_offsets* fde_offsets,
 149                     Fde_addresses<size>* fde_addresses);
 150
 151   // The .eh_frame section.
 152   Output_section* eh_frame_section_;
 153   // The .eh_frame section data.
 154   const Eh_frame* eh_frame_data_;
 155   // Data from the FDEs in the .eh_frame sections.
 156   Fde_offsets fde_offsets_;
 157   // Whether we found any .eh_frame sections which we could not
 158   // process.
 159   bool any_unrecognized_eh_frame_sections_;
 160 };
 161
 162 // This class holds an FDE.
 163
 164 class Fde
 165 {
 166  public:
 167   Fde(Relobj* object, unsigned int shndx, section_offset_type input_offset,
 168       const unsigned char* contents, size_t length)
 169     : object_(object),
 170       contents_(reinterpret_cast<const char*>(contents), length)
 171   {
 172     this->u_.from_object.shndx = shndx;
 173     this->u_.from_object.input_offset = input_offset;
 174   }
 175
 176   // Create an FDE associated with a PLT.
 177   Fde(Output_data* plt, const unsigned char* contents, size_t length,
 178       bool post_map)
 179     : object_(NULL),
 180       contents_(reinterpret_cast<const char*>(contents), length)
 181   {
 182     this->u_.from_linker.plt = plt;
 183     this->u_.from_linker.post_map = post_map;
 184   }
 185
 186   // Return the length of this FDE.  Add 4 for the length and 4 for
 187   // the offset to the CIE.
 188   size_t
 189   length() const
 190   { return this->contents_.length() + 8; }
 191
 192   // Add a mapping for this FDE to MERGE_MAP, so that relocations
 193   // against the FDE are applied to right part of the output file.
 194   void
 195   add_mapping(section_offset_type output_offset,
 196               Output_section_data* output_data) const
 197   {
 198     if (this->object_ != NULL)
 199       this->object_->add_merge_mapping(output_data, this->u_.from_object.shndx,
 200                              this->u_.from_object.input_offset, this->length(),
 201                              output_offset);
 202   }
 203
 204   // Return whether this FDE was added after merge mapping.
 205   bool
 206   post_map() const
 207   { return this->object_ == NULL && this->u_.from_linker.post_map; }
 208
 209   // Return whether this FDE was added for the PLT after merge mapping.
 210   bool
 211   post_map(const Output_data* plt) const
 212   { return this->post_map() && this->u_.from_linker.plt == plt; }
 213
 214   // Write the FDE to OVIEW starting at OFFSET.  FDE_ENCODING is the
 215   // encoding, from the CIE.  Round up the bytes to ADDRALIGN if
 216   // necessary.  ADDRESS is the virtual address of OVIEW.  Record the
 217   // FDE in EH_FRAME_HDR.  Return the new offset.
 218   template<int size, bool big_endian>
 219   section_offset_type
 220   write(unsigned char* oview, section_offset_type output_section_offset,
 221         section_offset_type offset, uint64_t address, unsigned int addralign,
 222         section_offset_type cie_offset, unsigned char fde_encoding,
 223         Eh_frame_hdr* eh_frame_hdr);
 224
 225  private:
 226   // The object in which this FDE was seen.  This will be NULL for a
 227   // linker generated FDE.
 228   Relobj* object_;
 229   union
 230   {
 231     // These fields are used if the FDE is from an input object (the
 232     // object_ field is not NULL).
 233     struct
 234     {
 235       // Input section index for this FDE.
 236       unsigned int shndx;
 237       // Offset within the input section for this FDE.
 238       section_offset_type input_offset;
 239     } from_object;
 240     // This field is used if the FDE is generated by the linker (the
 241     // object_ field is NULL).
 242     struct
 243     {
 244       // The only linker generated FDEs are for PLT sections, and this
 245       // points to the PLT section.
 246       Output_data* plt;
 247       // Set if the FDE was added after merge mapping.
 248       bool post_map;
 249     } from_linker;
 250   } u_;
 251   // FDE data.
 252   std::string contents_;
 253 };
 254
 255 // A FDE plus some info from a CIE to allow later writing of the FDE.
 256
 257 struct Post_fde
 258 {
 259   Post_fde(Fde* f, section_offset_type cie_off, unsigned char encoding)
 260     : fde(f), cie_offset(cie_off), fde_encoding(encoding)
 261   { }
 262
 263   Fde* fde;
 264   section_offset_type cie_offset;
 265   unsigned char fde_encoding;
 266 };
 267
 268 typedef std::vector<Post_fde> Post_fdes;
 269
 270 // This class holds a CIE.
 271
 272 class Cie
 273 {
 274  public:
 275   Cie(Relobj* object, unsigned int shndx, section_offset_type input_offset,
 276       unsigned char fde_encoding, const char* personality_name,
 277       const unsigned char* contents, size_t length)
 278     : object_(object),
 279       shndx_(shndx),
 280       input_offset_(input_offset),
 281       fde_encoding_(fde_encoding),
 282       personality_name_(personality_name),
 283       fdes_(),
 284       contents_(reinterpret_cast<const char*>(contents), length)
 285   { }
 286
 287   ~Cie();
 288
 289   // We permit copying a CIE when there are no FDEs.  This is
 290   // convenient in the code which creates them.
 291   Cie(const Cie& cie)
 292     : object_(cie.object_),
 293       shndx_(cie.shndx_),
 294       input_offset_(cie.input_offset_),
 295       fde_encoding_(cie.fde_encoding_),
 296       personality_name_(cie.personality_name_),
 297       fdes_(),
 298       contents_(cie.contents_)
 299   { gold_assert(cie.fdes_.empty()); }
 300
 301   // Add an FDE associated with this CIE.
 302   void
 303   add_fde(Fde* fde)
 304   { this->fdes_.push_back(fde); }
 305
 306   // Remove the last FDE associated with this CIE.
 307   void
 308   remove_fde()
 309   { this->fdes_.pop_back(); }
 310
 311   // Access the last FDE associated with this CIE.
 312   const Fde*
 313   last_fde() const
 314   { return this->fdes_.back(); }
 315
 316   // Return the number of FDEs.
 317   unsigned int
 318   fde_count() const
 319   { return this->fdes_.size(); }
 320
 321   // Set the output offset of this CIE to OUTPUT_OFFSET.  It will be
 322   // followed by all its FDEs.  ADDRALIGN is the required address
 323   // alignment, typically 4 or 8.  This updates MERGE_MAP with the
 324   // mapping.  It returns the new output offset.
 325   section_offset_type
 326   set_output_offset(section_offset_type output_offset, unsigned int addralign,
 327                     Output_section_data*);
 328
 329   // Write the CIE to OVIEW starting at OFFSET.  Round up the bytes to
 330   // ADDRALIGN.  ADDRESS is the virtual address of OVIEW.
 331   // EH_FRAME_HDR is the exception frame header for FDE recording.
 332   // POST_FDES stashes FDEs created after mappings were done, for later
 333   // writing.  Return the new offset.
 334   template<int size, bool big_endian>
 335   section_offset_type
 336   write(unsigned char* oview, section_offset_type output_section_offset,
 337         section_offset_type offset, uint64_t address,
 338         unsigned int addralign, Eh_frame_hdr* eh_frame_hdr,
 339         Post_fdes* post_fdes);
 340
 341   // Return the FDE encoding.
 342   unsigned char
 343   fde_encoding() const
 344   { return this->fde_encoding_; }
 345
 346   friend bool operator<(const Cie&, const Cie&);
 347   friend bool operator==(const Cie&, const Cie&);
 348
 349  private:
 350   // The class is not assignable.
 351   Cie& operator=(const Cie&);
 352
 353   // The object in which this CIE was first seen.  This will be NULL
 354   // for a linker generated CIE.
 355   Relobj* object_;
 356   // Input section index for this CIE.  This will be 0 for a linker
 357   // generated CIE.
 358   unsigned int shndx_;
 359   // Offset within the input section for this CIE.  This will be 0 for
 360   // a linker generated CIE.
 361   section_offset_type input_offset_;
 362   // The encoding of the FDE.  This is a DW_EH_PE code.
 363   unsigned char fde_encoding_;
 364   // The name of the personality routine.  This will be the name of a
 365   // global symbol, or will be the empty string.
 366   std::string personality_name_;
 367   // List of FDEs.
 368   std::vector<Fde*> fdes_;
 369   // CIE data.
 370   std::string contents_;
 371 };
 372
 373 extern bool operator<(const Cie&, const Cie&);
 374 extern bool operator==(const Cie&, const Cie&);
 375
 376 // This class manages .eh_frame sections.  It discards duplicate
 377 // exception information.
 378
 379 class Eh_frame : public Output_section_data
 380 {
 381  public:
 382   enum Eh_frame_section_disposition
 383   {
 384     EH_EMPTY_SECTION,
 385     EH_UNRECOGNIZED_SECTION,
 386     EH_OPTIMIZABLE_SECTION,
 387     EH_END_MARKER_SECTION
 388   };
 389
 390   Eh_frame();
 391
 392   // Record the associated Eh_frame_hdr, if any.
 393   void
 394   set_eh_frame_hdr(Eh_frame_hdr* hdr)
 395   { this->eh_frame_hdr_ = hdr; }
 396
 397   // Add the input section SHNDX in OBJECT.  SYMBOLS is the contents
 398   // of the symbol table section (size SYMBOLS_SIZE), SYMBOL_NAMES is
 399   // the symbol names section (size SYMBOL_NAMES_SIZE).  RELOC_SHNDX
 400   // is the relocation section if any (0 for none, -1U for multiple).
 401   // RELOC_TYPE is the type of the relocation section if any.  This
 402   // returns whether the section was incorporated into the .eh_frame
 403   // data.
 404   template<int size, bool big_endian>
 405   Eh_frame_section_disposition
 406   add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object,
 407                             const unsigned char* symbols,
 408                             section_size_type symbols_size,
 409                             const unsigned char* symbol_names,
 410                             section_size_type symbol_names_size,
 411                             unsigned int shndx, unsigned int reloc_shndx,
 412                             unsigned int reloc_type);
 413
 414   // Add a CIE and an FDE for a PLT section, to permit unwinding
 415   // through a PLT.  The FDE data should start with 8 bytes of zero,
 416   // which will be replaced by a 4 byte PC relative reference to the
 417   // address of PLT and a 4 byte size of PLT.
 418   void
 419   add_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,
 420                       size_t cie_length, const unsigned char* fde_data,
 421                       size_t fde_length);
 422
 423   // Remove all post-map unwind information for a PLT.
 424   void
 425   remove_ehframe_for_plt(Output_data* plt, const unsigned char* cie_data,
 426                          size_t cie_length);
 427
 428   // Return the number of FDEs.
 429   unsigned int
 430   fde_count() const;
 431
 432  protected:
 433   // Set the final data size.
 434   void
 435   set_final_data_size();
 436
 437   // Return the output address for an input address.
 438   bool
 439   do_output_offset(const Relobj*, unsigned int shndx,
 440                    section_offset_type offset,
 441                    section_offset_type* poutput) const;
 442
 443   // Write the data to the file.
 444   void
 445   do_write(Output_file*);
 446
 447   // Write to a map file.
 448   void
 449   do_print_to_mapfile(Mapfile* mapfile) const
 450   { mapfile->print_output_data(this, _("** eh_frame")); }
 451
 452  private:
 453   // The comparison routine for the CIE map.
 454   struct Cie_less
 455   {
 456     bool
 457     operator()(const Cie* cie1, const Cie* cie2) const
 458     { return *cie1 < *cie2; }
 459   };
 460
 461   // A set of unique CIEs.
 462   typedef std::set<Cie*, Cie_less> Cie_offsets;
 463
 464   // A list of unmergeable CIEs.
 465   typedef std::vector<Cie*> Unmergeable_cie_offsets;
 466
 467   // A mapping from offsets to CIEs.  This is used while reading an
 468   // input section.
 469   typedef std::map<uint64_t, Cie*> Offsets_to_cie;
 470
 471   // A list of CIEs, and a bool indicating whether the CIE is
 472   // mergeable.
 473   typedef std::vector<std::pair<Cie*, bool> > New_cies;
 474
 475   // Skip an LEB128.
 476   static bool
 477   skip_leb128(const unsigned char**, const unsigned char*);
 478
 479   // The implementation of add_ehframe_input_section.
 480   template<int size, bool big_endian>
 481   bool
 482   do_add_ehframe_input_section(Sized_relobj_file<size, big_endian>* object,
 483                                const unsigned char* symbols,
 484                                section_size_type symbols_size,
 485                                const unsigned char* symbol_names,
 486                                section_size_type symbol_names_size,
 487                                unsigned int shndx,
 488                                unsigned int reloc_shndx,
 489                                unsigned int reloc_type,
 490                                const unsigned char* pcontents,
 491                                section_size_type contents_len,
 492                                New_cies*);
 493
 494   // Read a CIE.
 495   template<int size, bool big_endian>
 496   bool
 497   read_cie(Sized_relobj_file<size, big_endian>* object,
 498            unsigned int shndx,
 499            const unsigned char* symbols,
 500            section_size_type symbols_size,
 501            const unsigned char* symbol_names,
 502            section_size_type symbol_names_size,
 503            const unsigned char* pcontents,
 504            const unsigned char* pcie,
 505            const unsigned char* pcieend,
 506            Track_relocs<size, big_endian>* relocs,
 507            Offsets_to_cie* cies,
 508            New_cies* new_cies);
 509
 510   // Read an FDE.
 511   template<int size, bool big_endian>
 512   bool
 513   read_fde(Sized_relobj_file<size, big_endian>* object,
 514            unsigned int shndx,
 515            const unsigned char* symbols,
 516            section_size_type symbols_size,
 517            const unsigned char* pcontents,
 518            unsigned int offset,
 519            const unsigned char* pfde,
 520            const unsigned char* pfdeend,
 521            Track_relocs<size, big_endian>* relocs,
 522            Offsets_to_cie* cies);
 523
 524   // Template version of write function.
 525   template<int size, bool big_endian>
 526   void
 527   do_sized_write(unsigned char* oview);
 528
 529   // The exception frame header, if any.
 530   Eh_frame_hdr* eh_frame_hdr_;
 531   // A mapping from all unique CIEs to their offset in the output
 532   // file.
 533   Cie_offsets cie_offsets_;
 534   // A mapping from unmergeable CIEs to their offset in the output
 535   // file.
 536   Unmergeable_cie_offsets unmergeable_cie_offsets_;
 537   // Whether we have created the mappings to the output section.
 538   bool mappings_are_done_;
 539   // The final data size.  This is only set if mappings_are_done_ is
 540   // true.
 541   section_size_type final_data_size_;
 542 };
 543
 544 } // End namespace gold.
 545
 546 #endif // !defined(GOLD_EHFRAME_H)