gnu/dist/gdb6/sim/common/sim-bits.h

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