1/* The common simulator framework for GDB, the GNU Debugger. 2 3 Copyright 2002, 2007, 2008, 2009, 2010, 2011 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 31INLINE_SIM_BITS\ 32(unsigned_word) 33LSMASKED (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 43INLINE_SIM_BITS\ 44(unsigned_word) 45MSMASKED (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 55INLINE_SIM_BITS\ 56(unsigned_word) 57LSEXTRACTED (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 90INLINE_SIM_BITS\ 91(unsigned_word) 92MSEXTRACTED (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 125INLINE_SIM_BITS\ 126(unsigned_word) 127LSINSERTED (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 161INLINE_SIM_BITS\ 162(unsigned_word) 163MSINSERTED (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 199INLINE_SIM_BITS\ 200(unsigned_word) 201LSSEXT (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 226INLINE_SIM_BITS\ 227(unsigned_word) 228MSSEXT (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_ */ 272