sim/common/sim-bits.c

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