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 #if 0 // Unused
 163 void OPPROTO glue(op_store_T1_crf_crf, REG) (void)
 164 {
 165     env->crf[REG] = T1;
 166     RETURN();
 167 }
 168 #endif
 169
 170 #endif /* REG <= 7 */
 171
 172 /* floating point registers moves */
 173 void OPPROTO glue(op_load_fpr_FT0_fpr, REG) (void)
 174 {
 175     FT0 = env->fpr[REG];
 176     RETURN();
 177 }
 178
 179 void OPPROTO glue(op_store_FT0_fpr_fpr, REG) (void)
 180 {
 181     env->fpr[REG] = FT0;
 182     RETURN();
 183 }
 184
 185 void OPPROTO glue(op_load_fpr_FT1_fpr, REG) (void)
 186 {
 187     FT1 = env->fpr[REG];
 188     RETURN();
 189 }
 190
 191 void OPPROTO glue(op_store_FT1_fpr_fpr, REG) (void)
 192 {
 193     env->fpr[REG] = FT1;
 194     RETURN();
 195 }
 196
 197 void OPPROTO glue(op_load_fpr_FT2_fpr, REG) (void)
 198 {
 199     FT2 = env->fpr[REG];
 200     RETURN();
 201 }
 202
 203 #if 0 // unused
 204 void OPPROTO glue(op_store_FT2_fpr_fpr, REG) (void)
 205 {
 206     env->fpr[REG] = FT2;
 207     RETURN();
 208 }
 209 #endif
 210
 211 #undef REG