daily update
[binutils.git] / elfcpp / elfcpp_swap.h
blob329ed163831af55aef3767164b80ec74c51d9923
1 // elfcpp_swap.h -- Handle swapping for elfcpp -*- C++ -*-
3 // Copyright 2006, 2007, Free Software Foundation, Inc.
4 // Written by Ian Lance Taylor <iant@google.com>.
6 // This file is part of elfcpp.
8 // This program is free software; you can redistribute it and/or
9 // modify it under the terms of the GNU Library General Public License
10 // as published by the Free Software Foundation; either version 2, or
11 // (at your option) any later version.
13 // In addition to the permissions in the GNU Library General Public
14 // License, the Free Software Foundation gives you unlimited
15 // permission to link the compiled version of this file into
16 // combinations with other programs, and to distribute those
17 // combinations without any restriction coming from the use of this
18 // file. (The Library Public License restrictions do apply in other
19 // respects; for example, they cover modification of the file, and
20 /// distribution when not linked into a combined executable.)
22 // This program is distributed in the hope that it will be useful, but
23 // WITHOUT ANY WARRANTY; without even the implied warranty of
24 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
25 // Library General Public License for more details.
27 // You should have received a copy of the GNU Library General Public
28 // License along with this program; if not, write to the Free Software
29 // Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
30 // 02110-1301, USA.
32 // This header file defines basic template classes to efficiently swap
33 // numbers between host form and target form. When the host and
34 // target have the same endianness, these turn into no-ops.
36 #ifndef ELFCPP_SWAP_H
37 #define ELFCPP_SWAP_H
39 #include <stdint.h>
40 #include <endian.h>
41 #include <byteswap.h>
43 namespace elfcpp
46 // Endian simply indicates whether the host is big endian or not.
48 struct Endian
50 public:
51 // Used for template specializations.
52 static const bool host_big_endian = __BYTE_ORDER == __BIG_ENDIAN;
55 // Valtype_base is a template based on size (8, 16, 32, 64) which
56 // defines the type Valtype as the unsigned integer, and
57 // Signed_valtype as the signed integer, of the specified size.
59 template<int size>
60 struct Valtype_base;
62 template<>
63 struct Valtype_base<8>
65 typedef uint8_t Valtype;
66 typedef int8_t Signed_valtype;
69 template<>
70 struct Valtype_base<16>
72 typedef uint16_t Valtype;
73 typedef int16_t Signed_valtype;
76 template<>
77 struct Valtype_base<32>
79 typedef uint32_t Valtype;
80 typedef int32_t Signed_valtype;
83 template<>
84 struct Valtype_base<64>
86 typedef uint64_t Valtype;
87 typedef int64_t Signed_valtype;
90 // Convert_endian is a template based on size and on whether the host
91 // and target have the same endianness. It defines the type Valtype
92 // as Valtype_base does, and also defines a function convert_host
93 // which takes an argument of type Valtype and returns the same value,
94 // but swapped if the host and target have different endianness.
96 template<int size, bool same_endian>
97 struct Convert_endian;
99 template<int size>
100 struct Convert_endian<size, true>
102 typedef typename Valtype_base<size>::Valtype Valtype;
104 static inline Valtype
105 convert_host(Valtype v)
106 { return v; }
109 template<>
110 struct Convert_endian<8, false>
112 typedef Valtype_base<8>::Valtype Valtype;
114 static inline Valtype
115 convert_host(Valtype v)
116 { return v; }
119 template<>
120 struct Convert_endian<16, false>
122 typedef Valtype_base<16>::Valtype Valtype;
124 static inline Valtype
125 convert_host(Valtype v)
126 { return bswap_16(v); }
129 template<>
130 struct Convert_endian<32, false>
132 typedef Valtype_base<32>::Valtype Valtype;
134 static inline Valtype
135 convert_host(Valtype v)
136 { return bswap_32(v); }
139 template<>
140 struct Convert_endian<64, false>
142 typedef Valtype_base<64>::Valtype Valtype;
144 static inline Valtype
145 convert_host(Valtype v)
146 { return bswap_64(v); }
149 // Convert is a template based on size and on whether the target is
150 // big endian. It defines Valtype and convert_host like
151 // Convert_endian. That is, it is just like Convert_endian except in
152 // the meaning of the second template parameter.
154 template<int size, bool big_endian>
155 struct Convert
157 typedef typename Valtype_base<size>::Valtype Valtype;
159 static inline Valtype
160 convert_host(Valtype v)
162 return Convert_endian<size, big_endian == Endian::host_big_endian>
163 ::convert_host(v);
167 // Swap is a template based on size and on whether the target is big
168 // endian. It defines the type Valtype and the functions readval and
169 // writeval. The functions read and write values of the appropriate
170 // size out of buffers, swapping them if necessary. readval and
171 // writeval are overloaded to take pointers to the appropriate type or
172 // pointers to unsigned char.
174 template<int size, bool big_endian>
175 struct Swap
177 typedef typename Valtype_base<size>::Valtype Valtype;
179 static inline Valtype
180 readval(const Valtype* wv)
181 { return Convert<size, big_endian>::convert_host(*wv); }
183 static inline void
184 writeval(Valtype* wv, Valtype v)
185 { *wv = Convert<size, big_endian>::convert_host(v); }
187 static inline Valtype
188 readval(const unsigned char* wv)
189 { return readval(reinterpret_cast<const Valtype*>(wv)); }
191 static inline void
192 writeval(unsigned char* wv, Valtype v)
193 { writeval(reinterpret_cast<Valtype*>(wv), v); }
196 // We need to specialize the 8-bit version of Swap to avoid
197 // conflicting overloads, since both versions of readval and writeval
198 // will have the same type parameters.
200 template<bool big_endian>
201 struct Swap<8, big_endian>
203 typedef typename Valtype_base<8>::Valtype Valtype;
205 static inline Valtype
206 readval(const Valtype* wv)
207 { return *wv; }
209 static inline void
210 writeval(Valtype* wv, Valtype v)
211 { *wv = v; }
214 // Swap_unaligned is a template based on size and on whether the
215 // target is big endian. It defines the type Valtype and the
216 // functions readval and writeval. The functions read and write
217 // values of the appropriate size out of buffers which may be
218 // misaligned.
220 template<int size, bool big_endian>
221 struct Swap_unaligned;
223 template<bool big_endian>
224 struct Swap_unaligned<8, big_endian>
226 typedef typename Valtype_base<8>::Valtype Valtype;
228 static inline Valtype
229 readval(const unsigned char* wv)
230 { return *wv; }
232 static inline void
233 writeval(unsigned char* wv, Valtype v)
234 { *wv = v; }
237 template<>
238 struct Swap_unaligned<16, false>
240 typedef Valtype_base<16>::Valtype Valtype;
242 static inline Valtype
243 readval(const unsigned char* wv)
245 return (wv[1] << 8) | wv[0];
248 static inline void
249 writeval(unsigned char* wv, Valtype v)
251 wv[1] = v >> 8;
252 wv[0] = v;
256 template<>
257 struct Swap_unaligned<16, true>
259 typedef Valtype_base<16>::Valtype Valtype;
261 static inline Valtype
262 readval(const unsigned char* wv)
264 return (wv[0] << 8) | wv[1];
267 static inline void
268 writeval(unsigned char* wv, Valtype v)
270 wv[0] = v >> 8;
271 wv[1] = v;
275 template<>
276 struct Swap_unaligned<32, false>
278 typedef Valtype_base<32>::Valtype Valtype;
280 static inline Valtype
281 readval(const unsigned char* wv)
283 return (wv[3] << 24) | (wv[2] << 16) | (wv[1] << 8) | wv[0];
286 static inline void
287 writeval(unsigned char* wv, Valtype v)
289 wv[3] = v >> 24;
290 wv[2] = v >> 16;
291 wv[1] = v >> 8;
292 wv[0] = v;
296 template<>
297 struct Swap_unaligned<32, true>
299 typedef Valtype_base<32>::Valtype Valtype;
301 static inline Valtype
302 readval(const unsigned char* wv)
304 return (wv[0] << 24) | (wv[1] << 16) | (wv[2] << 8) | wv[3];
307 static inline void
308 writeval(unsigned char* wv, Valtype v)
310 wv[0] = v >> 24;
311 wv[1] = v >> 16;
312 wv[2] = v >> 8;
313 wv[3] = v;
317 template<>
318 struct Swap_unaligned<64, false>
320 typedef Valtype_base<64>::Valtype Valtype;
322 static inline Valtype
323 readval(const unsigned char* wv)
325 return ((static_cast<Valtype>(wv[7]) << 56)
326 | (static_cast<Valtype>(wv[6]) << 48)
327 | (static_cast<Valtype>(wv[5]) << 40)
328 | (static_cast<Valtype>(wv[4]) << 32)
329 | (static_cast<Valtype>(wv[3]) << 24)
330 | (static_cast<Valtype>(wv[2]) << 16)
331 | (static_cast<Valtype>(wv[1]) << 8)
332 | static_cast<Valtype>(wv[0]));
335 static inline void
336 writeval(unsigned char* wv, Valtype v)
338 wv[7] = v >> 56;
339 wv[6] = v >> 48;
340 wv[5] = v >> 40;
341 wv[4] = v >> 32;
342 wv[3] = v >> 24;
343 wv[2] = v >> 16;
344 wv[1] = v >> 8;
345 wv[0] = v;
349 template<>
350 struct Swap_unaligned<64, true>
352 typedef Valtype_base<64>::Valtype Valtype;
354 static inline Valtype
355 readval(const unsigned char* wv)
357 return ((static_cast<Valtype>(wv[0]) << 56)
358 | (static_cast<Valtype>(wv[1]) << 48)
359 | (static_cast<Valtype>(wv[2]) << 40)
360 | (static_cast<Valtype>(wv[3]) << 32)
361 | (static_cast<Valtype>(wv[4]) << 24)
362 | (static_cast<Valtype>(wv[5]) << 16)
363 | (static_cast<Valtype>(wv[6]) << 8)
364 | static_cast<Valtype>(wv[7]));
367 static inline void
368 writeval(unsigned char* wv, Valtype v)
370 wv[7] = v >> 56;
371 wv[6] = v >> 48;
372 wv[5] = v >> 40;
373 wv[4] = v >> 32;
374 wv[3] = v >> 24;
375 wv[2] = v >> 16;
376 wv[1] = v >> 8;
377 wv[0] = v;
381 } // End namespace elfcpp.
383 #endif // !defined(ELFCPP_SWAP_H)