Retro68/binutils/gold/int_encoding.h
2015-08-28 17:32:19 +02:00

159 lines
4.9 KiB
C++

// int_encoding.h -- variable length and unaligned integers -*- C++ -*-
// Copyright (C) 2009-2014 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)