| // int_encoding.h -- variable length and unaligned integers -*- C++ -*- |
| |
| // Copyright (C) 2009-2021 Free Software Foundation, Inc. |
| // Written by Doug Kwan <dougkwan@google.com> by refactoring scattered |
| // contents from other files in gold. Original code written by Ian |
| // Lance Taylor <iant@google.com> and Caleb Howe <cshowe@google.com>. |
| |
| // This file is part of gold. |
| |
| // This program is free software; you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation; either version 3 of the License, or |
| // (at your option) any later version. |
| |
| // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. |
| |
| // You should have received a copy of the GNU General Public License |
| // along with this program; if not, write to the Free Software |
| // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, |
| // MA 02110-1301, USA. |
| |
| #ifndef GOLD_INT_ENCODING_H |
| #define GOLD_INT_ENCODING_H |
| |
| #include <vector> |
| #include "elfcpp.h" |
| #include "target.h" |
| #include "parameters.h" |
| |
| namespace gold |
| { |
| |
| // |
| // LEB 128 encoding support. |
| // |
| |
| // Read a ULEB 128 encoded integer from BUFFER. Return the length of the |
| // encoded integer at the location PLEN. The common case of a single-byte |
| // value is handled inline, and multi-byte values are processed by the _x |
| // routine, where BYTE is the first byte of the value. |
| |
| uint64_t |
| read_unsigned_LEB_128_x(const unsigned char* buffer, size_t* plen, |
| unsigned char byte); |
| |
| inline uint64_t |
| read_unsigned_LEB_128(const unsigned char* buffer, size_t* plen) |
| { |
| unsigned char byte = *buffer++; |
| |
| if ((byte & 0x80) != 0) |
| return read_unsigned_LEB_128_x(buffer, plen, byte); |
| |
| *plen = 1; |
| return static_cast<uint64_t>(byte); |
| } |
| |
| // Read an SLEB 128 encoded integer from BUFFER. Return the length of the |
| // encoded integer at the location PLEN. The common case of a single-byte |
| // value is handled inline, and multi-byte values are processed by the _x |
| // routine, where BYTE is the first byte of the value. |
| |
| int64_t |
| read_signed_LEB_128_x(const unsigned char* buffer, size_t* plen, |
| unsigned char byte); |
| |
| inline int64_t |
| read_signed_LEB_128(const unsigned char* buffer, size_t* plen) |
| { |
| unsigned char byte = *buffer++; |
| |
| if ((byte & 0x80) != 0) |
| return read_signed_LEB_128_x(buffer, plen, byte); |
| |
| *plen = 1; |
| if (byte & 0x40) |
| return -(static_cast<int64_t>(1) << 7) | static_cast<int64_t>(byte); |
| return static_cast<int64_t>(byte); |
| } |
| |
| // Write a ULEB 128 encoded VALUE to BUFFER. |
| |
| void |
| write_unsigned_LEB_128(std::vector<unsigned char>* buffer, uint64_t value); |
| |
| // Return the ULEB 128 encoded size of VALUE. |
| |
| size_t |
| get_length_as_unsigned_LEB_128(uint64_t value); |
| |
| // |
| // Unaligned integer encoding support. |
| // |
| |
| // Insert VALSIZE-bit integer VALUE into DESTINATION. |
| |
| template <int valsize> |
| void insert_into_vector(std::vector<unsigned char>* destination, |
| typename elfcpp::Valtype_base<valsize>::Valtype value) |
| { |
| unsigned char buffer[valsize / 8]; |
| if (parameters->target().is_big_endian()) |
| elfcpp::Swap_unaligned<valsize, true>::writeval(buffer, value); |
| else |
| elfcpp::Swap_unaligned<valsize, false>::writeval(buffer, value); |
| destination->insert(destination->end(), buffer, buffer + valsize / 8); |
| } |
| |
| // Read a possibly unaligned integer of SIZE from SOURCE. |
| |
| template <int valsize> |
| typename elfcpp::Valtype_base<valsize>::Valtype |
| read_from_pointer(const unsigned char* source) |
| { |
| typename elfcpp::Valtype_base<valsize>::Valtype return_value; |
| if (parameters->target().is_big_endian()) |
| return_value = elfcpp::Swap_unaligned<valsize, true>::readval(source); |
| else |
| return_value = elfcpp::Swap_unaligned<valsize, false>::readval(source); |
| return return_value; |
| } |
| |
| // Read a possibly unaligned integer of SIZE. Update SOURCE after read. |
| |
| template <int valsize> |
| typename elfcpp::Valtype_base<valsize>::Valtype |
| read_from_pointer(unsigned char** source) |
| { |
| typename elfcpp::Valtype_base<valsize>::Valtype return_value; |
| if (parameters->target().is_big_endian()) |
| return_value = elfcpp::Swap_unaligned<valsize, true>::readval(*source); |
| else |
| return_value = elfcpp::Swap_unaligned<valsize, false>::readval(*source); |
| *source += valsize / 8; |
| return return_value; |
| } |
| |
| // Same as the above except for use with const unsigned char data. |
| |
| template <int valsize> |
| typename elfcpp::Valtype_base<valsize>::Valtype |
| read_from_pointer(const unsigned char** source) |
| { |
| typename elfcpp::Valtype_base<valsize>::Valtype return_value; |
| if (parameters->target().is_big_endian()) |
| return_value = elfcpp::Swap_unaligned<valsize, true>::readval(*source); |
| else |
| return_value = elfcpp::Swap_unaligned<valsize, false>::readval(*source); |
| *source += valsize / 8; |
| return return_value; |
| } |
| |
| } // End namespace gold. |
| |
| #endif // !defined(GOLD_INT_ENCODING_H) |