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_R64_TO_RM64   (0x89) /* /r */
Damien's avatar
Damien committed
53
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
#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)

81
#define MODRM_R64(x)    (((x) & 0x7) << 3)
Damien's avatar
Damien committed
82
83
84
85
#define MODRM_RM_DISP0  (0x00)
#define MODRM_RM_DISP8  (0x40)
#define MODRM_RM_DISP32 (0x80)
#define MODRM_RM_REG    (0xc0)
86
#define MODRM_RM_R64(x) ((x) & 0x7)
Damien's avatar
Damien committed
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

#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 {
108
    uint pass;
109
110
    mp_uint_t code_offset;
    mp_uint_t code_size;
Damien's avatar
Damien committed
111
112
113
    byte *code_base;
    byte dummy_data[8];

114
    uint max_num_labels;
Damien's avatar
Damien committed
115
    int *label_offsets;
116
    int num_locals;
Damien's avatar
Damien committed
117
118
};

119
120
asm_x64_t *asm_x64_new(uint max_num_labels) {
    asm_x64_t *as;
Damien's avatar
Damien committed
121

122
    as = m_new0(asm_x64_t, 1);
123
124
    as->max_num_labels = max_num_labels;
    as->label_offsets = m_new(int, max_num_labels);
Damien's avatar
Damien committed
125
126
127
128

    return as;
}

129
void asm_x64_free(asm_x64_t *as, bool free_code) {
Damien's avatar
Damien committed
130
    if (free_code) {
131
        MP_PLAT_FREE_EXEC(as->code_base, as->code_size);
Damien's avatar
Damien committed
132
133
134
135
136
137
138
139
140
141
142
143
144
    }
    /*
    if (as->label != NULL) {
        int i;
        for (i = 0; i < as->label->len; ++i)
        {
            Label* lab = &g_array_index(as->label, Label, i);
            if (lab->unresolved != NULL)
                g_array_free(lab->unresolved, true);
        }
        g_array_free(as->label, true);
    }
    */
145
    m_del_obj(asm_x64_t, as);
Damien's avatar
Damien committed
146
147
}

148
void asm_x64_start_pass(asm_x64_t *as, uint pass) {
Damien's avatar
Damien committed
149
150
    as->pass = pass;
    as->code_offset = 0;
151
    if (pass == ASM_X64_PASS_COMPUTE) {
152
153
        // reset all labels
        memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
Damien's avatar
Damien committed
154
155
156
157
    }
}

void asm_x64_end_pass(asm_x64_t *as) {
158
    if (as->pass == ASM_X64_PASS_COMPUTE) {
159
        MP_PLAT_ALLOC_EXEC(as->code_offset, (void**) &as->code_base, &as->code_size);
160
        if(as->code_base == NULL) {
161
162
            assert(0);
        }
163
        //printf("code_size: %u\n", as->code_size);
Damien's avatar
Damien committed
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
    }

    /*
    // 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
179
STATIC byte *asm_x64_get_cur_to_write_bytes(asm_x64_t *as, int num_bytes_to_write) {
Damien's avatar
Damien committed
180
    //printf("emit %d\n", num_bytes_to_write);
181
    if (as->pass < ASM_X64_PASS_EMIT) {
Damien's avatar
Damien committed
182
183
184
185
186
187
188
189
190
191
        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;
    }
}

192
uint asm_x64_get_code_size(asm_x64_t *as) {
Damien's avatar
Damien committed
193
194
195
    return as->code_size;
}

196
void *asm_x64_get_code(asm_x64_t *as) {
Damien's avatar
Damien committed
197
198
199
    return as->code_base;
}

200
STATIC void asm_x64_write_byte_1(asm_x64_t *as, byte b1) {
Damien's avatar
Damien committed
201
202
203
204
    byte* c = asm_x64_get_cur_to_write_bytes(as, 1);
    c[0] = b1;
}

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

211
STATIC void asm_x64_write_byte_3(asm_x64_t *as, byte b1, byte b2, byte b3) {
Damien's avatar
Damien committed
212
213
214
215
216
217
    byte* c = asm_x64_get_cur_to_write_bytes(as, 3);
    c[0] = b1;
    c[1] = b2;
    c[2] = b3;
}

218
STATIC void asm_x64_write_word32(asm_x64_t *as, int w32) {
Damien's avatar
Damien committed
219
220
221
222
223
224
225
    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);
}

226
STATIC void asm_x64_write_word64(asm_x64_t *as, int64_t w64) {
Damien's avatar
Damien committed
227
228
229
230
231
232
233
234
235
236
237
238
    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
239
STATIC void asm_x64_write_word32_to(asm_x64_t *as, int offset, int w32) {
Damien's avatar
Damien committed
240
241
242
243
244
245
246
247
248
249
    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);
}
*/

250
STATIC void asm_x64_write_r64_disp(asm_x64_t *as, int r64, int disp_r64, int disp_offset) {
251
    assert(disp_r64 < 8);
Damien's avatar
Damien committed
252
253
254
255
256
257
258
259
260
261
262
263
    assert(disp_r64 != REG_RSP);

    if (disp_offset == 0 && disp_r64 != REG_RBP) {
        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);
    }
}

264
void asm_x64_nop(asm_x64_t *as) {
Damien's avatar
Damien committed
265
266
267
    asm_x64_write_byte_1(as, OPCODE_NOP);
}

268
void asm_x64_push_r64(asm_x64_t *as, int src_r64) {
269
270
271
272
273
    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
274
275
}

276
/*
277
void asm_x64_push_i32(asm_x64_t *as, int src_i32) {
Damien's avatar
Damien committed
278
279
280
    asm_x64_write_byte_1(as, OPCODE_PUSH_I64);
    asm_x64_write_word32(as, src_i32); // will be sign extended to 64 bits
}
281
*/
Damien's avatar
Damien committed
282

283
void asm_x64_push_disp(asm_x64_t *as, int src_r64, int src_offset) {
284
    assert(src_r64 < 8);
Damien's avatar
Damien committed
285
286
287
288
    asm_x64_write_byte_1(as, OPCODE_PUSH_M64);
    asm_x64_write_r64_disp(as, 6, src_r64, src_offset);
}

289
void asm_x64_pop_r64(asm_x64_t *as, int dest_r64) {
290
291
292
293
294
    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
295
296
}

297
STATIC void asm_x64_ret(asm_x64_t *as) {
Damien's avatar
Damien committed
298
299
300
    asm_x64_write_byte_1(as, OPCODE_RET);
}

301
void asm_x64_mov_r32_to_r32(asm_x64_t *as, int src_r32, int dest_r32) {
Damien's avatar
Damien committed
302
    // defaults to 32 bit operation
303
304
    assert(src_r32 < 8);
    assert(dest_r32 < 8);
Damien's avatar
Damien committed
305
306
307
    asm_x64_write_byte_2(as, OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r32) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
}

308
void asm_x64_mov_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
Damien's avatar
Damien committed
309
    // use REX prefix for 64 bit operation
310
    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
311
312
}

313
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
314
    // use REX prefix for 64 bit operation
315
316
    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
317
318
319
    asm_x64_write_r64_disp(as, src_r64, dest_r64, dest_disp);
}

320
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
321
    // use REX prefix for 64 bit operation
322
323
    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
324
325
326
    asm_x64_write_r64_disp(as, dest_r64, src_r64, src_disp);
}

327
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
328
    // use REX prefix for 64 bit operation
329
330
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
331
332
333
334
335
    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) {
336
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
337
338
339
    asm_x64_write_byte_2(as, OPCODE_MOV_I8_TO_R8 | dest_r64, src_i8);
}

340
STATIC void asm_x64_mov_i32_to_r64(asm_x64_t *as, int src_i32, int dest_r64) {
Damien's avatar
Damien committed
341
    // cpu defaults to i32 to r64, with zero extension
342
343
344
345
346
    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
347
348
349
    asm_x64_write_word32(as, src_i32);
}

350
void asm_x64_mov_i64_to_r64(asm_x64_t *as, int64_t src_i64, int dest_r64) {
Damien's avatar
Damien committed
351
352
    // cpu defaults to i32 to r64
    // to mov i64 to r64 need to use REX prefix
353
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
354
355
356
357
358
359
360
361
362
363
364
365
366
367
    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) {
    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);
    }
}

368
369
370
371
372
373
374
375
376
// 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
377
void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
378
379
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
380
381
382
    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));
}

383
void asm_x64_add_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
384
385
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
386
387
388
    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));
}

389
/*
390
void asm_x64_add_i32_to_r32(asm_x64_t *as, int src_i32, int dest_r32)
Damien's avatar
Damien committed
391
392
393
394
395
396
397
398
399
400
401
402
403
{
    assert(dest_r32 != REG_RSP); // in this case i think src_i32 must be 64 bits
    if (SIGNED_FIT8(src_i32))
    {
        asm_x64_write_byte_2(as, OPCODE_ADD_I8_TO_RM32, MODRM_R64(0) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
        asm_x64_write_byte_1(as, src_i32 & 0xff);
    }
    else
    {
        asm_x64_write_byte_2(as, OPCODE_ADD_I32_TO_RM32, MODRM_R64(0) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
        asm_x64_write_word32(as, src_i32);
    }
}
404
*/
Damien's avatar
Damien committed
405

406
/*
407
void asm_x64_sub_r32_from_r32(asm_x64_t *as, int src_r32, int dest_r32) {
Damien's avatar
Damien committed
408
409
410
    // 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));
}
411
*/
Damien's avatar
Damien committed
412

413
void asm_x64_sub_r64_from_r64(asm_x64_t *as, int src_r64, int dest_r64) {
Damien's avatar
Damien committed
414
    // use REX prefix for 64 bit operation
415
416
    assert(src_r64 < 8);
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
417
418
419
    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));
}

420
/*
421
void asm_x64_sub_i32_from_r32(asm_x64_t *as, int src_i32, int dest_r32) {
Damien's avatar
Damien committed
422
423
424
425
426
427
428
429
430
431
    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);
    }
}
432
*/
Damien's avatar
Damien committed
433

434
void asm_x64_sub_i32_from_r64(asm_x64_t *as, int src_i32, int dest_r64) {
435
    assert(dest_r64 < 8);
Damien's avatar
Damien committed
436
437
438
439
440
441
442
443
444
445
446
    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);
    }
}

447
/*
448
void asm_x64_shl_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
449
450
451
452
    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);
}

453
void asm_x64_shr_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
454
455
456
457
    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);
}

458
void asm_x64_sar_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
459
460
461
    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);
}
462
*/
Damien's avatar
Damien committed
463

464
void asm_x64_cmp_r64_with_r64(asm_x64_t *as, int src_r64_a, int src_r64_b) {
465
466
    assert(src_r64_a < 8);
    assert(src_r64_b < 8);
Damien's avatar
Damien committed
467
468
469
    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));
}

470
/*
471
void asm_x64_cmp_i32_with_r32(asm_x64_t *as, int src_i32, int src_r32) {
Damien's avatar
Damien committed
472
473
474
475
476
477
478
479
    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);
    }
}
480
*/
Damien's avatar
Damien committed
481

482
void asm_x64_test_r8_with_r8(asm_x64_t *as, int src_r64_a, int src_r64_b) {
Damien's avatar
Damien committed
483
484
485
    // TODO implement for other registers
    assert(src_r64_a == REG_RAX);
    assert(src_r64_b == REG_RAX);
Damien's avatar
Damien committed
486
487
488
    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));
}

489
void asm_x64_setcc_r8(asm_x64_t *as, int jcc_type, int dest_r8) {
490
    assert(dest_r8 < 8);
Damien's avatar
Damien committed
491
492
493
    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));
}

494
void asm_x64_label_assign(asm_x64_t *as, int label) {
495
    assert(label < as->max_num_labels);
496
    if (as->pass < ASM_X64_PASS_EMIT) {
497
498
499
        // assign label offset
        assert(as->label_offsets[label] == -1);
        as->label_offsets[label] = as->code_offset;
500
501
    } else {
        // ensure label offset has not changed from PASS_COMPUTE to PASS_EMIT
502
503
        //printf("l%d: (at %d=%ld)\n", label, as->label_offsets[label], as->code_offset);
        assert(as->label_offsets[label] == as->code_offset);
Damien's avatar
Damien committed
504
505
506
    }
}

507
STATIC int get_label_dest(asm_x64_t *as, int label) {
508
509
510
511
512
513
514
515
516
517
518
519
520
    assert(label < as->max_num_labels);
    return as->label_offsets[label];
}

void asm_x64_jmp_label(asm_x64_t *as, int label) {
    int dest = get_label_dest(as, label);
    int rel = dest - as->code_offset;
    if (dest >= 0 && rel < 0) {
        // 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
521
        } else {
522
523
            rel += 2;
            goto large_jump;
Damien's avatar
Damien committed
524
        }
525
526
527
528
529
530
    } 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
531
532
533
    }
}

534
535
536
537
538
539
540
541
542
void asm_x64_jcc_label(asm_x64_t *as, int jcc_type, int label) {
    int dest = get_label_dest(as, label);
    int rel = dest - as->code_offset;
    if (dest >= 0 && rel < 0) {
        // 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
543
        } else {
544
545
            rel += 2;
            goto large_jump;
Damien's avatar
Damien committed
546
        }
547
548
549
550
551
552
    } 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
553
554
555
    }
}

556
void asm_x64_entry(asm_x64_t *as, int num_locals) {
Damien's avatar
Damien committed
557
558
559
560
561
562
563
564
    asm_x64_push_r64(as, REG_RBP);
    asm_x64_mov_r64_to_r64(as, REG_RSP, REG_RBP);
    if (num_locals < 0) {
        num_locals = 0;
    }
    num_locals |= 1; // make it odd so stack is aligned on 16 byte boundary
    asm_x64_sub_i32_from_r64(as, num_locals * WORD_SIZE, REG_RSP);
    asm_x64_push_r64(as, REG_RBX);
565
566
    asm_x64_push_r64(as, REG_R12);
    asm_x64_push_r64(as, REG_R13);
567
    as->num_locals = num_locals;
Damien's avatar
Damien committed
568
569
}

570
void asm_x64_exit(asm_x64_t *as) {
571
572
    asm_x64_pop_r64(as, REG_R13);
    asm_x64_pop_r64(as, REG_R12);
Damien's avatar
Damien committed
573
574
575
576
577
    asm_x64_pop_r64(as, REG_RBX);
    asm_x64_write_byte_1(as, OPCODE_LEAVE);
    asm_x64_ret(as);
}

578
579
580
581
582
583
584
585
586
587
588
// 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
//
589
STATIC int asm_x64_local_offset_from_ebp(asm_x64_t *as, int local_num) {
590
    return (-as->num_locals + local_num) * WORD_SIZE;
Damien's avatar
Damien committed
591
592
}

593
594
void asm_x64_mov_local_to_r64(asm_x64_t *as, int src_local_num, int dest_r64) {
    asm_x64_mov_disp_to_r64(as, REG_RBP, asm_x64_local_offset_from_ebp(as, src_local_num), dest_r64);
Damien's avatar
Damien committed
595
596
}

597
598
void asm_x64_mov_r64_to_local(asm_x64_t *as, int src_r64, int dest_local_num) {
    asm_x64_mov_r64_to_disp(as, src_r64, REG_RBP, asm_x64_local_offset_from_ebp(as, dest_local_num));
Damien's avatar
Damien committed
599
600
}

601
602
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
603
604
605
606
607
608
609
    if (offset == 0) {
        asm_x64_mov_r64_to_r64(as, REG_RBP, dest_r64);
    } else {
        asm_x64_lea_disp_to_r64(as, REG_RBP, offset, dest_r64);
    }
}

610
/*
611
612
void asm_x64_push_local(asm_x64_t *as, int local_num) {
    asm_x64_push_disp(as, REG_RBP, asm_x64_local_offset_from_ebp(as, local_num));
Damien's avatar
Damien committed
613
614
}

615
void asm_x64_push_local_addr(asm_x64_t *as, int local_num, int temp_r64)
Damien's avatar
Damien committed
616
617
{
    asm_x64_mov_r64_to_r64(as, REG_RBP, temp_r64);
618
    asm_x64_add_i32_to_r32(as, asm_x64_local_offset_from_ebp(as, local_num), temp_r64);
Damien's avatar
Damien committed
619
620
    asm_x64_push_r64(as, temp_r64);
}
621
*/
Damien's avatar
Damien committed
622
623
624
625

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

626
void asm_x64_call(asm_x64_t *as, void* func)
Damien's avatar
Damien committed
627
628
629
630
631
632
633
{
    asm_x64_sub_i32_from_r32(as, 8, REG_RSP);
    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
    asm_x64_write_word32(as, func - (void*)(as->code_cur + 4));
    asm_x64_mov_r64_to_r64(as, REG_RBP, REG_RSP);
}

634
void asm_x64_call_i1(asm_x64_t *as, void* func, int i1)
Damien's avatar
Damien committed
635
636
637
638
639
640
641
642
643
644
645
{
    asm_x64_sub_i32_from_r32(as, 8, REG_RSP);
    asm_x64_sub_i32_from_r32(as, 12, REG_RSP);
    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));
    asm_x64_add_i32_to_r32(as, 16, REG_RSP);
    asm_x64_mov_r64_to_r64(as, REG_RBP, REG_RSP);
}
*/

646
void asm_x64_call_ind(asm_x64_t *as, void *ptr, int temp_r64) {
647
    assert(temp_r64 < 8);
648
649
650
651
652
653
#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
654
655
    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
656
657
    // doesn't work anymore because calls are 64 bits away
    /*
Damien's avatar
Damien committed
658
659
    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
    asm_x64_write_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4));
660
    */
Damien's avatar
Damien committed
661
}
662
663

#endif // MICROPY_EMIT_X64