asmx64.c 23 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
40
41
42
#include <sys/types.h>
#include <sys/mman.h>

#include "asmx64.h"

43
#if defined(__OpenBSD__) || defined(__MACH__)
44
45
46
#define MAP_ANONYMOUS MAP_ANON
#endif

Damien's avatar
Damien committed
47
48
49
50
51
52
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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
/* all offsets are measured in multiples of 8 bytes */
#define WORD_SIZE                (8)

#define OPCODE_NOP               (0x90)
#define OPCODE_PUSH_R64          (0x50)
#define OPCODE_PUSH_I64          (0x68)
#define OPCODE_PUSH_M64          (0xff) /* /6 */
#define OPCODE_POP_R64           (0x58)
#define OPCODE_RET               (0xc3)
#define OPCODE_MOV_I8_TO_R8      (0xb0) /* +rb */
#define OPCODE_MOV_I64_TO_R64    (0xb8)
#define OPCODE_MOV_I32_TO_RM32   (0xc7)
#define OPCODE_MOV_R64_TO_RM64   (0x89)
#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)

#define MODRM_R64(x)    ((x) << 3)
#define MODRM_RM_DISP0  (0x00)
#define MODRM_RM_DISP8  (0x40)
#define MODRM_RM_DISP32 (0x80)
#define MODRM_RM_REG    (0xc0)
#define MODRM_RM_R64(x) (x)

#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 {
115
    uint pass;
Damien's avatar
Damien committed
116
117
118
119
120
    uint code_offset;
    uint code_size;
    byte *code_base;
    byte dummy_data[8];

121
    uint max_num_labels;
Damien's avatar
Damien committed
122
    int *label_offsets;
123
    int num_locals;
Damien's avatar
Damien committed
124
125
126
127
128
129
130
131
132
133
134
135
136
137
};

// for allocating memory, see src/v8/src/platform-linux.cc
void *alloc_mem(uint req_size, uint *alloc_size, bool is_exec) {
    req_size = (req_size + 0xfff) & (~0xfff);
    int prot = PROT_READ | PROT_WRITE | (is_exec ? PROT_EXEC : 0);
    void *ptr = mmap(NULL, req_size, prot, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
    if (ptr == MAP_FAILED) {
        assert(0);
    }
    *alloc_size = req_size;
    return ptr;
}

138
139
asm_x64_t *asm_x64_new(uint max_num_labels) {
    asm_x64_t *as;
Damien's avatar
Damien committed
140

141
    as = m_new0(asm_x64_t, 1);
142
143
    as->max_num_labels = max_num_labels;
    as->label_offsets = m_new(int, max_num_labels);
Damien's avatar
Damien committed
144
145
146
147

    return as;
}

148
void asm_x64_free(asm_x64_t *as, bool free_code) {
Damien's avatar
Damien committed
149
    if (free_code) {
150
151
        // need to un-mmap
        //m_free(as->code_base);
Damien's avatar
Damien committed
152
153
154
155
156
157
158
159
160
161
162
163
164
    }
    /*
    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);
    }
    */
165
    m_del_obj(asm_x64_t, as);
Damien's avatar
Damien committed
166
167
}

168
void asm_x64_start_pass(asm_x64_t *as, uint pass) {
Damien's avatar
Damien committed
169
170
    as->pass = pass;
    as->code_offset = 0;
171
    if (pass == ASM_X64_PASS_COMPUTE) {
172
173
        // reset all labels
        memset(as->label_offsets, -1, as->max_num_labels * sizeof(int));
Damien's avatar
Damien committed
174
175
176
177
    }
}

void asm_x64_end_pass(asm_x64_t *as) {
178
    if (as->pass == ASM_X64_PASS_COMPUTE) {
Damien's avatar
Damien committed
179
180
        // calculate size of code in bytes
        as->code_size = as->code_offset;
181
182
183
        //as->code_base = m_new(byte, as->code_size); need to allocale executable memory
        uint actual_alloc;
        as->code_base = alloc_mem(as->code_size, &actual_alloc, true);
184
        //printf("code_size: %u\n", as->code_size);
Damien's avatar
Damien committed
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
    }

    /*
    // 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
200
STATIC byte *asm_x64_get_cur_to_write_bytes(asm_x64_t *as, int num_bytes_to_write) {
Damien's avatar
Damien committed
201
    //printf("emit %d\n", num_bytes_to_write);
202
    if (as->pass < ASM_X64_PASS_EMIT) {
Damien's avatar
Damien committed
203
204
205
206
207
208
209
210
211
212
        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;
    }
}

213
uint asm_x64_get_code_size(asm_x64_t *as) {
Damien's avatar
Damien committed
214
215
216
    return as->code_size;
}

217
void *asm_x64_get_code(asm_x64_t *as) {
Damien's avatar
Damien committed
218
219
220
    return as->code_base;
}

221
STATIC void asm_x64_write_byte_1(asm_x64_t *as, byte b1) {
Damien's avatar
Damien committed
222
223
224
225
    byte* c = asm_x64_get_cur_to_write_bytes(as, 1);
    c[0] = b1;
}

226
STATIC void asm_x64_write_byte_2(asm_x64_t *as, byte b1, byte b2) {
Damien's avatar
Damien committed
227
228
229
230
231
    byte* c = asm_x64_get_cur_to_write_bytes(as, 2);
    c[0] = b1;
    c[1] = b2;
}

232
STATIC void asm_x64_write_byte_3(asm_x64_t *as, byte b1, byte b2, byte b3) {
Damien's avatar
Damien committed
233
234
235
236
237
238
    byte* c = asm_x64_get_cur_to_write_bytes(as, 3);
    c[0] = b1;
    c[1] = b2;
    c[2] = b3;
}

239
STATIC void asm_x64_write_word32(asm_x64_t *as, int w32) {
Damien's avatar
Damien committed
240
241
242
243
244
245
246
    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);
}

247
STATIC void asm_x64_write_word64(asm_x64_t *as, int64_t w64) {
Damien's avatar
Damien committed
248
249
250
251
252
253
254
255
256
257
258
259
    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
260
STATIC void asm_x64_write_word32_to(asm_x64_t *as, int offset, int w32) {
Damien's avatar
Damien committed
261
262
263
264
265
266
267
268
269
270
    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);
}
*/

271
STATIC void asm_x64_write_r64_disp(asm_x64_t *as, int r64, int disp_r64, int disp_offset) {
Damien's avatar
Damien committed
272
273
274
275
276
277
278
279
280
281
282
283
    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);
    }
}

284
void asm_x64_nop(asm_x64_t *as) {
Damien's avatar
Damien committed
285
286
287
    asm_x64_write_byte_1(as, OPCODE_NOP);
}

288
void asm_x64_push_r64(asm_x64_t *as, int src_r64) {
Damien's avatar
Damien committed
289
290
291
    asm_x64_write_byte_1(as, OPCODE_PUSH_R64 | src_r64);
}

292
void asm_x64_push_i32(asm_x64_t *as, int src_i32) {
Damien's avatar
Damien committed
293
294
295
296
    asm_x64_write_byte_1(as, OPCODE_PUSH_I64);
    asm_x64_write_word32(as, src_i32); // will be sign extended to 64 bits
}

297
void asm_x64_push_disp(asm_x64_t *as, int src_r64, int src_offset) {
Damien's avatar
Damien committed
298
299
300
301
    asm_x64_write_byte_1(as, OPCODE_PUSH_M64);
    asm_x64_write_r64_disp(as, 6, src_r64, src_offset);
}

302
void asm_x64_pop_r64(asm_x64_t *as, int dest_r64) {
Damien's avatar
Damien committed
303
304
305
    asm_x64_write_byte_1(as, OPCODE_POP_R64 | dest_r64);
}

306
STATIC void asm_x64_ret(asm_x64_t *as) {
Damien's avatar
Damien committed
307
308
309
    asm_x64_write_byte_1(as, OPCODE_RET);
}

310
void asm_x64_mov_r32_to_r32(asm_x64_t *as, int src_r32, int dest_r32) {
Damien's avatar
Damien committed
311
312
313
314
    // defaults to 32 bit operation
    asm_x64_write_byte_2(as, OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r32) | MODRM_RM_REG | MODRM_RM_R64(dest_r32));
}

315
void asm_x64_mov_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
Damien's avatar
Damien committed
316
317
318
319
    // use REX prefix for 64 bit operation
    asm_x64_write_byte_3(as, REX_PREFIX | REX_W, OPCODE_MOV_R64_TO_RM64, MODRM_R64(src_r64) | MODRM_RM_REG | MODRM_RM_R64(dest_r64));
}

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

326
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
327
328
329
330
331
    // use REX prefix for 64 bit operation
    asm_x64_write_byte_2(as, REX_PREFIX | REX_W, OPCODE_MOV_RM64_TO_R64);
    asm_x64_write_r64_disp(as, dest_r64, src_r64, src_disp);
}

332
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
333
334
335
336
337
338
339
340
341
    // use REX prefix for 64 bit operation
    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) {
    asm_x64_write_byte_2(as, OPCODE_MOV_I8_TO_R8 | dest_r64, src_i8);
}

342
void asm_x64_mov_i32_to_r64(asm_x64_t *as, int src_i32, int dest_r64) {
Damien's avatar
Damien committed
343
344
345
346
347
    // cpu defaults to i32 to r64, with zero extension
    asm_x64_write_byte_1(as, OPCODE_MOV_I64_TO_R64 | dest_r64);
    asm_x64_write_word32(as, src_i32);
}

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

365
366
367
368
369
370
371
372
373
// 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);
}

374
void asm_x64_mov_i32_to_disp(asm_x64_t *as, int src_i32, int dest_r32, int dest_disp)
Damien's avatar
Damien committed
375
376
377
378
379
380
381
382
383
384
385
{
    assert(0);
    asm_x64_write_byte_1(as, OPCODE_MOV_I32_TO_RM32);
    //asm_x64_write_r32_disp(as, 0, dest_r32, dest_disp);
    asm_x64_write_word32(as, src_i32);
}

void asm_x64_xor_r64_to_r64(asm_x64_t *as, int src_r64, int dest_r64) {
    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) {
Damien's avatar
Damien committed
387
388
389
    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));
}

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
404
{
    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);
    }
}

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

410
void asm_x64_sub_r64_from_r64(asm_x64_t *as, int src_r64, int dest_r64) {
Damien's avatar
Damien committed
411
412
413
414
    // use REX prefix for 64 bit operation
    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));
}

415
void asm_x64_sub_i32_from_r32(asm_x64_t *as, int src_i32, int dest_r32) {
Damien's avatar
Damien committed
416
417
418
419
420
421
422
423
424
425
426
    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);
    }
}

427
void asm_x64_sub_i32_from_r64(asm_x64_t *as, int src_i32, int dest_r64) {
Damien's avatar
Damien committed
428
429
430
431
432
433
434
435
436
437
438
439
    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);
    }
}

/* shifts not tested */
440
void asm_x64_shl_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
441
442
443
444
    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);
}

445
void asm_x64_shr_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
446
447
448
449
    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);
}

450
void asm_x64_sar_r32_by_imm(asm_x64_t *as, int r32, int imm) {
Damien's avatar
Damien committed
451
452
453
454
    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);
}

455
void asm_x64_cmp_r64_with_r64(asm_x64_t *as, int src_r64_a, int src_r64_b) {
Damien's avatar
Damien committed
456
457
458
    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));
}

459
void asm_x64_cmp_r32_with_disp(asm_x64_t *as, int src_r32_a, int src_r32_b, int src_disp_b) {
Damien's avatar
Damien committed
460
461
462
463
464
    assert(0);
    asm_x64_write_byte_1(as, OPCODE_CMP_R64_WITH_RM64);
    //asm_x64_write_r32_disp(as, src_r32_a, src_r32_b, src_disp_b);
}

465
void asm_x64_cmp_disp_with_r32(asm_x64_t *as, int src_r32_a, int src_disp_a, int src_r32_b) {
Damien's avatar
Damien committed
466
467
468
469
470
    assert(0);
    asm_x64_write_byte_1(as, OPCODE_CMP_RM32_WITH_R32);
    //asm_x64_write_r32_disp(as, src_r32_b, src_r32_a, src_disp_a);
}

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
480
    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);
    }
}

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

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

492
void asm_x64_label_assign(asm_x64_t *as, int label) {
493
    assert(label < as->max_num_labels);
494
    if (as->pass < ASM_X64_PASS_EMIT) {
495
496
497
        // assign label offset
        assert(as->label_offsets[label] == -1);
        as->label_offsets[label] = as->code_offset;
498
499
    } else {
        // ensure label offset has not changed from PASS_COMPUTE to PASS_EMIT
500
501
        //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
502
503
504
    }
}

505
STATIC int get_label_dest(asm_x64_t *as, int label) {
506
507
508
509
510
511
512
513
514
515
516
517
518
    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
519
        } else {
520
521
            rel += 2;
            goto large_jump;
Damien's avatar
Damien committed
522
        }
523
524
525
526
527
528
    } 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
529
530
531
    }
}

532
533
534
535
536
537
538
539
540
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
541
        } else {
542
543
            rel += 2;
            goto large_jump;
Damien's avatar
Damien committed
544
        }
545
546
547
548
549
550
    } 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
551
552
553
    }
}

554
void asm_x64_entry(asm_x64_t *as, int num_locals) {
Damien's avatar
Damien committed
555
556
557
558
559
560
561
562
    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);
563
    as->num_locals = num_locals;
Damien's avatar
Damien committed
564
565
}

566
void asm_x64_exit(asm_x64_t *as) {
Damien's avatar
Damien committed
567
568
569
570
571
    asm_x64_pop_r64(as, REG_RBX);
    asm_x64_write_byte_1(as, OPCODE_LEAVE);
    asm_x64_ret(as);
}

572
void asm_x64_push_arg(asm_x64_t *as, int src_arg_num) {
Damien's avatar
Damien committed
573
574
575
576
    assert(0);
    asm_x64_push_disp(as, REG_RBP, 8 + src_arg_num * WORD_SIZE);
}

577
void asm_x64_mov_arg_to_r32(asm_x64_t *as, int src_arg_num, int dest_r32) {
Damien's avatar
Damien committed
578
579
580
581
    assert(0);
    //asm_x64_mov_disp_to_r32(as, REG_RBP, 8 + src_arg_num * WORD_SIZE, dest_r32);
}

582
void asm_x64_mov_r32_to_arg(asm_x64_t *as, int src_r32, int dest_arg_num) {
Damien's avatar
Damien committed
583
584
585
586
    assert(0);
    //asm_x64_mov_r32_to_disp(as, src_r32, REG_RBP, 8 + dest_arg_num * WORD_SIZE);
}

587
588
589
590
591
592
593
594
595
596
597
// 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
//
598
STATIC int asm_x64_local_offset_from_ebp(asm_x64_t *as, int local_num) {
599
    return (-as->num_locals + local_num) * WORD_SIZE;
Damien's avatar
Damien committed
600
601
}

602
603
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
604
605
}

606
607
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
608
609
}

610
611
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
612
613
614
615
616
617
618
    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);
    }
}

619
620
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
621
622
}

623
void asm_x64_push_local_addr(asm_x64_t *as, int local_num, int temp_r64)
Damien's avatar
Damien committed
624
625
{
    asm_x64_mov_r64_to_r64(as, REG_RBP, temp_r64);
626
    asm_x64_add_i32_to_r32(as, asm_x64_local_offset_from_ebp(as, local_num), temp_r64);
Damien's avatar
Damien committed
627
628
629
630
631
632
    asm_x64_push_r64(as, temp_r64);
}

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

633
void asm_x64_call(asm_x64_t *as, void* func)
Damien's avatar
Damien committed
634
635
636
637
638
639
640
{
    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);
}

641
void asm_x64_call_i1(asm_x64_t *as, void* func, int i1)
Damien's avatar
Damien committed
642
643
644
645
646
647
648
649
650
651
652
{
    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);
}
*/

653
void asm_x64_call_ind(asm_x64_t *as, void *ptr, int temp_r64) {
654
655
656
657
658
659
#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
660
661
    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
662
663
    // doesn't work anymore because calls are 64 bits away
    /*
Damien's avatar
Damien committed
664
665
    asm_x64_write_byte_1(as, OPCODE_CALL_REL32);
    asm_x64_write_word32(as, ptr - (void*)(as->code_base + as->code_offset + 4));
666
    */
Damien's avatar
Damien committed
667
}
668
669

#endif // MICROPY_EMIT_X64