asmx64.c 22.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/*
 * This file is part of the Micro Python project, http://micropython.org/
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2013, 2014 Damien P. George
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

Markus Siemens's avatar
Markus Siemens committed
27
#include <stdint.h>
Damien's avatar
Damien committed
28
29
30
31
#include <stdio.h>
#include <assert.h>
#include <string.h>

32
#include "mpconfig.h"
33
#include "misc.h"
34
35
36

// wrapper around everything in this file
#if MICROPY_EMIT_X64
Damien's avatar
Damien committed
37

38
39
#include "asmx64.h"

Damien's avatar
Damien committed
40
41
42
43
/* all offsets are measured in multiples of 8 bytes */
#define WORD_SIZE                (8)

#define OPCODE_NOP               (0x90)
44
#define OPCODE_PUSH_R64          (0x50) /* +rq */
Damien's avatar
Damien committed
45
46
#define OPCODE_PUSH_I64          (0x68)
#define OPCODE_PUSH_M64          (0xff) /* /6 */
47
#define OPCODE_POP_R64           (0x58) /* +rq */
Damien's avatar
Damien committed
48
49
#define OPCODE_RET               (0xc3)
#define OPCODE_MOV_I8_TO_R8      (0xb0) /* +rb */
50
#define OPCODE_MOV_I64_TO_R64    (0xb8) /* +rq */
Damien's avatar
Damien committed
51
#define OPCODE_MOV_I32_TO_RM32   (0xc7)
52
#define OPCODE_MOV_R8_TO_RM8     (0x88) /* /r */
53
#define OPCODE_MOV_R64_TO_RM64   (0x89) /* /r */
Damien's avatar
Damien committed
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
#define OPCODE_MOV_RM64_TO_R64   (0x8b)
#define OPCODE_LEA_MEM_TO_R64    (0x8d) /* /r */
#define OPCODE_XOR_R64_TO_RM64   (0x31) /* /r */
#define OPCODE_ADD_R64_TO_RM64   (0x01)
#define OPCODE_ADD_I32_TO_RM32   (0x81) /* /0 */
#define OPCODE_ADD_I8_TO_RM32    (0x83) /* /0 */
#define OPCODE_SUB_R64_FROM_RM64 (0x29)
#define OPCODE_SUB_I32_FROM_RM64 (0x81) /* /5 */
#define OPCODE_SUB_I8_FROM_RM64  (0x83) /* /5 */
#define OPCODE_SHL_RM32_BY_I8    (0xc1) /* /4 */
#define OPCODE_SHR_RM32_BY_I8    (0xc1) /* /5 */
#define OPCODE_SAR_RM32_BY_I8    (0xc1) /* /7 */
#define OPCODE_CMP_I32_WITH_RM32 (0x81) /* /7 */
#define OPCODE_CMP_I8_WITH_RM32  (0x83) /* /7 */
#define OPCODE_CMP_R64_WITH_RM64 (0x39)
#define OPCODE_CMP_RM32_WITH_R32 (0x3b)
#define OPCODE_TEST_R8_WITH_RM8  (0x84) /* /r */
#define OPCODE_JMP_REL8          (0xeb)
#define OPCODE_JMP_REL32         (0xe9)
#define OPCODE_JCC_REL8          (0x70) /* | jcc type */
#define OPCODE_JCC_REL32_A       (0x0f)
#define OPCODE_JCC_REL32_B       (0x80) /* | jcc type */
#define OPCODE_SETCC_RM8_A       (0x0f)
#define OPCODE_SETCC_RM8_B       (0x90) /* | jcc type, /0 */
#define OPCODE_CALL_REL32        (0xe8)
#define OPCODE_CALL_RM32         (0xff) /* /2 */
#define OPCODE_LEAVE             (0xc9)

82
#define MODRM_R64(x)    (((x) & 0x7) << 3)
Damien's avatar
Damien committed
83
84
85
86
#define MODRM_RM_DISP0  (0x00)
#define MODRM_RM_DISP8  (0x40)
#define MODRM_RM_DISP32 (0x80)
#define MODRM_RM_REG    (0xc0)
87
#define MODRM_RM_R64(x) ((x) & 0x7)
Damien's avatar
Damien committed
88

89
90
#define OP_SIZE_PREFIX (0x66)

Damien's avatar
Damien committed
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#define REX_PREFIX  (0x40)
#define REX_W       (0x08)  // width
#define REX_R       (0x04)  // register
#define REX_X       (0x02)  // index
#define REX_B       (0x01)  // base

#define IMM32_L0(x) ((x) & 0xff)
#define IMM32_L1(x) (((x) >> 8) & 0xff)
#define IMM32_L2(x) (((x) >> 16) & 0xff)
#define IMM32_L3(x) (((x) >> 24) & 0xff)
#define IMM64_L4(x) (((x) >> 32) & 0xff)
#define IMM64_L5(x) (((x) >> 40) & 0xff)
#define IMM64_L6(x) (((x) >> 48) & 0xff)
#define IMM64_L7(x) (((x) >> 56) & 0xff)

#define UNSIGNED_FIT8(x) (((x) & 0xffffffffffffff00) == 0)
#define UNSIGNED_FIT32(x) (((x) & 0xffffffff00000000) == 0)
#define SIGNED_FIT8(x) (((x) & 0xffffff80) == 0) || (((x) & 0xffffff80) == 0xffffff80)

struct _asm_x64_t {
111
    uint pass;
112
113
    mp_uint_t code_offset;
    mp_uint_t code_size;
Damien's avatar
Damien committed
114
115
116
    byte *code_base;
    byte dummy_data[8];

117
118
    mp_uint_t max_num_labels;
    mp_uint_t *label_offsets;
119
    int num_locals;
Damien's avatar
Damien committed
120
121
};

122
asm_x64_t *asm_x64_new(mp_uint_t max_num_labels) {
123
    asm_x64_t *as;
Damien's avatar
Damien committed
124

125
    as = m_new0(asm_x64_t, 1);
126
    as->max_num_labels = max_num_labels;
127
    as->label_offsets = m_new(mp_uint_t, max_num_labels);
Damien's avatar
Damien committed
128
129
130
131

    return as;
}

132
void asm_x64_free(asm_x64_t *as, bool free_code) {
Damien's avatar
Damien committed
133
    if (free_code) {
134
        MP_PLAT_FREE_EXEC(as->code_base, as->code_size);
Damien's avatar
Damien committed
135
    }
136
    m_del(mp_uint_t, as->label_offsets, as->max_num_labels);
137
    m_del_obj(asm_x64_t, as);
Damien's avatar
Damien committed
138
139
}

140
void asm_x64_start_pass(asm_x64_t *as, uint pass) {
Damien's avatar
Damien committed
141
142
    as->pass = pass;
    as->code_offset = 0;
143
    if (pass == ASM_X64_PASS_COMPUTE) {
144
        // reset all labels
145
        memset(as->label_offsets, -1, as->max_num_labels * sizeof(mp_uint_t));
Damien's avatar
Damien committed
146
147
148
149
    }
}

void asm_x64_end_pass(asm_x64_t *as) {
150
    if (as->pass == ASM_X64_PASS_COMPUTE) {
151
        MP_PLAT_ALLOC_EXEC(as->code_offset, (void**) &as->code_base, &as->code_size);
152
        if(as->code_base == NULL) {
153
154
            assert(0);
        }
155
        //printf("code_size: %u\n", as->code_size);
Damien's avatar
Damien committed
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
    }

    /*
    // check labels are resolved
    if (as->label != NULL)
    {
        int i;
        for (i = 0; i < as->label->len; ++i)
            if (g_array_index(as->label, Label, i).unresolved != NULL)
                return false;
    }
    */
}

// all functions must go through this one to emit bytes
171
STATIC byte *asm_x64_get_cur_to_write_bytes(asm_x64_t *as, int num_bytes_to_write) {
Damien's avatar
Damien committed
172
    //printf("emit %d\n", num_bytes_to_write);
173
    if (as->pass < ASM_X64_PASS_EMIT) {
Damien's avatar
Damien committed
174
175
176
177
178
179
180
181
182
183
        as->code_offset += num_bytes_to_write;
        return as->dummy_data;
    } else {
        assert(as->code_offset + num_bytes_to_write <= as->code_size);
        byte *c = as->code_base + as->code_offset;
        as->code_offset += num_bytes_to_write;
        return c;
    }
}

184
mp_uint_t asm_x64_get_code_size(asm_x64_t *as) {
Damien's avatar
Damien committed
185
186
187
    return as->code_size;
}

188
void *asm_x64_get_code(asm_x64_t *as) {
Damien's avatar
Damien committed
189
190
191
    return as->code_base;
}

192
STATIC void asm_x64_write_byte_1(asm_x64_t *as, byte b1) {
Damien's avatar
Damien committed
193
194
195
196
    byte* c = asm_x64_get_cur_to_write_bytes(as, 1);
    c[0] = b1;
}

197
STATIC void asm_x64_write_byte_2(asm_x64_t *as, byte b1, byte b2) {
Damien's avatar
Damien committed
198
199
200
201
202
    byte* c = asm_x64_get_cur_to_write_bytes(as, 2);
    c[0] = b1;
    c[1] = b2;
}

203
STATIC void asm_x64_write_byte_3(asm_x64_t *as, byte b1, byte b2, byte b3) {
Damien's avatar
Damien committed
204
205
206
207
208
209
    byte* c = asm_x64_get_cur_to_write_bytes(as, 3);
    c[0] = b1;
    c[1] = b2;
    c[2] = b3;
}

210
STATIC void asm_x64_write_word32(asm_x64_t *as, int w32) {
Damien's avatar
Damien committed
211
212
213
214
215
216
217
    byte* c = asm_x64_get_cur_to_write_bytes(as, 4);
    c[0] = IMM32_L0(w32);
    c[1] = IMM32_L1(w32);
    c[2] = IMM32_L2(w32);
    c[3] = IMM32_L3(w32);
}

218
STATIC void asm_x64_write_word64(asm_x64_t *as, int64_t w64) {
Damien's avatar
Damien committed
219
220
221
222
223
224
225
226
227
228
229
230
    byte* c = asm_x64_get_cur_to_write_bytes(as, 8);
    c[0] = IMM32_L0(w64);
    c[1] = IMM32_L1(w64);
    c[2] = IMM32_L2(w64);
    c[3] = IMM32_L3(w64);
    c[4] = IMM64_L4(w64);
    c[5] = IMM64_L5(w64);
    c[6] = IMM64_L6(w64);
    c[7] = IMM64_L7(w64);
}

/* unused
231
STATIC void asm_x64_write_word32_to(asm_x64_t *as, int offset, int w32) {
Damien's avatar
Damien committed
232
233
234
235
236
237
238
239
240
241
    byte* c;
    assert(offset + 4 <= as->code_size);
    c = as->code_base + offset;
    c[0] = IMM32_L0(w32);
    c[1] = IMM32_L1(w32);
    c[2] = IMM32_L2(w32);
    c[3] = IMM32_L3(w32);
}
*/

242
STATIC void asm_x64_write_r64_disp(asm_x64_t *as, int r64, int disp_r64, int disp_offset) {
243
    assert(disp_r64 < 8);
244
    assert(disp_r64 != ASM_X64_REG_RSP);
Damien's avatar
Damien committed
245

246
    if (disp_offset == 0 && disp_r64 != ASM_X64_REG_RBP) {
Damien's avatar
Damien committed
247
248
249
250
251
252
253
254
255
        asm_x64_write_byte_1(as, MODRM_R64(r64) | MODRM_RM_DISP0 | MODRM_RM_R64(disp_r64));
    } else if (SIGNED_FIT8(disp_offset)) {
        asm_x64_write_byte_2(as, MODRM_R64(r64) | MODRM_RM_DISP8 | MODRM_RM_R64(disp_r64), IMM32_L0(disp_offset));
    } else {
        asm_x64_write_byte_1(as, MODRM_R64(r64) | MODRM_RM_DISP32 | MODRM_RM_R64(disp_r64));
        asm_x64_write_word32(as, disp_offset);
    }
}

256
void asm_x64_nop(asm_x64_t *as) {
Damien's avatar
Damien committed
257
258
259
    asm_x64_write_byte_1(as, OPCODE_NOP);
}

260
void asm_x64_push_r64(asm_x64_t *as, int src_r64) {
261
262
263
264
265
    if (src_r64 < 8) {
        asm_x64_write_byte_1(as, OPCODE_PUSH_R64 | src_r64);
    } else {
        asm_x64_write_byte_2(as, REX_PREFIX | REX_B, OPCODE_PUSH_R64 | (src_r64 & 7));
    }
Damien's avatar
Damien committed
266
267
}

268
/*
269
void asm_x64_push_i32(asm_x64_t *as, int src_i32) {
Damien's avatar
Damien committed
270
271
272
    asm_x64_write_byte_1(as, OPCODE_PUSH_I64);
    asm_x64_write_word32(as, src_i32); // will be sign extended to 64 bits
}
273
*/
Damien's avatar
Damien committed
274

275
void asm_x64_push_disp(asm_x64_t *as, int src_r64, int src_offset) {
276
    assert(src_r64 < 8);
Damien's avatar
Damien committed
277
278
279
280
    asm_x64_write_byte_1(as, OPCODE_PUSH_M64);
    asm_x64_write_r64_disp(as, 6, src_r64, src_offset);
}

281
void asm_x64_pop_r64(asm_x64_t *as, int dest_r64) {
282
283
284
285
286
    if (dest_r64 < 8) {
        asm_x64_write_byte_1(as, OPCODE_POP_R64 | dest_r64);
    } else {
        asm_x64_write_byte_2(as, REX_PREFIX | REX_B, OPCODE_POP_R64 | (dest_r64 & 7));
    }
Damien's avatar
Damien committed
287
288
}

289
STATIC void asm_x64_ret(asm_x64_t *as) {
Damien's avatar
Damien committed
290
291
292
    asm_x64_write_byte_1(as, OPCODE_RET);
}

293
void asm_x64_mov_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
Damien's avatar
Damien committed
294
    // use REX prefix for 64 bit operation
295
    asm_x64_write_byte_3(as, REX_PREFIX | REX_W | (src_r64 < 8 ? 0 : REX_R) | (dest_r64 < 8 ? 0 : REX_B), OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
Damien's avatar
Damien committed
296
297
}

298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
void asm_x64_mov_r8_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp) {
    assert(dest_r64 < 8);
    if (src_r64 < 8) {
        asm_x64_write_byte_1(as, OPCODE_MOV_R8_TO_RM8);
    } else {
        asm_x64_write_byte_2(as, REX_PREFIX | REX_R, OPCODE_MOV_R8_TO_RM8);
    }
    asm_x64_write_r64_disp(as, src_r64, dest_r64, dest_disp);
}

void asm_x64_mov_r16_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp) {
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
    asm_x64_write_byte_2(as, OP_SIZE_PREFIX, OPCODE_MOV_R64_TO_RM64);
    asm_x64_write_r64_disp(as, src_r64, dest_r64, dest_disp);
}

315
void asm_x64_mov_r64_to_disp(asm_x64_t *as, int src_r64, int dest_r64, int dest_disp) {
Damien's avatar
Damien committed
316
    // use REX prefix for 64 bit operation
317
318
    assert(dest_r64 < 8);
    asm_x64_write_byte_2(as, REX_PREFIX | REX_W | (src_r64 < 8 ? 0 : REX_R), OPCODE_MOV_R64_TO_RM64);
Damien's avatar
Damien committed
319
320
321
    asm_x64_write_r64_disp(as, src_r64, dest_r64, dest_disp);
}

322
void asm_x64_mov_disp_to_r64(asm_x64_t *as, int src_r64, int src_disp, int dest_r64) {
Damien's avatar
Damien committed
323
    // use REX prefix for 64 bit operation
324
325
    assert(src_r64 < 8);
    asm_x64_write_byte_2(as, REX_PREFIX | REX_W | (dest_r64 < 8 ? 0 : REX_R), OPCODE_MOV_RM64_TO_R64);
Damien's avatar
Damien committed
326
327
328
    asm_x64_write_r64_disp(as, dest_r64, src_r64, src_disp);
}

329
void asm_x64_lea_disp_to_r64(asm_x64_t *as, int src_r64, int src_disp, int dest_r64) {
Damien's avatar
Damien committed
330
    // use REX prefix for 64 bit operation
331
332
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
333
334
335
336
337
    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_LEA_MEM_TO_R64);
    asm_x64_write_r64_disp(as, dest_r64, src_r64, src_disp);
}

void asm_x64_mov_i8_to_r8(asm_x64_t *as, int src_i8, int dest_r64) {
338
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
339
340
341
    asm_x64_write_byte_2(as, OPCODE_MOV_I8_TO_R8 | dest_r64, src_i8);
}

342
STATIC void asm_x64_mov_i32_to_r64(asm_x64_t *as, int src_i32, int dest_r64) {
Damien's avatar
Damien committed
343
    // cpu defaults to i32 to r64, with zero extension
344
345
346
347
348
    if (dest_r64 < 8) {
        asm_x64_write_byte_1(as, OPCODE_MOV_I64_TO_R64 | dest_r64);
    } else {
        asm_x64_write_byte_2(as, REX_PREFIX | REX_B, OPCODE_MOV_I64_TO_R64 | (dest_r64 & 7));
    }
Damien's avatar
Damien committed
349
350
351
    asm_x64_write_word32(as, src_i32);
}

352
void asm_x64_mov_i64_to_r64(asm_x64_t *as, int64_t src_i64, int dest_r64) {
Damien's avatar
Damien committed
353
354
    // cpu defaults to i32 to r64
    // to mov i64 to r64 need to use REX prefix
355
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
356
357
358
359
360
    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_MOV_I64_TO_R64 | dest_r64);
    asm_x64_write_word64(as, src_i64);
}

void asm_x64_mov_i64_to_r64_optimised(asm_x64_t *as, int64_t src_i64, int dest_r64) {
361
    // TODO use movzx, movsx if possible
Damien's avatar
Damien committed
362
363
364
365
366
367
368
369
370
    if (UNSIGNED_FIT32(src_i64)) {
        // 5 bytes
        asm_x64_mov_i32_to_r64(as, src_i64 & 0xffffffff, dest_r64);
    } else {
        // 10 bytes
        asm_x64_mov_i64_to_r64(as, src_i64, dest_r64);
    }
}

371
372
373
374
375
376
377
378
379
// src_i64 is stored as a full word in the code, and aligned to machine-word boundary
void asm_x64_mov_i64_to_r64_aligned(asm_x64_t *as, int64_t src_i64, int dest_r64) {
    // mov instruction uses 2 bytes for the instruction, before the i64
    while (((as->code_offset + 2) & (WORD_SIZE - 1)) != 0) {
        asm_x64_nop(as);
    }
    asm_x64_mov_i64_to_r64(as, src_i64, dest_r64);
}

Damien's avatar
Damien committed
380
void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
381
382
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
383
384
385
    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_XOR_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
}

386
void asm_x64_add_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
387
388
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
389
390
391
    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_ADD_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
}

392
/*
393
void asm_x64_sub_r32_from_r32(asm_x64_t *as, int src_r32, int dest_r32) {
Damien's avatar
Damien committed
394
395
396
    // defaults to 32 bit operation
    asm_x64_write_byte_2(as, OPCODE_SUB_R64_FROM_RM64, MODRM_R64(src_r32) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
}
397
*/
Damien's avatar
Damien committed
398

399
void asm_x64_sub_r64_from_r64(asm_x64_t *as, int src_r64, int dest_r64) {
Damien's avatar
Damien committed
400
    // use REX prefix for 64 bit operation
401
402
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
403
404
405
    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_R64_FROM_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
}

406
/*
407
void asm_x64_sub_i32_from_r32(asm_x64_t *as, int src_i32, int dest_r32) {
Damien's avatar
Damien committed
408
409
410
411
412
413
414
415
416
417
    if (SIGNED_FIT8(src_i32)) {
        // defaults to 32 bit operation
        asm_x64_write_byte_2(as, OPCODE_SUB_I8_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
        asm_x64_write_byte_1(as, src_i32 & 0xff);
    } else {
        // defaults to 32 bit operation
        asm_x64_write_byte_2(as, OPCODE_SUB_I32_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
        asm_x64_write_word32(as, src_i32);
    }
}
418
*/
Damien's avatar
Damien committed
419

420
void asm_x64_sub_i32_from_r64(asm_x64_t *as, int src_i32, int dest_r64) {
421
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
422
423
424
425
426
427
428
429
430
431
432
    if (SIGNED_FIT8(src_i32)) {
        // use REX prefix for 64 bit operation
        asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_I8_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
        asm_x64_write_byte_1(as, src_i32 & 0xff);
    } else {
        // use REX prefix for 64 bit operation
        asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_SUB_I32_FROM_RM64, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
        asm_x64_write_word32(as, src_i32);
    }
}

433
/*
434
void asm_x64_shl_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
435
436
437
438
    asm_x64_write_byte_2(as, OPCODE_SHL_RM32_BY_I8, MODRM_R64(4) | MODRM_RM_REG | MODRM_RM_R64(r32));
    asm_x64_write_byte_1(as, imm);
}

439
void asm_x64_shr_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
440
441
442
443
    asm_x64_write_byte_2(as, OPCODE_SHR_RM32_BY_I8, MODRM_R64(5) | MODRM_RM_REG | MODRM_RM_R64(r32));
    asm_x64_write_byte_1(as, imm);
}

444
void asm_x64_sar_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
445
446
447
    asm_x64_write_byte_2(as, OPCODE_SAR_RM32_BY_I8, MODRM_R64(7) | MODRM_RM_REG | MODRM_RM_R64(r32));
    asm_x64_write_byte_1(as, imm);
}
448
*/
Damien's avatar
Damien committed
449

450
void asm_x64_cmp_r64_with_r64(asm_x64_t *as, int src_r64_a, int src_r64_b) {
451
452
    assert(src_r64_a < 8);
    assert(src_r64_b < 8);
Damien's avatar
Damien committed
453
454
455
    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_CMP_R64_WITH_RM64, MODRM_R64(src_r64_a) | MODRM_RM_REG | MODRM_RM_R64(src_r64_b));
}

456
/*
457
void asm_x64_cmp_i32_with_r32(asm_x64_t *as, int src_i32, int src_r32) {
Damien's avatar
Damien committed
458
459
460
461
462
463
464
465
    if (SIGNED_FIT8(src_i32)) {
        asm_x64_write_byte_2(as, OPCODE_CMP_I8_WITH_RM32, MODRM_R64(7) | MODRM_RM_REG | MODRM_RM_R64(src_r32));
        asm_x64_write_byte_1(as, src_i32 & 0xff);
    } else {
        asm_x64_write_byte_2(as, OPCODE_CMP_I32_WITH_RM32, MODRM_R64(7) | MODRM_RM_REG | MODRM_RM_R64(src_r32));
        asm_x64_write_word32(as, src_i32);
    }
}
466
*/
Damien's avatar
Damien committed
467

468
void asm_x64_test_r8_with_r8(asm_x64_t *as, int src_r64_a, int src_r64_b) {
Damien's avatar
Damien committed
469
    // TODO implement for other registers
470
471
    assert(src_r64_a == ASM_X64_REG_RAX);
    assert(src_r64_b == ASM_X64_REG_RAX);
Damien's avatar
Damien committed
472
473
474
    asm_x64_write_byte_2(as, OPCODE_TEST_R8_WITH_RM8, MODRM_R64(src_r64_a) | MODRM_RM_REG | MODRM_RM_R64(src_r64_b));
}

475
void asm_x64_setcc_r8(asm_x64_t *as, int jcc_type, int dest_r8) {
476
    assert(dest_r8 < 8);
Damien's avatar
Damien committed
477
478
479
    asm_x64_write_byte_3(as, OPCODE_SETCC_RM8_A, OPCODE_SETCC_RM8_B | jcc_type, MODRM_R64(0) | MODRM_RM_REG | MODRM_RM_R64(dest_r8));
}

480
void asm_x64_label_assign(asm_x64_t *as, int label) {
481
    assert(label < as->max_num_labels);
482
    if (as->pass < ASM_X64_PASS_EMIT) {
483
484
485
        // assign label offset
        assert(as->label_offsets[label] == -1);
        as->label_offsets[label] = as->code_offset;
486
487
    } else {
        // ensure label offset has not changed from PASS_COMPUTE to PASS_EMIT
488
        //printf("l%d: (at %ld=%ld)\n", label, as->label_offsets[label], as->code_offset);
489
        assert(as->label_offsets[label] == as->code_offset);
Damien's avatar
Damien committed
490
491
492
    }
}

493
STATIC mp_uint_t get_label_dest(asm_x64_t *as, int label) {
494
495
496
497
498
    assert(label < as->max_num_labels);
    return as->label_offsets[label];
}

void asm_x64_jmp_label(asm_x64_t *as, int label) {
499
500
501
    mp_uint_t dest = get_label_dest(as, label);
    mp_int_t rel = dest - as->code_offset;
    if (dest != -1 && rel < 0) {
502
503
504
505
506
        // is a backwards jump, so we know the size of the jump on the first pass
        // calculate rel assuming 8 bit relative jump
        rel -= 2;
        if (SIGNED_FIT8(rel)) {
            asm_x64_write_byte_2(as, OPCODE_JMP_REL8, rel & 0xff);
Damien's avatar
Damien committed
507
        } else {
508
509
            rel += 2;
            goto large_jump;
Damien's avatar
Damien committed
510
        }
511
512
513
514
515
516
    } else {
        // is a forwards jump, so need to assume it's large
        large_jump:
        rel -= 5;
        asm_x64_write_byte_1(as, OPCODE_JMP_REL32);
        asm_x64_write_word32(as, rel);
Damien's avatar
Damien committed
517
518
519
    }
}

520
void asm_x64_jcc_label(asm_x64_t *as, int jcc_type, int label) {
521
522
523
    mp_uint_t dest = get_label_dest(as, label);
    mp_int_t rel = dest - as->code_offset;
    if (dest != -1 && rel < 0) {
524
525
526
527
528
        // is a backwards jump, so we know the size of the jump on the first pass
        // calculate rel assuming 8 bit relative jump
        rel -= 2;
        if (SIGNED_FIT8(rel)) {
            asm_x64_write_byte_2(as, OPCODE_JCC_REL8 | jcc_type, rel & 0xff);
Damien's avatar
Damien committed
529
        } else {
530
531
            rel += 2;
            goto large_jump;
Damien's avatar
Damien committed
532
        }
533
534
535
536
537
538
    } else {
        // is a forwards jump, so need to assume it's large
        large_jump:
        rel -= 6;
        asm_x64_write_byte_2(as, OPCODE_JCC_REL32_A, OPCODE_JCC_REL32_B | jcc_type);
        asm_x64_write_word32(as, rel);
Damien's avatar
Damien committed
539
540
541
    }
}

542
void asm_x64_entry(asm_x64_t *as, int num_locals) {
543
544
    asm_x64_push_r64(as, ASM_X64_REG_RBP);
    asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RSP, ASM_X64_REG_RBP);
Damien's avatar
Damien committed
545
546
547
548
    if (num_locals < 0) {
        num_locals = 0;
    }
    num_locals |= 1; // make it odd so stack is aligned on 16 byte boundary
549
550
551
552
    asm_x64_sub_i32_from_r64(as, num_locals * WORD_SIZE, ASM_X64_REG_RSP);
    asm_x64_push_r64(as, ASM_X64_REG_RBX);
    asm_x64_push_r64(as, ASM_X64_REG_R12);
    asm_x64_push_r64(as, ASM_X64_REG_R13);
553
    as->num_locals = num_locals;
Damien's avatar
Damien committed
554
555
}

556
void asm_x64_exit(asm_x64_t *as) {
557
558
559
    asm_x64_pop_r64(as, ASM_X64_REG_R13);
    asm_x64_pop_r64(as, ASM_X64_REG_R12);
    asm_x64_pop_r64(as, ASM_X64_REG_RBX);
Damien's avatar
Damien committed
560
561
562
563
    asm_x64_write_byte_1(as, OPCODE_LEAVE);
    asm_x64_ret(as);
}

564
565
566
567
568
569
570
571
572
573
574
// locals:
//  - stored on the stack in ascending order
//  - numbered 0 through as->num_locals-1
//  - RBP points above the last local
//
//                          | RPB
//                          v
//  l0  l1  l2  ...  l(n-1)
//  ^                ^
//  | low address    | high address in RAM
//
575
STATIC int asm_x64_local_offset_from_ebp(asm_x64_t *as, int local_num) {
576
    return (-as->num_locals + local_num) * WORD_SIZE;
Damien's avatar
Damien committed
577
578
}

579
void asm_x64_mov_local_to_r64(asm_x64_t *as, int src_local_num, int dest_r64) {
580
    asm_x64_mov_disp_to_r64(as, ASM_X64_REG_RBP, asm_x64_local_offset_from_ebp(as, src_local_num), dest_r64);
Damien's avatar
Damien committed
581
582
}

583
void asm_x64_mov_r64_to_local(asm_x64_t *as, int src_r64, int dest_local_num) {
584
    asm_x64_mov_r64_to_disp(as, src_r64, ASM_X64_REG_RBP, asm_x64_local_offset_from_ebp(as, dest_local_num));
Damien's avatar
Damien committed
585
586
}

587
588
void asm_x64_mov_local_addr_to_r64(asm_x64_t *as, int local_num, int dest_r64) {
    int offset = asm_x64_local_offset_from_ebp(as, local_num);
Damien's avatar
Damien committed
589
    if (offset == 0) {
590
        asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, dest_r64);
Damien's avatar
Damien committed
591
    } else {
592
        asm_x64_lea_disp_to_r64(as, ASM_X64_REG_RBP, offset, dest_r64);
Damien's avatar
Damien committed
593
594
595
    }
}

596
/*
597
void asm_x64_push_local(asm_x64_t *as, int local_num) {
598
    asm_x64_push_disp(as, ASM_X64_REG_RBP, asm_x64_local_offset_from_ebp(as, local_num));
Damien's avatar
Damien committed
599
600
}

601
void asm_x64_push_local_addr(asm_x64_t *as, int local_num, int temp_r64)
Damien's avatar
Damien committed
602
{
603
    asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, temp_r64);
604
    asm_x64_add_i32_to_r32(as, asm_x64_local_offset_from_ebp(as, local_num), temp_r64);
Damien's avatar
Damien committed
605
606
    asm_x64_push_r64(as, temp_r64);
}
607
*/
Damien's avatar
Damien committed
608
609
610
611

/*
   can't use these because code might be relocated when resized

612
void asm_x64_call(asm_x64_t *as, void* func)
Damien's avatar
Damien committed
613
{
614
    asm_x64_sub_i32_from_r32(as, 8, ASM_X64_REG_RSP);
Damien's avatar
Damien committed
615
616
    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
    asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
617
    asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, ASM_X64_REG_RSP);
Damien's avatar
Damien committed
618
619
}

620
void asm_x64_call_i1(asm_x64_t *as, void* func, int i1)
Damien's avatar
Damien committed
621
{
622
623
    asm_x64_sub_i32_from_r32(as, 8, ASM_X64_REG_RSP);
    asm_x64_sub_i32_from_r32(as, 12, ASM_X64_REG_RSP);
Damien's avatar
Damien committed
624
625
626
    asm_x64_push_i32(as, i1);
    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
    asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
627
628
    asm_x64_add_i32_to_r32(as, 16, ASM_X64_REG_RSP);
    asm_x64_mov_r64_to_r64(as, ASM_X64_REG_RBP, ASM_X64_REG_RSP);
Damien's avatar
Damien committed
629
630
631
}
*/

632
void asm_x64_call_ind(asm_x64_t *as, void *ptr, int temp_r64) {
633
    assert(temp_r64 < 8);
634
635
636
637
638
639
#ifdef __LP64__
    asm_x64_mov_i64_to_r64_optimised(as, (int64_t)ptr, temp_r64);
#else
    // If we get here, sizeof(int) == sizeof(void*).
    asm_x64_mov_i64_to_r64_optimised(as, (int64_t)(unsigned int)ptr, temp_r64);
#endif
Damien's avatar
Damien committed
640
641
    asm_x64_write_byte_2(as, OPCODE_CALL_RM32, MODRM_R64(2) | MODRM_RM_REG | MODRM_RM_R64(temp_r64));
    // this reduces code size by 2 bytes per call, but doesn't seem to speed it up at all
642
643
    // doesn't work anymore because calls are 64 bits away
    /*
Damien's avatar
Damien committed
644
645
    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
    asm_x64_write_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4));
646
    */
Damien's avatar
Damien committed
647
}
648
649

#endif // MICROPY_EMIT_X64