sim/common/sim-bits.c

   1 /* The common simulator framework for GDB, the GNU Debugger.
   2
   3    Copyright 2002-2023 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_C_
  24 #define _SIM_BITS_C_
  25
  26 /* This must come before any other includes.  */
  27 #include "defs.h"
  28
  29 #include "sim-basics.h"
  30 #include "sim-assert.h"
  31 #include "sim-io.h"
  32
  33
  34 INLINE_SIM_BITS\
  35 (unsigned_word)
  36 LSMASKED (unsigned_word val,
  37           int start,
  38           int stop)
  39 {
  40   /* NOTE - start, stop can wrap */
  41   val &= LSMASK (start, stop);
  42   return val;
  43 }
  44
  45
  46 INLINE_SIM_BITS\
  47 (unsigned_word)
  48 MSMASKED (unsigned_word val,
  49           int start,
  50           int stop)
  51 {
  52   /* NOTE - start, stop can wrap */
  53   val &= MSMASK (start, stop);
  54   return val;
  55 }
  56
  57
  58 INLINE_SIM_BITS\
  59 (unsigned_word)
  60 LSEXTRACTED (unsigned_word val,
  61              int start,
  62              int stop)
  63 {
  64   ASSERT (start >= stop);
  65 #if (WITH_TARGET_WORD_BITSIZE == 64)
  66   return LSEXTRACTED64 (val, start, stop);
  67 #endif
  68 #if (WITH_TARGET_WORD_BITSIZE == 32)
  69   if (stop >= 32)
  70     return 0;
  71   else
  72     {
  73       if (start < 32)
  74         val &= LSMASK (start, 0);
  75       val >>= stop;
  76       return val;
  77     }
  78 #endif
  79 #if (WITH_TARGET_WORD_BITSIZE == 16)
  80   if (stop >= 16)
  81     return 0;
  82   else
  83     {
  84       if (start < 16)
  85         val &= LSMASK (start, 0);
  86       val >>= stop;
  87       return val;
  88     }
  89 #endif
  90 }
  91
  92
  93 INLINE_SIM_BITS\
  94 (unsigned_word)
  95 MSEXTRACTED (unsigned_word val,
  96              int start,
  97              int stop)
  98 {
  99   ASSERT (start <= stop);
 100 #if (WITH_TARGET_WORD_BITSIZE == 64)
 101   return MSEXTRACTED64 (val, start, stop);
 102 #endif
 103 #if (WITH_TARGET_WORD_BITSIZE == 32)
 104   if (stop < 32)
 105     return 0;
 106   else
 107     {
 108       if (start >= 32)
 109         val &= MSMASK (start, 64 - 1);
 110       val >>= (64 - stop - 1);
 111       return val;
 112     }
 113 #endif
 114 #if (WITH_TARGET_WORD_BITSIZE == 16)
 115   if (stop < 16)
 116     return 0;
 117   else
 118     {
 119       if (start >= 16)
 120         val &= MSMASK (start, 64 - 1);
 121       val >>= (64 - stop - 1);
 122       return val;
 123     }
 124 #endif
 125 }
 126
 127
 128 INLINE_SIM_BITS\
 129 (unsigned_word)
 130 LSINSERTED (unsigned_word val,
 131             int start,
 132             int stop)
 133 {
 134   ASSERT (start >= stop);
 135 #if (WITH_TARGET_WORD_BITSIZE == 64)
 136   return LSINSERTED64 (val, start, stop);
 137 #endif
 138 #if (WITH_TARGET_WORD_BITSIZE == 32)
 139   /* Bit numbers are 63..0, even for 32 bit targets.
 140      On 32 bit targets we ignore 63..32  */
 141   if (stop >= 32)
 142     return 0;
 143   else
 144     {
 145       val <<= stop;
 146       val &= LSMASK (start, stop);
 147       return val;
 148     }
 149 #endif
 150 #if (WITH_TARGET_WORD_BITSIZE == 16)
 151   /* Bit numbers are 63..0, even for 16 bit targets.
 152      On 16 bit targets we ignore 63..16  */
 153   if (stop >= 16)
 154     return 0;
 155   else
 156     {
 157       val <<= stop;
 158       val &= LSMASK (start, stop);
 159       return val;
 160     }
 161 #endif
 162 }
 163
 164 INLINE_SIM_BITS\
 165 (unsigned_word)
 166 MSINSERTED (unsigned_word val,
 167             int start,
 168             int stop)
 169 {
 170   ASSERT (start <= stop);
 171 #if (WITH_TARGET_WORD_BITSIZE == 64)
 172   return MSINSERTED64 (val, start, stop);
 173 #endif
 174 #if (WITH_TARGET_WORD_BITSIZE == 32)
 175   /* Bit numbers are 0..63, even for 32 bit targets.
 176      On 32 bit targets we ignore 0..31.  */
 177   if (stop < 32)
 178     return 0;
 179   else
 180     {
 181       val <<= ((64 - 1) - stop);
 182       val &= MSMASK (start, stop);
 183       return val;
 184     }
 185 #endif
 186 #if (WITH_TARGET_WORD_BITSIZE == 16)
 187   /* Bit numbers are 0..63, even for 16 bit targets.
 188      On 16 bit targets we ignore 0..47.  */
 189   if (stop < 32 + 16)
 190     return 0;
 191   else
 192     {
 193       val <<= ((64 - 1) - stop);
 194       val &= MSMASK (start, stop);
 195       return val;
 196     }
 197 #endif
 198 }
 199
 200
 201
 202 INLINE_SIM_BITS\
 203 (unsigned_word)
 204 LSSEXT (signed_word val,
 205         int sign_bit)
 206 {
 207   ASSERT (sign_bit < 64);
 208 #if (WITH_TARGET_WORD_BITSIZE == 64)
 209   return LSSEXT64 (val, sign_bit);
 210 #endif
 211 #if (WITH_TARGET_WORD_BITSIZE == 32)
 212   if (sign_bit >= 32)
 213     return val;
 214   else {
 215     val = LSSEXT32 (val, sign_bit);
 216     return val;
 217   }
 218 #endif
 219 #if (WITH_TARGET_WORD_BITSIZE == 16)
 220   if (sign_bit >= 16)
 221     return val;
 222   else {
 223     val = LSSEXT16 (val, sign_bit);
 224     return val;
 225   }
 226 #endif
 227 }
 228
 229 INLINE_SIM_BITS\
 230 (unsigned_word)
 231 MSSEXT (signed_word val,
 232         int sign_bit)
 233 {
 234   ASSERT (sign_bit < 64);
 235 #if (WITH_TARGET_WORD_BITSIZE == 64)
 236   return MSSEXT64 (val, sign_bit);
 237 #endif
 238 #if (WITH_TARGET_WORD_BITSIZE == 32)
 239   if (sign_bit < 32)
 240     return val;
 241   else {
 242     val = MSSEXT32 (val, sign_bit - 32);
 243     return val;
 244   }
 245 #endif
 246 #if (WITH_TARGET_WORD_BITSIZE == 16)
 247   if (sign_bit < 32 + 16)
 248     return val;
 249   else {
 250     val = MSSEXT16 (val, sign_bit - 32 - 16);
 251     return val;
 252   }
 253 #endif
 254 }
 255
 256
 257
 258 #define N 8
 259 #include "sim-n-bits.h"
 260 #undef N
 261
 262 #define N 16
 263 #include "sim-n-bits.h"
 264 #undef N
 265
 266 #define N 32
 267 #include "sim-n-bits.h"
 268 #undef N
 269
 270 #define N 64
 271 #include "sim-n-bits.h"
 272 #undef N
 273
 274 #endif /* _SIM_BITS_C_ */