Revision 36081602 target-ppc/op_template.h

b/target-ppc/op_template.h
21 21
/* General purpose registers moves */
22 22
void OPPROTO glue(op_load_gpr_T0_gpr, REG) (void)
23 23
{
24
    T0 = regs->gpr[REG];
24
    T0 = env->gpr[REG];
25 25
    RETURN();
26 26
}
27 27

  
28 28
void OPPROTO glue(op_load_gpr_T1_gpr, REG) (void)
29 29
{
30
    T1 = regs->gpr[REG];
30
    T1 = env->gpr[REG];
31 31
    RETURN();
32 32
}
33 33

  
34 34
void OPPROTO glue(op_load_gpr_T2_gpr, REG) (void)
35 35
{
36
    T2 = regs->gpr[REG];
36
    T2 = env->gpr[REG];
37 37
    RETURN();
38 38
}
39 39

  
40 40
void OPPROTO glue(op_store_T0_gpr_gpr, REG) (void)
41 41
{
42
    regs->gpr[REG] = T0;
42
    env->gpr[REG] = T0;
43 43
    RETURN();
44 44
}
45 45

  
46 46
void OPPROTO glue(op_store_T1_gpr_gpr, REG) (void)
47 47
{
48
    regs->gpr[REG] = T1;
48
    env->gpr[REG] = T1;
49 49
    RETURN();
50 50
}
51 51

  
52 52
#if 0 // unused
53 53
void OPPROTO glue(op_store_T2_gpr_gpr, REG) (void)
54 54
{
55
    regs->gpr[REG] = T2;
55
    env->gpr[REG] = T2;
56 56
    RETURN();
57 57
}
58 58
#endif
......
60 60
#if defined(TARGET_PPCEMB)
61 61
void OPPROTO glue(op_load_gpr64_T0_gpr, REG) (void)
62 62
{
63
    T0_64 = regs->gpr[REG];
63
    T0_64 = env->gpr[REG];
64 64
    RETURN();
65 65
}
66 66

  
67 67
void OPPROTO glue(op_load_gpr64_T1_gpr, REG) (void)
68 68
{
69
    T1_64 = regs->gpr[REG];
69
    T1_64 = env->gpr[REG];
70 70
    RETURN();
71 71
}
72 72

  
73 73
#if 0 // unused
74 74
void OPPROTO glue(op_load_gpr64_T2_gpr, REG) (void)
75 75
{
76
    T2_64 = regs->gpr[REG];
76
    T2_64 = env->gpr[REG];
77 77
    RETURN();
78 78
}
79 79
#endif
80 80

  
81 81
void OPPROTO glue(op_store_T0_gpr64_gpr, REG) (void)
82 82
{
83
    regs->gpr[REG] = T0_64;
83
    env->gpr[REG] = T0_64;
84 84
    RETURN();
85 85
}
86 86

  
87 87
void OPPROTO glue(op_store_T1_gpr64_gpr, REG) (void)
88 88
{
89
    regs->gpr[REG] = T1_64;
89
    env->gpr[REG] = T1_64;
90 90
    RETURN();
91 91
}
92 92

  
93 93
#if 0 // unused
94 94
void OPPROTO glue(op_store_T2_gpr64_gpr, REG) (void)
95 95
{
96
    regs->gpr[REG] = T2_64;
96
    env->gpr[REG] = T2_64;
97 97
    RETURN();
98 98
}
99 99
#endif
......
103 103
/* Condition register moves */
104 104
void OPPROTO glue(op_load_crf_T0_crf, REG) (void)
105 105
{
106
    T0 = regs->crf[REG];
106
    T0 = env->crf[REG];
107 107
    RETURN();
108 108
}
109 109

  
110 110
void OPPROTO glue(op_load_crf_T1_crf, REG) (void)
111 111
{
112
    T1 = regs->crf[REG];
112
    T1 = env->crf[REG];
113 113
    RETURN();
114 114
}
115 115

  
116 116
void OPPROTO glue(op_store_T0_crf_crf, REG) (void)
117 117
{
118
    regs->crf[REG] = T0;
118
    env->crf[REG] = T0;
119 119
    RETURN();
120 120
}
121 121

  
122 122
void OPPROTO glue(op_store_T1_crf_crf, REG) (void)
123 123
{
124
    regs->crf[REG] = T1;
124
    env->crf[REG] = T1;
125 125
    RETURN();
126 126
}
127 127

  
128 128
/* Floating point condition and status register moves */
129 129
void OPPROTO glue(op_load_fpscr_T0_fpscr, REG) (void)
130 130
{
131
    T0 = regs->fpscr[REG];
131
    T0 = env->fpscr[REG];
132 132
    RETURN();
133 133
}
134 134

  
135 135
#if REG == 0
136 136
void OPPROTO glue(op_store_T0_fpscr_fpscr, REG) (void)
137 137
{
138
    regs->fpscr[REG] = (regs->fpscr[REG] & 0x9) | (T0 & ~0x9);
138
    env->fpscr[REG] = (env->fpscr[REG] & 0x9) | (T0 & ~0x9);
139 139
    RETURN();
140 140
}
141 141

  
142 142
void OPPROTO glue(op_clear_fpscr_fpscr, REG) (void)
143 143
{
144
    regs->fpscr[REG] = (regs->fpscr[REG] & 0x9);
144
    env->fpscr[REG] = (env->fpscr[REG] & 0x9);
145 145
    RETURN();
146 146
}
147 147
#else
148 148
void OPPROTO glue(op_store_T0_fpscr_fpscr, REG) (void)
149 149
{
150
    regs->fpscr[REG] = T0;
150
    env->fpscr[REG] = T0;
151 151
    RETURN();
152 152
}
153 153

  
154 154
void OPPROTO glue(op_clear_fpscr_fpscr, REG) (void)
155 155
{
156
    regs->fpscr[REG] = 0x0;
156
    env->fpscr[REG] = 0x0;
157 157
    RETURN();
158 158
}
159 159
#endif

Also available in: Unified diff