Subversion Repositories openrisc_me

/* Very simple endian-ness layer for LTO object file handling
   Copyright 2010 Free Software Foundation, Inc.
 
This file is part of GCC.
 
GCC 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, or (at your option) any later
version.
 
GCC 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 GCC; see the file COPYING3.  If not see
<http://www.gnu.org/licenses/>.  */
 
/* This header file provides a simple way to handle object files in
   another endian-ness than the host machine.  This is necesarry to
   enable cross-compilation with LTO enabled.  Targets that use the
   ELF binary object format do not need this (libelf already handles
   endian-ness) but for COFF and Mach-O the functions in this header
   are used in the minimal binary object reader/writer.
 
   For all functions in this header, the user is responsible for
   making sure that the memory accesses are valid.  */
 
#ifndef GCC_LTO_ENDIAN_H
#define GCC_LTO_ENDIAN_H
 
#include <stdint.h>
#include <inttypes.h>
 
static inline uint16_t
get_uint16_le (const unsigned char *ptr)
{
  return ptr[0] | (ptr[1] << 8);
}
 
static inline uint32_t
get_uint32_le (const unsigned char *ptr)
{
  return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
}
 
static inline uint64_t
get_uint64_le (const unsigned char *ptr_)
{
#define ptr (uint64_t) ptr_
  return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24)
         | (ptr[4] << 32) | (ptr[5] << 40) | (ptr[6] << 48) | (ptr[7] << 56);
#undef ptr
}
 
static inline uint16_t
get_uint16_be (const unsigned char *ptr)
{
  return ptr[1] | (ptr[2] << 8);
}
 
static inline uint32_t
get_uint32_be (const unsigned char *ptr)
{
  return ptr[3] | (ptr[2] << 8) | (ptr[1] << 16) | (ptr[0] << 24);
}
 
static inline uint64_t
get_uint64_be (const unsigned char *ptr_)
{
#define ptr (uint64_t) ptr_
  return ptr[7] | (ptr[6] << 8) | (ptr[5] << 16) | (ptr[4] << 24)
         | (ptr[3] << 32) | (ptr[2] << 40) | (ptr[1] << 48) | (ptr[0] << 56);
#undef ptr
}
 
static inline void
put_uint16_le (unsigned char *ptr, uint16_t data)
{
  ptr[0] = data & 0xff;
  ptr[1] = (data >> 8) & 0xff;
}
 
static inline void
put_uint32_le (unsigned char *ptr, uint32_t data)
{
  ptr[0] = data & 0xff;
  ptr[1] = (data >> 8) & 0xff;
  ptr[2] = (data >> 16) & 0xff;
  ptr[3] = (data >> 24) & 0xff;
}
 
static inline void
put_uint64_le (unsigned char *ptr, uint64_t data)
{
  ptr[0] = data & 0xff;
  ptr[1] = (data >> 8) & 0xff;
  ptr[2] = (data >> 16) & 0xff;
  ptr[3] = (data >> 24) & 0xff;
  ptr[4] = (data >> 32) & 0xff;
  ptr[5] = (data >> 40) & 0xff;
  ptr[6] = (data >> 48) & 0xff;
  ptr[7] = (data >> 56) & 0xff;
}
 
static inline void
put_uint16_be (unsigned char *ptr, uint16_t data)
{
  ptr[1] = data & 0xff;
  ptr[0] = (data >> 8) & 0xff;
}
 
static inline void
put_uint32_be (unsigned char *ptr, uint32_t data)
{
  ptr[3] = data & 0xff;
  ptr[2] = (data >> 8) & 0xff;
  ptr[1] = (data >> 16) & 0xff;
  ptr[0] = (data >> 24) & 0xff;
}
 
static inline void
put_uint64_be (unsigned char *ptr, uint64_t data)
{
  ptr[7] = data & 0xff;
  ptr[6] = (data >> 8) & 0xff;
  ptr[5] = (data >> 16) & 0xff;
  ptr[4] = (data >> 24) & 0xff;
  ptr[3] = (data >> 32) & 0xff;
  ptr[2] = (data >> 40) & 0xff;
  ptr[1] = (data >> 48) & 0xff;
  ptr[0] = (data >> 56) & 0xff;
}
 
static inline void
get_string (unsigned char *ptr, char *dest, size_t len)
{
  memcpy (dest, ptr, len);
}
 
static inline void
put_string (unsigned char *ptr, char *src, size_t len)
{
  memcpy (ptr, src, len);
}
 
/* Use the target macro BYTES_BIG_ENDIAN to choose.  */
 
static inline uint16_t
get_uint16 (const unsigned char *ptr)
{
  if (BYTES_BIG_ENDIAN)
    return get_uint16_be (ptr);
  else
    return get_uint16_le (ptr);
}
 
static inline uint32_t
get_uint32 (const unsigned char *ptr)
{
  if (BYTES_BIG_ENDIAN)
    return get_uint32_be (ptr);
  else
    return get_uint32_le (ptr);
}
 
static inline uint64_t
get_uint64 (const unsigned char *ptr)
{
  if (BYTES_BIG_ENDIAN)
    return get_uint64_be (ptr);
  else
    return get_uint64_le (ptr);
}
 
static inline void
put_uint16 (unsigned char *ptr, uint16_t data)
{
  if (BYTES_BIG_ENDIAN)
    put_uint16_be (ptr, data);
  else
    put_uint16_le (ptr, data);
}
 
static inline void
put_uint32 (unsigned char *ptr, uint32_t data)
{
  if (BYTES_BIG_ENDIAN)
    put_uint32_be (ptr, data);
  else
    put_uint32_le (ptr, data);
}
 
static inline void
put_uint64 (unsigned char *ptr, uint64_t data)
{
  if (BYTES_BIG_ENDIAN)
    put_uint64_be (ptr, data);
  else
    put_uint64_le (ptr, data);
}
 
#endif /* GCC_LTO_ENDIAN_H  */