Home | History | Annotate | Line # | Download | only in common
sim-endian.h revision 1.1.1.10.2.1 
      1 /* The common simulator framework for GDB, the GNU Debugger.
      2 
      3    Copyright 2002-2024 Free Software Foundation, Inc.
      4 
      5    Contributed by Andrew Cagney and Red Hat.
      6 
      7    This file is part of GDB.
      8 
      9    This program is free software; you can redistribute it and/or modify
     10    it under the terms of the GNU General Public License as published by
     11    the Free Software Foundation; either version 3 of the License, or
     12    (at your option) any later version.
     13 
     14    This program is distributed in the hope that it will be useful,
     15    but WITHOUT ANY WARRANTY; without even the implied warranty of
     16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     17    GNU General Public License for more details.
     18 
     19    You should have received a copy of the GNU General Public License
     20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
     21 
     22 
     23 #ifndef SIM_ENDIAN_H
     24 #define SIM_ENDIAN_H
     25 
     26 #include "sim-types.h"
     27 
     28 /* C byte conversion functions */
     29 
     30 INLINE_SIM_ENDIAN(unsigned_1) endian_h2t_1(unsigned_1 x);
     31 INLINE_SIM_ENDIAN(unsigned_2) endian_h2t_2(unsigned_2 x);
     32 INLINE_SIM_ENDIAN(unsigned_4) endian_h2t_4(unsigned_4 x);
     33 INLINE_SIM_ENDIAN(unsigned_8) endian_h2t_8(unsigned_8 x);
     34 INLINE_SIM_ENDIAN(unsigned_16) endian_h2t_16(unsigned_16 x);
     35 
     36 INLINE_SIM_ENDIAN(unsigned_1) endian_t2h_1(unsigned_1 x);
     37 INLINE_SIM_ENDIAN(unsigned_2) endian_t2h_2(unsigned_2 x);
     38 INLINE_SIM_ENDIAN(unsigned_4) endian_t2h_4(unsigned_4 x);
     39 INLINE_SIM_ENDIAN(unsigned_8) endian_t2h_8(unsigned_8 x);
     40 INLINE_SIM_ENDIAN(unsigned_16) endian_t2h_16(unsigned_16 x);
     41 
     42 INLINE_SIM_ENDIAN(unsigned_1) swap_1(unsigned_1 x);
     43 INLINE_SIM_ENDIAN(unsigned_2) swap_2(unsigned_2 x);
     44 INLINE_SIM_ENDIAN(unsigned_4) swap_4(unsigned_4 x);
     45 INLINE_SIM_ENDIAN(unsigned_8) swap_8(unsigned_8 x);
     46 INLINE_SIM_ENDIAN(unsigned_16) swap_16(unsigned_16 x);
     47 
     48 INLINE_SIM_ENDIAN(unsigned_1) endian_h2be_1(unsigned_1 x);
     49 INLINE_SIM_ENDIAN(unsigned_2) endian_h2be_2(unsigned_2 x);
     50 INLINE_SIM_ENDIAN(unsigned_4) endian_h2be_4(unsigned_4 x);
     51 INLINE_SIM_ENDIAN(unsigned_8) endian_h2be_8(unsigned_8 x);
     52 INLINE_SIM_ENDIAN(unsigned_16) endian_h2be_16(unsigned_16 x);
     53 
     54 INLINE_SIM_ENDIAN(unsigned_1) endian_be2h_1(unsigned_1 x);
     55 INLINE_SIM_ENDIAN(unsigned_2) endian_be2h_2(unsigned_2 x);
     56 INLINE_SIM_ENDIAN(unsigned_4) endian_be2h_4(unsigned_4 x);
     57 INLINE_SIM_ENDIAN(unsigned_8) endian_be2h_8(unsigned_8 x);
     58 INLINE_SIM_ENDIAN(unsigned_16) endian_be2h_16(unsigned_16 x);
     59 
     60 INLINE_SIM_ENDIAN(unsigned_1) endian_h2le_1(unsigned_1 x);
     61 INLINE_SIM_ENDIAN(unsigned_2) endian_h2le_2(unsigned_2 x);
     62 INLINE_SIM_ENDIAN(unsigned_4) endian_h2le_4(unsigned_4 x);
     63 INLINE_SIM_ENDIAN(unsigned_8) endian_h2le_8(unsigned_8 x);
     64 INLINE_SIM_ENDIAN(unsigned_16) endian_h2le_16(unsigned_16 x);
     65 
     66 INLINE_SIM_ENDIAN(unsigned_1) endian_le2h_1(unsigned_1 x);
     67 INLINE_SIM_ENDIAN(unsigned_2) endian_le2h_2(unsigned_2 x);
     68 INLINE_SIM_ENDIAN(unsigned_4) endian_le2h_4(unsigned_4 x);
     69 INLINE_SIM_ENDIAN(unsigned_8) endian_le2h_8(unsigned_8 x);
     70 INLINE_SIM_ENDIAN(unsigned_16) endian_le2h_16(unsigned_16 x);
     71 
     72 INLINE_SIM_ENDIAN(void*) offset_1(unsigned_1 *x, unsigned ws, unsigned w);
     73 INLINE_SIM_ENDIAN(void*) offset_2(unsigned_2 *x, unsigned ws, unsigned w);
     74 INLINE_SIM_ENDIAN(void*) offset_4(unsigned_4 *x, unsigned ws, unsigned w);
     75 INLINE_SIM_ENDIAN(void*) offset_8(unsigned_8 *x, unsigned ws, unsigned w);
     76 INLINE_SIM_ENDIAN(void*) offset_16(unsigned_16 *x, unsigned ws, unsigned w);
     77 
     78 INLINE_SIM_ENDIAN(unsigned_16) sim_endian_join_16 (unsigned_8 h, unsigned_8 l);
     79 INLINE_SIM_ENDIAN(unsigned_8) sim_endian_split_16 (unsigned_16 word, int w);
     80 
     81 
     82 /* SWAP */
     83 
     84 #define SWAP_1 swap_1
     85 #define SWAP_2 swap_2
     86 #define SWAP_4 swap_4
     87 #define SWAP_8 swap_8
     88 #define SWAP_16 swap_16
     89 
     90 
     91 /* HOST to BE */
     92 
     93 #define H2BE_1 endian_h2be_1
     94 #define H2BE_2 endian_h2be_2
     95 #define H2BE_4 endian_h2be_4
     96 #define H2BE_8 endian_h2be_8
     97 #define H2BE_16 endian_h2be_16
     98 #define BE2H_1 endian_be2h_1
     99 #define BE2H_2 endian_be2h_2
    100 #define BE2H_4 endian_be2h_4
    101 #define BE2H_8 endian_be2h_8
    102 #define BE2H_16 endian_be2h_16
    103 
    104 
    105 /* HOST to LE */
    106 
    107 #define H2LE_1 endian_h2le_1
    108 #define H2LE_2 endian_h2le_2
    109 #define H2LE_4 endian_h2le_4
    110 #define H2LE_8 endian_h2le_8
    111 #define H2LE_16 endian_h2le_16
    112 #define LE2H_1 endian_le2h_1
    113 #define LE2H_2 endian_le2h_2
    114 #define LE2H_4 endian_le2h_4
    115 #define LE2H_8 endian_le2h_8
    116 #define LE2H_16 endian_le2h_16
    117 
    118 
    119 /* HOST to TARGET */
    120 
    121 #define H2T_1 endian_h2t_1
    122 #define H2T_2 endian_h2t_2
    123 #define H2T_4 endian_h2t_4
    124 #define H2T_8 endian_h2t_8
    125 #define H2T_16 endian_h2t_16
    126 #define T2H_1 endian_t2h_1
    127 #define T2H_2 endian_t2h_2
    128 #define T2H_4 endian_t2h_4
    129 #define T2H_8 endian_t2h_8
    130 #define T2H_16 endian_t2h_16
    131 
    132 
    133 /* CONVERT IN PLACE
    134 
    135    These macros, given an argument of unknown size, swap its value in
    136    place if a host/target conversion is required. */
    137 
    138 #define H2T(VARIABLE) \
    139 do { \
    140   void *vp = &(VARIABLE); \
    141   switch (sizeof (VARIABLE)) { \
    142   case 1: *(unsigned_1*)vp = H2T_1(*(unsigned_1*)vp); break; \
    143   case 2: *(unsigned_2*)vp = H2T_2(*(unsigned_2*)vp); break; \
    144   case 4: *(unsigned_4*)vp = H2T_4(*(unsigned_4*)vp); break; \
    145   case 8: *(unsigned_8*)vp = H2T_8(*(unsigned_8*)vp); break; \
    146   case 16: *(unsigned_16*)vp = H2T_16(*(unsigned_16*)vp); break; \
    147   } \
    148 } while (0)
    149 
    150 #define T2H(VARIABLE) \
    151 do { \
    152   switch (sizeof(VARIABLE)) { \
    153   case 1: VARIABLE = T2H_1(VARIABLE); break; \
    154   case 2: VARIABLE = T2H_2(VARIABLE); break; \
    155   case 4: VARIABLE = T2H_4(VARIABLE); break; \
    156   case 8: VARIABLE = T2H_8(VARIABLE); break; \
    157   /*case 16: VARIABLE = T2H_16(VARIABLE); break;*/ \
    158   } \
    159 } while (0)
    160 
    161 #define SWAP(VARIABLE) \
    162 do { \
    163   switch (sizeof(VARIABLE)) { \
    164   case 1: VARIABLE = SWAP_1(VARIABLE); break; \
    165   case 2: VARIABLE = SWAP_2(VARIABLE); break; \
    166   case 4: VARIABLE = SWAP_4(VARIABLE); break; \
    167   case 8: VARIABLE = SWAP_8(VARIABLE); break; \
    168   /*case 16: VARIABLE = SWAP_16(VARIABLE); break;*/ \
    169   } \
    170 } while (0)
    171 
    172 #define H2BE(VARIABLE) \
    173 do { \
    174   switch (sizeof(VARIABLE)) { \
    175   case 1: VARIABLE = H2BE_1(VARIABLE); break; \
    176   case 2: VARIABLE = H2BE_2(VARIABLE); break; \
    177   case 4: VARIABLE = H2BE_4(VARIABLE); break; \
    178   case 8: VARIABLE = H2BE_8(VARIABLE); break; \
    179   /*case 16: VARIABLE = H2BE_16(VARIABLE); break;*/ \
    180   } \
    181 } while (0)
    182 
    183 #define BE2H(VARIABLE) \
    184 do { \
    185   switch (sizeof(VARIABLE)) { \
    186   case 1: VARIABLE = BE2H_1(VARIABLE); break; \
    187   case 2: VARIABLE = BE2H_2(VARIABLE); break; \
    188   case 4: VARIABLE = BE2H_4(VARIABLE); break; \
    189   case 8: VARIABLE = BE2H_8(VARIABLE); break; \
    190   /*case 16: VARIABLE = BE2H_16(VARIABLE); break;*/ \
    191   } \
    192 } while (0)
    193 
    194 #define H2LE(VARIABLE) \
    195 do { \
    196   switch (sizeof(VARIABLE)) { \
    197   case 1: VARIABLE = H2LE_1(VARIABLE); break; \
    198   case 2: VARIABLE = H2LE_2(VARIABLE); break; \
    199   case 4: VARIABLE = H2LE_4(VARIABLE); break; \
    200   case 8: VARIABLE = H2LE_8(VARIABLE); break; \
    201   /*case 16: VARIABLE = H2LE_16(VARIABLE); break;*/ \
    202   } \
    203 } while (0)
    204 
    205 #define LE2H(VARIABLE) \
    206 do { \
    207   switch (sizeof(VARIABLE)) { \
    208   case 1: VARIABLE = LE2H_1(VARIABLE); break; \
    209   case 2: VARIABLE = LE2H_2(VARIABLE); break; \
    210   case 4: VARIABLE = LE2H_4(VARIABLE); break; \
    211   case 8: VARIABLE = LE2H_8(VARIABLE); break; \
    212   /*case 16: VARIABLE = LE2H_16(VARIABLE); break;*/ \
    213   } \
    214 } while (0)
    215 
    216 
    217 
    218 /* TARGET WORD:
    219 
    220    Byte swap a quantity the size of the targets word */
    221 
    222 #if (WITH_TARGET_WORD_BITSIZE == 64)
    223 #define H2T_word H2T_8
    224 #define T2H_word T2H_8
    225 #define H2BE_word H2BE_8
    226 #define BE2H_word BE2H_8
    227 #define H2LE_word H2LE_8
    228 #define LE2H_word LE2H_8
    229 #define SWAP_word SWAP_8
    230 #endif
    231 #if (WITH_TARGET_WORD_BITSIZE == 32)
    232 #define H2T_word H2T_4
    233 #define T2H_word T2H_4
    234 #define H2BE_word H2BE_4
    235 #define BE2H_word BE2H_4
    236 #define H2LE_word H2LE_4
    237 #define LE2H_word LE2H_4
    238 #define SWAP_word SWAP_4
    239 #endif
    240 
    241 
    242 
    243 /* TARGET CELL:
    244 
    245    Byte swap a quantity the size of the targets IEEE 1275 memory cell */
    246 
    247 #define H2T_cell H2T_4
    248 #define T2H_cell T2H_4
    249 #define H2BE_cell H2BE_4
    250 #define BE2H_cell BE2H_4
    251 #define H2LE_cell H2LE_4
    252 #define LE2H_cell LE2H_4
    253 #define SWAP_cell SWAP_4
    254 
    255 
    256 
    257 /* HOST Offsets:
    258 
    259    Address of high/low sub-word within a host word quantity.
    260 
    261    Address of sub-word N within a host word quantity.  NOTE: Numbering
    262    is BIG endian always. */
    263 
    264 #define AH1_2(X) (unsigned_1*)offset_2((X), 1, 0)
    265 #define AL1_2(X) (unsigned_1*)offset_2((X), 1, 1)
    266 
    267 #define AH2_4(X) (unsigned_2*)offset_4((X), 2, 0)
    268 #define AL2_4(X) (unsigned_2*)offset_4((X), 2, 1)
    269 
    270 #define AH4_8(X) (unsigned_4*)offset_8((X), 4, 0)
    271 #define AL4_8(X) (unsigned_4*)offset_8((X), 4, 1)
    272 
    273 #define AH8_16(X) (unsigned_8*)offset_16((X), 8, 0)
    274 #define AL8_16(X) (unsigned_8*)offset_16((X), 8, 1)
    275 
    276 #if (WITH_TARGET_WORD_BITSIZE == 64)
    277 #define AH_word(X) AH4_8(X)
    278 #define AL_word(X) AL4_8(X)
    279 #endif
    280 #if (WITH_TARGET_WORD_BITSIZE == 32)
    281 #define AH_word(X) AH2_4(X)
    282 #define AL_word(X) AL2_4(X)
    283 #endif
    284 
    285 
    286 #define A1_2(X,N) (unsigned_1*)offset_2((X), 1, (N))
    287 
    288 #define A1_4(X,N) (unsigned_1*)offset_4((X), 1, (N))
    289 #define A2_4(X,N) (unsigned_2*)offset_4((X), 2, (N))
    290 
    291 #define A1_8(X,N) (unsigned_1*)offset_8((X), 1, (N))
    292 #define A2_8(X,N) (unsigned_2*)offset_8((X), 2, (N))
    293 #define A4_8(X,N) (unsigned_4*)offset_8((X), 4, (N))
    294 
    295 #define A1_16(X,N) (unsigned_1*)offset_16((X), 1, (N))
    296 #define A2_16(X,N) (unsigned_2*)offset_16((X), 2, (N))
    297 #define A4_16(X,N) (unsigned_4*)offset_16((X), 4, (N))
    298 #define A8_16(X,N) (unsigned_8*)offset_16((X), 8, (N))
    299 
    300 
    301 
    302 
    303 /* HOST Components:
    304 
    305    Value of sub-word within a host word quantity */
    306 
    307 #define VH1_2(X) ((unsigned_1)((unsigned_2)(X) >> 8))
    308 #define VL1_2(X) (unsigned_1)(X)
    309 
    310 #define VH2_4(X) ((unsigned_2)((unsigned_4)(X) >> 16))
    311 #define VL2_4(X) ((unsigned_2)(X))
    312 
    313 #define VH4_8(X) ((unsigned_4)((unsigned_8)(X) >> 32))
    314 #define VL4_8(X) ((unsigned_4)(X))
    315 
    316 #define VH8_16(X) (sim_endian_split_16 ((X), 0))
    317 #define VL8_16(X) (sim_endian_split_16 ((X), 1))
    318 
    319 #if (WITH_TARGET_WORD_BITSIZE == 64)
    320 #define VH_word(X) VH4_8(X)
    321 #define VL_word(X) VL4_8(X)
    322 #endif
    323 #if (WITH_TARGET_WORD_BITSIZE == 32)
    324 #define VH_word(X) VH2_4(X)
    325 #define VL_word(X) VL2_4(X)
    326 #endif
    327 
    328 
    329 #define V1_2(X,N) ((unsigned_1)((unsigned_2)(X) >> ( 8 * (1 - (N)))))
    330 
    331 #define V1_4(X,N) ((unsigned_1)((unsigned_4)(X) >> ( 8 * (3 - (N)))))
    332 #define V2_4(X,N) ((unsigned_2)((unsigned_4)(X) >> (16 * (1 - (N)))))
    333 
    334 #define V1_8(X,N) ((unsigned_1)((unsigned_8)(X) >> ( 8 * (7 - (N)))))
    335 #define V2_8(X,N) ((unsigned_2)((unsigned_8)(X) >> (16 * (3 - (N)))))
    336 #define V4_8(X,N) ((unsigned_4)((unsigned_8)(X) >> (32 * (1 - (N)))))
    337 
    338 #define V1_16(X,N) (*A1_16 (&(X),N))
    339 #define V2_16(X,N) (*A2_16 (&(X),N))
    340 #define V4_16(X,N) (*A4_16 (&(X),N))
    341 #define V8_16(X,N) (*A8_16 (&(X),N))
    342 
    343 
    344 /* Reverse - insert sub-word into word quantity */
    345 
    346 #define V2_H1(X) ((unsigned_2)(unsigned_1)(X) <<  8)
    347 #define V2_L1(X) ((unsigned_2)(unsigned_1)(X))
    348 
    349 #define V4_H2(X) ((unsigned_4)(unsigned_2)(X) << 16)
    350 #define V4_L2(X) ((unsigned_4)(unsigned_2)(X))
    351 
    352 #define V8_H4(X) ((unsigned_8)(unsigned_4)(X) << 32)
    353 #define V8_L4(X) ((unsigned_8)(unsigned_4)(X))
    354 
    355 #define V16_H8(X) ((unsigned_16)(unsigned_8)(X) << 64)
    356 #define V16_L8(X) ((unsigned_16)(unsigned_8)(X))
    357 
    358 
    359 #define V2_1(X,N) ((unsigned_2)(unsigned_1)(X) << ( 8 * (1 - (N))))
    360 
    361 #define V4_1(X,N) ((unsigned_4)(unsigned_1)(X) << ( 8 * (3 - (N))))
    362 #define V4_2(X,N) ((unsigned_4)(unsigned_2)(X) << (16 * (1 - (N))))
    363 
    364 #define V8_1(X,N) ((unsigned_8)(unsigned_1)(X) << ( 8 * (7 - (N))))
    365 #define V8_2(X,N) ((unsigned_8)(unsigned_2)(X) << (16 * (3 - (N))))
    366 #define V8_4(X,N) ((unsigned_8)(unsigned_4)(X) << (32 * (1 - (N))))
    367 
    368 #define V16_1(X,N) ((unsigned_16)(unsigned_1)(X) << ( 8 * (15 - (N))))
    369 #define V16_2(X,N) ((unsigned_16)(unsigned_2)(X) << (16 * (7 - (N))))
    370 #define V16_4(X,N) ((unsigned_16)(unsigned_4)(X) << (32 * (3 - (N))))
    371 #define V16_8(X,N) ((unsigned_16)(unsigned_8)(X) << (64 * (1 - (N))))
    372 
    373 
    374 /* Reverse - insert N sub-words into single word quantity */
    375 
    376 #define U2_1(I0,I1) (V2_1(I0,0) | V2_1(I1,1))
    377 #define U4_1(I0,I1,I2,I3) (V4_1(I0,0) | V4_1(I1,1) | V4_1(I2,2) | V4_1(I3,3))
    378 #define U8_1(I0,I1,I2,I3,I4,I5,I6,I7) \
    379 (V8_1(I0,0) | V8_1(I1,1) | V8_1(I2,2) | V8_1(I3,3) \
    380  | V8_1(I4,4) | V8_1(I5,5) | V8_1(I6,6) | V8_1(I7,7))
    381 #define U16_1(I0,I1,I2,I3,I4,I5,I6,I7,I8,I9,I10,I11,I12,I13,I14,I15) \
    382 (V16_1(I0,0) | V16_1(I1,1) | V16_1(I2,2) | V16_1(I3,3) \
    383  | V16_1(I4,4) | V16_1(I5,5) | V16_1(I6,6) | V16_1(I7,7) \
    384  | V16_1(I8,8) | V16_1(I9,9) | V16_1(I10,10) | V16_1(I11,11) \
    385  | V16_1(I12,12) | V16_1(I13,13) | V16_1(I14,14) | V16_1(I15,15))
    386 
    387 #define U4_2(I0,I1) (V4_2(I0,0) | V4_2(I1,1))
    388 #define U8_2(I0,I1,I2,I3) (V8_2(I0,0) | V8_2(I1,1) | V8_2(I2,2) | V8_2(I3,3))
    389 #define U16_2(I0,I1,I2,I3,I4,I5,I6,I7) \
    390 (V16_2(I0,0) | V16_2(I1,1) | V16_2(I2,2) | V16_2(I3,3) \
    391  | V16_2(I4,4) | V16_2(I5,5) | V16_2(I6,6) | V16_2(I7,7) )
    392 
    393 #define U8_4(I0,I1) (V8_4(I0,0) | V8_4(I1,1))
    394 #define U16_4(I0,I1,I2,I3) (V16_4(I0,0) | V16_4(I1,1) | V16_4(I2,2) | V16_4(I3,3))
    395 
    396 #define U16_8(I0,I1) (sim_endian_join_16 (I0, I1))
    397 
    398 
    399 #if (WITH_TARGET_WORD_BITSIZE == 64)
    400 #define Vword_H(X) V8_H4(X)
    401 #define Vword_L(X) V8_L4(X)
    402 #endif
    403 #if (WITH_TARGET_WORD_BITSIZE == 32)
    404 #define Vword_H(X) V4_H2(X)
    405 #define Vword_L(X) V4_L2(X)
    406 #endif
    407 
    408 
    409 
    410 
    411 #if H_REVEALS_MODULE_P (SIM_ENDIAN_INLINE)
    412 #include "sim-endian.c"
    413 #endif
    414 
    415 #endif /* SIM_ENDIAN_H */
    416