← Back to branch summary

~ubuntu-branches/ubuntu/hardy/kvm/hardy-backports

« back to all changes in this revision

Viewing changes to qemu/tcg/tcg-op.h

  • Committer: Bazaar Package Importer
  • Author(s): Soren Hansen
  • Date: 2008-02-26 13:10:57 UTC
  • mfrom: (1.1.18 upstream)
  • Revision ID: james.westby@ubuntu.com-20080226131057-s67x6l89mtjw1x9b
Tags: 1:62+dfsg-0ubuntu1
New upstream release

Show diffs side-by-side

added added

removed removed

Lines of Context:
qemu/tcg/tcg-op.h
 
1
/*
 
2
 * Tiny Code Generator for QEMU
 
3
 *
 
4
 * Copyright (c) 2008 Fabrice Bellard
 
5
 *
 
6
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 
7
 * of this software and associated documentation files (the "Software"), to deal
 
8
 * in the Software without restriction, including without limitation the rights
 
9
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 
10
 * copies of the Software, and to permit persons to whom the Software is
 
11
 * furnished to do so, subject to the following conditions:
 
12
 *
 
13
 * The above copyright notice and this permission notice shall be included in
 
14
 * all copies or substantial portions of the Software.
 
15
 *
 
16
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 
17
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 
18
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 
19
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 
20
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 
21
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 
22
 * THE SOFTWARE.
 
23
 */
 
24
#include "tcg.h"
 
25
 
 
26
/* legacy dyngen operations */
 
27
#include "gen-op.h"
 
28
 
 
29
int gen_new_label(void);
 
30
 
 
31
static inline void tcg_gen_op1(int opc, TCGv arg1)
 
32
{
 
33
    *gen_opc_ptr++ = opc;
 
34
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
35
}
 
36
 
 
37
static inline void tcg_gen_op1i(int opc, TCGArg arg1)
 
38
{
 
39
    *gen_opc_ptr++ = opc;
 
40
    *gen_opparam_ptr++ = arg1;
 
41
}
 
42
 
 
43
static inline void tcg_gen_op2(int opc, TCGv arg1, TCGv arg2)
 
44
{
 
45
    *gen_opc_ptr++ = opc;
 
46
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
47
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
48
}
 
49
 
 
50
static inline void tcg_gen_op2i(int opc, TCGv arg1, TCGArg arg2)
 
51
{
 
52
    *gen_opc_ptr++ = opc;
 
53
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
54
    *gen_opparam_ptr++ = arg2;
 
55
}
 
56
 
 
57
static inline void tcg_gen_op3(int opc, TCGv arg1, TCGv arg2, TCGv arg3)
 
58
{
 
59
    *gen_opc_ptr++ = opc;
 
60
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
61
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
62
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
63
}
 
64
 
 
65
static inline void tcg_gen_op3i(int opc, TCGv arg1, TCGv arg2, TCGArg arg3)
 
66
{
 
67
    *gen_opc_ptr++ = opc;
 
68
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
69
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
70
    *gen_opparam_ptr++ = arg3;
 
71
}
 
72
 
 
73
static inline void tcg_gen_op4(int opc, TCGv arg1, TCGv arg2, TCGv arg3, 
 
74
                               TCGv arg4)
 
75
{
 
76
    *gen_opc_ptr++ = opc;
 
77
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
78
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
79
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
80
    *gen_opparam_ptr++ = GET_TCGV(arg4);
 
81
}
 
82
 
 
83
static inline void tcg_gen_op4i(int opc, TCGv arg1, TCGv arg2, TCGv arg3, 
 
84
                                TCGArg arg4)
 
85
{
 
86
    *gen_opc_ptr++ = opc;
 
87
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
88
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
89
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
90
    *gen_opparam_ptr++ = arg4;
 
91
}
 
92
 
 
93
static inline void tcg_gen_op4ii(int opc, TCGv arg1, TCGv arg2, TCGArg arg3, 
 
94
                                 TCGArg arg4)
 
95
{
 
96
    *gen_opc_ptr++ = opc;
 
97
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
98
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
99
    *gen_opparam_ptr++ = arg3;
 
100
    *gen_opparam_ptr++ = arg4;
 
101
}
 
102
 
 
103
static inline void tcg_gen_op5(int opc, TCGv arg1, TCGv arg2, 
 
104
                               TCGv arg3, TCGv arg4,
 
105
                               TCGv arg5)
 
106
{
 
107
    *gen_opc_ptr++ = opc;
 
108
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
109
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
110
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
111
    *gen_opparam_ptr++ = GET_TCGV(arg4);
 
112
    *gen_opparam_ptr++ = GET_TCGV(arg5);
 
113
}
 
114
 
 
115
static inline void tcg_gen_op5i(int opc, TCGv arg1, TCGv arg2, 
 
116
                                TCGv arg3, TCGv arg4,
 
117
                                TCGArg arg5)
 
118
{
 
119
    *gen_opc_ptr++ = opc;
 
120
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
121
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
122
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
123
    *gen_opparam_ptr++ = GET_TCGV(arg4);
 
124
    *gen_opparam_ptr++ = arg5;
 
125
}
 
126
 
 
127
static inline void tcg_gen_op6(int opc, TCGv arg1, TCGv arg2, 
 
128
                               TCGv arg3, TCGv arg4,
 
129
                               TCGv arg5, TCGv arg6)
 
130
{
 
131
    *gen_opc_ptr++ = opc;
 
132
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
133
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
134
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
135
    *gen_opparam_ptr++ = GET_TCGV(arg4);
 
136
    *gen_opparam_ptr++ = GET_TCGV(arg5);
 
137
    *gen_opparam_ptr++ = GET_TCGV(arg6);
 
138
}
 
139
 
 
140
static inline void tcg_gen_op6ii(int opc, TCGv arg1, TCGv arg2, 
 
141
                                 TCGv arg3, TCGv arg4,
 
142
                                 TCGArg arg5, TCGArg arg6)
 
143
{
 
144
    *gen_opc_ptr++ = opc;
 
145
    *gen_opparam_ptr++ = GET_TCGV(arg1);
 
146
    *gen_opparam_ptr++ = GET_TCGV(arg2);
 
147
    *gen_opparam_ptr++ = GET_TCGV(arg3);
 
148
    *gen_opparam_ptr++ = GET_TCGV(arg4);
 
149
    *gen_opparam_ptr++ = arg5;
 
150
    *gen_opparam_ptr++ = arg6;
 
151
}
 
152
 
 
153
static inline void gen_set_label(int n)
 
154
{
 
155
    tcg_gen_op1i(INDEX_op_set_label, n);
 
156
}
 
157
 
 
158
static inline void tcg_gen_mov_i32(TCGv ret, TCGv arg)
 
159
{
 
160
    tcg_gen_op2(INDEX_op_mov_i32, ret, arg);
 
161
}
 
162
 
 
163
static inline void tcg_gen_movi_i32(TCGv ret, int32_t arg)
 
164
{
 
165
    tcg_gen_op2i(INDEX_op_movi_i32, ret, arg);
 
166
}
 
167
 
 
168
/* helper calls */
 
169
#define TCG_HELPER_CALL_FLAGS 0
 
170
 
 
171
static inline void tcg_gen_helper_0_0(void *func)
 
172
{
 
173
    tcg_gen_call(&tcg_ctx, 
 
174
                 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
 
175
                 0, NULL, 0, NULL);
 
176
}
 
177
 
 
178
static inline void tcg_gen_helper_0_1(void *func, TCGv arg)
 
179
{
 
180
    tcg_gen_call(&tcg_ctx,
 
181
                 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
 
182
                 0, NULL, 1, &arg);
 
183
}
 
184
 
 
185
static inline void tcg_gen_helper_0_2(void *func, TCGv arg1, TCGv arg2)
 
186
{
 
187
    TCGv args[2];
 
188
    args[0] = arg1;
 
189
    args[1] = arg2;
 
190
    tcg_gen_call(&tcg_ctx, 
 
191
                 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
 
192
                 0, NULL, 2, args);
 
193
}
 
194
 
 
195
static inline void tcg_gen_helper_1_2(void *func, TCGv ret, 
 
196
                                      TCGv arg1, TCGv arg2)
 
197
{
 
198
    TCGv args[2];
 
199
    args[0] = arg1;
 
200
    args[1] = arg2;
 
201
    tcg_gen_call(&tcg_ctx, 
 
202
                 tcg_const_ptr((tcg_target_long)func), TCG_HELPER_CALL_FLAGS,
 
203
                 1, &ret, 2, args);
 
204
}
 
205
 
 
206
/* 32 bit ops */
 
207
 
 
208
static inline void tcg_gen_ld8u_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
 
209
{
 
210
    tcg_gen_op3i(INDEX_op_ld8u_i32, ret, arg2, offset);
 
211
}
 
212
 
 
213
static inline void tcg_gen_ld8s_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
 
214
{
 
215
    tcg_gen_op3i(INDEX_op_ld8s_i32, ret, arg2, offset);
 
216
}
 
217
 
 
218
static inline void tcg_gen_ld16u_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
 
219
{
 
220
    tcg_gen_op3i(INDEX_op_ld16u_i32, ret, arg2, offset);
 
221
}
 
222
 
 
223
static inline void tcg_gen_ld16s_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
 
224
{
 
225
    tcg_gen_op3i(INDEX_op_ld16s_i32, ret, arg2, offset);
 
226
}
 
227
 
 
228
static inline void tcg_gen_ld_i32(TCGv ret, TCGv arg2, tcg_target_long offset)
 
229
{
 
230
    tcg_gen_op3i(INDEX_op_ld_i32, ret, arg2, offset);
 
231
}
 
232
 
 
233
static inline void tcg_gen_st8_i32(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
234
{
 
235
    tcg_gen_op3i(INDEX_op_st8_i32, arg1, arg2, offset);
 
236
}
 
237
 
 
238
static inline void tcg_gen_st16_i32(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
239
{
 
240
    tcg_gen_op3i(INDEX_op_st16_i32, arg1, arg2, offset);
 
241
}
 
242
 
 
243
static inline void tcg_gen_st_i32(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
244
{
 
245
    tcg_gen_op3i(INDEX_op_st_i32, arg1, arg2, offset);
 
246
}
 
247
 
 
248
static inline void tcg_gen_add_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
249
{
 
250
    tcg_gen_op3(INDEX_op_add_i32, ret, arg1, arg2);
 
251
}
 
252
 
 
253
static inline void tcg_gen_addi_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
254
{
 
255
    tcg_gen_add_i32(ret, arg1, tcg_const_i32(arg2));
 
256
}
 
257
 
 
258
static inline void tcg_gen_sub_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
259
{
 
260
    tcg_gen_op3(INDEX_op_sub_i32, ret, arg1, arg2);
 
261
}
 
262
 
 
263
static inline void tcg_gen_subi_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
264
{
 
265
    tcg_gen_sub_i32(ret, arg1, tcg_const_i32(arg2));
 
266
}
 
267
 
 
268
static inline void tcg_gen_and_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
269
{
 
270
    tcg_gen_op3(INDEX_op_and_i32, ret, arg1, arg2);
 
271
}
 
272
 
 
273
static inline void tcg_gen_andi_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
274
{
 
275
    /* some cases can be optimized here */
 
276
    if (arg2 == 0) {
 
277
        tcg_gen_movi_i32(ret, 0);
 
278
    } else if (arg2 == 0xffffffff) {
 
279
        tcg_gen_mov_i32(ret, arg1);
 
280
    } else {
 
281
        tcg_gen_and_i32(ret, arg1, tcg_const_i32(arg2));
 
282
    }
 
283
}
 
284
 
 
285
static inline void tcg_gen_or_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
286
{
 
287
    tcg_gen_op3(INDEX_op_or_i32, ret, arg1, arg2);
 
288
}
 
289
 
 
290
static inline void tcg_gen_ori_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
291
{
 
292
    /* some cases can be optimized here */
 
293
    if (arg2 == 0xffffffff) {
 
294
        tcg_gen_movi_i32(ret, 0);
 
295
    } else if (arg2 == 0) {
 
296
        tcg_gen_mov_i32(ret, arg1);
 
297
    } else {
 
298
        tcg_gen_or_i32(ret, arg1, tcg_const_i32(arg2));
 
299
    }
 
300
}
 
301
 
 
302
static inline void tcg_gen_xor_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
303
{
 
304
    tcg_gen_op3(INDEX_op_xor_i32, ret, arg1, arg2);
 
305
}
 
306
 
 
307
static inline void tcg_gen_xori_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
308
{
 
309
    /* some cases can be optimized here */
 
310
    if (arg2 == 0) {
 
311
        tcg_gen_mov_i32(ret, arg1);
 
312
    } else {
 
313
        tcg_gen_xor_i32(ret, arg1, tcg_const_i32(arg2));
 
314
    }
 
315
}
 
316
 
 
317
static inline void tcg_gen_shl_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
318
{
 
319
    tcg_gen_op3(INDEX_op_shl_i32, ret, arg1, arg2);
 
320
}
 
321
 
 
322
static inline void tcg_gen_shli_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
323
{
 
324
    tcg_gen_shl_i32(ret, arg1, tcg_const_i32(arg2));
 
325
}
 
326
 
 
327
static inline void tcg_gen_shr_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
328
{
 
329
    tcg_gen_op3(INDEX_op_shr_i32, ret, arg1, arg2);
 
330
}
 
331
 
 
332
static inline void tcg_gen_shri_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
333
{
 
334
    tcg_gen_shr_i32(ret, arg1, tcg_const_i32(arg2));
 
335
}
 
336
 
 
337
static inline void tcg_gen_sar_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
338
{
 
339
    tcg_gen_op3(INDEX_op_sar_i32, ret, arg1, arg2);
 
340
}
 
341
 
 
342
static inline void tcg_gen_sari_i32(TCGv ret, TCGv arg1, int32_t arg2)
 
343
{
 
344
    tcg_gen_sar_i32(ret, arg1, tcg_const_i32(arg2));
 
345
}
 
346
 
 
347
static inline void tcg_gen_brcond_i32(int cond, TCGv arg1, TCGv arg2, 
 
348
                                      int label_index)
 
349
{
 
350
    tcg_gen_op4ii(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
 
351
}
 
352
 
 
353
static inline void tcg_gen_mul_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
354
{
 
355
    tcg_gen_op3(INDEX_op_mul_i32, ret, arg1, arg2);
 
356
}
 
357
 
 
358
#ifdef TCG_TARGET_HAS_div_i32
 
359
static inline void tcg_gen_div_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
360
{
 
361
    tcg_gen_op3(INDEX_op_div_i32, ret, arg1, arg2);
 
362
}
 
363
 
 
364
static inline void tcg_gen_rem_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
365
{
 
366
    tcg_gen_op3(INDEX_op_rem_i32, ret, arg1, arg2);
 
367
}
 
368
 
 
369
static inline void tcg_gen_divu_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
370
{
 
371
    tcg_gen_op3(INDEX_op_divu_i32, ret, arg1, arg2);
 
372
}
 
373
 
 
374
static inline void tcg_gen_remu_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
375
{
 
376
    tcg_gen_op3(INDEX_op_remu_i32, ret, arg1, arg2);
 
377
}
 
378
#else
 
379
static inline void tcg_gen_div_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
380
{
 
381
    TCGv t0;
 
382
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
383
    tcg_gen_sari_i32(t0, arg1, 31);
 
384
    tcg_gen_op5(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
 
385
}
 
386
 
 
387
static inline void tcg_gen_rem_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
388
{
 
389
    TCGv t0;
 
390
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
391
    tcg_gen_sari_i32(t0, arg1, 31);
 
392
    tcg_gen_op5(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
 
393
}
 
394
 
 
395
static inline void tcg_gen_divu_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
396
{
 
397
    TCGv t0;
 
398
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
399
    tcg_gen_movi_i32(t0, 0);
 
400
    tcg_gen_op5(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
 
401
}
 
402
 
 
403
static inline void tcg_gen_remu_i32(TCGv ret, TCGv arg1, TCGv arg2)
 
404
{
 
405
    TCGv t0;
 
406
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
407
    tcg_gen_movi_i32(t0, 0);
 
408
    tcg_gen_op5(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
 
409
}
 
410
#endif
 
411
 
 
412
#if TCG_TARGET_REG_BITS == 32
 
413
 
 
414
static inline void tcg_gen_mov_i64(TCGv ret, TCGv arg)
 
415
{
 
416
    tcg_gen_mov_i32(ret, arg);
 
417
    tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 
418
}
 
419
 
 
420
static inline void tcg_gen_movi_i64(TCGv ret, int64_t arg)
 
421
{
 
422
    tcg_gen_movi_i32(ret, arg);
 
423
    tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32);
 
424
}
 
425
 
 
426
static inline void tcg_gen_ld8u_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
427
{
 
428
    tcg_gen_ld8u_i32(ret, arg2, offset);
 
429
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
430
}
 
431
 
 
432
static inline void tcg_gen_ld8s_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
433
{
 
434
    tcg_gen_ld8s_i32(ret, arg2, offset);
 
435
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
436
}
 
437
 
 
438
static inline void tcg_gen_ld16u_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
439
{
 
440
    tcg_gen_ld16u_i32(ret, arg2, offset);
 
441
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
442
}
 
443
 
 
444
static inline void tcg_gen_ld16s_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
445
{
 
446
    tcg_gen_ld16s_i32(ret, arg2, offset);
 
447
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
448
}
 
449
 
 
450
static inline void tcg_gen_ld32u_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
451
{
 
452
    tcg_gen_ld_i32(ret, arg2, offset);
 
453
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
454
}
 
455
 
 
456
static inline void tcg_gen_ld32s_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
457
{
 
458
    tcg_gen_ld_i32(ret, arg2, offset);
 
459
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
460
}
 
461
 
 
462
static inline void tcg_gen_ld_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
463
{
 
464
    /* since arg2 and ret have different types, they cannot be the
 
465
       same temporary */
 
466
#ifdef TCG_TARGET_WORDS_BIGENDIAN
 
467
    tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset);
 
468
    tcg_gen_ld_i32(ret, arg2, offset + 4);
 
469
#else
 
470
    tcg_gen_ld_i32(ret, arg2, offset);
 
471
    tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4);
 
472
#endif
 
473
}
 
474
 
 
475
static inline void tcg_gen_st8_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
476
{
 
477
    tcg_gen_st8_i32(arg1, arg2, offset);
 
478
}
 
479
 
 
480
static inline void tcg_gen_st16_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
481
{
 
482
    tcg_gen_st16_i32(arg1, arg2, offset);
 
483
}
 
484
 
 
485
static inline void tcg_gen_st32_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
486
{
 
487
    tcg_gen_st_i32(arg1, arg2, offset);
 
488
}
 
489
 
 
490
static inline void tcg_gen_st_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
491
{
 
492
#ifdef TCG_TARGET_WORDS_BIGENDIAN
 
493
    tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset);
 
494
    tcg_gen_st_i32(arg1, arg2, offset + 4);
 
495
#else
 
496
    tcg_gen_st_i32(arg1, arg2, offset);
 
497
    tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4);
 
498
#endif
 
499
}
 
500
 
 
501
static inline void tcg_gen_add_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
502
{
 
503
    tcg_gen_op6(INDEX_op_add2_i32, ret, TCGV_HIGH(ret), 
 
504
                arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2));
 
505
}
 
506
 
 
507
static inline void tcg_gen_addi_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
508
{
 
509
    tcg_gen_add_i64(ret, arg1, tcg_const_i64(arg2));
 
510
}
 
511
 
 
512
static inline void tcg_gen_sub_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
513
{
 
514
    tcg_gen_op6(INDEX_op_sub2_i32, ret, TCGV_HIGH(ret), 
 
515
                arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2));
 
516
}
 
517
 
 
518
static inline void tcg_gen_subi_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
519
{
 
520
    tcg_gen_sub_i64(ret, arg1, tcg_const_i64(arg2));
 
521
}
 
522
 
 
523
static inline void tcg_gen_and_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
524
{
 
525
    tcg_gen_and_i32(ret, arg1, arg2);
 
526
    tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
527
}
 
528
 
 
529
static inline void tcg_gen_andi_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
530
{
 
531
    tcg_gen_andi_i32(ret, arg1, arg2);
 
532
    tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 
533
}
 
534
 
 
535
static inline void tcg_gen_or_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
536
{
 
537
    tcg_gen_or_i32(ret, arg1, arg2);
 
538
    tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
539
}
 
540
 
 
541
static inline void tcg_gen_ori_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
542
{
 
543
    tcg_gen_ori_i32(ret, arg1, arg2);
 
544
    tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 
545
}
 
546
 
 
547
static inline void tcg_gen_xor_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
548
{
 
549
    tcg_gen_xor_i32(ret, arg1, arg2);
 
550
    tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
551
}
 
552
 
 
553
static inline void tcg_gen_xori_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
554
{
 
555
    tcg_gen_xori_i32(ret, arg1, arg2);
 
556
    tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 
557
}
 
558
 
 
559
/* XXX: use generic code when basic block handling is OK or CPU
 
560
   specific code (x86) */
 
561
static inline void tcg_gen_shl_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
562
{
 
563
    tcg_gen_helper_1_2(tcg_helper_shl_i64, ret, arg1, arg2);
 
564
}
 
565
 
 
566
static inline void tcg_gen_shli_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
567
{
 
568
    tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
 
569
}
 
570
 
 
571
static inline void tcg_gen_shr_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
572
{
 
573
    tcg_gen_helper_1_2(tcg_helper_shr_i64, ret, arg1, arg2);
 
574
}
 
575
 
 
576
static inline void tcg_gen_shri_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
577
{
 
578
    tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
 
579
}
 
580
 
 
581
static inline void tcg_gen_sar_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
582
{
 
583
    tcg_gen_helper_1_2(tcg_helper_sar_i64, ret, arg1, arg2);
 
584
}
 
585
 
 
586
static inline void tcg_gen_sari_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
587
{
 
588
    tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
 
589
}
 
590
 
 
591
static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2, 
 
592
                                      int label_index)
 
593
{
 
594
    tcg_gen_op6ii(INDEX_op_brcond2_i32, 
 
595
                  arg1, TCGV_HIGH(arg1), arg2, TCGV_HIGH(arg2),
 
596
                  cond, label_index);
 
597
}
 
598
 
 
599
static inline void tcg_gen_mul_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
600
{
 
601
    TCGv t0, t1;
 
602
    
 
603
    t0 = tcg_temp_new(TCG_TYPE_I64);
 
604
    t1 = tcg_temp_new(TCG_TYPE_I32);
 
605
 
 
606
    tcg_gen_op4(INDEX_op_mulu2_i32, t0, TCGV_HIGH(t0), arg1, arg2);
 
607
    
 
608
    tcg_gen_mul_i32(t1, arg1, TCGV_HIGH(arg2));
 
609
    tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 
610
    tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), arg2);
 
611
    tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 
612
    
 
613
    tcg_gen_mov_i64(ret, t0);
 
614
}
 
615
 
 
616
static inline void tcg_gen_div_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
617
{
 
618
    tcg_gen_helper_1_2(tcg_helper_div_i64, ret, arg1, arg2);
 
619
}
 
620
 
 
621
static inline void tcg_gen_rem_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
622
{
 
623
    tcg_gen_helper_1_2(tcg_helper_rem_i64, ret, arg1, arg2);
 
624
}
 
625
 
 
626
static inline void tcg_gen_divu_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
627
{
 
628
    tcg_gen_helper_1_2(tcg_helper_divu_i64, ret, arg1, arg2);
 
629
}
 
630
 
 
631
static inline void tcg_gen_remu_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
632
{
 
633
    tcg_gen_helper_1_2(tcg_helper_remu_i64, ret, arg1, arg2);
 
634
}
 
635
 
 
636
#else
 
637
 
 
638
static inline void tcg_gen_mov_i64(TCGv ret, TCGv arg)
 
639
{
 
640
    tcg_gen_op2(INDEX_op_mov_i64, ret, arg);
 
641
}
 
642
 
 
643
static inline void tcg_gen_movi_i64(TCGv ret, int64_t arg)
 
644
{
 
645
    tcg_gen_op2i(INDEX_op_movi_i64, ret, arg);
 
646
}
 
647
 
 
648
static inline void tcg_gen_ld8u_i64(TCGv ret, TCGv arg2,
 
649
                                    tcg_target_long offset)
 
650
{
 
651
    tcg_gen_op3i(INDEX_op_ld8u_i64, ret, arg2, offset);
 
652
}
 
653
 
 
654
static inline void tcg_gen_ld8s_i64(TCGv ret, TCGv arg2,
 
655
                                    tcg_target_long offset)
 
656
{
 
657
    tcg_gen_op3i(INDEX_op_ld8s_i64, ret, arg2, offset);
 
658
}
 
659
 
 
660
static inline void tcg_gen_ld16u_i64(TCGv ret, TCGv arg2,
 
661
                                     tcg_target_long offset)
 
662
{
 
663
    tcg_gen_op3i(INDEX_op_ld16u_i64, ret, arg2, offset);
 
664
}
 
665
 
 
666
static inline void tcg_gen_ld16s_i64(TCGv ret, TCGv arg2,
 
667
                                     tcg_target_long offset)
 
668
{
 
669
    tcg_gen_op3i(INDEX_op_ld16s_i64, ret, arg2, offset);
 
670
}
 
671
 
 
672
static inline void tcg_gen_ld32u_i64(TCGv ret, TCGv arg2,
 
673
                                     tcg_target_long offset)
 
674
{
 
675
    tcg_gen_op3i(INDEX_op_ld32u_i64, ret, arg2, offset);
 
676
}
 
677
 
 
678
static inline void tcg_gen_ld32s_i64(TCGv ret, TCGv arg2,
 
679
                                     tcg_target_long offset)
 
680
{
 
681
    tcg_gen_op3i(INDEX_op_ld32s_i64, ret, arg2, offset);
 
682
}
 
683
 
 
684
static inline void tcg_gen_ld_i64(TCGv ret, TCGv arg2, tcg_target_long offset)
 
685
{
 
686
    tcg_gen_op3i(INDEX_op_ld_i64, ret, arg2, offset);
 
687
}
 
688
 
 
689
static inline void tcg_gen_st8_i64(TCGv arg1, TCGv arg2,
 
690
                                   tcg_target_long offset)
 
691
{
 
692
    tcg_gen_op3i(INDEX_op_st8_i64, arg1, arg2, offset);
 
693
}
 
694
 
 
695
static inline void tcg_gen_st16_i64(TCGv arg1, TCGv arg2,
 
696
                                    tcg_target_long offset)
 
697
{
 
698
    tcg_gen_op3i(INDEX_op_st16_i64, arg1, arg2, offset);
 
699
}
 
700
 
 
701
static inline void tcg_gen_st32_i64(TCGv arg1, TCGv arg2,
 
702
                                    tcg_target_long offset)
 
703
{
 
704
    tcg_gen_op3i(INDEX_op_st32_i64, arg1, arg2, offset);
 
705
}
 
706
 
 
707
static inline void tcg_gen_st_i64(TCGv arg1, TCGv arg2, tcg_target_long offset)
 
708
{
 
709
    tcg_gen_op3i(INDEX_op_st_i64, arg1, arg2, offset);
 
710
}
 
711
 
 
712
static inline void tcg_gen_add_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
713
{
 
714
    tcg_gen_op3(INDEX_op_add_i64, ret, arg1, arg2);
 
715
}
 
716
 
 
717
static inline void tcg_gen_addi_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
718
{
 
719
    tcg_gen_add_i64(ret, arg1, tcg_const_i64(arg2));
 
720
}
 
721
 
 
722
static inline void tcg_gen_sub_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
723
{
 
724
    tcg_gen_op3(INDEX_op_sub_i64, ret, arg1, arg2);
 
725
}
 
726
 
 
727
static inline void tcg_gen_subi_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
728
{
 
729
    tcg_gen_sub_i64(ret, arg1, tcg_const_i64(arg2));
 
730
}
 
731
 
 
732
static inline void tcg_gen_and_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
733
{
 
734
    tcg_gen_op3(INDEX_op_and_i64, ret, arg1, arg2);
 
735
}
 
736
 
 
737
static inline void tcg_gen_andi_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
738
{
 
739
    tcg_gen_and_i64(ret, arg1, tcg_const_i64(arg2));
 
740
}
 
741
 
 
742
static inline void tcg_gen_or_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
743
{
 
744
    tcg_gen_op3(INDEX_op_or_i64, ret, arg1, arg2);
 
745
}
 
746
 
 
747
static inline void tcg_gen_ori_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
748
{
 
749
    tcg_gen_or_i64(ret, arg1, tcg_const_i64(arg2));
 
750
}
 
751
 
 
752
static inline void tcg_gen_xor_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
753
{
 
754
    tcg_gen_op3(INDEX_op_xor_i64, ret, arg1, arg2);
 
755
}
 
756
 
 
757
static inline void tcg_gen_xori_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
758
{
 
759
    tcg_gen_xor_i64(ret, arg1, tcg_const_i64(arg2));
 
760
}
 
761
 
 
762
static inline void tcg_gen_shl_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
763
{
 
764
    tcg_gen_op3(INDEX_op_shl_i64, ret, arg1, arg2);
 
765
}
 
766
 
 
767
static inline void tcg_gen_shli_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
768
{
 
769
    tcg_gen_shl_i64(ret, arg1, tcg_const_i64(arg2));
 
770
}
 
771
 
 
772
static inline void tcg_gen_shr_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
773
{
 
774
    tcg_gen_op3(INDEX_op_shr_i64, ret, arg1, arg2);
 
775
}
 
776
 
 
777
static inline void tcg_gen_shri_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
778
{
 
779
    tcg_gen_shr_i64(ret, arg1, tcg_const_i64(arg2));
 
780
}
 
781
 
 
782
static inline void tcg_gen_sar_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
783
{
 
784
    tcg_gen_op3(INDEX_op_sar_i64, ret, arg1, arg2);
 
785
}
 
786
 
 
787
static inline void tcg_gen_sari_i64(TCGv ret, TCGv arg1, int64_t arg2)
 
788
{
 
789
    tcg_gen_sar_i64(ret, arg1, tcg_const_i64(arg2));
 
790
}
 
791
 
 
792
static inline void tcg_gen_brcond_i64(int cond, TCGv arg1, TCGv arg2, 
 
793
                                      int label_index)
 
794
{
 
795
    tcg_gen_op4ii(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
 
796
}
 
797
 
 
798
static inline void tcg_gen_mul_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
799
{
 
800
    tcg_gen_op3(INDEX_op_mul_i64, ret, arg1, arg2);
 
801
}
 
802
 
 
803
#ifdef TCG_TARGET_HAS_div_i64
 
804
static inline void tcg_gen_div_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
805
{
 
806
    tcg_gen_op3(INDEX_op_div_i64, ret, arg1, arg2);
 
807
}
 
808
 
 
809
static inline void tcg_gen_rem_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
810
{
 
811
    tcg_gen_op3(INDEX_op_rem_i64, ret, arg1, arg2);
 
812
}
 
813
 
 
814
static inline void tcg_gen_divu_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
815
{
 
816
    tcg_gen_op3(INDEX_op_divu_i64, ret, arg1, arg2);
 
817
}
 
818
 
 
819
static inline void tcg_gen_remu_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
820
{
 
821
    tcg_gen_op3(INDEX_op_remu_i64, ret, arg1, arg2);
 
822
}
 
823
#else
 
824
static inline void tcg_gen_div_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
825
{
 
826
    TCGv t0;
 
827
    t0 = tcg_temp_new(TCG_TYPE_I64);
 
828
    tcg_gen_sari_i64(t0, arg1, 63);
 
829
    tcg_gen_op5(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
 
830
}
 
831
 
 
832
static inline void tcg_gen_rem_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
833
{
 
834
    TCGv t0;
 
835
    t0 = tcg_temp_new(TCG_TYPE_I64);
 
836
    tcg_gen_sari_i64(t0, arg1, 63);
 
837
    tcg_gen_op5(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
 
838
}
 
839
 
 
840
static inline void tcg_gen_divu_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
841
{
 
842
    TCGv t0;
 
843
    t0 = tcg_temp_new(TCG_TYPE_I64);
 
844
    tcg_gen_movi_i64(t0, 0);
 
845
    tcg_gen_op5(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
 
846
}
 
847
 
 
848
static inline void tcg_gen_remu_i64(TCGv ret, TCGv arg1, TCGv arg2)
 
849
{
 
850
    TCGv t0;
 
851
    t0 = tcg_temp_new(TCG_TYPE_I64);
 
852
    tcg_gen_movi_i64(t0, 0);
 
853
    tcg_gen_op5(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
 
854
}
 
855
#endif
 
856
 
 
857
#endif
 
858
 
 
859
/***************************************/
 
860
/* optional operations */
 
861
 
 
862
static inline void tcg_gen_ext8s_i32(TCGv ret, TCGv arg)
 
863
{
 
864
#ifdef TCG_TARGET_HAS_ext8s_i32
 
865
    tcg_gen_op2(INDEX_op_ext8s_i32, ret, arg);
 
866
#else
 
867
    tcg_gen_shli_i32(ret, arg, 24);
 
868
    tcg_gen_sari_i32(ret, ret, 24);
 
869
#endif
 
870
}
 
871
 
 
872
static inline void tcg_gen_ext16s_i32(TCGv ret, TCGv arg)
 
873
{
 
874
#ifdef TCG_TARGET_HAS_ext16s_i32
 
875
    tcg_gen_op2(INDEX_op_ext16s_i32, ret, arg);
 
876
#else
 
877
    tcg_gen_shli_i32(ret, arg, 16);
 
878
    tcg_gen_sari_i32(ret, ret, 16);
 
879
#endif
 
880
}
 
881
 
 
882
/* Note: we assume the two high bytes are set to zero */
 
883
static inline void tcg_gen_bswap16_i32(TCGv ret, TCGv arg)
 
884
{
 
885
#ifdef TCG_TARGET_HAS_bswap16_i32
 
886
    tcg_gen_op2(INDEX_op_bswap16_i32, ret, arg);
 
887
#else
 
888
    TCGv t0, t1;
 
889
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
890
    t1 = tcg_temp_new(TCG_TYPE_I32);
 
891
    
 
892
    tcg_gen_shri_i32(t0, arg, 8);
 
893
    tcg_gen_andi_i32(t1, arg, 0x000000ff);
 
894
    tcg_gen_shli_i32(t1, t1, 8);
 
895
    tcg_gen_or_i32(ret, t0, t1);
 
896
#endif
 
897
}
 
898
 
 
899
static inline void tcg_gen_bswap_i32(TCGv ret, TCGv arg)
 
900
{
 
901
#ifdef TCG_TARGET_HAS_bswap_i32
 
902
    tcg_gen_op2(INDEX_op_bswap_i32, ret, arg);
 
903
#else
 
904
    TCGv t0, t1;
 
905
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
906
    t1 = tcg_temp_new(TCG_TYPE_I32);
 
907
    
 
908
    tcg_gen_shli_i32(t0, arg, 24);
 
909
    
 
910
    tcg_gen_andi_i32(t1, arg, 0x0000ff00);
 
911
    tcg_gen_shli_i32(t1, t1, 8);
 
912
    tcg_gen_or_i32(t0, t0, t1);
 
913
    
 
914
    tcg_gen_shri_i32(t1, arg, 8);
 
915
    tcg_gen_andi_i32(t1, t1, 0x0000ff00);
 
916
    tcg_gen_or_i32(t0, t0, t1);
 
917
    
 
918
    tcg_gen_shri_i32(t1, arg, 24);
 
919
    tcg_gen_or_i32(ret, t0, t1);
 
920
#endif
 
921
}
 
922
 
 
923
#if TCG_TARGET_REG_BITS == 32
 
924
static inline void tcg_gen_ext8s_i64(TCGv ret, TCGv arg)
 
925
{
 
926
    tcg_gen_ext8s_i32(ret, arg);
 
927
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
928
}
 
929
 
 
930
static inline void tcg_gen_ext16s_i64(TCGv ret, TCGv arg)
 
931
{
 
932
    tcg_gen_ext16s_i32(ret, arg);
 
933
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
934
}
 
935
 
 
936
static inline void tcg_gen_ext32s_i64(TCGv ret, TCGv arg)
 
937
{
 
938
    tcg_gen_mov_i32(ret, arg);
 
939
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
940
}
 
941
 
 
942
static inline void tcg_gen_trunc_i64_i32(TCGv ret, TCGv arg)
 
943
{
 
944
    tcg_gen_mov_i32(ret, arg);
 
945
}
 
946
 
 
947
static inline void tcg_gen_extu_i32_i64(TCGv ret, TCGv arg)
 
948
{
 
949
    tcg_gen_mov_i32(ret, arg);
 
950
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
951
}
 
952
 
 
953
static inline void tcg_gen_ext_i32_i64(TCGv ret, TCGv arg)
 
954
{
 
955
    tcg_gen_mov_i32(ret, arg);
 
956
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
957
}
 
958
 
 
959
static inline void tcg_gen_bswap_i64(TCGv ret, TCGv arg)
 
960
{
 
961
    TCGv t0, t1;
 
962
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
963
    t1 = tcg_temp_new(TCG_TYPE_I32);
 
964
 
 
965
    tcg_gen_bswap_i32(t0, arg);
 
966
    tcg_gen_bswap_i32(t1, TCGV_HIGH(arg));
 
967
    tcg_gen_mov_i32(ret, t1);
 
968
    tcg_gen_mov_i32(TCGV_HIGH(ret), t0);
 
969
}
 
970
#else
 
971
 
 
972
static inline void tcg_gen_ext8s_i64(TCGv ret, TCGv arg)
 
973
{
 
974
#ifdef TCG_TARGET_HAS_ext8s_i64
 
975
    tcg_gen_op2(INDEX_op_ext8s_i64, ret, arg);
 
976
#else
 
977
    tcg_gen_shli_i64(ret, arg, 56);
 
978
    tcg_gen_sari_i64(ret, ret, 56);
 
979
#endif
 
980
}
 
981
 
 
982
static inline void tcg_gen_ext16s_i64(TCGv ret, TCGv arg)
 
983
{
 
984
#ifdef TCG_TARGET_HAS_ext16s_i64
 
985
    tcg_gen_op2(INDEX_op_ext16s_i64, ret, arg);
 
986
#else
 
987
    tcg_gen_shli_i64(ret, arg, 48);
 
988
    tcg_gen_sari_i64(ret, ret, 48);
 
989
#endif
 
990
}
 
991
 
 
992
static inline void tcg_gen_ext32s_i64(TCGv ret, TCGv arg)
 
993
{
 
994
#ifdef TCG_TARGET_HAS_ext32s_i64
 
995
    tcg_gen_op2(INDEX_op_ext32s_i64, ret, arg);
 
996
#else
 
997
    tcg_gen_shli_i64(ret, arg, 32);
 
998
    tcg_gen_sari_i64(ret, ret, 32);
 
999
#endif
 
1000
}
 
1001
 
 
1002
/* Note: we assume the target supports move between 32 and 64 bit
 
1003
   registers.  This will probably break MIPS64 targets.  */
 
1004
static inline void tcg_gen_trunc_i64_i32(TCGv ret, TCGv arg)
 
1005
{
 
1006
    tcg_gen_mov_i32(ret, arg);
 
1007
}
 
1008
 
 
1009
/* Note: we assume the target supports move between 32 and 64 bit
 
1010
   registers */
 
1011
static inline void tcg_gen_extu_i32_i64(TCGv ret, TCGv arg)
 
1012
{
 
1013
    tcg_gen_andi_i64(ret, arg, 0xffffffff);
 
1014
}
 
1015
 
 
1016
/* Note: we assume the target supports move between 32 and 64 bit
 
1017
   registers */
 
1018
static inline void tcg_gen_ext_i32_i64(TCGv ret, TCGv arg)
 
1019
{
 
1020
    tcg_gen_ext32s_i64(ret, arg);
 
1021
}
 
1022
 
 
1023
static inline void tcg_gen_bswap_i64(TCGv ret, TCGv arg)
 
1024
{
 
1025
#ifdef TCG_TARGET_HAS_bswap_i64
 
1026
    tcg_gen_op2(INDEX_op_bswap_i64, ret, arg);
 
1027
#else
 
1028
    TCGv t0, t1;
 
1029
    t0 = tcg_temp_new(TCG_TYPE_I32);
 
1030
    t1 = tcg_temp_new(TCG_TYPE_I32);
 
1031
    
 
1032
    tcg_gen_shli_i64(t0, arg, 56);
 
1033
    
 
1034
    tcg_gen_andi_i64(t1, arg, 0x0000ff00);
 
1035
    tcg_gen_shli_i64(t1, t1, 40);
 
1036
    tcg_gen_or_i64(t0, t0, t1);
 
1037
    
 
1038
    tcg_gen_andi_i64(t1, arg, 0x00ff0000);
 
1039
    tcg_gen_shli_i64(t1, t1, 24);
 
1040
    tcg_gen_or_i64(t0, t0, t1);
 
1041
 
 
1042
    tcg_gen_andi_i64(t1, arg, 0xff000000);
 
1043
    tcg_gen_shli_i64(t1, t1, 8);
 
1044
    tcg_gen_or_i64(t0, t0, t1);
 
1045
 
 
1046
    tcg_gen_shri_i64(t1, arg, 8);
 
1047
    tcg_gen_andi_i64(t1, t1, 0xff000000);
 
1048
    tcg_gen_or_i64(t0, t0, t1);
 
1049
    
 
1050
    tcg_gen_shri_i64(t1, arg, 24);
 
1051
    tcg_gen_andi_i64(t1, t1, 0x00ff0000);
 
1052
    tcg_gen_or_i64(t0, t0, t1);
 
1053
 
 
1054
    tcg_gen_shri_i64(t1, arg, 40);
 
1055
    tcg_gen_andi_i64(t1, t1, 0x0000ff00);
 
1056
    tcg_gen_or_i64(t0, t0, t1);
 
1057
 
 
1058
    tcg_gen_shri_i64(t1, arg, 56);
 
1059
    tcg_gen_or_i64(ret, t0, t1);
 
1060
#endif
 
1061
}
 
1062
 
 
1063
#endif
 
1064
 
 
1065
 
 
1066
static inline void tcg_gen_discard_i32(TCGv arg)
 
1067
{
 
1068
    tcg_gen_op1(INDEX_op_discard, arg);
 
1069
}
 
1070
 
 
1071
#if TCG_TARGET_REG_BITS == 32
 
1072
static inline void tcg_gen_discard_i64(TCGv arg)
 
1073
{
 
1074
    tcg_gen_discard_i32(arg);
 
1075
    tcg_gen_discard_i32(TCGV_HIGH(arg));
 
1076
}
 
1077
#else
 
1078
static inline void tcg_gen_discard_i64(TCGv arg)
 
1079
{
 
1080
    tcg_gen_op1(INDEX_op_discard, arg);
 
1081
}
 
1082
#endif
 
1083
 
 
1084
/***************************************/
 
1085
static inline void tcg_gen_macro_2(TCGv ret0, TCGv ret1, int macro_id)
 
1086
{
 
1087
    tcg_gen_op3i(INDEX_op_macro_2, ret0, ret1, macro_id);
 
1088
}
 
1089
 
 
1090
/***************************************/
 
1091
/* QEMU specific operations. Their type depend on the QEMU CPU
 
1092
   type. */
 
1093
#ifndef TARGET_LONG_BITS
 
1094
#error must include QEMU headers
 
1095
#endif
 
1096
 
 
1097
static inline void tcg_gen_exit_tb(tcg_target_long val)
 
1098
{
 
1099
    tcg_gen_op1i(INDEX_op_exit_tb, val);
 
1100
}
 
1101
 
 
1102
static inline void tcg_gen_goto_tb(int idx)
 
1103
{
 
1104
    tcg_gen_op1i(INDEX_op_goto_tb, idx);
 
1105
}
 
1106
 
 
1107
#if TCG_TARGET_REG_BITS == 32
 
1108
static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
 
1109
{
 
1110
#if TARGET_LONG_BITS == 32
 
1111
    tcg_gen_op3i(INDEX_op_qemu_ld8u, ret, addr, mem_index);
 
1112
#else
 
1113
    tcg_gen_op4i(INDEX_op_qemu_ld8u, ret, addr, TCGV_HIGH(addr), mem_index);
 
1114
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1115
#endif
 
1116
}
 
1117
 
 
1118
static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
 
1119
{
 
1120
#if TARGET_LONG_BITS == 32
 
1121
    tcg_gen_op3i(INDEX_op_qemu_ld8s, ret, addr, mem_index);
 
1122
#else
 
1123
    tcg_gen_op4i(INDEX_op_qemu_ld8s, ret, addr, TCGV_HIGH(addr), mem_index);
 
1124
    tcg_gen_ext8s_i32(TCGV_HIGH(ret), ret);
 
1125
#endif
 
1126
}
 
1127
 
 
1128
static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
 
1129
{
 
1130
#if TARGET_LONG_BITS == 32
 
1131
    tcg_gen_op3i(INDEX_op_qemu_ld16u, ret, addr, mem_index);
 
1132
#else
 
1133
    tcg_gen_op4i(INDEX_op_qemu_ld16u, ret, addr, TCGV_HIGH(addr), mem_index);
 
1134
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1135
#endif
 
1136
}
 
1137
 
 
1138
static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
 
1139
{
 
1140
#if TARGET_LONG_BITS == 32
 
1141
    tcg_gen_op3i(INDEX_op_qemu_ld16s, ret, addr, mem_index);
 
1142
#else
 
1143
    tcg_gen_op4i(INDEX_op_qemu_ld16s, ret, addr, TCGV_HIGH(addr), mem_index);
 
1144
    tcg_gen_ext16s_i32(TCGV_HIGH(ret), ret);
 
1145
#endif
 
1146
}
 
1147
 
 
1148
static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
 
1149
{
 
1150
#if TARGET_LONG_BITS == 32
 
1151
    tcg_gen_op3i(INDEX_op_qemu_ld32u, ret, addr, mem_index);
 
1152
#else
 
1153
    tcg_gen_op4i(INDEX_op_qemu_ld32u, ret, addr, TCGV_HIGH(addr), mem_index);
 
1154
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1155
#endif
 
1156
}
 
1157
 
 
1158
static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
 
1159
{
 
1160
#if TARGET_LONG_BITS == 32
 
1161
    tcg_gen_op3i(INDEX_op_qemu_ld32u, ret, addr, mem_index);
 
1162
#else
 
1163
    tcg_gen_op4i(INDEX_op_qemu_ld32u, ret, addr, TCGV_HIGH(addr), mem_index);
 
1164
    tcg_gen_sari_i32(TCGV_HIGH(ret), ret, 31);
 
1165
#endif
 
1166
}
 
1167
 
 
1168
static inline void tcg_gen_qemu_ld64(TCGv ret, TCGv addr, int mem_index)
 
1169
{
 
1170
#if TARGET_LONG_BITS == 32
 
1171
    tcg_gen_op4i(INDEX_op_qemu_ld64, ret, TCGV_HIGH(ret), addr, mem_index);
 
1172
#else
 
1173
    tcg_gen_op5i(INDEX_op_qemu_ld64, ret, TCGV_HIGH(ret),
 
1174
                 addr, TCGV_HIGH(addr), mem_index);
 
1175
#endif
 
1176
}
 
1177
 
 
1178
static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
 
1179
{
 
1180
#if TARGET_LONG_BITS == 32
 
1181
    tcg_gen_op3i(INDEX_op_qemu_st8, arg, addr, mem_index);
 
1182
#else
 
1183
    tcg_gen_op4i(INDEX_op_qemu_st8, arg, addr, TCGV_HIGH(addr), mem_index);
 
1184
#endif
 
1185
}
 
1186
 
 
1187
static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
 
1188
{
 
1189
#if TARGET_LONG_BITS == 32
 
1190
    tcg_gen_op3i(INDEX_op_qemu_st16, arg, addr, mem_index);
 
1191
#else
 
1192
    tcg_gen_op4i(INDEX_op_qemu_st16, arg, addr, TCGV_HIGH(addr), mem_index);
 
1193
#endif
 
1194
}
 
1195
 
 
1196
static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
 
1197
{
 
1198
#if TARGET_LONG_BITS == 32
 
1199
    tcg_gen_op3i(INDEX_op_qemu_st32, arg, addr, mem_index);
 
1200
#else
 
1201
    tcg_gen_op4i(INDEX_op_qemu_st32, arg, addr, TCGV_HIGH(addr), mem_index);
 
1202
#endif
 
1203
}
 
1204
 
 
1205
static inline void tcg_gen_qemu_st64(TCGv arg, TCGv addr, int mem_index)
 
1206
{
 
1207
#if TARGET_LONG_BITS == 32
 
1208
    tcg_gen_op4i(INDEX_op_qemu_st64, arg, TCGV_HIGH(arg), addr, mem_index);
 
1209
#else
 
1210
    tcg_gen_op5i(INDEX_op_qemu_st64, arg, TCGV_HIGH(arg),
 
1211
                 addr, TCGV_HIGH(addr), mem_index);
 
1212
#endif
 
1213
}
 
1214
 
 
1215
#else /* TCG_TARGET_REG_BITS == 32 */
 
1216
 
 
1217
static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
 
1218
{
 
1219
    tcg_gen_op3i(INDEX_op_qemu_ld8u, ret, addr, mem_index);
 
1220
}
 
1221
 
 
1222
static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
 
1223
{
 
1224
    tcg_gen_op3i(INDEX_op_qemu_ld8s, ret, addr, mem_index);
 
1225
}
 
1226
 
 
1227
static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
 
1228
{
 
1229
    tcg_gen_op3i(INDEX_op_qemu_ld16u, ret, addr, mem_index);
 
1230
}
 
1231
 
 
1232
static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
 
1233
{
 
1234
    tcg_gen_op3i(INDEX_op_qemu_ld16s, ret, addr, mem_index);
 
1235
}
 
1236
 
 
1237
static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
 
1238
{
 
1239
    tcg_gen_op3i(INDEX_op_qemu_ld32u, ret, addr, mem_index);
 
1240
}
 
1241
 
 
1242
static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
 
1243
{
 
1244
    tcg_gen_op3i(INDEX_op_qemu_ld32s, ret, addr, mem_index);
 
1245
}
 
1246
 
 
1247
static inline void tcg_gen_qemu_ld64(TCGv ret, TCGv addr, int mem_index)
 
1248
{
 
1249
    tcg_gen_op3i(INDEX_op_qemu_ld64, ret, addr, mem_index);
 
1250
}
 
1251
 
 
1252
static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
 
1253
{
 
1254
    tcg_gen_op3i(INDEX_op_qemu_st8, arg, addr, mem_index);
 
1255
}
 
1256
 
 
1257
static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
 
1258
{
 
1259
    tcg_gen_op3i(INDEX_op_qemu_st16, arg, addr, mem_index);
 
1260
}
 
1261
 
 
1262
static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
 
1263
{
 
1264
    tcg_gen_op3i(INDEX_op_qemu_st32, arg, addr, mem_index);
 
1265
}
 
1266
 
 
1267
static inline void tcg_gen_qemu_st64(TCGv arg, TCGv addr, int mem_index)
 
1268
{
 
1269
    tcg_gen_op3i(INDEX_op_qemu_st64, arg, addr, mem_index);
 
1270
}
 
1271
 
 
1272
#endif /* TCG_TARGET_REG_BITS != 32 */