OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [lto/] [lto-endian.h] - Blame information for rev 316

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 288 jeremybenn
/* Very simple endian-ness layer for LTO object file handling
2
   Copyright 2010 Free Software Foundation, Inc.
3
 
4
This file is part of GCC.
5
 
6
GCC is free software; you can redistribute it and/or modify it under
7
the terms of the GNU General Public License as published by the Free
8
Software Foundation; either version 3, or (at your option) any later
9
version.
10
 
11
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12
WARRANTY; without even the implied warranty of MERCHANTABILITY or
13
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14
for more details.
15
 
16
You should have received a copy of the GNU General Public License
17
along with GCC; see the file COPYING3.  If not see
18
<http://www.gnu.org/licenses/>.  */
19
 
20
/* This header file provides a simple way to handle object files in
21
   another endian-ness than the host machine.  This is necesarry to
22
   enable cross-compilation with LTO enabled.  Targets that use the
23
   ELF binary object format do not need this (libelf already handles
24
   endian-ness) but for COFF and Mach-O the functions in this header
25
   are used in the minimal binary object reader/writer.
26
 
27
   For all functions in this header, the user is responsible for
28
   making sure that the memory accesses are valid.  */
29
 
30
#ifndef GCC_LTO_ENDIAN_H
31
#define GCC_LTO_ENDIAN_H
32
 
33
#include <stdint.h>
34
#include <inttypes.h>
35
 
36
static inline uint16_t
37
get_uint16_le (const unsigned char *ptr)
38
{
39
  return ptr[0] | (ptr[1] << 8);
40
}
41
 
42
static inline uint32_t
43
get_uint32_le (const unsigned char *ptr)
44
{
45
  return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24);
46
}
47
 
48
static inline uint64_t
49
get_uint64_le (const unsigned char *ptr_)
50
{
51
#define ptr (uint64_t) ptr_
52
  return ptr[0] | (ptr[1] << 8) | (ptr[2] << 16) | (ptr[3] << 24)
53
         | (ptr[4] << 32) | (ptr[5] << 40) | (ptr[6] << 48) | (ptr[7] << 56);
54
#undef ptr
55
}
56
 
57
static inline uint16_t
58
get_uint16_be (const unsigned char *ptr)
59
{
60
  return ptr[1] | (ptr[2] << 8);
61
}
62
 
63
static inline uint32_t
64
get_uint32_be (const unsigned char *ptr)
65
{
66
  return ptr[3] | (ptr[2] << 8) | (ptr[1] << 16) | (ptr[0] << 24);
67
}
68
 
69
static inline uint64_t
70
get_uint64_be (const unsigned char *ptr_)
71
{
72
#define ptr (uint64_t) ptr_
73
  return ptr[7] | (ptr[6] << 8) | (ptr[5] << 16) | (ptr[4] << 24)
74
         | (ptr[3] << 32) | (ptr[2] << 40) | (ptr[1] << 48) | (ptr[0] << 56);
75
#undef ptr
76
}
77
 
78
static inline void
79
put_uint16_le (unsigned char *ptr, uint16_t data)
80
{
81
  ptr[0] = data & 0xff;
82
  ptr[1] = (data >> 8) & 0xff;
83
}
84
 
85
static inline void
86
put_uint32_le (unsigned char *ptr, uint32_t data)
87
{
88
  ptr[0] = data & 0xff;
89
  ptr[1] = (data >> 8) & 0xff;
90
  ptr[2] = (data >> 16) & 0xff;
91
  ptr[3] = (data >> 24) & 0xff;
92
}
93
 
94
static inline void
95
put_uint64_le (unsigned char *ptr, uint64_t data)
96
{
97
  ptr[0] = data & 0xff;
98
  ptr[1] = (data >> 8) & 0xff;
99
  ptr[2] = (data >> 16) & 0xff;
100
  ptr[3] = (data >> 24) & 0xff;
101
  ptr[4] = (data >> 32) & 0xff;
102
  ptr[5] = (data >> 40) & 0xff;
103
  ptr[6] = (data >> 48) & 0xff;
104
  ptr[7] = (data >> 56) & 0xff;
105
}
106
 
107
static inline void
108
put_uint16_be (unsigned char *ptr, uint16_t data)
109
{
110
  ptr[1] = data & 0xff;
111
  ptr[0] = (data >> 8) & 0xff;
112
}
113
 
114
static inline void
115
put_uint32_be (unsigned char *ptr, uint32_t data)
116
{
117
  ptr[3] = data & 0xff;
118
  ptr[2] = (data >> 8) & 0xff;
119
  ptr[1] = (data >> 16) & 0xff;
120
  ptr[0] = (data >> 24) & 0xff;
121
}
122
 
123
static inline void
124
put_uint64_be (unsigned char *ptr, uint64_t data)
125
{
126
  ptr[7] = data & 0xff;
127
  ptr[6] = (data >> 8) & 0xff;
128
  ptr[5] = (data >> 16) & 0xff;
129
  ptr[4] = (data >> 24) & 0xff;
130
  ptr[3] = (data >> 32) & 0xff;
131
  ptr[2] = (data >> 40) & 0xff;
132
  ptr[1] = (data >> 48) & 0xff;
133
  ptr[0] = (data >> 56) & 0xff;
134
}
135
 
136
static inline void
137
get_string (unsigned char *ptr, char *dest, size_t len)
138
{
139
  memcpy (dest, ptr, len);
140
}
141
 
142
static inline void
143
put_string (unsigned char *ptr, char *src, size_t len)
144
{
145
  memcpy (ptr, src, len);
146
}
147
 
148
/* Use the target macro BYTES_BIG_ENDIAN to choose.  */
149
 
150
static inline uint16_t
151
get_uint16 (const unsigned char *ptr)
152
{
153
  if (BYTES_BIG_ENDIAN)
154
    return get_uint16_be (ptr);
155
  else
156
    return get_uint16_le (ptr);
157
}
158
 
159
static inline uint32_t
160
get_uint32 (const unsigned char *ptr)
161
{
162
  if (BYTES_BIG_ENDIAN)
163
    return get_uint32_be (ptr);
164
  else
165
    return get_uint32_le (ptr);
166
}
167
 
168
static inline uint64_t
169
get_uint64 (const unsigned char *ptr)
170
{
171
  if (BYTES_BIG_ENDIAN)
172
    return get_uint64_be (ptr);
173
  else
174
    return get_uint64_le (ptr);
175
}
176
 
177
static inline void
178
put_uint16 (unsigned char *ptr, uint16_t data)
179
{
180
  if (BYTES_BIG_ENDIAN)
181
    put_uint16_be (ptr, data);
182
  else
183
    put_uint16_le (ptr, data);
184
}
185
 
186
static inline void
187
put_uint32 (unsigned char *ptr, uint32_t data)
188
{
189
  if (BYTES_BIG_ENDIAN)
190
    put_uint32_be (ptr, data);
191
  else
192
    put_uint32_le (ptr, data);
193
}
194
 
195
static inline void
196
put_uint64 (unsigned char *ptr, uint64_t data)
197
{
198
  if (BYTES_BIG_ENDIAN)
199
    put_uint64_be (ptr, data);
200
  else
201
    put_uint64_le (ptr, data);
202
}
203
 
204
#endif /* GCC_LTO_ENDIAN_H  */
205
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.