sim/common/sim-bits.h

   1 /* The common simulator framework for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2019 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_BITS_H
  24 #define SIM_BITS_H
  25
  26
  27 /* Bit manipulation routines:
  28
  29    Bit numbering: The bits are numbered according to the target ISA's
  30    convention.  That being controlled by WITH_TARGET_WORD_MSB.  For
  31    the PowerPC (WITH_TARGET_WORD_MSB == 0) the numbering is 0..31
  32    while for the MIPS (WITH_TARGET_WORD_MSB == 31) it is 31..0.
  33
  34    Size convention: Each macro is in three forms - <MACRO>32 which
  35    operates in 32bit quantity (bits are numbered 0..31); <MACRO>64
  36    which operates using 64bit quantites (and bits are numbered 0..63);
  37    and <MACRO> which operates using the bit size of the target
  38    architecture (bits are still numbered 0..63), with 32bit
  39    architectures ignoring the first 32bits leaving bit 32 as the most
  40    significant.
  41
  42    NB: Use EXTRACTED, MSEXTRACTED and LSEXTRACTED as a guideline for
  43    naming.  LSMASK and LSMASKED are wrong.
  44
  45    BIT*(POS): `*' bit constant with just 1 bit set.
  46
  47    LSBIT*(OFFSET): `*' bit constant with just 1 bit set - LS bit is
  48    zero.
  49
  50    MSBIT*(OFFSET): `*' bit constant with just 1 bit set - MS bit is
  51    zero.
  52
  53    MASK*(FIRST, LAST): `*' bit constant with bits [FIRST .. LAST]
  54    set. The <MACRO> (no size) version permits FIRST >= LAST and
  55    generates a wrapped bit mask vis ([0..LAST] | [FIRST..LSB]).
  56
  57    LSMASK*(FIRST, LAST): Like MASK - LS bit is zero.
  58
  59    MSMASK*(FIRST, LAST): Like MASK - LS bit is zero.
  60
  61    MASKED*(VALUE, FIRST, LAST): Masks out all but bits [FIRST
  62    .. LAST].
  63
  64    LSMASKED*(VALUE, FIRST, LAST): Like MASKED - LS bit is zero.
  65
  66    MSMASKED*(VALUE, FIRST, LAST): Like MASKED - MS bit is zero.
  67
  68    EXTRACTED*(VALUE, FIRST, LAST): Masks out bits [FIRST .. LAST] but
  69    also right shifts the masked value so that bit LAST becomes the
  70    least significant (right most).
  71
  72    LSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - LS bit is
  73    zero.
  74
  75    MSEXTRACTED*(VALUE, FIRST, LAST): Same as extracted - MS bit is
  76    zero.
  77
  78    SHUFFLED**(VALUE, OLD, NEW): Mask then move a single bit from OLD
  79    new NEW.
  80
  81    MOVED**(VALUE, OLD_FIRST, OLD_LAST, NEW_FIRST, NEW_LAST): Moves
  82    things around so that bits OLD_FIRST..OLD_LAST are masked then
  83    moved to NEW_FIRST..NEW_LAST.
  84
  85    INSERTED*(VALUE, FIRST, LAST): Takes VALUE and `inserts' the (LAST
  86    - FIRST + 1) least significant bits into bit positions [ FIRST
  87    .. LAST ].  This is almost the complement to EXTRACTED.
  88
  89    IEA_MASKED(SHOULD_MASK, ADDR): Convert the address to the targets
  90    natural size.  If in 32bit mode, discard the high 32bits.
  91
  92    EXTEND*(VALUE): Convert the `*' bit value to the targets natural
  93    word size.  Sign extend the value if needed.
  94
  95    ALIGN_*(VALUE): Round the value upwards so that it is aligned to a
  96    `_*' byte boundary.
  97
  98    FLOOR_*(VALUE): Truncate the value so that it is aligned to a `_*'
  99    byte boundary.
 100
 101    ROT*(VALUE, NR_BITS): Return the `*' bit VALUE rotated by NR_BITS
 102    right (positive) or left (negative).
 103
 104    ROTL*(VALUE, NR_BITS): Return the `*' bit value rotated by NR_BITS
 105    left.  0 <= NR_BITS <= `*'.
 106
 107    ROTR*(VALUE, NR_BITS): Return the `*' bit value rotated by NR_BITS
 108    right.  0 <= NR_BITS <= N.
 109
 110    SEXT*(VALUE, SIGN_BIT): Treat SIGN_BIT as VALUEs sign, extend it ti
 111    `*' bits.
 112
 113    Note: Only the BIT* and MASK* macros return a constant that can be
 114    used in variable declarations.
 115
 116    */
 117
 118
 119 /* compute the number of bits between START and STOP */
 120
 121 #if (WITH_TARGET_WORD_MSB == 0)
 122 #define _MAKE_WIDTH(START, STOP) (STOP - START + 1)
 123 #else
 124 #define _MAKE_WIDTH(START, STOP) (START - STOP + 1)
 125 #endif
 126
 127
 128
 129 /* compute the number shifts required to move a bit between LSB (MSB)
 130    and POS */
 131
 132 #if (WITH_TARGET_WORD_MSB == 0)
 133 #define _LSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
 134 #else
 135 #define _LSB_SHIFT(WIDTH, POS) (POS)
 136 #endif
 137
 138 #if (WITH_TARGET_WORD_MSB == 0)
 139 #define _MSB_SHIFT(WIDTH, POS) (POS)
 140 #else
 141 #define _MSB_SHIFT(WIDTH, POS) (WIDTH - 1 - POS)
 142 #endif
 143
 144
 145 /* compute the absolute bit position given the OFFSET from the MSB(LSB)
 146    NB: _MAKE_xxx_POS (WIDTH, _MAKE_xxx_SHIFT (WIDTH, POS)) == POS */
 147
 148 #if (WITH_TARGET_WORD_MSB == 0)
 149 #define _MSB_POS(WIDTH, SHIFT) (SHIFT)
 150 #else
 151 #define _MSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
 152 #endif
 153
 154 #if (WITH_TARGET_WORD_MSB == 0)
 155 #define _LSB_POS(WIDTH, SHIFT) (WIDTH - 1 - SHIFT)
 156 #else
 157 #define _LSB_POS(WIDTH, SHIFT) (SHIFT)
 158 #endif
 159
 160
 161 /* convert a 64 bit position into a corresponding 32bit position. MSB
 162    pos handles the posibility that the bit lies beyond the 32bit
 163    boundary */
 164
 165 #if (WITH_TARGET_WORD_MSB == 0)
 166 #define _MSB_32(START, STOP) (START <= STOP \
 167                               ? (START < 32 ? 0 : START - 32) \
 168                               : (STOP < 32 ? 0 : STOP - 32))
 169 #define _MSB_16(START, STOP) (START <= STOP \
 170                               ? (START < 48 ? 0 : START - 48) \
 171                               : (STOP < 48 ? 0 : STOP - 48))
 172 #else
 173 #define _MSB_32(START, STOP) (START >= STOP \
 174                               ? (START >= 32 ? 31 : START) \
 175                               : (STOP >= 32 ? 31 : STOP))
 176 #define _MSB_16(START, STOP) (START >= STOP \
 177                               ? (START >= 16 ? 15 : START) \
 178                               : (STOP >= 16 ? 15 : STOP))
 179 #endif
 180
 181 #if (WITH_TARGET_WORD_MSB == 0)
 182 #define _LSB_32(START, STOP) (START <= STOP \
 183                               ? (STOP < 32 ? 0 : STOP - 32) \
 184                               : (START < 32 ? 0 : START - 32))
 185 #define _LSB_16(START, STOP) (START <= STOP \
 186                               ? (STOP < 48 ? 0 : STOP - 48) \
 187                               : (START < 48 ? 0 : START - 48))
 188 #else
 189 #define _LSB_32(START, STOP) (START >= STOP \
 190                               ? (STOP >= 32 ? 31 : STOP) \
 191                               : (START >= 32 ? 31 : START))
 192 #define _LSB_16(START, STOP) (START >= STOP \
 193                               ? (STOP >= 16 ? 15 : STOP) \
 194                               : (START >= 16 ? 15 : START))
 195 #endif
 196
 197 #if (WITH_TARGET_WORD_MSB == 0)
 198 #define _MSB(START, STOP) (START <= STOP ? START : STOP)
 199 #else
 200 #define _MSB(START, STOP) (START >= STOP ? START : STOP)
 201 #endif
 202
 203 #if (WITH_TARGET_WORD_MSB == 0)
 204 #define _LSB(START, STOP) (START <= STOP ? STOP : START)
 205 #else
 206 #define _LSB(START, STOP) (START >= STOP ? STOP : START)
 207 #endif
 208
 209
 210 /* LS/MS Bit operations */
 211
 212 #define LSBIT8(POS)  ((unsigned8) 1 << (POS))
 213 #define LSBIT16(POS) ((unsigned16)1 << (POS))
 214 #define LSBIT32(POS) ((unsigned32)1 << (POS))
 215 #define LSBIT64(POS) ((unsigned64)1 << (POS))
 216
 217 #if (WITH_TARGET_WORD_BITSIZE == 64)
 218 #define LSBIT(POS) LSBIT64 (POS)
 219 #endif
 220 #if (WITH_TARGET_WORD_BITSIZE == 32)
 221 #define LSBIT(POS) ((unsigned32)((POS) >= 32 \
 222                                  ? 0 \
 223                                  : (1 << ((POS) >= 32 ? 0 : (POS)))))
 224 #endif
 225 #if (WITH_TARGET_WORD_BITSIZE == 16)
 226 #define LSBIT(POS) ((unsigned16)((POS) >= 16 \
 227                                  ? 0 \
 228                                  : (1 << ((POS) >= 16 ? 0 : (POS)))))
 229 #endif
 230
 231
 232 #define MSBIT8(POS)  ((unsigned8) 1 << ( 8 - 1 - (POS)))
 233 #define MSBIT16(POS) ((unsigned16)1 << (16 - 1 - (POS)))
 234 #define MSBIT32(POS) ((unsigned32)1 << (32 - 1 - (POS)))
 235 #define MSBIT64(POS) ((unsigned64)1 << (64 - 1 - (POS)))
 236
 237 #if (WITH_TARGET_WORD_BITSIZE == 64)
 238 #define MSBIT(POS) MSBIT64 (POS)
 239 #endif
 240 #if (WITH_TARGET_WORD_BITSIZE == 32)
 241 #define MSBIT(POS) ((unsigned32)((POS) < 32 \
 242                                  ? 0 \
 243                                  : (1 << ((POS) < 32 ? 0 : (64 - 1) - (POS)))))
 244 #endif
 245 #if (WITH_TARGET_WORD_BITSIZE == 16)
 246 #define MSBIT(POS) ((unsigned16)((POS) < 48 \
 247                                  ? 0 \
 248                                  : (1 << ((POS) < 48 ? 0 : (64 - 1) - (POS)))))
 249 #endif
 250
 251
 252 /* Bit operations */
 253
 254 #define BIT4(POS)  (1 << _LSB_SHIFT (4, (POS)))
 255 #define BIT5(POS)  (1 << _LSB_SHIFT (5, (POS)))
 256 #define BIT10(POS) (1 << _LSB_SHIFT (10, (POS)))
 257
 258 #if (WITH_TARGET_WORD_MSB == 0)
 259 #define BIT8  MSBIT8
 260 #define BIT16 MSBIT16
 261 #define BIT32 MSBIT32
 262 #define BIT64 MSBIT64
 263 #define BIT   MSBIT
 264 #else
 265 #define BIT8  LSBIT8
 266 #define BIT16 LSBIT16
 267 #define BIT32 LSBIT32
 268 #define BIT64 LSBIT64
 269 #define BIT   LSBIT
 270 #endif
 271
 272
 273
 274 /* multi bit mask */
 275
 276 /* 111111 -> mmll11 -> mm11ll */
 277 #define _MASKn(WIDTH, START, STOP) (((unsigned##WIDTH)(-1) \
 278                                      >> (_MSB_SHIFT (WIDTH, START) \
 279                                          + _LSB_SHIFT (WIDTH, STOP))) \
 280                                     << _LSB_SHIFT (WIDTH, STOP))
 281
 282 #if (WITH_TARGET_WORD_MSB == 0)
 283 #define _POS_LE(START, STOP) (START <= STOP)
 284 #else
 285 #define _POS_LE(START, STOP) (STOP <= START)
 286 #endif
 287
 288 #if (WITH_TARGET_WORD_BITSIZE == 64)
 289 #define MASK(START, STOP) \
 290      (_POS_LE ((START), (STOP)) \
 291       ? _MASKn(64, \
 292                _MSB ((START), (STOP)), \
 293                _LSB ((START), (STOP)) ) \
 294       : (_MASKn(64, _MSB_POS (64, 0), (STOP)) \
 295          | _MASKn(64, (START), _LSB_POS (64, 0))))
 296 #endif
 297 #if (WITH_TARGET_WORD_BITSIZE == 32)
 298 #define MASK(START, STOP) \
 299      (_POS_LE ((START), (STOP)) \
 300       ? (_POS_LE ((STOP), _MSB_POS (64, 31)) \
 301          ? 0 \
 302          : _MASKn (32, \
 303                    _MSB_32 ((START), (STOP)), \
 304                    _LSB_32 ((START), (STOP)))) \
 305       : (_MASKn (32, \
 306                  _LSB_32 ((START), (STOP)), \
 307                  _LSB_POS (32, 0)) \
 308          | (_POS_LE ((STOP), _MSB_POS (64, 31)) \
 309             ? 0 \
 310             : _MASKn (32, \
 311                       _MSB_POS (32, 0), \
 312                       _MSB_32 ((START), (STOP))))))
 313 #endif
 314 #if (WITH_TARGET_WORD_BITSIZE == 16)
 315 #define MASK(START, STOP) \
 316      (_POS_LE ((START), (STOP)) \
 317       ? (_POS_LE ((STOP), _MSB_POS (64, 15)) \
 318          ? 0 \
 319          : _MASKn (16, \
 320                    _MSB_16 ((START), (STOP)), \
 321                    _LSB_16 ((START), (STOP)))) \
 322       : (_MASKn (16, \
 323                  _LSB_16 ((START), (STOP)), \
 324                  _LSB_POS (16, 0)) \
 325          | (_POS_LE ((STOP), _MSB_POS (64, 15)) \
 326             ? 0 \
 327             : _MASKn (16, \
 328                       _MSB_POS (16, 0), \
 329                       _MSB_16 ((START), (STOP))))))
 330 #endif
 331 #if !defined (MASK)
 332 #error "MASK never undefined"
 333 #endif
 334
 335
 336 /* Multi-bit mask on least significant bits */
 337
 338 #define _LSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
 339                                              _LSB_POS (WIDTH, FIRST), \
 340                                              _LSB_POS (WIDTH, LAST))
 341
 342 #define LSMASK8(FIRST, LAST)   _LSMASKn ( 8, (FIRST), (LAST))
 343 #define LSMASK16(FIRST, LAST)  _LSMASKn (16, (FIRST), (LAST))
 344 #define LSMASK32(FIRST, LAST)  _LSMASKn (32, (FIRST), (LAST))
 345 #define LSMASK64(FIRST, LAST)  _LSMASKn (64, (FIRST), (LAST))
 346
 347 #define LSMASK(FIRST, LAST) (MASK (_LSB_POS (64, FIRST), _LSB_POS (64, LAST)))
 348
 349
 350 /* Multi-bit mask on most significant bits */
 351
 352 #define _MSMASKn(WIDTH, FIRST, LAST) _MASKn (WIDTH, \
 353                                              _MSB_POS (WIDTH, FIRST), \
 354                                              _MSB_POS (WIDTH, LAST))
 355
 356 #define MSMASK8(FIRST, LAST)  _MSMASKn ( 8, (FIRST), (LAST))
 357 #define MSMASK16(FIRST, LAST) _MSMASKn (16, (FIRST), (LAST))
 358 #define MSMASK32(FIRST, LAST) _MSMASKn (32, (FIRST), (LAST))
 359 #define MSMASK64(FIRST, LAST) _MSMASKn (64, (FIRST), (LAST))
 360
 361 #define MSMASK(FIRST, LAST) (MASK (_MSB_POS (64, FIRST), _MSB_POS (64, LAST)))
 362
 363
 364
 365 #if (WITH_TARGET_WORD_MSB == 0)
 366 #define MASK8  MSMASK8
 367 #define MASK16 MSMASK16
 368 #define MASK32 MSMASK32
 369 #define MASK64 MSMASK64
 370 #else
 371 #define MASK8  LSMASK8
 372 #define MASK16 LSMASK16
 373 #define MASK32 LSMASK32
 374 #define MASK64 LSMASK64
 375 #endif
 376
 377
 378
 379 /* mask the required bits, leaving them in place */
 380
 381 INLINE_SIM_BITS(unsigned8)  LSMASKED8  (unsigned8  word, int first, int last);
 382 INLINE_SIM_BITS(unsigned16) LSMASKED16 (unsigned16 word, int first, int last);
 383 INLINE_SIM_BITS(unsigned32) LSMASKED32 (unsigned32 word, int first, int last);
 384 INLINE_SIM_BITS(unsigned64) LSMASKED64 (unsigned64 word, int first, int last);
 385
 386 INLINE_SIM_BITS(unsigned_word) LSMASKED (unsigned_word word, int first, int last);
 387
 388 INLINE_SIM_BITS(unsigned8)  MSMASKED8  (unsigned8  word, int first, int last);
 389 INLINE_SIM_BITS(unsigned16) MSMASKED16 (unsigned16 word, int first, int last);
 390 INLINE_SIM_BITS(unsigned32) MSMASKED32 (unsigned32 word, int first, int last);
 391 INLINE_SIM_BITS(unsigned64) MSMASKED64 (unsigned64 word, int first, int last);
 392
 393 INLINE_SIM_BITS(unsigned_word) MSMASKED (unsigned_word word, int first, int last);
 394
 395 #if (WITH_TARGET_WORD_MSB == 0)
 396 #define MASKED8  MSMASKED8
 397 #define MASKED16 MSMASKED16
 398 #define MASKED32 MSMASKED32
 399 #define MASKED64 MSMASKED64
 400 #define MASKED   MSMASKED
 401 #else
 402 #define MASKED8  LSMASKED8
 403 #define MASKED16 LSMASKED16
 404 #define MASKED32 LSMASKED32
 405 #define MASKED64 LSMASKED64
 406 #define MASKED LSMASKED
 407 #endif
 408
 409
 410
 411 /* extract the required bits aligning them with the lsb */
 412
 413 INLINE_SIM_BITS(unsigned8)  LSEXTRACTED8  (unsigned8  val, int start, int stop);
 414 INLINE_SIM_BITS(unsigned16) LSEXTRACTED16 (unsigned16 val, int start, int stop);
 415 INLINE_SIM_BITS(unsigned32) LSEXTRACTED32 (unsigned32 val, int start, int stop);
 416 INLINE_SIM_BITS(unsigned64) LSEXTRACTED64 (unsigned64 val, int start, int stop);
 417
 418 INLINE_SIM_BITS(unsigned_word) LSEXTRACTED (unsigned_word val, int start, int stop);
 419
 420 INLINE_SIM_BITS(unsigned8)  MSEXTRACTED8  (unsigned8  val, int start, int stop);
 421 INLINE_SIM_BITS(unsigned16) MSEXTRACTED16 (unsigned16 val, int start, int stop);
 422 INLINE_SIM_BITS(unsigned32) MSEXTRACTED32 (unsigned32 val, int start, int stop);
 423 INLINE_SIM_BITS(unsigned64) MSEXTRACTED64 (unsigned64 val, int start, int stop);
 424
 425 INLINE_SIM_BITS(unsigned_word) MSEXTRACTED (unsigned_word val, int start, int stop);
 426
 427 #if (WITH_TARGET_WORD_MSB == 0)
 428 #define EXTRACTED8  MSEXTRACTED8
 429 #define EXTRACTED16 MSEXTRACTED16
 430 #define EXTRACTED32 MSEXTRACTED32
 431 #define EXTRACTED64 MSEXTRACTED64
 432 #define EXTRACTED   MSEXTRACTED
 433 #else
 434 #define EXTRACTED8  LSEXTRACTED8
 435 #define EXTRACTED16 LSEXTRACTED16
 436 #define EXTRACTED32 LSEXTRACTED32
 437 #define EXTRACTED64 LSEXTRACTED64
 438 #define EXTRACTED   LSEXTRACTED
 439 #endif
 440
 441
 442
 443 /* move a single bit around */
 444 /* NB: the wierdness (N>O?N-O:0) is to stop a warning from GCC */
 445 #define _SHUFFLEDn(N, WORD, OLD, NEW) \
 446 ((OLD) < (NEW) \
 447  ? (((unsigned##N)(WORD) \
 448      >> (((NEW) > (OLD)) ? ((NEW) - (OLD)) : 0)) \
 449     & MASK32((NEW), (NEW))) \
 450  : (((unsigned##N)(WORD) \
 451      << (((OLD) > (NEW)) ? ((OLD) - (NEW)) : 0)) \
 452     & MASK32((NEW), (NEW))))
 453
 454 #define SHUFFLED32(WORD, OLD, NEW) _SHUFFLEDn (32, WORD, OLD, NEW)
 455 #define SHUFFLED64(WORD, OLD, NEW) _SHUFFLEDn (64, WORD, OLD, NEW)
 456
 457 #define SHUFFLED(WORD, OLD, NEW) _SHUFFLEDn (_word, WORD, OLD, NEW)
 458
 459
 460 /* Insert a group of bits into a bit position */
 461
 462 INLINE_SIM_BITS(unsigned8)  LSINSERTED8  (unsigned8  val, int start, int stop);
 463 INLINE_SIM_BITS(unsigned16) LSINSERTED16 (unsigned16 val, int start, int stop);
 464 INLINE_SIM_BITS(unsigned32) LSINSERTED32 (unsigned32 val, int start, int stop);
 465 INLINE_SIM_BITS(unsigned64) LSINSERTED64 (unsigned64 val, int start, int stop);
 466 INLINE_SIM_BITS(unsigned_word) LSINSERTED (unsigned_word val, int start, int stop);
 467
 468 INLINE_SIM_BITS(unsigned8)  MSINSERTED8  (unsigned8  val, int start, int stop);
 469 INLINE_SIM_BITS(unsigned16) MSINSERTED16 (unsigned16 val, int start, int stop);
 470 INLINE_SIM_BITS(unsigned32) MSINSERTED32 (unsigned32 val, int start, int stop);
 471 INLINE_SIM_BITS(unsigned64) MSINSERTED64 (unsigned64 val, int start, int stop);
 472 INLINE_SIM_BITS(unsigned_word) MSINSERTED (unsigned_word val, int start, int stop);
 473
 474 #if (WITH_TARGET_WORD_MSB == 0)
 475 #define INSERTED8  MSINSERTED8
 476 #define INSERTED16 MSINSERTED16
 477 #define INSERTED32 MSINSERTED32
 478 #define INSERTED64 MSINSERTED64
 479 #define INSERTED   MSINSERTED
 480 #else
 481 #define INSERTED8  LSINSERTED8
 482 #define INSERTED16 LSINSERTED16
 483 #define INSERTED32 LSINSERTED32
 484 #define INSERTED64 LSINSERTED64
 485 #define INSERTED   LSINSERTED
 486 #endif
 487
 488
 489
 490 /* MOVE bits from one loc to another (combination of extract/insert) */
 491
 492 #define MOVED8(VAL,OH,OL,NH,NL)  INSERTED8 (EXTRACTED8 ((VAL), OH, OL), NH, NL)
 493 #define MOVED16(VAL,OH,OL,NH,NL) INSERTED16(EXTRACTED16((VAL), OH, OL), NH, NL)
 494 #define MOVED32(VAL,OH,OL,NH,NL) INSERTED32(EXTRACTED32((VAL), OH, OL), NH, NL)
 495 #define MOVED64(VAL,OH,OL,NH,NL) INSERTED64(EXTRACTED64((VAL), OH, OL), NH, NL)
 496 #define MOVED(VAL,OH,OL,NH,NL)   INSERTED  (EXTRACTED  ((VAL), OH, OL), NH, NL)
 497
 498
 499
 500 /* Sign extend the quantity to the targets natural word size */
 501
 502 #define EXTEND4(X)  (LSSEXT ((X), 3))
 503 #define EXTEND5(X)  (LSSEXT ((X), 4))
 504 #define EXTEND6(X)  (LSSEXT ((X), 5))
 505 #define EXTEND8(X)  ((signed_word)(signed8)(X))
 506 #define EXTEND11(X)  (LSSEXT ((X), 10))
 507 #define EXTEND12(X)  (LSSEXT ((X), 11))
 508 #define EXTEND15(X)  (LSSEXT ((X), 14))
 509 #define EXTEND16(X) ((signed_word)(signed16)(X))
 510 #define EXTEND24(X)  (LSSEXT ((X), 23))
 511 #define EXTEND25(X)  (LSSEXT ((X), 24))
 512 #define EXTEND32(X) ((signed_word)(signed32)(X))
 513 #define EXTEND64(X) ((signed_word)(signed64)(X))
 514
 515 /* depending on MODE return a 64bit or 32bit (sign extended) value */
 516 #if (WITH_TARGET_WORD_BITSIZE == 64)
 517 #define EXTENDED(X)     ((signed64)(signed32)(X))
 518 #endif
 519 #if (WITH_TARGET_WORD_BITSIZE == 32)
 520 #define EXTENDED(X)     (X)
 521 #endif
 522 #if (WITH_TARGET_WORD_BITSIZE == 16)
 523 #define EXTENDED(X)     (X)
 524 #endif
 525
 526
 527 /* memory alignment macro's */
 528 #define _ALIGNa(A,X)  (((X) + ((A) - 1)) & ~((A) - 1))
 529 #define _FLOORa(A,X)  ((X) & ~((A) - 1))
 530
 531 #define ALIGN_8(X)      _ALIGNa (8, X)
 532 #define ALIGN_16(X)     _ALIGNa (16, X)
 533
 534 #define ALIGN_PAGE(X)   _ALIGNa (0x1000, X)
 535 #define FLOOR_PAGE(X)   ((X) & ~(0x1000 - 1))
 536
 537
 538 /* bit bliting macro's */
 539 #define BLIT32(V, POS, BIT) \
 540 do { \
 541   if (BIT) \
 542     V |= BIT32 (POS); \
 543   else \
 544     V &= ~BIT32 (POS); \
 545 } while (0)
 546 #define MBLIT32(V, LO, HI, VAL) \
 547 do { \
 548   (V) = (((V) & ~MASK32 ((LO), (HI))) \
 549          | INSERTED32 (VAL, LO, HI)); \
 550 } while (0)
 551
 552
 553
 554 /* some rotate functions.  The generic macro's ROT, ROTL, ROTR are
 555    intentionally omited. */
 556
 557
 558 INLINE_SIM_BITS(unsigned8)  ROT8  (unsigned8  val, int shift);
 559 INLINE_SIM_BITS(unsigned16) ROT16 (unsigned16 val, int shift);
 560 INLINE_SIM_BITS(unsigned32) ROT32 (unsigned32 val, int shift);
 561 INLINE_SIM_BITS(unsigned64) ROT64 (unsigned64 val, int shift);
 562
 563
 564 INLINE_SIM_BITS(unsigned8)  ROTL8  (unsigned8  val, int shift);
 565 INLINE_SIM_BITS(unsigned16) ROTL16 (unsigned16 val, int shift);
 566 INLINE_SIM_BITS(unsigned32) ROTL32 (unsigned32 val, int shift);
 567 INLINE_SIM_BITS(unsigned64) ROTL64 (unsigned64 val, int shift);
 568
 569
 570 INLINE_SIM_BITS(unsigned8)  ROTR8  (unsigned8  val, int shift);
 571 INLINE_SIM_BITS(unsigned16) ROTR16 (unsigned16 val, int shift);
 572 INLINE_SIM_BITS(unsigned32) ROTR32 (unsigned32 val, int shift);
 573 INLINE_SIM_BITS(unsigned64) ROTR64 (unsigned64 val, int shift);
 574
 575
 576
 577 /* Sign extension operations */
 578
 579 INLINE_SIM_BITS(unsigned8)  LSSEXT8  (signed8  val, int sign_bit);
 580 INLINE_SIM_BITS(unsigned16) LSSEXT16 (signed16 val, int sign_bit);
 581 INLINE_SIM_BITS(unsigned32) LSSEXT32 (signed32 val, int sign_bit);
 582 INLINE_SIM_BITS(unsigned64) LSSEXT64 (signed64 val, int sign_bit);
 583 INLINE_SIM_BITS(unsigned_word) LSSEXT (signed_word val, int sign_bit);
 584
 585 INLINE_SIM_BITS(unsigned8)  MSSEXT8  (signed8  val, int sign_bit);
 586 INLINE_SIM_BITS(unsigned16) MSSEXT16 (signed16 val, int sign_bit);
 587 INLINE_SIM_BITS(unsigned32) MSSEXT32 (signed32 val, int sign_bit);
 588 INLINE_SIM_BITS(unsigned64) MSSEXT64 (signed64 val, int sign_bit);
 589 INLINE_SIM_BITS(unsigned_word) MSSEXT (signed_word val, int sign_bit);
 590
 591 #if (WITH_TARGET_WORD_MSB == 0)
 592 #define SEXT8  MSSEXT8
 593 #define SEXT16 MSSEXT16
 594 #define SEXT32 MSSEXT32
 595 #define SEXT64 MSSEXT64
 596 #define SEXT   MSSEXT
 597 #else
 598 #define SEXT8  LSSEXT8
 599 #define SEXT16 LSSEXT16
 600 #define SEXT32 LSSEXT32
 601 #define SEXT64 LSSEXT64
 602 #define SEXT   LSSEXT
 603 #endif
 604
 605
 606
 607 #if H_REVEALS_MODULE_P (SIM_BITS_INLINE)
 608 #include "sim-bits.c"
 609 #endif
 610
 611 #endif /* SIM_BITS_H */