← Back to branch summary

~ubuntu-branches/ubuntu/hardy/qemu/hardy

« back to all changes in this revision

Viewing changes to target-mips/op_helper_mem.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Vogt
  • Date: 2007-05-02 11:55:16 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070502115516-rf8z0ba1ojbncx10
Tags: 0.9.0-1ubuntu1
* merged from Debian/experimental
* Merge from debian unstable, remaining changes:
   - Remove 34_syscalls_types.patch from debian/patches/series: add an
     unnecessary kernel header breaking compilation of linux-user/syscall.c.
   - Move proll and openhackware from Depends to Recommends.
   - set Maintainer field to MOTU

Show diffs side-by-side

added added

removed removed

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