target-mips/op_helper_mem.c

   1 #ifdef TARGET_WORDS_BIGENDIAN
   2 #define GET_LMASK(v) ((v) & 3)
   3 #else
   4 #define GET_LMASK(v) (((v) & 3) ^ 3)
   5 #endif
   6
   7 void glue(do_lwl, MEMSUFFIX) (uint32_t tmp)
   8 {
   9 #if defined (DEBUG_OP)
  10     target_ulong sav = T0;
  11 #endif
  12
  13     switch (GET_LMASK(T0)) {
  14     case 0:
  15         T0 = tmp;
  16         break;
  17     case 1:
  18         T0 = (tmp << 8) | (T1 & 0x000000FF);
  19         break;
  20     case 2:
  21         T0 = (tmp << 16) | (T1 & 0x0000FFFF);
  22         break;
  23     case 3:
  24         T0 = (tmp << 24) | (T1 & 0x00FFFFFF);
  25         break;
  26     }
  27 #if defined (DEBUG_OP)
  28     if (logfile) {
  29         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
  30                 __func__, sav, tmp, T1, T0);
  31     }
  32 #endif
  33     RETURN();
  34 }
  35
  36 void glue(do_lwr, MEMSUFFIX) (uint32_t tmp)
  37 {
  38 #if defined (DEBUG_OP)
  39     target_ulong sav = T0;
  40 #endif
  41
  42     switch (GET_LMASK(T0)) {
  43     case 0:
  44         T0 = (tmp >> 24) | (T1 & 0xFFFFFF00);
  45         break;
  46     case 1:
  47         T0 = (tmp >> 16) | (T1 & 0xFFFF0000);
  48         break;
  49     case 2:
  50         T0 = (tmp >> 8) | (T1 & 0xFF000000);
  51         break;
  52     case 3:
  53         T0 = tmp;
  54         break;
  55     }
  56 #if defined (DEBUG_OP)
  57     if (logfile) {
  58         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
  59                 __func__, sav, tmp, T1, T0);
  60     }
  61 #endif
  62     RETURN();
  63 }
  64
  65 uint32_t glue(do_swl, MEMSUFFIX) (uint32_t tmp)
  66 {
  67 #if defined (DEBUG_OP)
  68     target_ulong sav = tmp;
  69 #endif
  70
  71     switch (GET_LMASK(T0)) {
  72     case 0:
  73         tmp = T1;
  74         break;
  75     case 1:
  76         tmp = (tmp & 0xFF000000) | (T1 >> 8);
  77         break;
  78     case 2:
  79         tmp = (tmp & 0xFFFF0000) | (T1 >> 16);
  80         break;
  81     case 3:
  82         tmp = (tmp & 0xFFFFFF00) | (T1 >> 24);
  83         break;
  84     }
  85 #if defined (DEBUG_OP)
  86     if (logfile) {
  87         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
  88                 __func__, T0, sav, T1, tmp);
  89     }
  90 #endif
  91     RETURN();
  92     return tmp;
  93 }
  94
  95 uint32_t glue(do_swr, MEMSUFFIX) (uint32_t tmp)
  96 {
  97 #if defined (DEBUG_OP)
  98     target_ulong sav = tmp;
  99 #endif
 100
 101     switch (GET_LMASK(T0)) {
 102     case 0:
 103         tmp = (tmp & 0x00FFFFFF) | (T1 << 24);
 104         break;
 105     case 1:
 106         tmp = (tmp & 0x0000FFFF) | (T1 << 16);
 107         break;
 108     case 2:
 109         tmp = (tmp & 0x000000FF) | (T1 << 8);
 110         break;
 111     case 3:
 112         tmp = T1;
 113         break;
 114     }
 115 #if defined (DEBUG_OP)
 116     if (logfile) {
 117         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
 118                 __func__, T0, sav, T1, tmp);
 119     }
 120 #endif
 121     RETURN();
 122     return tmp;
 123 }
 124
 125 #ifdef MIPS_HAS_MIPS64
 126
 127 # ifdef TARGET_WORDS_BIGENDIAN
 128 #define GET_LMASK64(v) ((v) & 4)
 129 #else
 130 #define GET_LMASK64(v) (((v) & 4) ^ 4)
 131 #endif
 132
 133 void glue(do_ldl, MEMSUFFIX) (uint64_t tmp)
 134 {
 135 #if defined (DEBUG_OP)
 136     target_ulong sav = T0;
 137 #endif
 138
 139     switch (GET_LMASK64(T0)) {
 140     case 0:
 141         T0 = tmp;
 142         break;
 143     case 1:
 144         T0 = (tmp << 8) | (T1 & 0x00000000000000FFULL);
 145         break;
 146     case 2:
 147         T0 = (tmp << 16) | (T1 & 0x000000000000FFFFULL);
 148         break;
 149     case 3:
 150         T0 = (tmp << 24) | (T1 & 0x0000000000FFFFFFULL);
 151         break;
 152     case 4:
 153         T0 = (tmp << 32) | (T1 & 0x00000000FFFFFFFFULL);
 154         break;
 155     case 5:
 156         T0 = (tmp << 40) | (T1 & 0x000000FFFFFFFFFFULL);
 157         break;
 158     case 6:
 159         T0 = (tmp << 48) | (T1 & 0x0000FFFFFFFFFFFFULL);
 160         break;
 161     case 7:
 162         T0 = (tmp << 56) | (T1 & 0x00FFFFFFFFFFFFFFULL);
 163         break;
 164     }
 165 #if defined (DEBUG_OP)
 166     if (logfile) {
 167         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
 168                 __func__, sav, tmp, T1, T0);
 169     }
 170 #endif
 171     RETURN();
 172 }
 173
 174 void glue(do_ldr, MEMSUFFIX) (uint64_t tmp)
 175 {
 176 #if defined (DEBUG_OP)
 177     target_ulong sav = T0;
 178 #endif
 179
 180     switch (GET_LMASK64(T0)) {
 181     case 0:
 182         T0 = (tmp >> 56) | (T1 & 0xFFFFFFFFFFFFFF00ULL);
 183         break;
 184     case 1:
 185         T0 = (tmp >> 48) | (T1 & 0xFFFFFFFFFFFF0000ULL);
 186         break;
 187     case 2:
 188         T0 = (tmp >> 40) | (T1 & 0xFFFFFFFFFF000000ULL);
 189         break;
 190     case 3:
 191         T0 = (tmp >> 32) | (T1 & 0xFFFFFFFF00000000ULL);
 192         break;
 193     case 4:
 194         T0 = (tmp >> 24) | (T1 & 0xFFFFFF0000000000ULL);
 195         break;
 196     case 5:
 197         T0 = (tmp >> 16) | (T1 & 0xFFFF000000000000ULL);
 198         break;
 199     case 6:
 200         T0 = (tmp >> 8) | (T1 & 0xFF00000000000000ULL);
 201         break;
 202     case 7:
 203         T0 = tmp;
 204         break;
 205     }
 206 #if defined (DEBUG_OP)
 207     if (logfile) {
 208         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
 209                 __func__, sav, tmp, T1, T0);
 210     }
 211 #endif
 212     RETURN();
 213 }
 214
 215 uint64_t glue(do_sdl, MEMSUFFIX) (uint64_t tmp)
 216 {
 217 #if defined (DEBUG_OP)
 218     target_ulong sav = tmp;
 219 #endif
 220
 221     switch (GET_LMASK64(T0)) {
 222     case 0:
 223         tmp = T1;
 224         break;
 225     case 1:
 226         tmp = (tmp & 0xFF00000000000000ULL) | (T1 >> 8);
 227         break;
 228     case 2:
 229         tmp = (tmp & 0xFFFF000000000000ULL) | (T1 >> 16);
 230         break;
 231     case 3:
 232         tmp = (tmp & 0xFFFFFF0000000000ULL) | (T1 >> 24);
 233         break;
 234     case 4:
 235         tmp = (tmp & 0xFFFFFFFF00000000ULL) | (T1 >> 32);
 236         break;
 237     case 5:
 238         tmp = (tmp & 0xFFFFFFFFFF000000ULL) | (T1 >> 40);
 239         break;
 240     case 6:
 241         tmp = (tmp & 0xFFFFFFFFFFFF0000ULL) | (T1 >> 48);
 242         break;
 243     case 7:
 244         tmp = (tmp & 0xFFFFFFFFFFFFFF00ULL) | (T1 >> 56);
 245         break;
 246     }
 247 #if defined (DEBUG_OP)
 248     if (logfile) {
 249         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
 250                 __func__, T0, sav, T1, tmp);
 251     }
 252 #endif
 253     RETURN();
 254     return tmp;
 255 }
 256
 257 uint64_t glue(do_sdr, MEMSUFFIX) (uint64_t tmp)
 258 {
 259 #if defined (DEBUG_OP)
 260     target_ulong sav = tmp;
 261 #endif
 262
 263     switch (GET_LMASK64(T0)) {
 264     case 0:
 265         tmp = (tmp & 0x00FFFFFFFFFFFFFFULL) | (T1 << 56);
 266         break;
 267     case 1:
 268         tmp = (tmp & 0x0000FFFFFFFFFFFFULL) | (T1 << 48);
 269         break;
 270     case 2:
 271         tmp = (tmp & 0x000000FFFFFFFFFFULL) | (T1 << 40);
 272         break;
 273     case 3:
 274         tmp = (tmp & 0x00000000FFFFFFFFULL) | (T1 << 32);
 275         break;
 276     case 4:
 277         tmp = (tmp & 0x0000000000FFFFFFULL) | (T1 << 24);
 278         break;
 279     case 5:
 280         tmp = (tmp & 0x000000000000FFFFULL) | (T1 << 16);
 281         break;
 282     case 6:
 283         tmp = (tmp & 0x00000000000000FFULL) | (T1 << 8);
 284         break;
 285     case 7:
 286         tmp = T1;
 287         break;
 288     }
 289 #if defined (DEBUG_OP)
 290     if (logfile) {
 291         fprintf(logfile, "%s: %08x - %08x %08x => %08x\n",
 292                 __func__, T0, sav, T1, tmp);
 293     }
 294 #endif
 295     RETURN();
 296     return tmp;
 297 }
 298
 299 #endif /* MIPS_HAS_MIPS64 */