projects / deliverable / binutils-gdb.git / blame
| Commit | Line | Data |
|---|---|---|
| 3a9c3d12 NC |
1 | /* |
| 2 | * Copyright (C) 1995 Advanced RISC Machines Limited. All rights reserved. | |
| 3 | * | |
| 4 | * This software may be freely used, copied, modified, and distributed | |
| 5 | * provided that the above copyright notice is preserved in all copies of the | |
| 6 | * software. | |
| 7 | */ | |
| 8 | ||
| 9 | /* -*-C-*- | |
| 10 | * | |
| 11 | * $Revision$ | |
| 12 | * $Date$ | |
| 13 | * | |
| 14 | * | |
| 15 | * endian.h - target endianness independent read/write primitives. | |
| 16 | */ | |
| 17 | ||
| 18 | #ifndef angel_endian_h | |
| 19 | #define angel_endian_h | |
| 20 | ||
| 21 | /* | |
| 22 | * The endianness of the data being processed needs to be known, but | |
| 23 | * the host endianness is not required (since the data is constructed | |
| 24 | * using bytes). At the moment these are provided as macros. This | |
| 25 | * gives the compiler freedom in optimising individual calls. However, | |
| 26 | * if space is at a premium then functions should be provided. | |
| 27 | * | |
| 28 | * NOTE: These macros assume that the data has been packed in the same format | |
| 29 | * as the packing on the build host. If this is not the case then | |
| 30 | * the wrong addresses could be used when dealing with structures. | |
| 31 | * | |
| 32 | */ | |
| 33 | ||
| 34 | /* | |
| 35 | * For all the following routines the target endianness is defined by the | |
| 36 | * following boolean definitions. | |
| 37 | */ | |
| 38 | #define BE (1 == 1) /* TRUE : big-endian */ | |
| 39 | #define LE (1 == 0) /* FALSE : little-endian */ | |
| 40 | ||
| 41 | /* | |
| 42 | * The following type definitions are used by the endianness converting | |
| 43 | * macros. | |
| 44 | */ | |
| 45 | typedef unsigned char U8; | |
| 46 | typedef U8 *P_U8; | |
| 47 | typedef const U8 *CP_U8; | |
| 48 | ||
| 49 | typedef unsigned short U16; | |
| 50 | typedef U16 *P_U16; | |
| 51 | ||
| 52 | typedef unsigned int U32; | |
| 53 | typedef U32 *P_U32; | |
| 54 | ||
| 55 | /* | |
| 56 | * If the endianness of the host and target are known (fixed) and the same | |
| 57 | * then the following macro definitions can be used. These just directly copy | |
| 58 | * the data. | |
| 59 | * | |
| 60 | * #define READ(e,a) (a) | |
| 61 | * #define WRITE(e,a,v) ((a) = (v)) | |
| 62 | * #define PREAD(e,a) (a) | |
| 63 | * #define PWRITE(e,a,v) (*(a) = (v)) | |
| 64 | */ | |
| 65 | ||
| 66 | /* | |
| 67 | * These macros assume that a byte (char) is 8bits in size, and that the | |
| 68 | * endianness is not important when reading or writing bytes. | |
| 69 | */ | |
| 70 | #define PUT8(a,v) (*((P_U8)(a)) = (U8)(v)) | |
| 71 | #define PUT16LE(a,v) (PUT8(a,((v) & 0xFF)), \ | |
| 72 | PUT8((((P_U8)(a)) + sizeof(char)),((v) >> 8))) | |
| 73 | #define PUT16BE(a,v) (PUT8(a,((v) >> 8)), \ | |
| 74 | PUT8((((P_U8)(a)) + sizeof(char)),((v) & 0xFF))) | |
| 75 | #define PUT32LE(a,v) (PUT16LE(a,v), \ | |
| 76 | PUT16LE((((P_U8)(a)) + sizeof(short)),((v) >> 16))) | |
| 77 | #define PUT32BE(a,v) (PUT16BE(a,((v) >> 16)), \ | |
| 78 | PUT16BE((((P_U8)(a)) + sizeof(short)),v)) | |
| 79 | ||
| 80 | #define GET8(a) (*((CP_U8)(a))) | |
| 81 | #define GET16LE(a) (GET8(a) | (((U16)GET8(((CP_U8)(a)) + sizeof(char))) << 8)) | |
| 82 | #define GET16BE(a) ((((U16)GET8(a)) << 8) | GET8(((CP_U8)(a)) + sizeof(char))) | |
| 83 | #define GET32LE(a) (GET16LE(a) | \ | |
| 84 | (((U32)GET16LE(((CP_U8)(a)) + sizeof(short))) << 16)) | |
| 85 | #define GET32BE(a) ((((U32)GET16BE(a)) << 16) | \ | |
| 86 | GET16BE(((CP_U8)(a)) + sizeof(short))) | |
| 87 | ||
| 88 | /* | |
| 89 | * These macros simplify the code in respect to reading and writing the | |
| 90 | * correct size data when dealing with endianness. "e" is TRUE if we are | |
| 91 | * dealing with big-endian data, FALSE if we are dealing with little-endian. | |
| 92 | */ | |
| 93 | ||
| 94 | /* void WRITE(int endianness, void *address, unsigned value); */ | |
| 95 | ||
| 96 | #define WRITE16(e,a,v) ((e) ? PUT16BE(&(a),v) : PUT16LE(&(a),v)) | |
| 97 | #define WRITE32(e,a,v) ((e) ? PUT32BE(&(a),v) : PUT32LE(&(a),v)) | |
| 98 | #define WRITE(e,a,v) ((sizeof(v) == sizeof(char)) ? \ | |
| 99 | PUT8(&(a),v) : ((sizeof(v) == sizeof(short)) ? \ | |
| 100 | WRITE16(e,a,v) : WRITE32(e,a,v))) | |
| 101 | ||
| 102 | /* unsigned READ(int endianness, void *address) */ | |
| 103 | #define READ16(e,a) ((e) ? GET16BE(&(a)) : GET16LE(&(a))) | |
| 104 | #define READ32(e,a) ((e) ? GET32BE(&(a)) : GET32LE(&(a))) | |
| 105 | #define READ(e,a) ((sizeof(a) == sizeof(char)) ? \ | |
| 106 | GET8((CP_U8)&(a)) : ((sizeof(a) == sizeof(short)) ? \ | |
| 107 | READ16(e,a) : READ32(e,a))) | |
| 108 | ||
| 109 | /* void PWRITE(int endianness, void *address, unsigned value); */ | |
| 110 | #define PWRITE16(e,a,v) ((e) ? PUT16BE(a,v) : PUT16LE(a,v)) | |
| 111 | #define PWRITE32(e,a,v) ((e) ? PUT32BE(a,v) : PUT32LE(a,v)) | |
| 112 | #define PWRITE(e,a,v) ((sizeof(v) == sizeof(char)) ? \ | |
| 113 | PUT8(a,v) : ((sizeof(v) == sizeof(short)) ? \ | |
| 114 | PWRITE16(e,a,v) : PWRITE32(e,a,v))) | |
| 115 | ||
| 116 | /* unsigned PREAD(int endianness, void *address) */ | |
| 117 | #define PREAD16(e,a) ((e) ? GET16BE(a) : GET16LE(a)) | |
| 118 | #define PREAD32(e,a) ((e) ? GET32BE(a) : GET32LE(a)) | |
| 119 | #define PREAD(e,a) ((sizeof(*(a)) == sizeof(char)) ? \ | |
| 120 | GET8((CP_U8)a) : ((sizeof(*(a)) == sizeof(short)) ? \ | |
| 121 | PREAD16(e,a) : PREAD32(e,a))) | |
| 122 | ||
| 123 | #endif /* !defined(angel_endian_h) */ | |
| 124 | ||
| 125 | /* EOF endian.h */ |