vcs.maemo.org Git - qemu/blob - target-ppc/op_template.h

   1 /*
   2  *  PowerPC emulation micro-operations for qemu.
   3  *
   4  *  Copyright (c) 2003-2007 Jocelyn Mayer
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 /* General purpose registers moves */
  22 void OPPROTO glue(op_load_gpr_T0_gpr, REG) (void)
  23 {
  24     T0 = env->gpr[REG];
  25     RETURN();
  26 }
  27
  28 void OPPROTO glue(op_load_gpr_T1_gpr, REG) (void)
  29 {
  30     T1 = env->gpr[REG];
  31     RETURN();
  32 }
  33
  34 void OPPROTO glue(op_load_gpr_T2_gpr, REG) (void)
  35 {
  36     T2 = env->gpr[REG];
  37     RETURN();
  38 }
  39
  40 void OPPROTO glue(op_store_T0_gpr_gpr, REG) (void)
  41 {
  42     env->gpr[REG] = T0;
  43     RETURN();
  44 }
  45
  46 void OPPROTO glue(op_store_T1_gpr_gpr, REG) (void)
  47 {
  48     env->gpr[REG] = T1;
  49     RETURN();
  50 }
  51
  52 #if 0 // unused
  53 void OPPROTO glue(op_store_T2_gpr_gpr, REG) (void)
  54 {
  55     env->gpr[REG] = T2;
  56     RETURN();
  57 }
  58 #endif
  59
  60 /* General purpose registers containing vector operands moves */
  61 #if defined(TARGET_PPCEMB)
  62 void OPPROTO glue(op_load_gpr64_T0_gpr, REG) (void)
  63 {
  64     T0_64 = env->gpr[REG];
  65     RETURN();
  66 }
  67
  68 void OPPROTO glue(op_load_gpr64_T1_gpr, REG) (void)
  69 {
  70     T1_64 = env->gpr[REG];
  71     RETURN();
  72 }
  73
  74 #if 0 // unused
  75 void OPPROTO glue(op_load_gpr64_T2_gpr, REG) (void)
  76 {
  77     T2_64 = env->gpr[REG];
  78     RETURN();
  79 }
  80 #endif
  81
  82 void OPPROTO glue(op_store_T0_gpr64_gpr, REG) (void)
  83 {
  84     env->gpr[REG] = T0_64;
  85     RETURN();
  86 }
  87
  88 void OPPROTO glue(op_store_T1_gpr64_gpr, REG) (void)
  89 {
  90     env->gpr[REG] = T1_64;
  91     RETURN();
  92 }
  93
  94 #if 0 // unused
  95 void OPPROTO glue(op_store_T2_gpr64_gpr, REG) (void)
  96 {
  97     env->gpr[REG] = T2_64;
  98     RETURN();
  99 }
 100 #endif
 101 #endif /* defined(TARGET_PPCEMB) */
 102
 103 /* Altivec registers moves */
 104 void OPPROTO glue(op_load_avr_A0_avr, REG) (void)
 105 {
 106     AVR0 = env->avr[REG];
 107     RETURN();
 108 }
 109
 110 void OPPROTO glue(op_load_avr_A1_avr, REG) (void)
 111 {
 112     AVR1 = env->avr[REG];
 113     RETURN();
 114 }
 115
 116 void OPPROTO glue(op_load_avr_A2_avr, REG) (void)
 117 {
 118     AVR2 = env->avr[REG];
 119     RETURN();
 120 }
 121
 122 void OPPROTO glue(op_store_A0_avr_avr, REG) (void)
 123 {
 124     env->avr[REG] = AVR0;
 125     RETURN();
 126 }
 127
 128 void OPPROTO glue(op_store_A1_avr_avr, REG) (void)
 129 {
 130     env->avr[REG] = AVR1;
 131     RETURN();
 132 }
 133
 134 #if 0 // unused
 135 void OPPROTO glue(op_store_A2_avr_avr, REG) (void)
 136 {
 137     env->avr[REG] = AVR2;
 138     RETURN();
 139 }
 140 #endif
 141
 142 #if REG <= 7
 143 /* Condition register moves */
 144 void OPPROTO glue(op_load_crf_T0_crf, REG) (void)
 145 {
 146     T0 = env->crf[REG];
 147     RETURN();
 148 }
 149
 150 void OPPROTO glue(op_load_crf_T1_crf, REG) (void)
 151 {
 152     T1 = env->crf[REG];
 153     RETURN();
 154 }
 155
 156 void OPPROTO glue(op_store_T0_crf_crf, REG) (void)
 157 {
 158     env->crf[REG] = T0;
 159     RETURN();
 160 }
 161
 162 void OPPROTO glue(op_store_T1_crf_crf, REG) (void)
 163 {
 164     env->crf[REG] = T1;
 165     RETURN();
 166 }
 167
 168 /* Floating point condition and status register moves */
 169 void OPPROTO glue(op_load_fpscr_T0_fpscr, REG) (void)
 170 {
 171     T0 = env->fpscr[REG];
 172     RETURN();
 173 }
 174
 175 #if REG == 0
 176 void OPPROTO glue(op_store_T0_fpscr_fpscr, REG) (void)
 177 {
 178     env->fpscr[REG] = (env->fpscr[REG] & 0x9) | (T0 & ~0x9);
 179     RETURN();
 180 }
 181
 182 void OPPROTO glue(op_clear_fpscr_fpscr, REG) (void)
 183 {
 184     env->fpscr[REG] = (env->fpscr[REG] & 0x9);
 185     RETURN();
 186 }
 187 #else
 188 void OPPROTO glue(op_store_T0_fpscr_fpscr, REG) (void)
 189 {
 190     env->fpscr[REG] = T0;
 191     RETURN();
 192 }
 193
 194 void OPPROTO glue(op_clear_fpscr_fpscr, REG) (void)
 195 {
 196     env->fpscr[REG] = 0x0;
 197     RETURN();
 198 }
 199 #endif
 200
 201 #endif /* REG <= 7 */
 202
 203 /* floating point registers moves */
 204 void OPPROTO glue(op_load_fpr_FT0_fpr, REG) (void)
 205 {
 206     FT0 = env->fpr[REG];
 207     RETURN();
 208 }
 209
 210 void OPPROTO glue(op_store_FT0_fpr_fpr, REG) (void)
 211 {
 212     env->fpr[REG] = FT0;
 213     RETURN();
 214 }
 215
 216 void OPPROTO glue(op_load_fpr_FT1_fpr, REG) (void)
 217 {
 218     FT1 = env->fpr[REG];
 219     RETURN();
 220 }
 221
 222 void OPPROTO glue(op_store_FT1_fpr_fpr, REG) (void)
 223 {
 224     env->fpr[REG] = FT1;
 225     RETURN();
 226 }
 227
 228 void OPPROTO glue(op_load_fpr_FT2_fpr, REG) (void)
 229 {
 230     FT2 = env->fpr[REG];
 231     RETURN();
 232 }
 233
 234 #if 0 // unused
 235 void OPPROTO glue(op_store_FT2_fpr_fpr, REG) (void)
 236 {
 237     env->fpr[REG] = FT2;
 238     RETURN();
 239 }
 240 #endif
 241
 242 #undef REG