← Back to branch summary

~ubuntu-branches/ubuntu/wily/qemu-kvm-spice/wily

« back to all changes in this revision

Viewing changes to tcg/tcg-op.h

  • Committer: Bazaar Package Importer
  • Author(s): Serge Hallyn
  • Date: 2011-10-19 10:44:56 UTC
  • Revision ID: james.westby@ubuntu.com-20111019104456-xgvskumk3sxi97f4
Tags: upstream-0.15.0+noroms
Import upstream version 0.15.0+noroms

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
int gen_new_label(void);
 
27
 
 
28
static inline void tcg_gen_op1_i32(TCGOpcode opc, TCGv_i32 arg1)
 
29
{
 
30
    *gen_opc_ptr++ = opc;
 
31
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
32
}
 
33
 
 
34
static inline void tcg_gen_op1_i64(TCGOpcode opc, TCGv_i64 arg1)
 
35
{
 
36
    *gen_opc_ptr++ = opc;
 
37
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
38
}
 
39
 
 
40
static inline void tcg_gen_op1i(TCGOpcode opc, TCGArg arg1)
 
41
{
 
42
    *gen_opc_ptr++ = opc;
 
43
    *gen_opparam_ptr++ = arg1;
 
44
}
 
45
 
 
46
static inline void tcg_gen_op2_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2)
 
47
{
 
48
    *gen_opc_ptr++ = opc;
 
49
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
50
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
51
}
 
52
 
 
53
static inline void tcg_gen_op2_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2)
 
54
{
 
55
    *gen_opc_ptr++ = opc;
 
56
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
57
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
58
}
 
59
 
 
60
static inline void tcg_gen_op2i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGArg arg2)
 
61
{
 
62
    *gen_opc_ptr++ = opc;
 
63
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
64
    *gen_opparam_ptr++ = arg2;
 
65
}
 
66
 
 
67
static inline void tcg_gen_op2i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGArg arg2)
 
68
{
 
69
    *gen_opc_ptr++ = opc;
 
70
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
71
    *gen_opparam_ptr++ = arg2;
 
72
}
 
73
 
 
74
static inline void tcg_gen_op2ii(TCGOpcode opc, TCGArg arg1, TCGArg arg2)
 
75
{
 
76
    *gen_opc_ptr++ = opc;
 
77
    *gen_opparam_ptr++ = arg1;
 
78
    *gen_opparam_ptr++ = arg2;
 
79
}
 
80
 
 
81
static inline void tcg_gen_op3_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
82
                                   TCGv_i32 arg3)
 
83
{
 
84
    *gen_opc_ptr++ = opc;
 
85
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
86
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
87
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
88
}
 
89
 
 
90
static inline void tcg_gen_op3_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
91
                                   TCGv_i64 arg3)
 
92
{
 
93
    *gen_opc_ptr++ = opc;
 
94
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
95
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
96
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
97
}
 
98
 
 
99
static inline void tcg_gen_op3i_i32(TCGOpcode opc, TCGv_i32 arg1,
 
100
                                    TCGv_i32 arg2, TCGArg arg3)
 
101
{
 
102
    *gen_opc_ptr++ = opc;
 
103
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
104
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
105
    *gen_opparam_ptr++ = arg3;
 
106
}
 
107
 
 
108
static inline void tcg_gen_op3i_i64(TCGOpcode opc, TCGv_i64 arg1,
 
109
                                    TCGv_i64 arg2, TCGArg arg3)
 
110
{
 
111
    *gen_opc_ptr++ = opc;
 
112
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
113
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
114
    *gen_opparam_ptr++ = arg3;
 
115
}
 
116
 
 
117
static inline void tcg_gen_ldst_op_i32(TCGOpcode opc, TCGv_i32 val,
 
118
                                       TCGv_ptr base, TCGArg offset)
 
119
{
 
120
    *gen_opc_ptr++ = opc;
 
121
    *gen_opparam_ptr++ = GET_TCGV_I32(val);
 
122
    *gen_opparam_ptr++ = GET_TCGV_PTR(base);
 
123
    *gen_opparam_ptr++ = offset;
 
124
}
 
125
 
 
126
static inline void tcg_gen_ldst_op_i64(TCGOpcode opc, TCGv_i64 val,
 
127
                                       TCGv_ptr base, TCGArg offset)
 
128
{
 
129
    *gen_opc_ptr++ = opc;
 
130
    *gen_opparam_ptr++ = GET_TCGV_I64(val);
 
131
    *gen_opparam_ptr++ = GET_TCGV_PTR(base);
 
132
    *gen_opparam_ptr++ = offset;
 
133
}
 
134
 
 
135
static inline void tcg_gen_qemu_ldst_op_i64_i32(TCGOpcode opc, TCGv_i64 val,
 
136
                                                TCGv_i32 addr, TCGArg mem_index)
 
137
{
 
138
    *gen_opc_ptr++ = opc;
 
139
    *gen_opparam_ptr++ = GET_TCGV_I64(val);
 
140
    *gen_opparam_ptr++ = GET_TCGV_I32(addr);
 
141
    *gen_opparam_ptr++ = mem_index;
 
142
}
 
143
 
 
144
static inline void tcg_gen_qemu_ldst_op_i64_i64(TCGOpcode opc, TCGv_i64 val,
 
145
                                                TCGv_i64 addr, TCGArg mem_index)
 
146
{
 
147
    *gen_opc_ptr++ = opc;
 
148
    *gen_opparam_ptr++ = GET_TCGV_I64(val);
 
149
    *gen_opparam_ptr++ = GET_TCGV_I64(addr);
 
150
    *gen_opparam_ptr++ = mem_index;
 
151
}
 
152
 
 
153
static inline void tcg_gen_op4_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
154
                                   TCGv_i32 arg3, TCGv_i32 arg4)
 
155
{
 
156
    *gen_opc_ptr++ = opc;
 
157
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
158
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
159
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
160
    *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 
161
}
 
162
 
 
163
static inline void tcg_gen_op4_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
164
                                   TCGv_i64 arg3, TCGv_i64 arg4)
 
165
{
 
166
    *gen_opc_ptr++ = opc;
 
167
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
168
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
169
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
170
    *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 
171
}
 
172
 
 
173
static inline void tcg_gen_op4i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
174
                                    TCGv_i32 arg3, TCGArg arg4)
 
175
{
 
176
    *gen_opc_ptr++ = opc;
 
177
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
178
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
179
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
180
    *gen_opparam_ptr++ = arg4;
 
181
}
 
182
 
 
183
static inline void tcg_gen_op4i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
184
                                    TCGv_i64 arg3, TCGArg arg4)
 
185
{
 
186
    *gen_opc_ptr++ = opc;
 
187
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
188
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
189
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
190
    *gen_opparam_ptr++ = arg4;
 
191
}
 
192
 
 
193
static inline void tcg_gen_op4ii_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
194
                                     TCGArg arg3, TCGArg arg4)
 
195
{
 
196
    *gen_opc_ptr++ = opc;
 
197
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
198
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
199
    *gen_opparam_ptr++ = arg3;
 
200
    *gen_opparam_ptr++ = arg4;
 
201
}
 
202
 
 
203
static inline void tcg_gen_op4ii_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
204
                                     TCGArg arg3, TCGArg arg4)
 
205
{
 
206
    *gen_opc_ptr++ = opc;
 
207
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
208
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
209
    *gen_opparam_ptr++ = arg3;
 
210
    *gen_opparam_ptr++ = arg4;
 
211
}
 
212
 
 
213
static inline void tcg_gen_op5_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
214
                                   TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5)
 
215
{
 
216
    *gen_opc_ptr++ = opc;
 
217
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
218
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
219
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
220
    *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 
221
    *gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 
222
}
 
223
 
 
224
static inline void tcg_gen_op5_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
225
                                   TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5)
 
226
{
 
227
    *gen_opc_ptr++ = opc;
 
228
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
229
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
230
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
231
    *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 
232
    *gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 
233
}
 
234
 
 
235
static inline void tcg_gen_op5i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
236
                                    TCGv_i32 arg3, TCGv_i32 arg4, TCGArg arg5)
 
237
{
 
238
    *gen_opc_ptr++ = opc;
 
239
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
240
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
241
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
242
    *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 
243
    *gen_opparam_ptr++ = arg5;
 
244
}
 
245
 
 
246
static inline void tcg_gen_op5i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
247
                                    TCGv_i64 arg3, TCGv_i64 arg4, TCGArg arg5)
 
248
{
 
249
    *gen_opc_ptr++ = opc;
 
250
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
251
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
252
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
253
    *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 
254
    *gen_opparam_ptr++ = arg5;
 
255
}
 
256
 
 
257
static inline void tcg_gen_op5ii_i32(TCGOpcode opc, TCGv_i32 arg1,
 
258
                                     TCGv_i32 arg2, TCGv_i32 arg3,
 
259
                                     TCGArg arg4, TCGArg arg5)
 
260
{
 
261
    *gen_opc_ptr++ = opc;
 
262
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
263
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
264
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
265
    *gen_opparam_ptr++ = arg4;
 
266
    *gen_opparam_ptr++ = arg5;
 
267
}
 
268
 
 
269
static inline void tcg_gen_op5ii_i64(TCGOpcode opc, TCGv_i64 arg1,
 
270
                                     TCGv_i64 arg2, TCGv_i64 arg3,
 
271
                                     TCGArg arg4, TCGArg arg5)
 
272
{
 
273
    *gen_opc_ptr++ = opc;
 
274
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
275
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
276
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
277
    *gen_opparam_ptr++ = arg4;
 
278
    *gen_opparam_ptr++ = arg5;
 
279
}
 
280
 
 
281
static inline void tcg_gen_op6_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
282
                                   TCGv_i32 arg3, TCGv_i32 arg4, TCGv_i32 arg5,
 
283
                                   TCGv_i32 arg6)
 
284
{
 
285
    *gen_opc_ptr++ = opc;
 
286
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
287
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
288
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
289
    *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 
290
    *gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 
291
    *gen_opparam_ptr++ = GET_TCGV_I32(arg6);
 
292
}
 
293
 
 
294
static inline void tcg_gen_op6_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
295
                                   TCGv_i64 arg3, TCGv_i64 arg4, TCGv_i64 arg5,
 
296
                                   TCGv_i64 arg6)
 
297
{
 
298
    *gen_opc_ptr++ = opc;
 
299
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
300
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
301
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
302
    *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 
303
    *gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 
304
    *gen_opparam_ptr++ = GET_TCGV_I64(arg6);
 
305
}
 
306
 
 
307
static inline void tcg_gen_op6i_i32(TCGOpcode opc, TCGv_i32 arg1, TCGv_i32 arg2,
 
308
                                    TCGv_i32 arg3, TCGv_i32 arg4,
 
309
                                    TCGv_i32 arg5, TCGArg arg6)
 
310
{
 
311
    *gen_opc_ptr++ = opc;
 
312
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
313
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
314
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
315
    *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 
316
    *gen_opparam_ptr++ = GET_TCGV_I32(arg5);
 
317
    *gen_opparam_ptr++ = arg6;
 
318
}
 
319
 
 
320
static inline void tcg_gen_op6i_i64(TCGOpcode opc, TCGv_i64 arg1, TCGv_i64 arg2,
 
321
                                    TCGv_i64 arg3, TCGv_i64 arg4,
 
322
                                    TCGv_i64 arg5, TCGArg arg6)
 
323
{
 
324
    *gen_opc_ptr++ = opc;
 
325
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
326
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
327
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
328
    *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 
329
    *gen_opparam_ptr++ = GET_TCGV_I64(arg5);
 
330
    *gen_opparam_ptr++ = arg6;
 
331
}
 
332
 
 
333
static inline void tcg_gen_op6ii_i32(TCGOpcode opc, TCGv_i32 arg1,
 
334
                                     TCGv_i32 arg2, TCGv_i32 arg3,
 
335
                                     TCGv_i32 arg4, TCGArg arg5, TCGArg arg6)
 
336
{
 
337
    *gen_opc_ptr++ = opc;
 
338
    *gen_opparam_ptr++ = GET_TCGV_I32(arg1);
 
339
    *gen_opparam_ptr++ = GET_TCGV_I32(arg2);
 
340
    *gen_opparam_ptr++ = GET_TCGV_I32(arg3);
 
341
    *gen_opparam_ptr++ = GET_TCGV_I32(arg4);
 
342
    *gen_opparam_ptr++ = arg5;
 
343
    *gen_opparam_ptr++ = arg6;
 
344
}
 
345
 
 
346
static inline void tcg_gen_op6ii_i64(TCGOpcode opc, TCGv_i64 arg1,
 
347
                                     TCGv_i64 arg2, TCGv_i64 arg3,
 
348
                                     TCGv_i64 arg4, TCGArg arg5, TCGArg arg6)
 
349
{
 
350
    *gen_opc_ptr++ = opc;
 
351
    *gen_opparam_ptr++ = GET_TCGV_I64(arg1);
 
352
    *gen_opparam_ptr++ = GET_TCGV_I64(arg2);
 
353
    *gen_opparam_ptr++ = GET_TCGV_I64(arg3);
 
354
    *gen_opparam_ptr++ = GET_TCGV_I64(arg4);
 
355
    *gen_opparam_ptr++ = arg5;
 
356
    *gen_opparam_ptr++ = arg6;
 
357
}
 
358
 
 
359
static inline void gen_set_label(int n)
 
360
{
 
361
    tcg_gen_op1i(INDEX_op_set_label, n);
 
362
}
 
363
 
 
364
static inline void tcg_gen_br(int label)
 
365
{
 
366
    tcg_gen_op1i(INDEX_op_br, label);
 
367
}
 
368
 
 
369
static inline void tcg_gen_mov_i32(TCGv_i32 ret, TCGv_i32 arg)
 
370
{
 
371
    if (!TCGV_EQUAL_I32(ret, arg))
 
372
        tcg_gen_op2_i32(INDEX_op_mov_i32, ret, arg);
 
373
}
 
374
 
 
375
static inline void tcg_gen_movi_i32(TCGv_i32 ret, int32_t arg)
 
376
{
 
377
    tcg_gen_op2i_i32(INDEX_op_movi_i32, ret, arg);
 
378
}
 
379
 
 
380
/* A version of dh_sizemask from def-helper.h that doesn't rely on
 
381
   preprocessor magic.  */
 
382
static inline int tcg_gen_sizemask(int n, int is_64bit, int is_signed)
 
383
{
 
384
    return (is_64bit << n*2) | (is_signed << (n*2 + 1));
 
385
}
 
386
 
 
387
/* helper calls */
 
388
static inline void tcg_gen_helperN(void *func, int flags, int sizemask,
 
389
                                   TCGArg ret, int nargs, TCGArg *args)
 
390
{
 
391
    TCGv_ptr fn;
 
392
    fn = tcg_const_ptr((tcg_target_long)func);
 
393
    tcg_gen_callN(&tcg_ctx, fn, flags, sizemask, ret,
 
394
                  nargs, args);
 
395
    tcg_temp_free_ptr(fn);
 
396
}
 
397
 
 
398
/* Note: Both tcg_gen_helper32() and tcg_gen_helper64() are currently
 
399
   reserved for helpers in tcg-runtime.c. These helpers are all const
 
400
   and pure, hence the call to tcg_gen_callN() with TCG_CALL_CONST |
 
401
   TCG_CALL_PURE. This may need to be adjusted if these functions
 
402
   start to be used with other helpers. */
 
403
static inline void tcg_gen_helper32(void *func, int sizemask, TCGv_i32 ret,
 
404
                                    TCGv_i32 a, TCGv_i32 b)
 
405
{
 
406
    TCGv_ptr fn;
 
407
    TCGArg args[2];
 
408
    fn = tcg_const_ptr((tcg_target_long)func);
 
409
    args[0] = GET_TCGV_I32(a);
 
410
    args[1] = GET_TCGV_I32(b);
 
411
    tcg_gen_callN(&tcg_ctx, fn, TCG_CALL_CONST | TCG_CALL_PURE, sizemask,
 
412
                  GET_TCGV_I32(ret), 2, args);
 
413
    tcg_temp_free_ptr(fn);
 
414
}
 
415
 
 
416
static inline void tcg_gen_helper64(void *func, int sizemask, TCGv_i64 ret,
 
417
                                    TCGv_i64 a, TCGv_i64 b)
 
418
{
 
419
    TCGv_ptr fn;
 
420
    TCGArg args[2];
 
421
    fn = tcg_const_ptr((tcg_target_long)func);
 
422
    args[0] = GET_TCGV_I64(a);
 
423
    args[1] = GET_TCGV_I64(b);
 
424
    tcg_gen_callN(&tcg_ctx, fn, TCG_CALL_CONST | TCG_CALL_PURE, sizemask,
 
425
                  GET_TCGV_I64(ret), 2, args);
 
426
    tcg_temp_free_ptr(fn);
 
427
}
 
428
 
 
429
/* 32 bit ops */
 
430
 
 
431
static inline void tcg_gen_ld8u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 
432
{
 
433
    tcg_gen_ldst_op_i32(INDEX_op_ld8u_i32, ret, arg2, offset);
 
434
}
 
435
 
 
436
static inline void tcg_gen_ld8s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 
437
{
 
438
    tcg_gen_ldst_op_i32(INDEX_op_ld8s_i32, ret, arg2, offset);
 
439
}
 
440
 
 
441
static inline void tcg_gen_ld16u_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 
442
{
 
443
    tcg_gen_ldst_op_i32(INDEX_op_ld16u_i32, ret, arg2, offset);
 
444
}
 
445
 
 
446
static inline void tcg_gen_ld16s_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 
447
{
 
448
    tcg_gen_ldst_op_i32(INDEX_op_ld16s_i32, ret, arg2, offset);
 
449
}
 
450
 
 
451
static inline void tcg_gen_ld_i32(TCGv_i32 ret, TCGv_ptr arg2, tcg_target_long offset)
 
452
{
 
453
    tcg_gen_ldst_op_i32(INDEX_op_ld_i32, ret, arg2, offset);
 
454
}
 
455
 
 
456
static inline void tcg_gen_st8_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 
457
{
 
458
    tcg_gen_ldst_op_i32(INDEX_op_st8_i32, arg1, arg2, offset);
 
459
}
 
460
 
 
461
static inline void tcg_gen_st16_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 
462
{
 
463
    tcg_gen_ldst_op_i32(INDEX_op_st16_i32, arg1, arg2, offset);
 
464
}
 
465
 
 
466
static inline void tcg_gen_st_i32(TCGv_i32 arg1, TCGv_ptr arg2, tcg_target_long offset)
 
467
{
 
468
    tcg_gen_ldst_op_i32(INDEX_op_st_i32, arg1, arg2, offset);
 
469
}
 
470
 
 
471
static inline void tcg_gen_add_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
472
{
 
473
    tcg_gen_op3_i32(INDEX_op_add_i32, ret, arg1, arg2);
 
474
}
 
475
 
 
476
static inline void tcg_gen_addi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
477
{
 
478
    /* some cases can be optimized here */
 
479
    if (arg2 == 0) {
 
480
        tcg_gen_mov_i32(ret, arg1);
 
481
    } else {
 
482
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
483
        tcg_gen_add_i32(ret, arg1, t0);
 
484
        tcg_temp_free_i32(t0);
 
485
    }
 
486
}
 
487
 
 
488
static inline void tcg_gen_sub_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
489
{
 
490
    tcg_gen_op3_i32(INDEX_op_sub_i32, ret, arg1, arg2);
 
491
}
 
492
 
 
493
static inline void tcg_gen_subfi_i32(TCGv_i32 ret, int32_t arg1, TCGv_i32 arg2)
 
494
{
 
495
    TCGv_i32 t0 = tcg_const_i32(arg1);
 
496
    tcg_gen_sub_i32(ret, t0, arg2);
 
497
    tcg_temp_free_i32(t0);
 
498
}
 
499
 
 
500
static inline void tcg_gen_subi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
501
{
 
502
    /* some cases can be optimized here */
 
503
    if (arg2 == 0) {
 
504
        tcg_gen_mov_i32(ret, arg1);
 
505
    } else {
 
506
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
507
        tcg_gen_sub_i32(ret, arg1, t0);
 
508
        tcg_temp_free_i32(t0);
 
509
    }
 
510
}
 
511
 
 
512
static inline void tcg_gen_and_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
513
{
 
514
    if (TCGV_EQUAL_I32(arg1, arg2)) {
 
515
        tcg_gen_mov_i32(ret, arg1);
 
516
    } else {
 
517
        tcg_gen_op3_i32(INDEX_op_and_i32, ret, arg1, arg2);
 
518
    }
 
519
}
 
520
 
 
521
static inline void tcg_gen_andi_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
522
{
 
523
    /* some cases can be optimized here */
 
524
    if (arg2 == 0) {
 
525
        tcg_gen_movi_i32(ret, 0);
 
526
    } else if (arg2 == 0xffffffff) {
 
527
        tcg_gen_mov_i32(ret, arg1);
 
528
    } else {
 
529
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
530
        tcg_gen_and_i32(ret, arg1, t0);
 
531
        tcg_temp_free_i32(t0);
 
532
    }
 
533
}
 
534
 
 
535
static inline void tcg_gen_or_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
536
{
 
537
    if (TCGV_EQUAL_I32(arg1, arg2)) {
 
538
        tcg_gen_mov_i32(ret, arg1);
 
539
    } else {
 
540
        tcg_gen_op3_i32(INDEX_op_or_i32, ret, arg1, arg2);
 
541
    }
 
542
}
 
543
 
 
544
static inline void tcg_gen_ori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
545
{
 
546
    /* some cases can be optimized here */
 
547
    if (arg2 == 0xffffffff) {
 
548
        tcg_gen_movi_i32(ret, 0xffffffff);
 
549
    } else if (arg2 == 0) {
 
550
        tcg_gen_mov_i32(ret, arg1);
 
551
    } else {
 
552
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
553
        tcg_gen_or_i32(ret, arg1, t0);
 
554
        tcg_temp_free_i32(t0);
 
555
    }
 
556
}
 
557
 
 
558
static inline void tcg_gen_xor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
559
{
 
560
    if (TCGV_EQUAL_I32(arg1, arg2)) {
 
561
        tcg_gen_movi_i32(ret, 0);
 
562
    } else {
 
563
        tcg_gen_op3_i32(INDEX_op_xor_i32, ret, arg1, arg2);
 
564
    }
 
565
}
 
566
 
 
567
static inline void tcg_gen_xori_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
568
{
 
569
    /* some cases can be optimized here */
 
570
    if (arg2 == 0) {
 
571
        tcg_gen_mov_i32(ret, arg1);
 
572
    } else {
 
573
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
574
        tcg_gen_xor_i32(ret, arg1, t0);
 
575
        tcg_temp_free_i32(t0);
 
576
    }
 
577
}
 
578
 
 
579
static inline void tcg_gen_shl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
580
{
 
581
    tcg_gen_op3_i32(INDEX_op_shl_i32, ret, arg1, arg2);
 
582
}
 
583
 
 
584
static inline void tcg_gen_shli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
585
{
 
586
    if (arg2 == 0) {
 
587
        tcg_gen_mov_i32(ret, arg1);
 
588
    } else {
 
589
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
590
        tcg_gen_shl_i32(ret, arg1, t0);
 
591
        tcg_temp_free_i32(t0);
 
592
    }
 
593
}
 
594
 
 
595
static inline void tcg_gen_shr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
596
{
 
597
    tcg_gen_op3_i32(INDEX_op_shr_i32, ret, arg1, arg2);
 
598
}
 
599
 
 
600
static inline void tcg_gen_shri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
601
{
 
602
    if (arg2 == 0) {
 
603
        tcg_gen_mov_i32(ret, arg1);
 
604
    } else {
 
605
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
606
        tcg_gen_shr_i32(ret, arg1, t0);
 
607
        tcg_temp_free_i32(t0);
 
608
    }
 
609
}
 
610
 
 
611
static inline void tcg_gen_sar_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
612
{
 
613
    tcg_gen_op3_i32(INDEX_op_sar_i32, ret, arg1, arg2);
 
614
}
 
615
 
 
616
static inline void tcg_gen_sari_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
617
{
 
618
    if (arg2 == 0) {
 
619
        tcg_gen_mov_i32(ret, arg1);
 
620
    } else {
 
621
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
622
        tcg_gen_sar_i32(ret, arg1, t0);
 
623
        tcg_temp_free_i32(t0);
 
624
    }
 
625
}
 
626
 
 
627
static inline void tcg_gen_brcond_i32(TCGCond cond, TCGv_i32 arg1,
 
628
                                      TCGv_i32 arg2, int label_index)
 
629
{
 
630
    tcg_gen_op4ii_i32(INDEX_op_brcond_i32, arg1, arg2, cond, label_index);
 
631
}
 
632
 
 
633
static inline void tcg_gen_brcondi_i32(TCGCond cond, TCGv_i32 arg1,
 
634
                                       int32_t arg2, int label_index)
 
635
{
 
636
    TCGv_i32 t0 = tcg_const_i32(arg2);
 
637
    tcg_gen_brcond_i32(cond, arg1, t0, label_index);
 
638
    tcg_temp_free_i32(t0);
 
639
}
 
640
 
 
641
static inline void tcg_gen_setcond_i32(TCGCond cond, TCGv_i32 ret,
 
642
                                       TCGv_i32 arg1, TCGv_i32 arg2)
 
643
{
 
644
    tcg_gen_op4i_i32(INDEX_op_setcond_i32, ret, arg1, arg2, cond);
 
645
}
 
646
 
 
647
static inline void tcg_gen_setcondi_i32(TCGCond cond, TCGv_i32 ret,
 
648
                                        TCGv_i32 arg1, int32_t arg2)
 
649
{
 
650
    TCGv_i32 t0 = tcg_const_i32(arg2);
 
651
    tcg_gen_setcond_i32(cond, ret, arg1, t0);
 
652
    tcg_temp_free_i32(t0);
 
653
}
 
654
 
 
655
static inline void tcg_gen_mul_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
656
{
 
657
    tcg_gen_op3_i32(INDEX_op_mul_i32, ret, arg1, arg2);
 
658
}
 
659
 
 
660
static inline void tcg_gen_muli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
661
{
 
662
    TCGv_i32 t0 = tcg_const_i32(arg2);
 
663
    tcg_gen_mul_i32(ret, arg1, t0);
 
664
    tcg_temp_free_i32(t0);
 
665
}
 
666
 
 
667
#ifdef TCG_TARGET_HAS_div_i32
 
668
static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
669
{
 
670
    tcg_gen_op3_i32(INDEX_op_div_i32, ret, arg1, arg2);
 
671
}
 
672
 
 
673
static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
674
{
 
675
    tcg_gen_op3_i32(INDEX_op_rem_i32, ret, arg1, arg2);
 
676
}
 
677
 
 
678
static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
679
{
 
680
    tcg_gen_op3_i32(INDEX_op_divu_i32, ret, arg1, arg2);
 
681
}
 
682
 
 
683
static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
684
{
 
685
    tcg_gen_op3_i32(INDEX_op_remu_i32, ret, arg1, arg2);
 
686
}
 
687
#elif defined(TCG_TARGET_HAS_div2_i32)
 
688
static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
689
{
 
690
    TCGv_i32 t0;
 
691
    t0 = tcg_temp_new_i32();
 
692
    tcg_gen_sari_i32(t0, arg1, 31);
 
693
    tcg_gen_op5_i32(INDEX_op_div2_i32, ret, t0, arg1, t0, arg2);
 
694
    tcg_temp_free_i32(t0);
 
695
}
 
696
 
 
697
static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
698
{
 
699
    TCGv_i32 t0;
 
700
    t0 = tcg_temp_new_i32();
 
701
    tcg_gen_sari_i32(t0, arg1, 31);
 
702
    tcg_gen_op5_i32(INDEX_op_div2_i32, t0, ret, arg1, t0, arg2);
 
703
    tcg_temp_free_i32(t0);
 
704
}
 
705
 
 
706
static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
707
{
 
708
    TCGv_i32 t0;
 
709
    t0 = tcg_temp_new_i32();
 
710
    tcg_gen_movi_i32(t0, 0);
 
711
    tcg_gen_op5_i32(INDEX_op_divu2_i32, ret, t0, arg1, t0, arg2);
 
712
    tcg_temp_free_i32(t0);
 
713
}
 
714
 
 
715
static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
716
{
 
717
    TCGv_i32 t0;
 
718
    t0 = tcg_temp_new_i32();
 
719
    tcg_gen_movi_i32(t0, 0);
 
720
    tcg_gen_op5_i32(INDEX_op_divu2_i32, t0, ret, arg1, t0, arg2);
 
721
    tcg_temp_free_i32(t0);
 
722
}
 
723
#else
 
724
static inline void tcg_gen_div_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
725
{
 
726
    int sizemask = 0;
 
727
    /* Return value and both arguments are 32-bit and signed.  */
 
728
    sizemask |= tcg_gen_sizemask(0, 0, 1);
 
729
    sizemask |= tcg_gen_sizemask(1, 0, 1);
 
730
    sizemask |= tcg_gen_sizemask(2, 0, 1);
 
731
 
 
732
    tcg_gen_helper32(tcg_helper_div_i32, sizemask, ret, arg1, arg2);
 
733
}
 
734
 
 
735
static inline void tcg_gen_rem_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
736
{
 
737
    int sizemask = 0;
 
738
    /* Return value and both arguments are 32-bit and signed.  */
 
739
    sizemask |= tcg_gen_sizemask(0, 0, 1);
 
740
    sizemask |= tcg_gen_sizemask(1, 0, 1);
 
741
    sizemask |= tcg_gen_sizemask(2, 0, 1);
 
742
 
 
743
    tcg_gen_helper32(tcg_helper_rem_i32, sizemask, ret, arg1, arg2);
 
744
}
 
745
 
 
746
static inline void tcg_gen_divu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
747
{
 
748
    int sizemask = 0;
 
749
    /* Return value and both arguments are 32-bit and unsigned.  */
 
750
    sizemask |= tcg_gen_sizemask(0, 0, 0);
 
751
    sizemask |= tcg_gen_sizemask(1, 0, 0);
 
752
    sizemask |= tcg_gen_sizemask(2, 0, 0);
 
753
 
 
754
    tcg_gen_helper32(tcg_helper_divu_i32, sizemask, ret, arg1, arg2);
 
755
}
 
756
 
 
757
static inline void tcg_gen_remu_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
758
{
 
759
    int sizemask = 0;
 
760
    /* Return value and both arguments are 32-bit and unsigned.  */
 
761
    sizemask |= tcg_gen_sizemask(0, 0, 0);
 
762
    sizemask |= tcg_gen_sizemask(1, 0, 0);
 
763
    sizemask |= tcg_gen_sizemask(2, 0, 0);
 
764
 
 
765
    tcg_gen_helper32(tcg_helper_remu_i32, sizemask, ret, arg1, arg2);
 
766
}
 
767
#endif
 
768
 
 
769
#if TCG_TARGET_REG_BITS == 32
 
770
 
 
771
static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 
772
{
 
773
    if (!TCGV_EQUAL_I64(ret, arg)) {
 
774
        tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
775
        tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 
776
    }
 
777
}
 
778
 
 
779
static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 
780
{
 
781
    tcg_gen_movi_i32(TCGV_LOW(ret), arg);
 
782
    tcg_gen_movi_i32(TCGV_HIGH(ret), arg >> 32);
 
783
}
 
784
 
 
785
static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
786
                                    tcg_target_long offset)
 
787
{
 
788
    tcg_gen_ld8u_i32(TCGV_LOW(ret), arg2, offset);
 
789
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
790
}
 
791
 
 
792
static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
793
                                    tcg_target_long offset)
 
794
{
 
795
    tcg_gen_ld8s_i32(TCGV_LOW(ret), arg2, offset);
 
796
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_HIGH(ret), 31);
 
797
}
 
798
 
 
799
static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
800
                                     tcg_target_long offset)
 
801
{
 
802
    tcg_gen_ld16u_i32(TCGV_LOW(ret), arg2, offset);
 
803
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
804
}
 
805
 
 
806
static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
807
                                     tcg_target_long offset)
 
808
{
 
809
    tcg_gen_ld16s_i32(TCGV_LOW(ret), arg2, offset);
 
810
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
811
}
 
812
 
 
813
static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
814
                                     tcg_target_long offset)
 
815
{
 
816
    tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 
817
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
818
}
 
819
 
 
820
static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
821
                                     tcg_target_long offset)
 
822
{
 
823
    tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 
824
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
825
}
 
826
 
 
827
static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
828
                                  tcg_target_long offset)
 
829
{
 
830
    /* since arg2 and ret have different types, they cannot be the
 
831
       same temporary */
 
832
#ifdef TCG_TARGET_WORDS_BIGENDIAN
 
833
    tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset);
 
834
    tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset + 4);
 
835
#else
 
836
    tcg_gen_ld_i32(TCGV_LOW(ret), arg2, offset);
 
837
    tcg_gen_ld_i32(TCGV_HIGH(ret), arg2, offset + 4);
 
838
#endif
 
839
}
 
840
 
 
841
static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
842
                                   tcg_target_long offset)
 
843
{
 
844
    tcg_gen_st8_i32(TCGV_LOW(arg1), arg2, offset);
 
845
}
 
846
 
 
847
static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
848
                                    tcg_target_long offset)
 
849
{
 
850
    tcg_gen_st16_i32(TCGV_LOW(arg1), arg2, offset);
 
851
}
 
852
 
 
853
static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
854
                                    tcg_target_long offset)
 
855
{
 
856
    tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 
857
}
 
858
 
 
859
static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
860
                                  tcg_target_long offset)
 
861
{
 
862
#ifdef TCG_TARGET_WORDS_BIGENDIAN
 
863
    tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset);
 
864
    tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset + 4);
 
865
#else
 
866
    tcg_gen_st_i32(TCGV_LOW(arg1), arg2, offset);
 
867
    tcg_gen_st_i32(TCGV_HIGH(arg1), arg2, offset + 4);
 
868
#endif
 
869
}
 
870
 
 
871
static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
872
{
 
873
    tcg_gen_op6_i32(INDEX_op_add2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 
874
                    TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 
875
                    TCGV_HIGH(arg2));
 
876
}
 
877
 
 
878
static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
879
{
 
880
    tcg_gen_op6_i32(INDEX_op_sub2_i32, TCGV_LOW(ret), TCGV_HIGH(ret),
 
881
                    TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 
882
                    TCGV_HIGH(arg2));
 
883
}
 
884
 
 
885
static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
886
{
 
887
    tcg_gen_and_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
888
    tcg_gen_and_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
889
}
 
890
 
 
891
static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
892
{
 
893
    tcg_gen_andi_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 
894
    tcg_gen_andi_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 
895
}
 
896
 
 
897
static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
898
{
 
899
    tcg_gen_or_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
900
    tcg_gen_or_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
901
}
 
902
 
 
903
static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
904
{
 
905
    tcg_gen_ori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 
906
    tcg_gen_ori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 
907
}
 
908
 
 
909
static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
910
{
 
911
    tcg_gen_xor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
912
    tcg_gen_xor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
913
}
 
914
 
 
915
static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
916
{
 
917
    tcg_gen_xori_i32(TCGV_LOW(ret), TCGV_LOW(arg1), arg2);
 
918
    tcg_gen_xori_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), arg2 >> 32);
 
919
}
 
920
 
 
921
/* XXX: use generic code when basic block handling is OK or CPU
 
922
   specific code (x86) */
 
923
static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
924
{
 
925
    int sizemask = 0;
 
926
    /* Return value and both arguments are 64-bit and signed.  */
 
927
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
928
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
929
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
930
 
 
931
    tcg_gen_helper64(tcg_helper_shl_i64, sizemask, ret, arg1, arg2);
 
932
}
 
933
 
 
934
static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
935
{
 
936
    tcg_gen_shifti_i64(ret, arg1, arg2, 0, 0);
 
937
}
 
938
 
 
939
static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
940
{
 
941
    int sizemask = 0;
 
942
    /* Return value and both arguments are 64-bit and signed.  */
 
943
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
944
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
945
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
946
 
 
947
    tcg_gen_helper64(tcg_helper_shr_i64, sizemask, ret, arg1, arg2);
 
948
}
 
949
 
 
950
static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
951
{
 
952
    tcg_gen_shifti_i64(ret, arg1, arg2, 1, 0);
 
953
}
 
954
 
 
955
static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
956
{
 
957
    int sizemask = 0;
 
958
    /* Return value and both arguments are 64-bit and signed.  */
 
959
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
960
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
961
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
962
 
 
963
    tcg_gen_helper64(tcg_helper_sar_i64, sizemask, ret, arg1, arg2);
 
964
}
 
965
 
 
966
static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
967
{
 
968
    tcg_gen_shifti_i64(ret, arg1, arg2, 1, 1);
 
969
}
 
970
 
 
971
static inline void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
 
972
                                      TCGv_i64 arg2, int label_index)
 
973
{
 
974
    tcg_gen_op6ii_i32(INDEX_op_brcond2_i32,
 
975
                      TCGV_LOW(arg1), TCGV_HIGH(arg1), TCGV_LOW(arg2),
 
976
                      TCGV_HIGH(arg2), cond, label_index);
 
977
}
 
978
 
 
979
static inline void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
 
980
                                       TCGv_i64 arg1, TCGv_i64 arg2)
 
981
{
 
982
    tcg_gen_op6i_i32(INDEX_op_setcond2_i32, TCGV_LOW(ret),
 
983
                     TCGV_LOW(arg1), TCGV_HIGH(arg1),
 
984
                     TCGV_LOW(arg2), TCGV_HIGH(arg2), cond);
 
985
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
986
}
 
987
 
 
988
static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
989
{
 
990
    TCGv_i64 t0;
 
991
    TCGv_i32 t1;
 
992
 
 
993
    t0 = tcg_temp_new_i64();
 
994
    t1 = tcg_temp_new_i32();
 
995
 
 
996
    tcg_gen_op4_i32(INDEX_op_mulu2_i32, TCGV_LOW(t0), TCGV_HIGH(t0),
 
997
                    TCGV_LOW(arg1), TCGV_LOW(arg2));
 
998
 
 
999
    tcg_gen_mul_i32(t1, TCGV_LOW(arg1), TCGV_HIGH(arg2));
 
1000
    tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 
1001
    tcg_gen_mul_i32(t1, TCGV_HIGH(arg1), TCGV_LOW(arg2));
 
1002
    tcg_gen_add_i32(TCGV_HIGH(t0), TCGV_HIGH(t0), t1);
 
1003
 
 
1004
    tcg_gen_mov_i64(ret, t0);
 
1005
    tcg_temp_free_i64(t0);
 
1006
    tcg_temp_free_i32(t1);
 
1007
}
 
1008
 
 
1009
static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1010
{
 
1011
    int sizemask = 0;
 
1012
    /* Return value and both arguments are 64-bit and signed.  */
 
1013
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
1014
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
1015
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
1016
 
 
1017
    tcg_gen_helper64(tcg_helper_div_i64, sizemask, ret, arg1, arg2);
 
1018
}
 
1019
 
 
1020
static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1021
{
 
1022
    int sizemask = 0;
 
1023
    /* Return value and both arguments are 64-bit and signed.  */
 
1024
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
1025
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
1026
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
1027
 
 
1028
    tcg_gen_helper64(tcg_helper_rem_i64, sizemask, ret, arg1, arg2);
 
1029
}
 
1030
 
 
1031
static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1032
{
 
1033
    int sizemask = 0;
 
1034
    /* Return value and both arguments are 64-bit and unsigned.  */
 
1035
    sizemask |= tcg_gen_sizemask(0, 1, 0);
 
1036
    sizemask |= tcg_gen_sizemask(1, 1, 0);
 
1037
    sizemask |= tcg_gen_sizemask(2, 1, 0);
 
1038
 
 
1039
    tcg_gen_helper64(tcg_helper_divu_i64, sizemask, ret, arg1, arg2);
 
1040
}
 
1041
 
 
1042
static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1043
{
 
1044
    int sizemask = 0;
 
1045
    /* Return value and both arguments are 64-bit and unsigned.  */
 
1046
    sizemask |= tcg_gen_sizemask(0, 1, 0);
 
1047
    sizemask |= tcg_gen_sizemask(1, 1, 0);
 
1048
    sizemask |= tcg_gen_sizemask(2, 1, 0);
 
1049
 
 
1050
    tcg_gen_helper64(tcg_helper_remu_i64, sizemask, ret, arg1, arg2);
 
1051
}
 
1052
 
 
1053
#else
 
1054
 
 
1055
static inline void tcg_gen_mov_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1056
{
 
1057
    if (!TCGV_EQUAL_I64(ret, arg))
 
1058
        tcg_gen_op2_i64(INDEX_op_mov_i64, ret, arg);
 
1059
}
 
1060
 
 
1061
static inline void tcg_gen_movi_i64(TCGv_i64 ret, int64_t arg)
 
1062
{
 
1063
    tcg_gen_op2i_i64(INDEX_op_movi_i64, ret, arg);
 
1064
}
 
1065
 
 
1066
static inline void tcg_gen_ld8u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
1067
                                    tcg_target_long offset)
 
1068
{
 
1069
    tcg_gen_ldst_op_i64(INDEX_op_ld8u_i64, ret, arg2, offset);
 
1070
}
 
1071
 
 
1072
static inline void tcg_gen_ld8s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
1073
                                    tcg_target_long offset)
 
1074
{
 
1075
    tcg_gen_ldst_op_i64(INDEX_op_ld8s_i64, ret, arg2, offset);
 
1076
}
 
1077
 
 
1078
static inline void tcg_gen_ld16u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
1079
                                     tcg_target_long offset)
 
1080
{
 
1081
    tcg_gen_ldst_op_i64(INDEX_op_ld16u_i64, ret, arg2, offset);
 
1082
}
 
1083
 
 
1084
static inline void tcg_gen_ld16s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
1085
                                     tcg_target_long offset)
 
1086
{
 
1087
    tcg_gen_ldst_op_i64(INDEX_op_ld16s_i64, ret, arg2, offset);
 
1088
}
 
1089
 
 
1090
static inline void tcg_gen_ld32u_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
1091
                                     tcg_target_long offset)
 
1092
{
 
1093
    tcg_gen_ldst_op_i64(INDEX_op_ld32u_i64, ret, arg2, offset);
 
1094
}
 
1095
 
 
1096
static inline void tcg_gen_ld32s_i64(TCGv_i64 ret, TCGv_ptr arg2,
 
1097
                                     tcg_target_long offset)
 
1098
{
 
1099
    tcg_gen_ldst_op_i64(INDEX_op_ld32s_i64, ret, arg2, offset);
 
1100
}
 
1101
 
 
1102
static inline void tcg_gen_ld_i64(TCGv_i64 ret, TCGv_ptr arg2, tcg_target_long offset)
 
1103
{
 
1104
    tcg_gen_ldst_op_i64(INDEX_op_ld_i64, ret, arg2, offset);
 
1105
}
 
1106
 
 
1107
static inline void tcg_gen_st8_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
1108
                                   tcg_target_long offset)
 
1109
{
 
1110
    tcg_gen_ldst_op_i64(INDEX_op_st8_i64, arg1, arg2, offset);
 
1111
}
 
1112
 
 
1113
static inline void tcg_gen_st16_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
1114
                                    tcg_target_long offset)
 
1115
{
 
1116
    tcg_gen_ldst_op_i64(INDEX_op_st16_i64, arg1, arg2, offset);
 
1117
}
 
1118
 
 
1119
static inline void tcg_gen_st32_i64(TCGv_i64 arg1, TCGv_ptr arg2,
 
1120
                                    tcg_target_long offset)
 
1121
{
 
1122
    tcg_gen_ldst_op_i64(INDEX_op_st32_i64, arg1, arg2, offset);
 
1123
}
 
1124
 
 
1125
static inline void tcg_gen_st_i64(TCGv_i64 arg1, TCGv_ptr arg2, tcg_target_long offset)
 
1126
{
 
1127
    tcg_gen_ldst_op_i64(INDEX_op_st_i64, arg1, arg2, offset);
 
1128
}
 
1129
 
 
1130
static inline void tcg_gen_add_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1131
{
 
1132
    tcg_gen_op3_i64(INDEX_op_add_i64, ret, arg1, arg2);
 
1133
}
 
1134
 
 
1135
static inline void tcg_gen_sub_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1136
{
 
1137
    tcg_gen_op3_i64(INDEX_op_sub_i64, ret, arg1, arg2);
 
1138
}
 
1139
 
 
1140
static inline void tcg_gen_and_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1141
{
 
1142
    if (TCGV_EQUAL_I64(arg1, arg2)) {
 
1143
        tcg_gen_mov_i64(ret, arg1);
 
1144
    } else {
 
1145
        tcg_gen_op3_i64(INDEX_op_and_i64, ret, arg1, arg2);
 
1146
    }
 
1147
}
 
1148
 
 
1149
static inline void tcg_gen_andi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1150
{
 
1151
    TCGv_i64 t0 = tcg_const_i64(arg2);
 
1152
    tcg_gen_and_i64(ret, arg1, t0);
 
1153
    tcg_temp_free_i64(t0);
 
1154
}
 
1155
 
 
1156
static inline void tcg_gen_or_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1157
{
 
1158
    if (TCGV_EQUAL_I64(arg1, arg2)) {
 
1159
        tcg_gen_mov_i64(ret, arg1);
 
1160
    } else {
 
1161
        tcg_gen_op3_i64(INDEX_op_or_i64, ret, arg1, arg2);
 
1162
    }
 
1163
}
 
1164
 
 
1165
static inline void tcg_gen_ori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1166
{
 
1167
    TCGv_i64 t0 = tcg_const_i64(arg2);
 
1168
    tcg_gen_or_i64(ret, arg1, t0);
 
1169
    tcg_temp_free_i64(t0);
 
1170
}
 
1171
 
 
1172
static inline void tcg_gen_xor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1173
{
 
1174
    if (TCGV_EQUAL_I64(arg1, arg2)) {
 
1175
        tcg_gen_movi_i64(ret, 0);
 
1176
    } else {
 
1177
        tcg_gen_op3_i64(INDEX_op_xor_i64, ret, arg1, arg2);
 
1178
    }
 
1179
}
 
1180
 
 
1181
static inline void tcg_gen_xori_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1182
{
 
1183
    TCGv_i64 t0 = tcg_const_i64(arg2);
 
1184
    tcg_gen_xor_i64(ret, arg1, t0);
 
1185
    tcg_temp_free_i64(t0);
 
1186
}
 
1187
 
 
1188
static inline void tcg_gen_shl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1189
{
 
1190
    tcg_gen_op3_i64(INDEX_op_shl_i64, ret, arg1, arg2);
 
1191
}
 
1192
 
 
1193
static inline void tcg_gen_shli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1194
{
 
1195
    if (arg2 == 0) {
 
1196
        tcg_gen_mov_i64(ret, arg1);
 
1197
    } else {
 
1198
        TCGv_i64 t0 = tcg_const_i64(arg2);
 
1199
        tcg_gen_shl_i64(ret, arg1, t0);
 
1200
        tcg_temp_free_i64(t0);
 
1201
    }
 
1202
}
 
1203
 
 
1204
static inline void tcg_gen_shr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1205
{
 
1206
    tcg_gen_op3_i64(INDEX_op_shr_i64, ret, arg1, arg2);
 
1207
}
 
1208
 
 
1209
static inline void tcg_gen_shri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1210
{
 
1211
    if (arg2 == 0) {
 
1212
        tcg_gen_mov_i64(ret, arg1);
 
1213
    } else {
 
1214
        TCGv_i64 t0 = tcg_const_i64(arg2);
 
1215
        tcg_gen_shr_i64(ret, arg1, t0);
 
1216
        tcg_temp_free_i64(t0);
 
1217
    }
 
1218
}
 
1219
 
 
1220
static inline void tcg_gen_sar_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1221
{
 
1222
    tcg_gen_op3_i64(INDEX_op_sar_i64, ret, arg1, arg2);
 
1223
}
 
1224
 
 
1225
static inline void tcg_gen_sari_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1226
{
 
1227
    if (arg2 == 0) {
 
1228
        tcg_gen_mov_i64(ret, arg1);
 
1229
    } else {
 
1230
        TCGv_i64 t0 = tcg_const_i64(arg2);
 
1231
        tcg_gen_sar_i64(ret, arg1, t0);
 
1232
        tcg_temp_free_i64(t0);
 
1233
    }
 
1234
}
 
1235
 
 
1236
static inline void tcg_gen_brcond_i64(TCGCond cond, TCGv_i64 arg1,
 
1237
                                      TCGv_i64 arg2, int label_index)
 
1238
{
 
1239
    tcg_gen_op4ii_i64(INDEX_op_brcond_i64, arg1, arg2, cond, label_index);
 
1240
}
 
1241
 
 
1242
static inline void tcg_gen_setcond_i64(TCGCond cond, TCGv_i64 ret,
 
1243
                                       TCGv_i64 arg1, TCGv_i64 arg2)
 
1244
{
 
1245
    tcg_gen_op4i_i64(INDEX_op_setcond_i64, ret, arg1, arg2, cond);
 
1246
}
 
1247
 
 
1248
static inline void tcg_gen_mul_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1249
{
 
1250
    tcg_gen_op3_i64(INDEX_op_mul_i64, ret, arg1, arg2);
 
1251
}
 
1252
 
 
1253
#ifdef TCG_TARGET_HAS_div_i64
 
1254
static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1255
{
 
1256
    tcg_gen_op3_i64(INDEX_op_div_i64, ret, arg1, arg2);
 
1257
}
 
1258
 
 
1259
static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1260
{
 
1261
    tcg_gen_op3_i64(INDEX_op_rem_i64, ret, arg1, arg2);
 
1262
}
 
1263
 
 
1264
static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1265
{
 
1266
    tcg_gen_op3_i64(INDEX_op_divu_i64, ret, arg1, arg2);
 
1267
}
 
1268
 
 
1269
static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1270
{
 
1271
    tcg_gen_op3_i64(INDEX_op_remu_i64, ret, arg1, arg2);
 
1272
}
 
1273
#elif defined(TCG_TARGET_HAS_div2_i64)
 
1274
static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1275
{
 
1276
    TCGv_i64 t0;
 
1277
    t0 = tcg_temp_new_i64();
 
1278
    tcg_gen_sari_i64(t0, arg1, 63);
 
1279
    tcg_gen_op5_i64(INDEX_op_div2_i64, ret, t0, arg1, t0, arg2);
 
1280
    tcg_temp_free_i64(t0);
 
1281
}
 
1282
 
 
1283
static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1284
{
 
1285
    TCGv_i64 t0;
 
1286
    t0 = tcg_temp_new_i64();
 
1287
    tcg_gen_sari_i64(t0, arg1, 63);
 
1288
    tcg_gen_op5_i64(INDEX_op_div2_i64, t0, ret, arg1, t0, arg2);
 
1289
    tcg_temp_free_i64(t0);
 
1290
}
 
1291
 
 
1292
static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1293
{
 
1294
    TCGv_i64 t0;
 
1295
    t0 = tcg_temp_new_i64();
 
1296
    tcg_gen_movi_i64(t0, 0);
 
1297
    tcg_gen_op5_i64(INDEX_op_divu2_i64, ret, t0, arg1, t0, arg2);
 
1298
    tcg_temp_free_i64(t0);
 
1299
}
 
1300
 
 
1301
static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1302
{
 
1303
    TCGv_i64 t0;
 
1304
    t0 = tcg_temp_new_i64();
 
1305
    tcg_gen_movi_i64(t0, 0);
 
1306
    tcg_gen_op5_i64(INDEX_op_divu2_i64, t0, ret, arg1, t0, arg2);
 
1307
    tcg_temp_free_i64(t0);
 
1308
}
 
1309
#else
 
1310
static inline void tcg_gen_div_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1311
{
 
1312
    int sizemask = 0;
 
1313
    /* Return value and both arguments are 64-bit and signed.  */
 
1314
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
1315
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
1316
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
1317
 
 
1318
    tcg_gen_helper64(tcg_helper_div_i64, sizemask, ret, arg1, arg2);
 
1319
}
 
1320
 
 
1321
static inline void tcg_gen_rem_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1322
{
 
1323
    int sizemask = 0;
 
1324
    /* Return value and both arguments are 64-bit and signed.  */
 
1325
    sizemask |= tcg_gen_sizemask(0, 1, 1);
 
1326
    sizemask |= tcg_gen_sizemask(1, 1, 1);
 
1327
    sizemask |= tcg_gen_sizemask(2, 1, 1);
 
1328
 
 
1329
    tcg_gen_helper64(tcg_helper_rem_i64, sizemask, ret, arg1, arg2);
 
1330
}
 
1331
 
 
1332
static inline void tcg_gen_divu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1333
{
 
1334
    int sizemask = 0;
 
1335
    /* Return value and both arguments are 64-bit and unsigned.  */
 
1336
    sizemask |= tcg_gen_sizemask(0, 1, 0);
 
1337
    sizemask |= tcg_gen_sizemask(1, 1, 0);
 
1338
    sizemask |= tcg_gen_sizemask(2, 1, 0);
 
1339
 
 
1340
    tcg_gen_helper64(tcg_helper_divu_i64, sizemask, ret, arg1, arg2);
 
1341
}
 
1342
 
 
1343
static inline void tcg_gen_remu_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1344
{
 
1345
    int sizemask = 0;
 
1346
    /* Return value and both arguments are 64-bit and unsigned.  */
 
1347
    sizemask |= tcg_gen_sizemask(0, 1, 0);
 
1348
    sizemask |= tcg_gen_sizemask(1, 1, 0);
 
1349
    sizemask |= tcg_gen_sizemask(2, 1, 0);
 
1350
 
 
1351
    tcg_gen_helper64(tcg_helper_remu_i64, sizemask, ret, arg1, arg2);
 
1352
}
 
1353
#endif
 
1354
 
 
1355
#endif
 
1356
 
 
1357
static inline void tcg_gen_addi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1358
{
 
1359
    /* some cases can be optimized here */
 
1360
    if (arg2 == 0) {
 
1361
        tcg_gen_mov_i64(ret, arg1);
 
1362
    } else {
 
1363
        TCGv_i64 t0 = tcg_const_i64(arg2);
 
1364
        tcg_gen_add_i64(ret, arg1, t0);
 
1365
        tcg_temp_free_i64(t0);
 
1366
    }
 
1367
}
 
1368
 
 
1369
static inline void tcg_gen_subfi_i64(TCGv_i64 ret, int64_t arg1, TCGv_i64 arg2)
 
1370
{
 
1371
    TCGv_i64 t0 = tcg_const_i64(arg1);
 
1372
    tcg_gen_sub_i64(ret, t0, arg2);
 
1373
    tcg_temp_free_i64(t0);
 
1374
}
 
1375
 
 
1376
static inline void tcg_gen_subi_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1377
{
 
1378
    /* some cases can be optimized here */
 
1379
    if (arg2 == 0) {
 
1380
        tcg_gen_mov_i64(ret, arg1);
 
1381
    } else {
 
1382
        TCGv_i64 t0 = tcg_const_i64(arg2);
 
1383
        tcg_gen_sub_i64(ret, arg1, t0);
 
1384
        tcg_temp_free_i64(t0);
 
1385
    }
 
1386
}
 
1387
static inline void tcg_gen_brcondi_i64(TCGCond cond, TCGv_i64 arg1,
 
1388
                                       int64_t arg2, int label_index)
 
1389
{
 
1390
    TCGv_i64 t0 = tcg_const_i64(arg2);
 
1391
    tcg_gen_brcond_i64(cond, arg1, t0, label_index);
 
1392
    tcg_temp_free_i64(t0);
 
1393
}
 
1394
 
 
1395
static inline void tcg_gen_setcondi_i64(TCGCond cond, TCGv_i64 ret,
 
1396
                                        TCGv_i64 arg1, int64_t arg2)
 
1397
{
 
1398
    TCGv_i64 t0 = tcg_const_i64(arg2);
 
1399
    tcg_gen_setcond_i64(cond, ret, arg1, t0);
 
1400
    tcg_temp_free_i64(t0);
 
1401
}
 
1402
 
 
1403
static inline void tcg_gen_muli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
1404
{
 
1405
    TCGv_i64 t0 = tcg_const_i64(arg2);
 
1406
    tcg_gen_mul_i64(ret, arg1, t0);
 
1407
    tcg_temp_free_i64(t0);
 
1408
}
 
1409
 
 
1410
 
 
1411
/***************************************/
 
1412
/* optional operations */
 
1413
 
 
1414
static inline void tcg_gen_ext8s_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1415
{
 
1416
#ifdef TCG_TARGET_HAS_ext8s_i32
 
1417
    tcg_gen_op2_i32(INDEX_op_ext8s_i32, ret, arg);
 
1418
#else
 
1419
    tcg_gen_shli_i32(ret, arg, 24);
 
1420
    tcg_gen_sari_i32(ret, ret, 24);
 
1421
#endif
 
1422
}
 
1423
 
 
1424
static inline void tcg_gen_ext16s_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1425
{
 
1426
#ifdef TCG_TARGET_HAS_ext16s_i32
 
1427
    tcg_gen_op2_i32(INDEX_op_ext16s_i32, ret, arg);
 
1428
#else
 
1429
    tcg_gen_shli_i32(ret, arg, 16);
 
1430
    tcg_gen_sari_i32(ret, ret, 16);
 
1431
#endif
 
1432
}
 
1433
 
 
1434
static inline void tcg_gen_ext8u_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1435
{
 
1436
#ifdef TCG_TARGET_HAS_ext8u_i32
 
1437
    tcg_gen_op2_i32(INDEX_op_ext8u_i32, ret, arg);
 
1438
#else
 
1439
    tcg_gen_andi_i32(ret, arg, 0xffu);
 
1440
#endif
 
1441
}
 
1442
 
 
1443
static inline void tcg_gen_ext16u_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1444
{
 
1445
#ifdef TCG_TARGET_HAS_ext16u_i32
 
1446
    tcg_gen_op2_i32(INDEX_op_ext16u_i32, ret, arg);
 
1447
#else
 
1448
    tcg_gen_andi_i32(ret, arg, 0xffffu);
 
1449
#endif
 
1450
}
 
1451
 
 
1452
/* Note: we assume the two high bytes are set to zero */
 
1453
static inline void tcg_gen_bswap16_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1454
{
 
1455
#ifdef TCG_TARGET_HAS_bswap16_i32
 
1456
    tcg_gen_op2_i32(INDEX_op_bswap16_i32, ret, arg);
 
1457
#else
 
1458
    TCGv_i32 t0 = tcg_temp_new_i32();
 
1459
    
 
1460
    tcg_gen_ext8u_i32(t0, arg);
 
1461
    tcg_gen_shli_i32(t0, t0, 8);
 
1462
    tcg_gen_shri_i32(ret, arg, 8);
 
1463
    tcg_gen_or_i32(ret, ret, t0);
 
1464
    tcg_temp_free_i32(t0);
 
1465
#endif
 
1466
}
 
1467
 
 
1468
static inline void tcg_gen_bswap32_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1469
{
 
1470
#ifdef TCG_TARGET_HAS_bswap32_i32
 
1471
    tcg_gen_op2_i32(INDEX_op_bswap32_i32, ret, arg);
 
1472
#else
 
1473
    TCGv_i32 t0, t1;
 
1474
    t0 = tcg_temp_new_i32();
 
1475
    t1 = tcg_temp_new_i32();
 
1476
    
 
1477
    tcg_gen_shli_i32(t0, arg, 24);
 
1478
    
 
1479
    tcg_gen_andi_i32(t1, arg, 0x0000ff00);
 
1480
    tcg_gen_shli_i32(t1, t1, 8);
 
1481
    tcg_gen_or_i32(t0, t0, t1);
 
1482
    
 
1483
    tcg_gen_shri_i32(t1, arg, 8);
 
1484
    tcg_gen_andi_i32(t1, t1, 0x0000ff00);
 
1485
    tcg_gen_or_i32(t0, t0, t1);
 
1486
    
 
1487
    tcg_gen_shri_i32(t1, arg, 24);
 
1488
    tcg_gen_or_i32(ret, t0, t1);
 
1489
    tcg_temp_free_i32(t0);
 
1490
    tcg_temp_free_i32(t1);
 
1491
#endif
 
1492
}
 
1493
 
 
1494
#if TCG_TARGET_REG_BITS == 32
 
1495
static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1496
{
 
1497
    tcg_gen_ext8s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1498
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
1499
}
 
1500
 
 
1501
static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1502
{
 
1503
    tcg_gen_ext16s_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1504
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
1505
}
 
1506
 
 
1507
static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1508
{
 
1509
    tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1510
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
1511
}
 
1512
 
 
1513
static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1514
{
 
1515
    tcg_gen_ext8u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1516
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1517
}
 
1518
 
 
1519
static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1520
{
 
1521
    tcg_gen_ext16u_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1522
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1523
}
 
1524
 
 
1525
static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1526
{
 
1527
    tcg_gen_mov_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1528
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1529
}
 
1530
 
 
1531
static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
 
1532
{
 
1533
    tcg_gen_mov_i32(ret, TCGV_LOW(arg));
 
1534
}
 
1535
 
 
1536
static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
 
1537
{
 
1538
    tcg_gen_mov_i32(TCGV_LOW(ret), arg);
 
1539
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
1540
}
 
1541
 
 
1542
static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
 
1543
{
 
1544
    tcg_gen_mov_i32(TCGV_LOW(ret), arg);
 
1545
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
1546
}
 
1547
 
 
1548
/* Note: we assume the six high bytes are set to zero */
 
1549
static inline void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1550
{
 
1551
    tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 
1552
    tcg_gen_bswap16_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1553
}
 
1554
 
 
1555
/* Note: we assume the four high bytes are set to zero */
 
1556
static inline void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1557
{
 
1558
    tcg_gen_mov_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 
1559
    tcg_gen_bswap32_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1560
}
 
1561
 
 
1562
static inline void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1563
{
 
1564
    TCGv_i32 t0, t1;
 
1565
    t0 = tcg_temp_new_i32();
 
1566
    t1 = tcg_temp_new_i32();
 
1567
 
 
1568
    tcg_gen_bswap32_i32(t0, TCGV_LOW(arg));
 
1569
    tcg_gen_bswap32_i32(t1, TCGV_HIGH(arg));
 
1570
    tcg_gen_mov_i32(TCGV_LOW(ret), t1);
 
1571
    tcg_gen_mov_i32(TCGV_HIGH(ret), t0);
 
1572
    tcg_temp_free_i32(t0);
 
1573
    tcg_temp_free_i32(t1);
 
1574
}
 
1575
#else
 
1576
 
 
1577
static inline void tcg_gen_ext8s_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1578
{
 
1579
#ifdef TCG_TARGET_HAS_ext8s_i64
 
1580
    tcg_gen_op2_i64(INDEX_op_ext8s_i64, ret, arg);
 
1581
#else
 
1582
    tcg_gen_shli_i64(ret, arg, 56);
 
1583
    tcg_gen_sari_i64(ret, ret, 56);
 
1584
#endif
 
1585
}
 
1586
 
 
1587
static inline void tcg_gen_ext16s_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1588
{
 
1589
#ifdef TCG_TARGET_HAS_ext16s_i64
 
1590
    tcg_gen_op2_i64(INDEX_op_ext16s_i64, ret, arg);
 
1591
#else
 
1592
    tcg_gen_shli_i64(ret, arg, 48);
 
1593
    tcg_gen_sari_i64(ret, ret, 48);
 
1594
#endif
 
1595
}
 
1596
 
 
1597
static inline void tcg_gen_ext32s_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1598
{
 
1599
#ifdef TCG_TARGET_HAS_ext32s_i64
 
1600
    tcg_gen_op2_i64(INDEX_op_ext32s_i64, ret, arg);
 
1601
#else
 
1602
    tcg_gen_shli_i64(ret, arg, 32);
 
1603
    tcg_gen_sari_i64(ret, ret, 32);
 
1604
#endif
 
1605
}
 
1606
 
 
1607
static inline void tcg_gen_ext8u_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1608
{
 
1609
#ifdef TCG_TARGET_HAS_ext8u_i64
 
1610
    tcg_gen_op2_i64(INDEX_op_ext8u_i64, ret, arg);
 
1611
#else
 
1612
    tcg_gen_andi_i64(ret, arg, 0xffu);
 
1613
#endif
 
1614
}
 
1615
 
 
1616
static inline void tcg_gen_ext16u_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1617
{
 
1618
#ifdef TCG_TARGET_HAS_ext16u_i64
 
1619
    tcg_gen_op2_i64(INDEX_op_ext16u_i64, ret, arg);
 
1620
#else
 
1621
    tcg_gen_andi_i64(ret, arg, 0xffffu);
 
1622
#endif
 
1623
}
 
1624
 
 
1625
static inline void tcg_gen_ext32u_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1626
{
 
1627
#ifdef TCG_TARGET_HAS_ext32u_i64
 
1628
    tcg_gen_op2_i64(INDEX_op_ext32u_i64, ret, arg);
 
1629
#else
 
1630
    tcg_gen_andi_i64(ret, arg, 0xffffffffu);
 
1631
#endif
 
1632
}
 
1633
 
 
1634
/* Note: we assume the target supports move between 32 and 64 bit
 
1635
   registers.  This will probably break MIPS64 targets.  */
 
1636
static inline void tcg_gen_trunc_i64_i32(TCGv_i32 ret, TCGv_i64 arg)
 
1637
{
 
1638
    tcg_gen_mov_i32(ret, MAKE_TCGV_I32(GET_TCGV_I64(arg)));
 
1639
}
 
1640
 
 
1641
/* Note: we assume the target supports move between 32 and 64 bit
 
1642
   registers */
 
1643
static inline void tcg_gen_extu_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
 
1644
{
 
1645
    tcg_gen_ext32u_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
 
1646
}
 
1647
 
 
1648
/* Note: we assume the target supports move between 32 and 64 bit
 
1649
   registers */
 
1650
static inline void tcg_gen_ext_i32_i64(TCGv_i64 ret, TCGv_i32 arg)
 
1651
{
 
1652
    tcg_gen_ext32s_i64(ret, MAKE_TCGV_I64(GET_TCGV_I32(arg)));
 
1653
}
 
1654
 
 
1655
/* Note: we assume the six high bytes are set to zero */
 
1656
static inline void tcg_gen_bswap16_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1657
{
 
1658
#ifdef TCG_TARGET_HAS_bswap16_i64
 
1659
    tcg_gen_op2_i64(INDEX_op_bswap16_i64, ret, arg);
 
1660
#else
 
1661
    TCGv_i64 t0 = tcg_temp_new_i64();
 
1662
 
 
1663
    tcg_gen_ext8u_i64(t0, arg);
 
1664
    tcg_gen_shli_i64(t0, t0, 8);
 
1665
    tcg_gen_shri_i64(ret, arg, 8);
 
1666
    tcg_gen_or_i64(ret, ret, t0);
 
1667
    tcg_temp_free_i64(t0);
 
1668
#endif
 
1669
}
 
1670
 
 
1671
/* Note: we assume the four high bytes are set to zero */
 
1672
static inline void tcg_gen_bswap32_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1673
{
 
1674
#ifdef TCG_TARGET_HAS_bswap32_i64
 
1675
    tcg_gen_op2_i64(INDEX_op_bswap32_i64, ret, arg);
 
1676
#else
 
1677
    TCGv_i64 t0, t1;
 
1678
    t0 = tcg_temp_new_i64();
 
1679
    t1 = tcg_temp_new_i64();
 
1680
 
 
1681
    tcg_gen_shli_i64(t0, arg, 24);
 
1682
    tcg_gen_ext32u_i64(t0, t0);
 
1683
 
 
1684
    tcg_gen_andi_i64(t1, arg, 0x0000ff00);
 
1685
    tcg_gen_shli_i64(t1, t1, 8);
 
1686
    tcg_gen_or_i64(t0, t0, t1);
 
1687
 
 
1688
    tcg_gen_shri_i64(t1, arg, 8);
 
1689
    tcg_gen_andi_i64(t1, t1, 0x0000ff00);
 
1690
    tcg_gen_or_i64(t0, t0, t1);
 
1691
 
 
1692
    tcg_gen_shri_i64(t1, arg, 24);
 
1693
    tcg_gen_or_i64(ret, t0, t1);
 
1694
    tcg_temp_free_i64(t0);
 
1695
    tcg_temp_free_i64(t1);
 
1696
#endif
 
1697
}
 
1698
 
 
1699
static inline void tcg_gen_bswap64_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1700
{
 
1701
#ifdef TCG_TARGET_HAS_bswap64_i64
 
1702
    tcg_gen_op2_i64(INDEX_op_bswap64_i64, ret, arg);
 
1703
#else
 
1704
    TCGv_i64 t0 = tcg_temp_new_i64();
 
1705
    TCGv_i64 t1 = tcg_temp_new_i64();
 
1706
    
 
1707
    tcg_gen_shli_i64(t0, arg, 56);
 
1708
    
 
1709
    tcg_gen_andi_i64(t1, arg, 0x0000ff00);
 
1710
    tcg_gen_shli_i64(t1, t1, 40);
 
1711
    tcg_gen_or_i64(t0, t0, t1);
 
1712
    
 
1713
    tcg_gen_andi_i64(t1, arg, 0x00ff0000);
 
1714
    tcg_gen_shli_i64(t1, t1, 24);
 
1715
    tcg_gen_or_i64(t0, t0, t1);
 
1716
 
 
1717
    tcg_gen_andi_i64(t1, arg, 0xff000000);
 
1718
    tcg_gen_shli_i64(t1, t1, 8);
 
1719
    tcg_gen_or_i64(t0, t0, t1);
 
1720
 
 
1721
    tcg_gen_shri_i64(t1, arg, 8);
 
1722
    tcg_gen_andi_i64(t1, t1, 0xff000000);
 
1723
    tcg_gen_or_i64(t0, t0, t1);
 
1724
    
 
1725
    tcg_gen_shri_i64(t1, arg, 24);
 
1726
    tcg_gen_andi_i64(t1, t1, 0x00ff0000);
 
1727
    tcg_gen_or_i64(t0, t0, t1);
 
1728
 
 
1729
    tcg_gen_shri_i64(t1, arg, 40);
 
1730
    tcg_gen_andi_i64(t1, t1, 0x0000ff00);
 
1731
    tcg_gen_or_i64(t0, t0, t1);
 
1732
 
 
1733
    tcg_gen_shri_i64(t1, arg, 56);
 
1734
    tcg_gen_or_i64(ret, t0, t1);
 
1735
    tcg_temp_free_i64(t0);
 
1736
    tcg_temp_free_i64(t1);
 
1737
#endif
 
1738
}
 
1739
 
 
1740
#endif
 
1741
 
 
1742
static inline void tcg_gen_neg_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1743
{
 
1744
#ifdef TCG_TARGET_HAS_neg_i32
 
1745
    tcg_gen_op2_i32(INDEX_op_neg_i32, ret, arg);
 
1746
#else
 
1747
    TCGv_i32 t0 = tcg_const_i32(0);
 
1748
    tcg_gen_sub_i32(ret, t0, arg);
 
1749
    tcg_temp_free_i32(t0);
 
1750
#endif
 
1751
}
 
1752
 
 
1753
static inline void tcg_gen_neg_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1754
{
 
1755
#ifdef TCG_TARGET_HAS_neg_i64
 
1756
    tcg_gen_op2_i64(INDEX_op_neg_i64, ret, arg);
 
1757
#else
 
1758
    TCGv_i64 t0 = tcg_const_i64(0);
 
1759
    tcg_gen_sub_i64(ret, t0, arg);
 
1760
    tcg_temp_free_i64(t0);
 
1761
#endif
 
1762
}
 
1763
 
 
1764
static inline void tcg_gen_not_i32(TCGv_i32 ret, TCGv_i32 arg)
 
1765
{
 
1766
#ifdef TCG_TARGET_HAS_not_i32
 
1767
    tcg_gen_op2_i32(INDEX_op_not_i32, ret, arg);
 
1768
#else
 
1769
    tcg_gen_xori_i32(ret, arg, -1);
 
1770
#endif
 
1771
}
 
1772
 
 
1773
static inline void tcg_gen_not_i64(TCGv_i64 ret, TCGv_i64 arg)
 
1774
{
 
1775
#ifdef TCG_TARGET_HAS_not_i64
 
1776
    tcg_gen_op2_i64(INDEX_op_not_i64, ret, arg);
 
1777
#elif defined(TCG_TARGET_HAS_not_i32) && TCG_TARGET_REG_BITS == 32
 
1778
    tcg_gen_not_i32(TCGV_LOW(ret), TCGV_LOW(arg));
 
1779
    tcg_gen_not_i32(TCGV_HIGH(ret), TCGV_HIGH(arg));
 
1780
#else
 
1781
    tcg_gen_xori_i64(ret, arg, -1);
 
1782
#endif
 
1783
}
 
1784
 
 
1785
static inline void tcg_gen_discard_i32(TCGv_i32 arg)
 
1786
{
 
1787
    tcg_gen_op1_i32(INDEX_op_discard, arg);
 
1788
}
 
1789
 
 
1790
#if TCG_TARGET_REG_BITS == 32
 
1791
static inline void tcg_gen_discard_i64(TCGv_i64 arg)
 
1792
{
 
1793
    tcg_gen_discard_i32(TCGV_LOW(arg));
 
1794
    tcg_gen_discard_i32(TCGV_HIGH(arg));
 
1795
}
 
1796
#else
 
1797
static inline void tcg_gen_discard_i64(TCGv_i64 arg)
 
1798
{
 
1799
    tcg_gen_op1_i64(INDEX_op_discard, arg);
 
1800
}
 
1801
#endif
 
1802
 
 
1803
static inline void tcg_gen_concat_i32_i64(TCGv_i64 dest, TCGv_i32 low, TCGv_i32 high)
 
1804
{
 
1805
#if TCG_TARGET_REG_BITS == 32
 
1806
    tcg_gen_mov_i32(TCGV_LOW(dest), low);
 
1807
    tcg_gen_mov_i32(TCGV_HIGH(dest), high);
 
1808
#else
 
1809
    TCGv_i64 tmp = tcg_temp_new_i64();
 
1810
    /* This extension is only needed for type correctness.
 
1811
       We may be able to do better given target specific information.  */
 
1812
    tcg_gen_extu_i32_i64(tmp, high);
 
1813
    tcg_gen_shli_i64(tmp, tmp, 32);
 
1814
    tcg_gen_extu_i32_i64(dest, low);
 
1815
    tcg_gen_or_i64(dest, dest, tmp);
 
1816
    tcg_temp_free_i64(tmp);
 
1817
#endif
 
1818
}
 
1819
 
 
1820
static inline void tcg_gen_concat32_i64(TCGv_i64 dest, TCGv_i64 low, TCGv_i64 high)
 
1821
{
 
1822
#if TCG_TARGET_REG_BITS == 32
 
1823
    tcg_gen_concat_i32_i64(dest, TCGV_LOW(low), TCGV_LOW(high));
 
1824
#else
 
1825
    TCGv_i64 tmp = tcg_temp_new_i64();
 
1826
    tcg_gen_ext32u_i64(dest, low);
 
1827
    tcg_gen_shli_i64(tmp, high, 32);
 
1828
    tcg_gen_or_i64(dest, dest, tmp);
 
1829
    tcg_temp_free_i64(tmp);
 
1830
#endif
 
1831
}
 
1832
 
 
1833
static inline void tcg_gen_andc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
1834
{
 
1835
#ifdef TCG_TARGET_HAS_andc_i32
 
1836
    tcg_gen_op3_i32(INDEX_op_andc_i32, ret, arg1, arg2);
 
1837
#else
 
1838
    TCGv_i32 t0;
 
1839
    t0 = tcg_temp_new_i32();
 
1840
    tcg_gen_not_i32(t0, arg2);
 
1841
    tcg_gen_and_i32(ret, arg1, t0);
 
1842
    tcg_temp_free_i32(t0);
 
1843
#endif
 
1844
}
 
1845
 
 
1846
static inline void tcg_gen_andc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1847
{
 
1848
#ifdef TCG_TARGET_HAS_andc_i64
 
1849
    tcg_gen_op3_i64(INDEX_op_andc_i64, ret, arg1, arg2);
 
1850
#elif defined(TCG_TARGET_HAS_andc_i32) && TCG_TARGET_REG_BITS == 32
 
1851
    tcg_gen_andc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
1852
    tcg_gen_andc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
1853
#else
 
1854
    TCGv_i64 t0;
 
1855
    t0 = tcg_temp_new_i64();
 
1856
    tcg_gen_not_i64(t0, arg2);
 
1857
    tcg_gen_and_i64(ret, arg1, t0);
 
1858
    tcg_temp_free_i64(t0);
 
1859
#endif
 
1860
}
 
1861
 
 
1862
static inline void tcg_gen_eqv_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
1863
{
 
1864
#ifdef TCG_TARGET_HAS_eqv_i32
 
1865
    tcg_gen_op3_i32(INDEX_op_eqv_i32, ret, arg1, arg2);
 
1866
#else
 
1867
    tcg_gen_xor_i32(ret, arg1, arg2);
 
1868
    tcg_gen_not_i32(ret, ret);
 
1869
#endif
 
1870
}
 
1871
 
 
1872
static inline void tcg_gen_eqv_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1873
{
 
1874
#ifdef TCG_TARGET_HAS_eqv_i64
 
1875
    tcg_gen_op3_i64(INDEX_op_eqv_i64, ret, arg1, arg2);
 
1876
#elif defined(TCG_TARGET_HAS_eqv_i32) && TCG_TARGET_REG_BITS == 32
 
1877
    tcg_gen_eqv_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
1878
    tcg_gen_eqv_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
1879
#else
 
1880
    tcg_gen_xor_i64(ret, arg1, arg2);
 
1881
    tcg_gen_not_i64(ret, ret);
 
1882
#endif
 
1883
}
 
1884
 
 
1885
static inline void tcg_gen_nand_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
1886
{
 
1887
#ifdef TCG_TARGET_HAS_nand_i32
 
1888
    tcg_gen_op3_i32(INDEX_op_nand_i32, ret, arg1, arg2);
 
1889
#else
 
1890
    tcg_gen_and_i32(ret, arg1, arg2);
 
1891
    tcg_gen_not_i32(ret, ret);
 
1892
#endif
 
1893
}
 
1894
 
 
1895
static inline void tcg_gen_nand_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1896
{
 
1897
#ifdef TCG_TARGET_HAS_nand_i64
 
1898
    tcg_gen_op3_i64(INDEX_op_nand_i64, ret, arg1, arg2);
 
1899
#elif defined(TCG_TARGET_HAS_nand_i32) && TCG_TARGET_REG_BITS == 32
 
1900
    tcg_gen_nand_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
1901
    tcg_gen_nand_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
1902
#else
 
1903
    tcg_gen_and_i64(ret, arg1, arg2);
 
1904
    tcg_gen_not_i64(ret, ret);
 
1905
#endif
 
1906
}
 
1907
 
 
1908
static inline void tcg_gen_nor_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
1909
{
 
1910
#ifdef TCG_TARGET_HAS_nor_i32
 
1911
    tcg_gen_op3_i32(INDEX_op_nor_i32, ret, arg1, arg2);
 
1912
#else
 
1913
    tcg_gen_or_i32(ret, arg1, arg2);
 
1914
    tcg_gen_not_i32(ret, ret);
 
1915
#endif
 
1916
}
 
1917
 
 
1918
static inline void tcg_gen_nor_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1919
{
 
1920
#ifdef TCG_TARGET_HAS_nor_i64
 
1921
    tcg_gen_op3_i64(INDEX_op_nor_i64, ret, arg1, arg2);
 
1922
#elif defined(TCG_TARGET_HAS_nor_i32) && TCG_TARGET_REG_BITS == 32
 
1923
    tcg_gen_nor_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
1924
    tcg_gen_nor_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
1925
#else
 
1926
    tcg_gen_or_i64(ret, arg1, arg2);
 
1927
    tcg_gen_not_i64(ret, ret);
 
1928
#endif
 
1929
}
 
1930
 
 
1931
static inline void tcg_gen_orc_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
1932
{
 
1933
#ifdef TCG_TARGET_HAS_orc_i32
 
1934
    tcg_gen_op3_i32(INDEX_op_orc_i32, ret, arg1, arg2);
 
1935
#else
 
1936
    TCGv_i32 t0;
 
1937
    t0 = tcg_temp_new_i32();
 
1938
    tcg_gen_not_i32(t0, arg2);
 
1939
    tcg_gen_or_i32(ret, arg1, t0);
 
1940
    tcg_temp_free_i32(t0);
 
1941
#endif
 
1942
}
 
1943
 
 
1944
static inline void tcg_gen_orc_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1945
{
 
1946
#ifdef TCG_TARGET_HAS_orc_i64
 
1947
    tcg_gen_op3_i64(INDEX_op_orc_i64, ret, arg1, arg2);
 
1948
#elif defined(TCG_TARGET_HAS_orc_i32) && TCG_TARGET_REG_BITS == 32
 
1949
    tcg_gen_orc_i32(TCGV_LOW(ret), TCGV_LOW(arg1), TCGV_LOW(arg2));
 
1950
    tcg_gen_orc_i32(TCGV_HIGH(ret), TCGV_HIGH(arg1), TCGV_HIGH(arg2));
 
1951
#else
 
1952
    TCGv_i64 t0;
 
1953
    t0 = tcg_temp_new_i64();
 
1954
    tcg_gen_not_i64(t0, arg2);
 
1955
    tcg_gen_or_i64(ret, arg1, t0);
 
1956
    tcg_temp_free_i64(t0);
 
1957
#endif
 
1958
}
 
1959
 
 
1960
static inline void tcg_gen_rotl_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
1961
{
 
1962
#ifdef TCG_TARGET_HAS_rot_i32
 
1963
    tcg_gen_op3_i32(INDEX_op_rotl_i32, ret, arg1, arg2);
 
1964
#else
 
1965
    TCGv_i32 t0, t1;
 
1966
 
 
1967
    t0 = tcg_temp_new_i32();
 
1968
    t1 = tcg_temp_new_i32();
 
1969
    tcg_gen_shl_i32(t0, arg1, arg2);
 
1970
    tcg_gen_subfi_i32(t1, 32, arg2);
 
1971
    tcg_gen_shr_i32(t1, arg1, t1);
 
1972
    tcg_gen_or_i32(ret, t0, t1);
 
1973
    tcg_temp_free_i32(t0);
 
1974
    tcg_temp_free_i32(t1);
 
1975
#endif
 
1976
}
 
1977
 
 
1978
static inline void tcg_gen_rotl_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
1979
{
 
1980
#ifdef TCG_TARGET_HAS_rot_i64
 
1981
    tcg_gen_op3_i64(INDEX_op_rotl_i64, ret, arg1, arg2);
 
1982
#else
 
1983
    TCGv_i64 t0, t1;
 
1984
 
 
1985
    t0 = tcg_temp_new_i64();
 
1986
    t1 = tcg_temp_new_i64();
 
1987
    tcg_gen_shl_i64(t0, arg1, arg2);
 
1988
    tcg_gen_subfi_i64(t1, 64, arg2);
 
1989
    tcg_gen_shr_i64(t1, arg1, t1);
 
1990
    tcg_gen_or_i64(ret, t0, t1);
 
1991
    tcg_temp_free_i64(t0);
 
1992
    tcg_temp_free_i64(t1);
 
1993
#endif
 
1994
}
 
1995
 
 
1996
static inline void tcg_gen_rotli_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
1997
{
 
1998
    /* some cases can be optimized here */
 
1999
    if (arg2 == 0) {
 
2000
        tcg_gen_mov_i32(ret, arg1);
 
2001
    } else {
 
2002
#ifdef TCG_TARGET_HAS_rot_i32
 
2003
        TCGv_i32 t0 = tcg_const_i32(arg2);
 
2004
        tcg_gen_rotl_i32(ret, arg1, t0);
 
2005
        tcg_temp_free_i32(t0);
 
2006
#else
 
2007
        TCGv_i32 t0, t1;
 
2008
        t0 = tcg_temp_new_i32();
 
2009
        t1 = tcg_temp_new_i32();
 
2010
        tcg_gen_shli_i32(t0, arg1, arg2);
 
2011
        tcg_gen_shri_i32(t1, arg1, 32 - arg2);
 
2012
        tcg_gen_or_i32(ret, t0, t1);
 
2013
        tcg_temp_free_i32(t0);
 
2014
        tcg_temp_free_i32(t1);
 
2015
#endif
 
2016
    }
 
2017
}
 
2018
 
 
2019
static inline void tcg_gen_rotli_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
2020
{
 
2021
    /* some cases can be optimized here */
 
2022
    if (arg2 == 0) {
 
2023
        tcg_gen_mov_i64(ret, arg1);
 
2024
    } else {
 
2025
#ifdef TCG_TARGET_HAS_rot_i64
 
2026
        TCGv_i64 t0 = tcg_const_i64(arg2);
 
2027
        tcg_gen_rotl_i64(ret, arg1, t0);
 
2028
        tcg_temp_free_i64(t0);
 
2029
#else
 
2030
        TCGv_i64 t0, t1;
 
2031
        t0 = tcg_temp_new_i64();
 
2032
        t1 = tcg_temp_new_i64();
 
2033
        tcg_gen_shli_i64(t0, arg1, arg2);
 
2034
        tcg_gen_shri_i64(t1, arg1, 64 - arg2);
 
2035
        tcg_gen_or_i64(ret, t0, t1);
 
2036
        tcg_temp_free_i64(t0);
 
2037
        tcg_temp_free_i64(t1);
 
2038
#endif
 
2039
    }
 
2040
}
 
2041
 
 
2042
static inline void tcg_gen_rotr_i32(TCGv_i32 ret, TCGv_i32 arg1, TCGv_i32 arg2)
 
2043
{
 
2044
#ifdef TCG_TARGET_HAS_rot_i32
 
2045
    tcg_gen_op3_i32(INDEX_op_rotr_i32, ret, arg1, arg2);
 
2046
#else
 
2047
    TCGv_i32 t0, t1;
 
2048
 
 
2049
    t0 = tcg_temp_new_i32();
 
2050
    t1 = tcg_temp_new_i32();
 
2051
    tcg_gen_shr_i32(t0, arg1, arg2);
 
2052
    tcg_gen_subfi_i32(t1, 32, arg2);
 
2053
    tcg_gen_shl_i32(t1, arg1, t1);
 
2054
    tcg_gen_or_i32(ret, t0, t1);
 
2055
    tcg_temp_free_i32(t0);
 
2056
    tcg_temp_free_i32(t1);
 
2057
#endif
 
2058
}
 
2059
 
 
2060
static inline void tcg_gen_rotr_i64(TCGv_i64 ret, TCGv_i64 arg1, TCGv_i64 arg2)
 
2061
{
 
2062
#ifdef TCG_TARGET_HAS_rot_i64
 
2063
    tcg_gen_op3_i64(INDEX_op_rotr_i64, ret, arg1, arg2);
 
2064
#else
 
2065
    TCGv_i64 t0, t1;
 
2066
 
 
2067
    t0 = tcg_temp_new_i64();
 
2068
    t1 = tcg_temp_new_i64();
 
2069
    tcg_gen_shr_i64(t0, arg1, arg2);
 
2070
    tcg_gen_subfi_i64(t1, 64, arg2);
 
2071
    tcg_gen_shl_i64(t1, arg1, t1);
 
2072
    tcg_gen_or_i64(ret, t0, t1);
 
2073
    tcg_temp_free_i64(t0);
 
2074
    tcg_temp_free_i64(t1);
 
2075
#endif
 
2076
}
 
2077
 
 
2078
static inline void tcg_gen_rotri_i32(TCGv_i32 ret, TCGv_i32 arg1, int32_t arg2)
 
2079
{
 
2080
    /* some cases can be optimized here */
 
2081
    if (arg2 == 0) {
 
2082
        tcg_gen_mov_i32(ret, arg1);
 
2083
    } else {
 
2084
        tcg_gen_rotli_i32(ret, arg1, 32 - arg2);
 
2085
    }
 
2086
}
 
2087
 
 
2088
static inline void tcg_gen_rotri_i64(TCGv_i64 ret, TCGv_i64 arg1, int64_t arg2)
 
2089
{
 
2090
    /* some cases can be optimized here */
 
2091
    if (arg2 == 0) {
 
2092
        tcg_gen_mov_i64(ret, arg1);
 
2093
    } else {
 
2094
        tcg_gen_rotli_i64(ret, arg1, 64 - arg2);
 
2095
    }
 
2096
}
 
2097
 
 
2098
static inline void tcg_gen_deposit_i32(TCGv_i32 ret, TCGv_i32 arg1,
 
2099
                                       TCGv_i32 arg2, unsigned int ofs,
 
2100
                                       unsigned int len)
 
2101
{
 
2102
#ifdef TCG_TARGET_HAS_deposit_i32
 
2103
  tcg_gen_op5ii_i32(INDEX_op_deposit_i32, ret, arg1, arg2, ofs, len);
 
2104
#else
 
2105
  uint32_t mask = (1u << len) - 1;
 
2106
  TCGv_i32 t1 = tcg_temp_new_i32 ();
 
2107
 
 
2108
  tcg_gen_andi_i32(t1, arg2, mask);
 
2109
  tcg_gen_shli_i32(t1, t1, ofs);
 
2110
  tcg_gen_andi_i32(ret, arg1, ~(mask << ofs));
 
2111
  tcg_gen_or_i32(ret, ret, t1);
 
2112
 
 
2113
  tcg_temp_free_i32(t1);
 
2114
#endif
 
2115
}
 
2116
 
 
2117
static inline void tcg_gen_deposit_i64(TCGv_i64 ret, TCGv_i64 arg1,
 
2118
                                       TCGv_i64 arg2, unsigned int ofs,
 
2119
                                       unsigned int len)
 
2120
{
 
2121
#ifdef TCG_TARGET_HAS_deposit_i64
 
2122
  tcg_gen_op5ii_i64(INDEX_op_deposit_i64, ret, arg1, arg2, ofs, len);
 
2123
#else
 
2124
  uint64_t mask = (1ull << len) - 1;
 
2125
  TCGv_i64 t1 = tcg_temp_new_i64 ();
 
2126
 
 
2127
  tcg_gen_andi_i64(t1, arg2, mask);
 
2128
  tcg_gen_shli_i64(t1, t1, ofs);
 
2129
  tcg_gen_andi_i64(ret, arg1, ~(mask << ofs));
 
2130
  tcg_gen_or_i64(ret, ret, t1);
 
2131
 
 
2132
  tcg_temp_free_i64(t1);
 
2133
#endif
 
2134
}
 
2135
 
 
2136
/***************************************/
 
2137
/* QEMU specific operations. Their type depend on the QEMU CPU
 
2138
   type. */
 
2139
#ifndef TARGET_LONG_BITS
 
2140
#error must include QEMU headers
 
2141
#endif
 
2142
 
 
2143
#if TARGET_LONG_BITS == 32
 
2144
#define TCGv TCGv_i32
 
2145
#define tcg_temp_new() tcg_temp_new_i32()
 
2146
#define tcg_global_reg_new tcg_global_reg_new_i32
 
2147
#define tcg_global_mem_new tcg_global_mem_new_i32
 
2148
#define tcg_temp_local_new() tcg_temp_local_new_i32()
 
2149
#define tcg_temp_free tcg_temp_free_i32
 
2150
#define tcg_gen_qemu_ldst_op tcg_gen_op3i_i32
 
2151
#define tcg_gen_qemu_ldst_op_i64 tcg_gen_qemu_ldst_op_i64_i32
 
2152
#define TCGV_UNUSED(x) TCGV_UNUSED_I32(x)
 
2153
#define TCGV_EQUAL(a, b) TCGV_EQUAL_I32(a, b)
 
2154
#else
 
2155
#define TCGv TCGv_i64
 
2156
#define tcg_temp_new() tcg_temp_new_i64()
 
2157
#define tcg_global_reg_new tcg_global_reg_new_i64
 
2158
#define tcg_global_mem_new tcg_global_mem_new_i64
 
2159
#define tcg_temp_local_new() tcg_temp_local_new_i64()
 
2160
#define tcg_temp_free tcg_temp_free_i64
 
2161
#define tcg_gen_qemu_ldst_op tcg_gen_op3i_i64
 
2162
#define tcg_gen_qemu_ldst_op_i64 tcg_gen_qemu_ldst_op_i64_i64
 
2163
#define TCGV_UNUSED(x) TCGV_UNUSED_I64(x)
 
2164
#define TCGV_EQUAL(a, b) TCGV_EQUAL_I64(a, b)
 
2165
#endif
 
2166
 
 
2167
/* debug info: write the PC of the corresponding QEMU CPU instruction */
 
2168
static inline void tcg_gen_debug_insn_start(uint64_t pc)
 
2169
{
 
2170
    /* XXX: must really use a 32 bit size for TCGArg in all cases */
 
2171
#if TARGET_LONG_BITS > TCG_TARGET_REG_BITS
 
2172
    tcg_gen_op2ii(INDEX_op_debug_insn_start, 
 
2173
                  (uint32_t)(pc), (uint32_t)(pc >> 32));
 
2174
#else
 
2175
    tcg_gen_op1i(INDEX_op_debug_insn_start, pc);
 
2176
#endif
 
2177
}
 
2178
 
 
2179
static inline void tcg_gen_exit_tb(tcg_target_long val)
 
2180
{
 
2181
    tcg_gen_op1i(INDEX_op_exit_tb, val);
 
2182
}
 
2183
 
 
2184
static inline void tcg_gen_goto_tb(int idx)
 
2185
{
 
2186
    tcg_gen_op1i(INDEX_op_goto_tb, idx);
 
2187
}
 
2188
 
 
2189
#if TCG_TARGET_REG_BITS == 32
 
2190
static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
 
2191
{
 
2192
#if TARGET_LONG_BITS == 32
 
2193
    tcg_gen_op3i_i32(INDEX_op_qemu_ld8u, ret, addr, mem_index);
 
2194
#else
 
2195
    tcg_gen_op4i_i32(INDEX_op_qemu_ld8u, TCGV_LOW(ret), TCGV_LOW(addr),
 
2196
                     TCGV_HIGH(addr), mem_index);
 
2197
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
2198
#endif
 
2199
}
 
2200
 
 
2201
static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
 
2202
{
 
2203
#if TARGET_LONG_BITS == 32
 
2204
    tcg_gen_op3i_i32(INDEX_op_qemu_ld8s, ret, addr, mem_index);
 
2205
#else
 
2206
    tcg_gen_op4i_i32(INDEX_op_qemu_ld8s, TCGV_LOW(ret), TCGV_LOW(addr),
 
2207
                     TCGV_HIGH(addr), mem_index);
 
2208
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
2209
#endif
 
2210
}
 
2211
 
 
2212
static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
 
2213
{
 
2214
#if TARGET_LONG_BITS == 32
 
2215
    tcg_gen_op3i_i32(INDEX_op_qemu_ld16u, ret, addr, mem_index);
 
2216
#else
 
2217
    tcg_gen_op4i_i32(INDEX_op_qemu_ld16u, TCGV_LOW(ret), TCGV_LOW(addr),
 
2218
                     TCGV_HIGH(addr), mem_index);
 
2219
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
2220
#endif
 
2221
}
 
2222
 
 
2223
static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
 
2224
{
 
2225
#if TARGET_LONG_BITS == 32
 
2226
    tcg_gen_op3i_i32(INDEX_op_qemu_ld16s, ret, addr, mem_index);
 
2227
#else
 
2228
    tcg_gen_op4i_i32(INDEX_op_qemu_ld16s, TCGV_LOW(ret), TCGV_LOW(addr),
 
2229
                     TCGV_HIGH(addr), mem_index);
 
2230
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
2231
#endif
 
2232
}
 
2233
 
 
2234
static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
 
2235
{
 
2236
#if TARGET_LONG_BITS == 32
 
2237
    tcg_gen_op3i_i32(INDEX_op_qemu_ld32, ret, addr, mem_index);
 
2238
#else
 
2239
    tcg_gen_op4i_i32(INDEX_op_qemu_ld32, TCGV_LOW(ret), TCGV_LOW(addr),
 
2240
                     TCGV_HIGH(addr), mem_index);
 
2241
    tcg_gen_movi_i32(TCGV_HIGH(ret), 0);
 
2242
#endif
 
2243
}
 
2244
 
 
2245
static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
 
2246
{
 
2247
#if TARGET_LONG_BITS == 32
 
2248
    tcg_gen_op3i_i32(INDEX_op_qemu_ld32, ret, addr, mem_index);
 
2249
#else
 
2250
    tcg_gen_op4i_i32(INDEX_op_qemu_ld32, TCGV_LOW(ret), TCGV_LOW(addr),
 
2251
                     TCGV_HIGH(addr), mem_index);
 
2252
    tcg_gen_sari_i32(TCGV_HIGH(ret), TCGV_LOW(ret), 31);
 
2253
#endif
 
2254
}
 
2255
 
 
2256
static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
 
2257
{
 
2258
#if TARGET_LONG_BITS == 32
 
2259
    tcg_gen_op4i_i32(INDEX_op_qemu_ld64, TCGV_LOW(ret), TCGV_HIGH(ret), addr, mem_index);
 
2260
#else
 
2261
    tcg_gen_op5i_i32(INDEX_op_qemu_ld64, TCGV_LOW(ret), TCGV_HIGH(ret),
 
2262
                     TCGV_LOW(addr), TCGV_HIGH(addr), mem_index);
 
2263
#endif
 
2264
}
 
2265
 
 
2266
static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
 
2267
{
 
2268
#if TARGET_LONG_BITS == 32
 
2269
    tcg_gen_op3i_i32(INDEX_op_qemu_st8, arg, addr, mem_index);
 
2270
#else
 
2271
    tcg_gen_op4i_i32(INDEX_op_qemu_st8, TCGV_LOW(arg), TCGV_LOW(addr),
 
2272
                     TCGV_HIGH(addr), mem_index);
 
2273
#endif
 
2274
}
 
2275
 
 
2276
static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
 
2277
{
 
2278
#if TARGET_LONG_BITS == 32
 
2279
    tcg_gen_op3i_i32(INDEX_op_qemu_st16, arg, addr, mem_index);
 
2280
#else
 
2281
    tcg_gen_op4i_i32(INDEX_op_qemu_st16, TCGV_LOW(arg), TCGV_LOW(addr),
 
2282
                     TCGV_HIGH(addr), mem_index);
 
2283
#endif
 
2284
}
 
2285
 
 
2286
static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
 
2287
{
 
2288
#if TARGET_LONG_BITS == 32
 
2289
    tcg_gen_op3i_i32(INDEX_op_qemu_st32, arg, addr, mem_index);
 
2290
#else
 
2291
    tcg_gen_op4i_i32(INDEX_op_qemu_st32, TCGV_LOW(arg), TCGV_LOW(addr),
 
2292
                     TCGV_HIGH(addr), mem_index);
 
2293
#endif
 
2294
}
 
2295
 
 
2296
static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
 
2297
{
 
2298
#if TARGET_LONG_BITS == 32
 
2299
    tcg_gen_op4i_i32(INDEX_op_qemu_st64, TCGV_LOW(arg), TCGV_HIGH(arg), addr,
 
2300
                     mem_index);
 
2301
#else
 
2302
    tcg_gen_op5i_i32(INDEX_op_qemu_st64, TCGV_LOW(arg), TCGV_HIGH(arg),
 
2303
                     TCGV_LOW(addr), TCGV_HIGH(addr), mem_index);
 
2304
#endif
 
2305
}
 
2306
 
 
2307
#define tcg_gen_ld_ptr(R, A, O) tcg_gen_ld_i32(TCGV_PTR_TO_NAT(R), (A), (O))
 
2308
#define tcg_gen_discard_ptr(A) tcg_gen_discard_i32(TCGV_PTR_TO_NAT(A))
 
2309
 
 
2310
#else /* TCG_TARGET_REG_BITS == 32 */
 
2311
 
 
2312
static inline void tcg_gen_qemu_ld8u(TCGv ret, TCGv addr, int mem_index)
 
2313
{
 
2314
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld8u, ret, addr, mem_index);
 
2315
}
 
2316
 
 
2317
static inline void tcg_gen_qemu_ld8s(TCGv ret, TCGv addr, int mem_index)
 
2318
{
 
2319
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld8s, ret, addr, mem_index);
 
2320
}
 
2321
 
 
2322
static inline void tcg_gen_qemu_ld16u(TCGv ret, TCGv addr, int mem_index)
 
2323
{
 
2324
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld16u, ret, addr, mem_index);
 
2325
}
 
2326
 
 
2327
static inline void tcg_gen_qemu_ld16s(TCGv ret, TCGv addr, int mem_index)
 
2328
{
 
2329
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld16s, ret, addr, mem_index);
 
2330
}
 
2331
 
 
2332
static inline void tcg_gen_qemu_ld32u(TCGv ret, TCGv addr, int mem_index)
 
2333
{
 
2334
#if TARGET_LONG_BITS == 32
 
2335
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32, ret, addr, mem_index);
 
2336
#else
 
2337
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32u, ret, addr, mem_index);
 
2338
#endif
 
2339
}
 
2340
 
 
2341
static inline void tcg_gen_qemu_ld32s(TCGv ret, TCGv addr, int mem_index)
 
2342
{
 
2343
#if TARGET_LONG_BITS == 32
 
2344
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32, ret, addr, mem_index);
 
2345
#else
 
2346
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_ld32s, ret, addr, mem_index);
 
2347
#endif
 
2348
}
 
2349
 
 
2350
static inline void tcg_gen_qemu_ld64(TCGv_i64 ret, TCGv addr, int mem_index)
 
2351
{
 
2352
    tcg_gen_qemu_ldst_op_i64(INDEX_op_qemu_ld64, ret, addr, mem_index);
 
2353
}
 
2354
 
 
2355
static inline void tcg_gen_qemu_st8(TCGv arg, TCGv addr, int mem_index)
 
2356
{
 
2357
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_st8, arg, addr, mem_index);
 
2358
}
 
2359
 
 
2360
static inline void tcg_gen_qemu_st16(TCGv arg, TCGv addr, int mem_index)
 
2361
{
 
2362
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_st16, arg, addr, mem_index);
 
2363
}
 
2364
 
 
2365
static inline void tcg_gen_qemu_st32(TCGv arg, TCGv addr, int mem_index)
 
2366
{
 
2367
    tcg_gen_qemu_ldst_op(INDEX_op_qemu_st32, arg, addr, mem_index);
 
2368
}
 
2369
 
 
2370
static inline void tcg_gen_qemu_st64(TCGv_i64 arg, TCGv addr, int mem_index)
 
2371
{
 
2372
    tcg_gen_qemu_ldst_op_i64(INDEX_op_qemu_st64, arg, addr, mem_index);
 
2373
}
 
2374
 
 
2375
#define tcg_gen_ld_ptr(R, A, O) tcg_gen_ld_i64(TCGV_PTR_TO_NAT(R), (A), (O))
 
2376
#define tcg_gen_discard_ptr(A) tcg_gen_discard_i64(TCGV_PTR_TO_NAT(A))
 
2377
 
 
2378
#endif /* TCG_TARGET_REG_BITS != 32 */
 
2379
 
 
2380
#if TARGET_LONG_BITS == 64
 
2381
#define tcg_gen_movi_tl tcg_gen_movi_i64
 
2382
#define tcg_gen_mov_tl tcg_gen_mov_i64
 
2383
#define tcg_gen_ld8u_tl tcg_gen_ld8u_i64
 
2384
#define tcg_gen_ld8s_tl tcg_gen_ld8s_i64
 
2385
#define tcg_gen_ld16u_tl tcg_gen_ld16u_i64
 
2386
#define tcg_gen_ld16s_tl tcg_gen_ld16s_i64
 
2387
#define tcg_gen_ld32u_tl tcg_gen_ld32u_i64
 
2388
#define tcg_gen_ld32s_tl tcg_gen_ld32s_i64
 
2389
#define tcg_gen_ld_tl tcg_gen_ld_i64
 
2390
#define tcg_gen_st8_tl tcg_gen_st8_i64
 
2391
#define tcg_gen_st16_tl tcg_gen_st16_i64
 
2392
#define tcg_gen_st32_tl tcg_gen_st32_i64
 
2393
#define tcg_gen_st_tl tcg_gen_st_i64
 
2394
#define tcg_gen_add_tl tcg_gen_add_i64
 
2395
#define tcg_gen_addi_tl tcg_gen_addi_i64
 
2396
#define tcg_gen_sub_tl tcg_gen_sub_i64
 
2397
#define tcg_gen_neg_tl tcg_gen_neg_i64
 
2398
#define tcg_gen_subfi_tl tcg_gen_subfi_i64
 
2399
#define tcg_gen_subi_tl tcg_gen_subi_i64
 
2400
#define tcg_gen_and_tl tcg_gen_and_i64
 
2401
#define tcg_gen_andi_tl tcg_gen_andi_i64
 
2402
#define tcg_gen_or_tl tcg_gen_or_i64
 
2403
#define tcg_gen_ori_tl tcg_gen_ori_i64
 
2404
#define tcg_gen_xor_tl tcg_gen_xor_i64
 
2405
#define tcg_gen_xori_tl tcg_gen_xori_i64
 
2406
#define tcg_gen_not_tl tcg_gen_not_i64
 
2407
#define tcg_gen_shl_tl tcg_gen_shl_i64
 
2408
#define tcg_gen_shli_tl tcg_gen_shli_i64
 
2409
#define tcg_gen_shr_tl tcg_gen_shr_i64
 
2410
#define tcg_gen_shri_tl tcg_gen_shri_i64
 
2411
#define tcg_gen_sar_tl tcg_gen_sar_i64
 
2412
#define tcg_gen_sari_tl tcg_gen_sari_i64
 
2413
#define tcg_gen_brcond_tl tcg_gen_brcond_i64
 
2414
#define tcg_gen_brcondi_tl tcg_gen_brcondi_i64
 
2415
#define tcg_gen_setcond_tl tcg_gen_setcond_i64
 
2416
#define tcg_gen_setcondi_tl tcg_gen_setcondi_i64
 
2417
#define tcg_gen_mul_tl tcg_gen_mul_i64
 
2418
#define tcg_gen_muli_tl tcg_gen_muli_i64
 
2419
#define tcg_gen_div_tl tcg_gen_div_i64
 
2420
#define tcg_gen_rem_tl tcg_gen_rem_i64
 
2421
#define tcg_gen_divu_tl tcg_gen_divu_i64
 
2422
#define tcg_gen_remu_tl tcg_gen_remu_i64
 
2423
#define tcg_gen_discard_tl tcg_gen_discard_i64
 
2424
#define tcg_gen_trunc_tl_i32 tcg_gen_trunc_i64_i32
 
2425
#define tcg_gen_trunc_i64_tl tcg_gen_mov_i64
 
2426
#define tcg_gen_extu_i32_tl tcg_gen_extu_i32_i64
 
2427
#define tcg_gen_ext_i32_tl tcg_gen_ext_i32_i64
 
2428
#define tcg_gen_extu_tl_i64 tcg_gen_mov_i64
 
2429
#define tcg_gen_ext_tl_i64 tcg_gen_mov_i64
 
2430
#define tcg_gen_ext8u_tl tcg_gen_ext8u_i64
 
2431
#define tcg_gen_ext8s_tl tcg_gen_ext8s_i64
 
2432
#define tcg_gen_ext16u_tl tcg_gen_ext16u_i64
 
2433
#define tcg_gen_ext16s_tl tcg_gen_ext16s_i64
 
2434
#define tcg_gen_ext32u_tl tcg_gen_ext32u_i64
 
2435
#define tcg_gen_ext32s_tl tcg_gen_ext32s_i64
 
2436
#define tcg_gen_bswap16_tl tcg_gen_bswap16_i64
 
2437
#define tcg_gen_bswap32_tl tcg_gen_bswap32_i64
 
2438
#define tcg_gen_bswap64_tl tcg_gen_bswap64_i64
 
2439
#define tcg_gen_concat_tl_i64 tcg_gen_concat32_i64
 
2440
#define tcg_gen_andc_tl tcg_gen_andc_i64
 
2441
#define tcg_gen_eqv_tl tcg_gen_eqv_i64
 
2442
#define tcg_gen_nand_tl tcg_gen_nand_i64
 
2443
#define tcg_gen_nor_tl tcg_gen_nor_i64
 
2444
#define tcg_gen_orc_tl tcg_gen_orc_i64
 
2445
#define tcg_gen_rotl_tl tcg_gen_rotl_i64
 
2446
#define tcg_gen_rotli_tl tcg_gen_rotli_i64
 
2447
#define tcg_gen_rotr_tl tcg_gen_rotr_i64
 
2448
#define tcg_gen_rotri_tl tcg_gen_rotri_i64
 
2449
#define tcg_gen_deposit_tl tcg_gen_deposit_i64
 
2450
#define tcg_const_tl tcg_const_i64
 
2451
#define tcg_const_local_tl tcg_const_local_i64
 
2452
#else
 
2453
#define tcg_gen_movi_tl tcg_gen_movi_i32
 
2454
#define tcg_gen_mov_tl tcg_gen_mov_i32
 
2455
#define tcg_gen_ld8u_tl tcg_gen_ld8u_i32
 
2456
#define tcg_gen_ld8s_tl tcg_gen_ld8s_i32
 
2457
#define tcg_gen_ld16u_tl tcg_gen_ld16u_i32
 
2458
#define tcg_gen_ld16s_tl tcg_gen_ld16s_i32
 
2459
#define tcg_gen_ld32u_tl tcg_gen_ld_i32
 
2460
#define tcg_gen_ld32s_tl tcg_gen_ld_i32
 
2461
#define tcg_gen_ld_tl tcg_gen_ld_i32
 
2462
#define tcg_gen_st8_tl tcg_gen_st8_i32
 
2463
#define tcg_gen_st16_tl tcg_gen_st16_i32
 
2464
#define tcg_gen_st32_tl tcg_gen_st_i32
 
2465
#define tcg_gen_st_tl tcg_gen_st_i32
 
2466
#define tcg_gen_add_tl tcg_gen_add_i32
 
2467
#define tcg_gen_addi_tl tcg_gen_addi_i32
 
2468
#define tcg_gen_sub_tl tcg_gen_sub_i32
 
2469
#define tcg_gen_neg_tl tcg_gen_neg_i32
 
2470
#define tcg_gen_subfi_tl tcg_gen_subfi_i32
 
2471
#define tcg_gen_subi_tl tcg_gen_subi_i32
 
2472
#define tcg_gen_and_tl tcg_gen_and_i32
 
2473
#define tcg_gen_andi_tl tcg_gen_andi_i32
 
2474
#define tcg_gen_or_tl tcg_gen_or_i32
 
2475
#define tcg_gen_ori_tl tcg_gen_ori_i32
 
2476
#define tcg_gen_xor_tl tcg_gen_xor_i32
 
2477
#define tcg_gen_xori_tl tcg_gen_xori_i32
 
2478
#define tcg_gen_not_tl tcg_gen_not_i32
 
2479
#define tcg_gen_shl_tl tcg_gen_shl_i32
 
2480
#define tcg_gen_shli_tl tcg_gen_shli_i32
 
2481
#define tcg_gen_shr_tl tcg_gen_shr_i32
 
2482
#define tcg_gen_shri_tl tcg_gen_shri_i32
 
2483
#define tcg_gen_sar_tl tcg_gen_sar_i32
 
2484
#define tcg_gen_sari_tl tcg_gen_sari_i32
 
2485
#define tcg_gen_brcond_tl tcg_gen_brcond_i32
 
2486
#define tcg_gen_brcondi_tl tcg_gen_brcondi_i32
 
2487
#define tcg_gen_setcond_tl tcg_gen_setcond_i32
 
2488
#define tcg_gen_setcondi_tl tcg_gen_setcondi_i32
 
2489
#define tcg_gen_mul_tl tcg_gen_mul_i32
 
2490
#define tcg_gen_muli_tl tcg_gen_muli_i32
 
2491
#define tcg_gen_div_tl tcg_gen_div_i32
 
2492
#define tcg_gen_rem_tl tcg_gen_rem_i32
 
2493
#define tcg_gen_divu_tl tcg_gen_divu_i32
 
2494
#define tcg_gen_remu_tl tcg_gen_remu_i32
 
2495
#define tcg_gen_discard_tl tcg_gen_discard_i32
 
2496
#define tcg_gen_trunc_tl_i32 tcg_gen_mov_i32
 
2497
#define tcg_gen_trunc_i64_tl tcg_gen_trunc_i64_i32
 
2498
#define tcg_gen_extu_i32_tl tcg_gen_mov_i32
 
2499
#define tcg_gen_ext_i32_tl tcg_gen_mov_i32
 
2500
#define tcg_gen_extu_tl_i64 tcg_gen_extu_i32_i64
 
2501
#define tcg_gen_ext_tl_i64 tcg_gen_ext_i32_i64
 
2502
#define tcg_gen_ext8u_tl tcg_gen_ext8u_i32
 
2503
#define tcg_gen_ext8s_tl tcg_gen_ext8s_i32
 
2504
#define tcg_gen_ext16u_tl tcg_gen_ext16u_i32
 
2505
#define tcg_gen_ext16s_tl tcg_gen_ext16s_i32
 
2506
#define tcg_gen_ext32u_tl tcg_gen_mov_i32
 
2507
#define tcg_gen_ext32s_tl tcg_gen_mov_i32
 
2508
#define tcg_gen_bswap16_tl tcg_gen_bswap16_i32
 
2509
#define tcg_gen_bswap32_tl tcg_gen_bswap32_i32
 
2510
#define tcg_gen_concat_tl_i64 tcg_gen_concat_i32_i64
 
2511
#define tcg_gen_andc_tl tcg_gen_andc_i32
 
2512
#define tcg_gen_eqv_tl tcg_gen_eqv_i32
 
2513
#define tcg_gen_nand_tl tcg_gen_nand_i32
 
2514
#define tcg_gen_nor_tl tcg_gen_nor_i32
 
2515
#define tcg_gen_orc_tl tcg_gen_orc_i32
 
2516
#define tcg_gen_rotl_tl tcg_gen_rotl_i32
 
2517
#define tcg_gen_rotli_tl tcg_gen_rotli_i32
 
2518
#define tcg_gen_rotr_tl tcg_gen_rotr_i32
 
2519
#define tcg_gen_rotri_tl tcg_gen_rotri_i32
 
2520
#define tcg_gen_deposit_tl tcg_gen_deposit_i32
 
2521
#define tcg_const_tl tcg_const_i32
 
2522
#define tcg_const_local_tl tcg_const_local_i32
 
2523
#endif
 
2524
 
 
2525
#if TCG_TARGET_REG_BITS == 32
 
2526
#define tcg_gen_add_ptr(R, A, B) tcg_gen_add_i32(TCGV_PTR_TO_NAT(R), \
 
2527
                                               TCGV_PTR_TO_NAT(A), \
 
2528
                                               TCGV_PTR_TO_NAT(B))
 
2529
#define tcg_gen_addi_ptr(R, A, B) tcg_gen_addi_i32(TCGV_PTR_TO_NAT(R), \
 
2530
                                                 TCGV_PTR_TO_NAT(A), (B))
 
2531
#define tcg_gen_ext_i32_ptr(R, A) tcg_gen_mov_i32(TCGV_PTR_TO_NAT(R), (A))
 
2532
#else /* TCG_TARGET_REG_BITS == 32 */
 
2533
#define tcg_gen_add_ptr(R, A, B) tcg_gen_add_i64(TCGV_PTR_TO_NAT(R), \
 
2534
                                               TCGV_PTR_TO_NAT(A), \
 
2535
                                               TCGV_PTR_TO_NAT(B))
 
2536
#define tcg_gen_addi_ptr(R, A, B) tcg_gen_addi_i64(TCGV_PTR_TO_NAT(R),   \
 
2537
                                                 TCGV_PTR_TO_NAT(A), (B))
 
2538
#define tcg_gen_ext_i32_ptr(R, A) tcg_gen_ext_i32_i64(TCGV_PTR_TO_NAT(R), (A))
 
2539
#endif /* TCG_TARGET_REG_BITS != 32 */