Changeset 4e7ec70 in rtems-tools


Ignore:
Timestamp:
Dec 31, 2012, 7:12:25 AM (7 years ago)
Author:
Chris Johns <chrisj@…>
Branches:
4.10, 4.11, e9f48e9face6c4dea62712d73b35412c0fe10332
Children:
f43851a
Parents:
06a2cf6
Message:

Make layout offsets match image offsets. Add a better strtab search.

The offsets of sections in objects have to be computed in load order
so the offsets work. For example an object could have a sections with
an alignment of 4 and 16 so the 4 may align with the current load
offset and the 16 is padded to align it. This is the way the image is
loaded and so the layout needs to follow these rules.

The strtab search needs to be better. An STL string find was finding
patrial strings and causing errors on the target.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • linkers/rld-rap.cpp

    r06a2cf6 r4e7ec70  
    7878
    7979    /**
     80     * An object section's offset, size and alignment.
     81     */
     82    struct osection
     83    {
     84      std::string name;     //< The name of the section.
     85      uint32_t    offset;   //< The offset in the object file.
     86      uint32_t    size;     //< The size of this section.
     87      uint32_t    align;    //< The alignment.
     88      uint32_t    relocs;   //< The number of relocations.
     89      uint64_t    flags;    //< The flags.
     90
     91      /**
     92       * Construct the object section.
     93       */
     94      osection (const std::string& name,
     95                uint32_t           offset,
     96                uint32_t           size,
     97                uint32_t           align,
     98                uint32_t           relocs,
     99                uint64_t           flags);
     100
     101      /**
     102       * Default constructor.
     103       */
     104      osection ();
     105    };
     106
     107    /**
    80108     * Map of object file section offsets keyed by the object file section
    81109     * index. This is used when adding the external symbols so the symbol's
    82110     * value can be adjusted by the offset of the section in the RAP section.
    83111     */
    84     typedef std::map < int, uint32_t > osections;
     112    typedef std::map < const int, osection > osections;
     113
     114    /**
     115     * An ordered container of object section indexes. We need the same
     116     * order so the alignments match up with the layout.
     117     */
     118    typedef std::vector < int > osecindexes;
    85119
    86120    /**
     
    89123    struct section
    90124    {
    91       std::string name;   //< The name of the section.
    92       uint32_t    size;   //< The size of the section.
    93       uint32_t    offset; //< The offset of the section.
    94       uint32_t    align;  //< The alignment of the section.
    95       bool        rela;   //< The relocation record has an addend field.
    96       relocations relocs; //< The relocations for this section.
    97       osections   osecs;  //< The object section index.
    98 
    99       /**
    100        * Operator to add up section data.
    101        */
    102       section& operator += (const section& sec);
     125      std::string name;      //< The name of the section.
     126      uint32_t    offset;    //< The offset of the section.
     127      bool        rela;      //< The relocation record has an addend field.
     128      relocations relocs;    //< The relocations for this section.
     129      osections   osecs;     //< The object section index.
     130      osecindexes osindexes; //< The object section indexes in order.
    103131
    104132      /**
     
    113141
    114142      /**
    115        * Update based on the section in the object file.
    116        */
    117       void update (const files::sections& secs);
     143       * The size of the section given the offset.
     144       */
     145      uint32_t size (uint32_t offset = 0) const;
     146
     147      /**
     148       * The alignment of the first section.
     149       */
     150      uint32_t alignment () const;
     151
     152      /**
     153       * The alignment of the object section given its index.
     154       */
     155      uint32_t alignment (int index) const;
    118156
    119157      /**
     
    123161
    124162      /**
    125        * Set the alignment.
    126        */
    127       void set_alignment (const section& sec);
     163       * Return the object section given the index.
     164       */
     165      const osection& get_osection (int index) const;
     166
     167      /**
     168       * Output helper function to report the sections in an object file. This
     169       * is useful when seeing the flags in the sections.
     170       */
     171      void output ();
    128172    };
    129173
     
    170214    struct object
    171215    {
    172 
    173216      files::object&  obj;            //< The object file.
    174217      files::sections text;           //< All executable code.
     
    255298
    256299      /**
    257        * Write the compressed output file.
     300       * Write the compressed output file. This is the top level write
     301       * interface.
    258302       *
    259303       * @param comp The compressor.
    260304       */
    261305      void write (compress::compressor& comp);
     306
     307      /**
     308       * Write the RAP section to the compressed output file given the object files.
     309       * Check to make sure the size in the layout and the size written match.
     310       *
     311       * @param comp The compressor.
     312       * @param sec The RAP setion to write.
     313       */
     314      void write (compress::compressor& comp, sections sec);
    262315
    263316      /**
     
    303356       * @param sec The object's RAP section.
    304357       */
    305       void update_section (int index, const section& sec);
     358      void update_section (int index, section& sec);
     359
     360      /**
     361       * Report the RAP section's size.
     362       */
     363      uint32_t section_size (sections sec) const;
     364
     365      /**
     366       * Find a symbol name in the string table.
     367       */
     368      std::size_t find_in_strtab (const std::string& symname);
    306369
    307370    private:
     
    353416    }
    354417
    355     /**
    356      * Output helper function to report the sections in an object file.
    357      * This is useful when seeing the flags in the sections.
    358      *
    359      * @param sec The RAP section to output.
    360      * @param secs The container of sections in the group from the object file.
    361      */
    362     void
    363     output (section& sec, const files::sections& osecs)
    364     {
    365       if (sec.size)
    366       {
    367         std::cout << ' ' << sec.name
    368                   << ": size: " << sec.size
    369                   << " offset: " << sec.offset
     418    relocation::relocation (const files::relocation& reloc,
     419                            const uint32_t           offset)
     420      : offset (reloc.offset + offset),
     421        info (reloc.info),
     422        addend (reloc.addend),
     423        symname (reloc.symname),
     424        symtype (reloc.symtype),
     425        symsect (reloc.symsect),
     426        symvalue (reloc.symvalue)
     427    {
     428    }
     429
     430    osection::osection (const std::string& name,
     431                        uint32_t           offset,
     432                        uint32_t           size,
     433                        uint32_t           align,
     434                        uint32_t           relocs,
     435                        uint64_t           flags)
     436      : name (name),
     437        offset (offset),
     438        size (size),
     439        align (align),
     440        relocs (relocs),
     441        flags (flags)
     442    {
     443    }
     444
     445    osection::osection ()
     446      : offset (0),
     447        size (0),
     448        align (0),
     449        relocs (0),
     450        flags (0)
     451    {
     452    }
     453
     454    section::section ()
     455      : offset (0),
     456        rela (false)
     457    {
     458    }
     459
     460    void
     461    section::clear ()
     462    {
     463      offset = 0;
     464      rela = false;
     465    }
     466
     467    uint32_t
     468    section::size (uint32_t offset_) const
     469    {
     470      uint32_t end = offset_;
     471      if (end == 0)
     472        end = offset;
     473      for (size_t si = 0; si < osindexes.size (); ++si)
     474      {
     475        const osection& osec = get_osection (osindexes[si]);
     476        end = align_offset (end, 0, osec.align);
     477        end += osec.size;
     478      }
     479      return end - offset;
     480    }
     481
     482    uint32_t
     483    section::alignment () const
     484    {
     485      if (!osindexes.empty ())
     486      {
     487        const osection& osec = get_osection (osindexes[0]);
     488        return osec.align;
     489      }
     490      return 0;
     491    }
     492
     493    uint32_t
     494    section::alignment (int index) const
     495    {
     496      const osection& osec = get_osection (index);
     497      return osec.align;
     498    }
     499
     500    void
     501    section::set_offset (const section& sec)
     502    {
     503      uint32_t align = alignment ();
     504      offset = align_offset (sec.offset, sec.size (), align);
     505      if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
     506        std::cout << "rap:section::set-offset: " << name
     507                  << " offset=" << offset
     508                  << " size=" << size ()
     509                  << " align=" << align
     510                  << " sec.offset=" << sec.offset
     511                  << " sec.size=" << sec.size (sec.offset)
    370512                  << std::endl;
    371 
    372         for (files::sections::const_iterator osi = osecs.begin ();
    373              osi != osecs.end ();
     513    }
     514
     515    const osection&
     516    section::get_osection (int index) const
     517    {
     518      osections::const_iterator osi = osecs.find (index);
     519      if (osi == osecs.end ())
     520        throw rld::error ("Invalid object seciton index in '" + name +"': index=" +
     521                          rld::to_string (index),
     522                          "rap::section");
     523      return (*osi).second;
     524    }
     525
     526    /**
     527     * Output helper function to report the sections in an object file. This is
     528     * useful when seeing the flags in the sections.
     529     */
     530    void
     531    section::output ()
     532    {
     533      if (!osindexes.empty ())
     534      {
     535        std::cout << ' ' << name
     536                  << ": size: " << size (offset)
     537                  << " offset: " << offset
     538                  << std::endl;
     539
     540        for (osecindexes::const_iterator osi = osindexes.begin ();
     541             osi != osindexes.end ();
    374542             ++osi)
    375543        {
    376           files::section osec = *osi;
     544          const osection& osec = get_osection (*osi);
    377545
    378546          if (osec.size)
     
    401569                      << " " << flags
    402570                      << " size: " << std::setw (5) << osec.size
    403                       << " align: " << std::setw (3) << osec.alignment
    404                       << " relocs: " << std::setw (4) << osec.relocs.size ()
    405                       << " offset: " << std::setw (5) << sec.osecs[osec.index]
     571                      << " align: " << std::setw (3) << osec.align
     572                      << " relocs: " << std::setw (4) << osec.relocs
     573                      << " offset: " << std::setw (5) << osec.offset
    406574                      << std::hex
    407                       << " image: 0x" << sec.offset + sec.osecs[osec.index]
     575                      << " image: 0x" << offset + osec.offset
    408576                      << std::dec << std::right << std::endl;
    409577          }
     
    412580    }
    413581
    414     relocation::relocation (const files::relocation& reloc,
    415                             const uint32_t           offset)
    416       : offset (reloc.offset + offset),
    417         info (reloc.info),
    418         addend (reloc.addend),
    419         symname (reloc.symname),
    420         symtype (reloc.symtype),
    421         symsect (reloc.symsect),
    422         symvalue (reloc.symvalue)
    423     {
    424     }
    425 
    426     section::section ()
    427       : size (0),
    428         offset (0),
    429         align (0),
    430         rela (false)
    431     {
    432     }
    433 
    434     void
    435     section::clear ()
    436     {
    437       size = 0;
    438       offset = 0;
    439       align = 0;
    440       rela = false;
    441     }
    442 
    443     section&
    444     section::operator += (const section& sec)
    445     {
    446       if (sec.size)
    447       {
    448         if (align < sec.align)
    449           align = sec.align;
    450 
    451         if (size && (align == 0))
    452           throw rld::error ("Invalid alignment '" + name + "'",
    453                             "rap::section");
    454 
    455         size += sec.size;
    456       }
    457 
    458       rela = sec.rela;
    459 
    460       return *this;
    461     }
    462 
    463     void
    464     section::set_alignment (const section& sec)
    465     {
    466       if (align < sec.align)
    467         align = sec.align;
    468     }
    469 
    470     void
    471     section::set_offset (const section& sec)
    472     {
    473       offset = align_offset (sec.offset, sec.size, align);
    474     }
    475 
    476     void
    477     section::update (const files::sections& secs)
    478     {
    479       if (!secs.empty ())
    480       {
    481         align = (*(secs.begin ())).alignment;
    482         size = files::sum_sizes (secs);
    483       }
    484     }
    485 
    486582    /**
    487583     * Helper for for_each to merge the related object sections into the RAP
     
    494590
    495591      section_merge (object& obj, section& sec);
     592
     593      ~section_merge ();
    496594
    497595      void operator () (const files::section& fsec);
     
    507605        sec (sec)
    508606    {
    509       sec.align = 0;
    510607      sec.offset = 0;
    511       sec.size = 0;
    512608      sec.rela = false;
    513609    }
    514610
     611    section_merge::~section_merge ()
     612    {
     613      if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
     614        std::cout << "rap:section-merge: " << sec.name
     615                  << " size=" << sec.size ()
     616                  << " offset=" << sec.offset
     617                  << " " << obj.obj.name ().full ()  << std::endl;
     618    }
     619
    515620    void
    516621    section_merge::operator () (const files::section& fsec)
    517622    {
    518       /*
    519        * The RAP section alignment is the largest of all sections that are
    520        * being merged. This object file section however can aligned at its
    521        * specific alignment. You see this with .const sections which can be say
    522        * 4 .eh_frame and 1 for strings.
    523        */
    524       if (sec.align < fsec.alignment)
    525         sec.align = fsec.alignment;
    526 
    527623      /*
    528624       * Align the size up to the next alignment boundary and use that as the
    529625       * offset for this object file section.
    530626       */
    531       uint32_t offset = align_offset (sec.size, 0, fsec.alignment);
     627      uint32_t offset = align_offset (sec.size (), 0, fsec.alignment);
    532628
    533629      if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
    534630        std::cout << "rap:section-merge: " << fsec.name
     631                  << " sec-size=" << sec.size ()
    535632                  << " relocs=" << fsec.relocs.size ()
    536633                  << " offset=" << offset
     
    543640       * to adjust the external symbol offsets.
    544641       */
    545       sec.osecs[fsec.index] = offset;
     642      osection osec (fsec.name,
     643                     offset,
     644                     fsec.size,
     645                     fsec.alignment,
     646                     fsec.relocs.size (),
     647                     fsec.flags);
     648      sec.osecs[fsec.index] = osec;
     649      sec.osindexes.push_back (fsec.index);
    546650
    547651      uint32_t rc = 0;
     
    567671
    568672      sec.rela = fsec.rela;
    569       sec.size = offset + fsec.size;
    570673    }
    571674
     
    711814    {
    712815      std::cout << "rap:object: " << obj.name ().full () << std::endl;
    713       rap::output (secs[rap_text], text);
    714       rap::output (secs[rap_const], const_);
    715       rap::output (secs[rap_ctor], ctor);
    716       rap::output (secs[rap_dtor], dtor);
    717       rap::output (secs[rap_data], data);
    718       if (secs[rap_bss].size)
    719         std::cout << " bss: size: " << secs[rap_bss].size << std::endl;
     816      secs[rap_text].output ();
     817      secs[rap_const].output ();
     818      secs[rap_ctor].output ();
     819      secs[rap_dtor].output ();
     820      secs[rap_data].output ();
     821      if (secs[rap_bss].size ())
     822        std::cout << " bss: size: " << secs[rap_bss].size () << std::endl;
    720823    }
    721824
     
    763866          object& pobj = *poi;
    764867          for (int s = 0; s < rap_secs; ++s)
     868          {
    765869            obj.secs[s].set_offset (pobj.secs[s]);
     870            sec_size[s] = obj.secs[s].offset + obj.secs[s].size ();
     871            sec_align[s] = obj.secs[s].alignment ();
     872          }
    766873          ++poi;
    767874        }
    768 
    769         for (int s = 0; s < rap_secs; ++s)
    770           update_section (s, obj.secs[s]);
    771875
    772876        collect_symbols (obj);
     
    788892      if (rld::verbose () >= RLD_VERBOSE_INFO)
    789893      {
    790         uint32_t total = (sec_size[rap_text] + sec_size[rap_data] +
     894        uint32_t total = (sec_size[rap_text] + sec_size[rap_const] +
    791895                          sec_size[rap_data] + sec_size[rap_bss] +
    792896                          symtab_size + strtab.size() + relocs_size);
     
    842946            externs.push_back (external (name,
    843947                                         rap_sec,
    844                                          sec.offset + sec.osecs[symsec] +
     948                                         sec.offset + sec.osecs[symsec].offset +
    845949                                         sym.value (),
    846950                                         sym.info ()));
     
    850954        }
    851955      }
     956    }
     957
     958    void
     959    image::write (compress::compressor& comp)
     960    {
     961      /*
     962       * Start with the machine type so the target can check the applicatiion
     963       * is ok and can be loaded. Add the init and fini labels to the string
     964       * table and add the references to the string table next. Follow this
     965       * with the section details then the string table and symbol table then
     966       * finally the relocation records.
     967       */
     968
     969      if (rld::verbose () >= RLD_VERBOSE_INFO)
     970        std::cout << "rap:output: machine=" << comp.transferred () << std::endl;
     971
     972      comp << elf::object_machine_type ()
     973           << elf::object_datatype ()
     974           << elf::object_class ();
     975
     976      /*
     977       * The init and fini label offsets. Then the symbol table and string
     978       * table sizes.
     979       */
     980
     981      if (rld::verbose () >= RLD_VERBOSE_INFO)
     982        std::cout << "rap:output: header=" << comp.transferred () << std::endl;
     983
     984      comp << init_off
     985           << fini_off
     986           << symtab_size
     987           << (uint32_t) strtab.size () + 1
     988           << (uint32_t) 0;
     989
     990      /*
     991       * The sections.
     992       */
     993      for (int s = 0; s < rap_secs; ++s)
     994        comp << sec_size[s]
     995             << sec_align[s];
     996
     997      /*
     998       * Output the sections from each object file.
     999       */
     1000      write (comp, rap_text);
     1001      write (comp, rap_const);
     1002      write (comp, rap_ctor);
     1003      write (comp, rap_dtor);
     1004      write (comp, rap_data);
     1005
     1006      if (rld::verbose () >= RLD_VERBOSE_INFO)
     1007        std::cout << "rap:output: strtab=" << comp.transferred () << std::endl;
     1008
     1009      strtab += '\0';
     1010      comp << strtab;
     1011
     1012      if (rld::verbose () >= RLD_VERBOSE_INFO)
     1013        std::cout << "rap:output: symbols=" << comp.transferred () << std::endl;
     1014
     1015      write_externals (comp);
     1016
     1017      if (rld::verbose () >= RLD_VERBOSE_INFO)
     1018        std::cout << "rap:output: relocs=" << comp.transferred () << std::endl;
     1019
     1020      write_relocations (comp);
    8521021    }
    8531022
     
    8841053      if (rld::verbose () >= RLD_VERBOSE_INFO)
    8851054        std::cout << "rap:output: " << section_names[sec]
    886                   << '=' << comp.transferred () << std::endl;
     1055                  << ": offset=" << comp.transferred ()
     1056                  << " size=" << img.section_size (sec) << std::endl;
    8871057    }
    8881058
     
    9161086
    9171087    void
    918     image::write (compress::compressor& comp)
    919     {
    920       /*
    921        * Start with the machine type so the target can check the applicatiion
    922        * is ok and can be loaded. Add the init and fini labels to the string
    923        * table and add the references to the string table next. Follow this
    924        * with the section details then the string table and symbol table then
    925        * finally the relocation records.
    926        */
    927 
    928       if (rld::verbose () >= RLD_VERBOSE_INFO)
    929         std::cout << "rap:output: machine=" << comp.transferred () << std::endl;
    930 
    931       comp << elf::object_machine_type ()
    932            << elf::object_datatype ()
    933            << elf::object_class ();
    934 
    935       /*
    936        * The init and fini label offsets. Then the symbol table and string
    937        * table sizes.
    938        */
    939 
    940       if (rld::verbose () >= RLD_VERBOSE_INFO)
    941         std::cout << "rap:output: header=" << comp.transferred () << std::endl;
    942 
    943       comp << init_off
    944            << fini_off
    945            << symtab_size
    946            << (uint32_t) strtab.size () + 1
    947            << (uint32_t) 0;
    948 
    949       /*
    950        * The sections.
    951        */
    952       for (int s = 0; s < rap_secs; ++s)
    953         comp << sec_size[s]
    954              << sec_align[s];
    955 
    956       /*
    957        * Output the sections from each object file.
    958        */
     1088    image::write (compress::compressor& comp, sections sec)
     1089    {
     1090      uint32_t image_offset = comp.transferred ();
     1091
    9591092      std::for_each (objs.begin (), objs.end (),
    960                      section_writer (*this, comp, rap_text));
    961       std::for_each (objs.begin (), objs.end (),
    962                      section_writer (*this, comp, rap_const));
    963       std::for_each (objs.begin (), objs.end (),
    964                      section_writer (*this, comp, rap_ctor));
    965       std::for_each (objs.begin (), objs.end (),
    966                      section_writer (*this, comp, rap_dtor));
    967       std::for_each (objs.begin (), objs.end (),
    968                      section_writer (*this, comp, rap_data));
    969 
    970       if (rld::verbose () >= RLD_VERBOSE_INFO)
    971         std::cout << "rap:output: strtab=" << comp.transferred () << std::endl;
    972 
    973       strtab += '\0';
    974       comp << strtab;
    975 
    976       if (rld::verbose () >= RLD_VERBOSE_INFO)
    977         std::cout << "rap:output: symbols=" << comp.transferred () << std::endl;
    978 
    979       write_externals (comp);
    980 
    981       if (rld::verbose () >= RLD_VERBOSE_INFO)
    982         std::cout << "rap:output: relocs=" << comp.transferred () << std::endl;
    983 
    984       write_relocations (comp);
     1093                     section_writer (*this, comp, sec));
     1094
     1095      uint32_t written = comp.transferred () - image_offset;
     1096
     1097      if (written != sec_size[sec])
     1098      {
     1099        std::string msg = "Image output size does not match layout size: ";
     1100        msg += section_names[sec];
     1101        msg += ": layout-size=" + rld::to_string (sec_size[sec]);
     1102        msg += " image-size=" + rld::to_string (written);
     1103        throw rld::error (msg, "rap::write");
     1104      }
    9851105    }
    9861106
     
    10221142          if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
    10231143            std::cout << " sec: " << sec.index << ' ' << sec.name
     1144                      << " offset=" << offset
    10241145                      << " size=" << sec.size
    1025                       << " offset=" << offset
    10261146                      << " align=" << sec.alignment
    10271147                      << " padding=" << (offset - unaligned_offset)  << std::endl;
     
    10831203        uint32_t header;
    10841204
    1085         if (rld::verbose () >= RLD_VERBOSE_TRACE)
     1205        if (1 || rld::verbose () >= RLD_VERBOSE_TRACE)
    10861206          std::cout << "rap:relocation: section:" << section_names[s]
    10871207                    << " relocs=" << count
     
    11031223          uint32_t     rc = 0;
    11041224
    1105           if (rld::verbose () >= RLD_VERBOSE_TRACE)
     1225          if (1 || rld::verbose () >= RLD_VERBOSE_TRACE)
    11061226            std::cout << " relocs=" << sec.relocs.size ()
    11071227                      << " sec.offset=" << sec.offset
    1108                       << " sec.size=" << sec.size
    1109                       << " sec.align=" << sec.align
     1228                      << " sec.size=" << sec.size ()
     1229                      << " sec.align=" << sec.alignment ()
    11101230                      << "  " << obj.obj.name ().full ()  << std::endl;
    11111231
     
    11331253
    11341254              addend += (obj.secs[rap_symsect].offset +
    1135                          obj.secs[rap_symsect].osecs[reloc.symsect] +
     1255                         obj.secs[rap_symsect].osecs[reloc.symsect].offset +
    11361256                         reloc.symvalue);
    11371257
    11381258              write_addend = true;
    11391259
    1140               if (rld::verbose () >= RLD_VERBOSE_TRACE)
     1260              if (1 || rld::verbose () >= RLD_VERBOSE_TRACE)
    11411261                std::cout << "  " << std::setw (2) << sr
    11421262                          << '/' << std::setw (2) << rc
     
    11441264                          << " rap_symsect=" << rap_symsect
    11451265                          << " sec.offset=" << obj.secs[rap_symsect].offset
    1146                           << " sec.osecs=" << obj.secs[rap_symsect].osecs[reloc.symsect]
     1266                          << " sec.osecs=" << obj.secs[rap_symsect].osecs[reloc.symsect].offset
    11471267                          << " (" << obj.obj.get_section (reloc.symsect).name << ')'
    11481268                          << " reloc.symsect=" << reloc.symsect
     
    11621282              info |= RAP_RELOC_STRING;
    11631283
    1164               std::size_t size = strtab.find (reloc.symname);
     1284              std::size_t size = find_in_strtab (reloc.symname);
    11651285
    11661286              if (size == std::string::npos)
     
    11811301            }
    11821302
    1183             if (rld::verbose () >= RLD_VERBOSE_TRACE)
     1303            if (1 || rld::verbose () >= RLD_VERBOSE_TRACE)
    11841304            {
    11851305              std::cout << "  " << std::setw (2) << sr << '/'
     
    11891309              if (write_addend)
    11901310                std::cout << " addend=" << addend;
    1191               if (write_symname)
     1311              if ((info & RAP_RELOC_STRING) != 0)
     1312              {
    11921313                std::cout << " symname=" << reloc.symname;
     1314                if (write_symname)
     1315                  std::cout << " (appended)";
     1316              }
    11931317              std::cout << std::hex
    11941318                        << " reloc.info=0x" << reloc.info << std::dec
     
    12471371
    12481372    void
    1249     image::update_section (int index, const section& sec)
    1250     {
    1251       sec_size[index] = align_offset (sec_size[index], 0, sec.align);
    1252       sec_size[index] += sec.size;
    1253       sec_align[index] = sec.align;
     1373    image::update_section (int index, section& sec)
     1374    {
     1375      uint32_t in = sec_size[index];
     1376      sec_size[index] = align_offset (sec_size[index], sec.size (), sec.alignment ());
     1377      sec_align[index] = sec.alignment ();
    12541378      sec_rela[index] = sec.rela;
     1379
     1380      if (rld::verbose () >= RLD_VERBOSE_FULL_DEBUG)
     1381        std::cout << "rap:image::update-section: " << section_names[index]
     1382                  << " offset=" << in
     1383                  << " sec_size=" << sec_size[index]
     1384                  << " sec_align=" << sec_align[index]
     1385                  << " sec.size=" << sec.size ()
     1386                  << std::endl;
     1387    }
     1388
     1389    uint32_t
     1390    image::section_size (sections sec) const
     1391    {
     1392      if ((sec < 0) || (sec >= rap_secs))
     1393        throw rld::error ("Invalid section index '" + rld::to_string (index),
     1394                          "rap::image::section_size");
     1395      return sec_size[sec];
     1396    }
     1397
     1398    std::size_t
     1399    image::find_in_strtab (const std::string& symname)
     1400    {
     1401      std::size_t pos = 0;
     1402      while (pos < strtab.size ())
     1403      {
     1404        std::size_t off = strtab.find (symname, pos);
     1405        if (off == std::string::npos)
     1406          break;
     1407        if (::strlen (strtab.c_str () + off) == symname.size ())
     1408          return off;
     1409        pos = off + 1;
     1410      }
     1411      return std::string::npos;
    12551412    }
    12561413
Note: See TracChangeset for help on using the changeset viewer.