emitnative.c 61.9 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.
 */

27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
// Essentially normal Python has 1 type: Python objects
// Viper has more than 1 type, and is just a more complicated (a superset of) Python.
// If you declare everything in Viper as a Python object (ie omit type decls) then
// it should in principle be exactly the same as Python native.
// Having types means having more opcodes, like binary_op_nat_nat, binary_op_nat_obj etc.
// In practice we won't have a VM but rather do this in asm which is actually very minimal.

// Because it breaks strict Python equivalence it should be a completely separate
// decorator.  It breaks equivalence because overflow on integers wraps around.
// It shouldn't break equivalence if you don't use the new types, but since the
// type decls might be used in normal Python for other reasons, it's probably safest,
// cleanest and clearest to make it a separate decorator.

// Actually, it does break equivalence because integers default to native integers,
// not Python objects.

// for x in l[0:8]: can be compiled into a native loop if l has pointer type

xbe's avatar
xbe committed
45
#include <stdbool.h>
46
47
48
49
50
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>

51
#include "mpconfig.h"
52
#include "nlr.h"
53
#include "misc.h"
54
#include "qstr.h"
55
56
#include "lexer.h"
#include "parse.h"
57
58
#include "obj.h"
#include "emitglue.h"
59
#include "scope.h"
60
#include "runtime0.h"
61
#include "emit.h"
62
#include "runtime.h"
63

64
65
66
67
68
69
70
#if 0 // print debugging info
#define DEBUG_PRINT (1)
#define DEBUG_printf DEBUG_printf
#else // don't print debugging info
#define DEBUG_printf(...) (void)0
#endif

71
// wrapper around everything in this file
Fabian Vogt's avatar
Fabian Vogt committed
72
#if (MICROPY_EMIT_X64 && N_X64) || (MICROPY_EMIT_THUMB && N_THUMB) || (MICROPY_EMIT_ARM && N_ARM)
73

74
#if N_X64
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

// x64 specific stuff

#include "asmx64.h"

#define REG_LOCAL_1 (REG_RBX)
#define REG_LOCAL_NUM (1)

#define EXPORT_FUN(name) emit_native_x64_##name

#define REG_TEMP0 (REG_RAX)
#define REG_TEMP1 (REG_RDI)
#define REG_TEMP2 (REG_RSI)
#define ASM_MOV_REG_TO_LOCAL(reg, local_num) asm_x64_mov_r64_to_local(emit->as, (reg), (local_num))
#define ASM_MOV_IMM_TO_REG(imm, reg) asm_x64_mov_i64_to_r64_optimised(emit->as, (imm), (reg))
90
#define ASM_MOV_ALIGNED_IMM_TO_REG(imm, reg) asm_x64_mov_i64_to_r64_aligned(emit->as, (imm), (reg))
91
#define ASM_MOV_IMM_TO_LOCAL_USING(imm, local_num, reg_temp) do { asm_x64_mov_i64_to_r64_optimised(emit->as, (imm), (reg_temp)); asm_x64_mov_r64_to_local(emit->as, (reg_temp), (local_num)); } while (false)
92
93
94
95
#define ASM_MOV_LOCAL_TO_REG(local_num, reg) asm_x64_mov_local_to_r64(emit->as, (local_num), (reg))
#define ASM_MOV_REG_TO_REG(reg_src, reg_dest) asm_x64_mov_r64_to_r64(emit->as, (reg_src), (reg_dest))
#define ASM_MOV_LOCAL_ADDR_TO_REG(local_num, reg) asm_x64_mov_local_addr_to_r64(emit->as, (local_num), (reg))

96
#elif N_THUMB
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

// thumb specific stuff

#include "asmthumb.h"

#define REG_LOCAL_1 (REG_R4)
#define REG_LOCAL_2 (REG_R5)
#define REG_LOCAL_3 (REG_R6)
#define REG_LOCAL_NUM (3)

#define EXPORT_FUN(name) emit_native_thumb_##name

#define REG_TEMP0 (REG_R0)
#define REG_TEMP1 (REG_R1)
#define REG_TEMP2 (REG_R2)
#define ASM_MOV_REG_TO_LOCAL(reg, local_num) asm_thumb_mov_local_reg(emit->as, (local_num), (reg))
#define ASM_MOV_IMM_TO_REG(imm, reg) asm_thumb_mov_reg_i32_optimised(emit->as, (reg), (imm))
114
#define ASM_MOV_ALIGNED_IMM_TO_REG(imm, reg) asm_thumb_mov_reg_i32_aligned(emit->as, (reg), (imm))
115
#define ASM_MOV_IMM_TO_LOCAL_USING(imm, local_num, reg_temp) do { asm_thumb_mov_reg_i32_optimised(emit->as, (reg_temp), (imm)); asm_thumb_mov_local_reg(emit->as, (local_num), (reg_temp)); } while (false)
116
117
118
119
#define ASM_MOV_LOCAL_TO_REG(local_num, reg) asm_thumb_mov_reg_local(emit->as, (reg), (local_num))
#define ASM_MOV_REG_TO_REG(reg_src, reg_dest) asm_thumb_mov_reg_reg(emit->as, (reg_dest), (reg_src))
#define ASM_MOV_LOCAL_ADDR_TO_REG(local_num, reg) asm_thumb_mov_reg_local_addr(emit->as, (reg), (local_num))

Fabian Vogt's avatar
Fabian Vogt committed
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
#elif N_ARM

// ARM specific stuff

#include "asmarm.h"

#define REG_LOCAL_1 (REG_R4)
#define REG_LOCAL_2 (REG_R5)
#define REG_LOCAL_3 (REG_R6)
#define REG_LOCAL_NUM (3)

#define EXPORT_FUN(name) emit_native_arm_##name

#define REG_TEMP0 (REG_R0)
#define REG_TEMP1 (REG_R1)
#define REG_TEMP2 (REG_R2)
#define ASM_MOV_REG_TO_LOCAL(reg, local_num) asm_arm_mov_local_reg(emit->as, (local_num), (reg))
#define ASM_MOV_IMM_TO_REG(imm, reg) asm_arm_mov_reg_i32(emit->as, (reg), (imm))
#define ASM_MOV_ALIGNED_IMM_TO_REG(imm, reg) asm_arm_mov_reg_i32(emit->as, (reg), (imm))
#define ASM_MOV_IMM_TO_LOCAL_USING(imm, local_num, reg_temp) do { asm_arm_mov_reg_i32(emit->as, (reg_temp), (imm)); asm_arm_mov_local_reg(emit->as, (local_num), (reg_temp)); } while (false)
#define ASM_MOV_LOCAL_TO_REG(local_num, reg) asm_arm_mov_reg_local(emit->as, (reg), (local_num))
#define ASM_MOV_REG_TO_REG(reg_src, reg_dest) asm_arm_mov_reg_reg(emit->as, (reg_dest), (reg_src))
#define ASM_MOV_LOCAL_ADDR_TO_REG(local_num, reg) asm_arm_mov_reg_local_addr(emit->as, (reg), (local_num))

144
145
146
#endif

typedef enum {
147
148
149
150
    STACK_VALUE,
    STACK_REG,
    STACK_IMM,
} stack_info_kind_t;
151
152

typedef enum {
153
154
155
156
    VTYPE_PYOBJ = MP_NATIVE_TYPE_OBJ,
    VTYPE_BOOL = MP_NATIVE_TYPE_BOOL,
    VTYPE_INT = MP_NATIVE_TYPE_INT,
    VTYPE_UINT = MP_NATIVE_TYPE_UINT,
157
158
159
160
161
162
    VTYPE_UNBOUND,
    VTYPE_PTR,
    VTYPE_PTR_NONE,
    VTYPE_BUILTIN_V_INT,
} vtype_kind_t;

163
164
165
166
167
typedef struct _stack_info_t {
    vtype_kind_t vtype;
    stack_info_kind_t kind;
    union {
        int u_reg;
168
        mp_int_t u_imm;
169
170
171
    };
} stack_info_t;

172
173
174
175
struct _emit_t {
    int pass;

    bool do_viper_types;
176

177
178
    vtype_kind_t return_vtype;

179
    uint local_vtype_alloc;
180
    vtype_kind_t *local_vtype;
181

182
    uint stack_info_alloc;
183
184
    stack_info_t *stack_info;

185
186
187
188
189
190
191
    int stack_start;
    int stack_size;

    bool last_emit_was_return_value;

    scope_t *scope;

192
#if N_X64
193
    asm_x64_t *as;
194
#elif N_THUMB
195
    asm_thumb_t *as;
Fabian Vogt's avatar
Fabian Vogt committed
196
197
#elif N_ARM
    asm_arm_t *as;
198
199
200
201
#endif
};

emit_t *EXPORT_FUN(new)(uint max_num_labels) {
202
    emit_t *emit = m_new0(emit_t, 1);
203
#if N_X64
204
    emit->as = asm_x64_new(max_num_labels);
205
#elif N_THUMB
206
    emit->as = asm_thumb_new(max_num_labels);
Fabian Vogt's avatar
Fabian Vogt committed
207
208
#elif N_ARM
    emit->as = asm_arm_new(max_num_labels);
209
210
211
212
#endif
    return emit;
}

213
void EXPORT_FUN(free)(emit_t *emit) {
214
215
216
217
#if N_X64
    asm_x64_free(emit->as, false);
#elif N_THUMB
    asm_thumb_free(emit->as, false);
Fabian Vogt's avatar
Fabian Vogt committed
218
219
#elif N_ARM
    asm_arm_free(emit->as, false);
220
#endif
221
222
    m_del(vtype_kind_t, emit->local_vtype, emit->local_vtype_alloc);
    m_del(stack_info_t, emit->stack_info, emit->stack_info_alloc);
223
224
225
    m_del_obj(emit_t, emit);
}

226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
STATIC void emit_native_set_native_type(emit_t *emit, mp_uint_t op, mp_uint_t arg1, qstr arg2) {
    switch (op) {
        case MP_EMIT_NATIVE_TYPE_ENABLE:
            emit->do_viper_types = arg1;
            break;

        default: {
            vtype_kind_t type;
            switch (arg2) {
                case MP_QSTR_object: type = VTYPE_PYOBJ; break;
                case MP_QSTR_bool: type = VTYPE_BOOL; break;
                case MP_QSTR_int: type = VTYPE_INT; break;
                case MP_QSTR_uint: type = VTYPE_UINT; break;
                default: printf("ViperTypeError: unknown type %s\n", qstr_str(arg2)); return;
            }
            if (op == MP_EMIT_NATIVE_TYPE_RETURN) {
                emit->return_vtype = type;
            } else {
                assert(arg1 < emit->local_vtype_alloc);
                emit->local_vtype[arg1] = type;
            }
            break;
        }
    }
250
251
}

252
STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
253
254
255
256
257
258
    emit->pass = pass;
    emit->stack_start = 0;
    emit->stack_size = 0;
    emit->last_emit_was_return_value = false;
    emit->scope = scope;

259
260
261
262
    // allocate memory for keeping track of the types of locals
    if (emit->local_vtype_alloc < scope->num_locals) {
        emit->local_vtype = m_renew(vtype_kind_t, emit->local_vtype, emit->local_vtype_alloc, scope->num_locals);
        emit->local_vtype_alloc = scope->num_locals;
263
    }
264
265
266

    // allocate memory for keeping track of the objects on the stack
    // XXX don't know stack size on entry, and it should be maximum over all scopes
267
    if (emit->stack_info == NULL) {
268
        emit->stack_info_alloc = scope->stack_size + 50;
269
        emit->stack_info = m_new(stack_info_t, emit->stack_info_alloc);
270
271
    }

272
273
    // set default type for return and arguments
    emit->return_vtype = VTYPE_PYOBJ;
274
    for (mp_uint_t i = 0; i < emit->scope->num_pos_args; i++) {
275
276
        emit->local_vtype[i] = VTYPE_PYOBJ;
    }
277
278
279
280
281
282
283
284

    // local variables begin unbound, and have unknown type
    for (mp_uint_t i = emit->scope->num_pos_args; i < emit->local_vtype_alloc; i++) {
        emit->local_vtype[i] = VTYPE_UNBOUND;
    }

    // values on stack begin unbound
    for (mp_uint_t i = 0; i < emit->stack_info_alloc; i++) {
285
        emit->stack_info[i].kind = STACK_VALUE;
286
        emit->stack_info[i].vtype = VTYPE_UNBOUND;
287
288
    }

289
#if N_X64
290
    asm_x64_start_pass(emit->as, pass == MP_PASS_EMIT ? ASM_X64_PASS_EMIT : ASM_X64_PASS_COMPUTE);
291
#elif N_THUMB
292
    asm_thumb_start_pass(emit->as, pass == MP_PASS_EMIT ? ASM_THUMB_PASS_EMIT : ASM_THUMB_PASS_COMPUTE);
Fabian Vogt's avatar
Fabian Vogt committed
293
294
#elif N_ARM
    asm_arm_start_pass(emit->as, pass == MP_PASS_EMIT ? ASM_ARM_PASS_EMIT : ASM_ARM_PASS_COMPUTE);
295
296
297
298
#endif

    // entry to function
    int num_locals = 0;
299
    if (pass > MP_PASS_SCOPE) {
300
301
302
303
304
305
306
        num_locals = scope->num_locals - REG_LOCAL_NUM;
        if (num_locals < 0) {
            num_locals = 0;
        }
        emit->stack_start = num_locals;
        num_locals += scope->stack_size;
    }
307
#if N_X64
308
    asm_x64_entry(emit->as, num_locals);
309
#elif N_THUMB
310
    asm_thumb_entry(emit->as, num_locals);
Fabian Vogt's avatar
Fabian Vogt committed
311
312
#elif N_ARM
    asm_arm_entry(emit->as, num_locals);
313
314
315
#endif

    // initialise locals from parameters
316
#if N_X64
317
    for (int i = 0; i < scope->num_pos_args; i++) {
318
319
320
        if (i == 0) {
            asm_x64_mov_r64_to_r64(emit->as, REG_ARG_1, REG_LOCAL_1);
        } else if (i == 1) {
321
            asm_x64_mov_r64_to_local(emit->as, REG_ARG_2, i - REG_LOCAL_NUM);
322
        } else if (i == 2) {
323
            asm_x64_mov_r64_to_local(emit->as, REG_ARG_3, i - REG_LOCAL_NUM);
324
325
326
327
328
        } else {
            // TODO not implemented
            assert(0);
        }
    }
329
#elif N_THUMB
330
    for (int i = 0; i < scope->num_pos_args; i++) {
331
332
333
334
335
336
337
338
339
340
341
342
343
344
        if (i == 0) {
            asm_thumb_mov_reg_reg(emit->as, REG_LOCAL_1, REG_ARG_1);
        } else if (i == 1) {
            asm_thumb_mov_reg_reg(emit->as, REG_LOCAL_2, REG_ARG_2);
        } else if (i == 2) {
            asm_thumb_mov_reg_reg(emit->as, REG_LOCAL_3, REG_ARG_3);
        } else if (i == 3) {
            asm_thumb_mov_local_reg(emit->as, i - REG_LOCAL_NUM, REG_ARG_4);
        } else {
            // TODO not implemented
            assert(0);
        }
    }

345
    asm_thumb_mov_reg_i32(emit->as, REG_R7, (mp_uint_t)mp_fun_table);
Fabian Vogt's avatar
Fabian Vogt committed
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
#elif N_ARM
    for (int i = 0; i < scope->num_pos_args; i++) {
        if (i == 0) {
            asm_arm_mov_reg_reg(emit->as, REG_LOCAL_1, REG_ARG_1);
        } else if (i == 1) {
            asm_arm_mov_reg_reg(emit->as, REG_LOCAL_2, REG_ARG_2);
        } else if (i == 2) {
            asm_arm_mov_reg_reg(emit->as, REG_LOCAL_3, REG_ARG_3);
        } else if (i == 3) {
            asm_arm_mov_local_reg(emit->as, i - REG_LOCAL_NUM, REG_ARG_4);
        } else {
            // TODO not implemented
            assert(0);
        }
    }

    asm_arm_mov_reg_i32(emit->as, REG_R7, (mp_uint_t)mp_fun_table);
363
364
365
#endif
}

366
STATIC void emit_native_end_pass(emit_t *emit) {
367
#if N_X64
368
369
370
371
    if (!emit->last_emit_was_return_value) {
        asm_x64_exit(emit->as);
    }
    asm_x64_end_pass(emit->as);
372
#elif N_THUMB
373
374
375
376
    if (!emit->last_emit_was_return_value) {
        asm_thumb_exit(emit->as);
    }
    asm_thumb_end_pass(emit->as);
Fabian Vogt's avatar
Fabian Vogt committed
377
378
379
380
381
#elif N_ARM
    if (!emit->last_emit_was_return_value) {
        asm_arm_exit(emit->as);
    }
    asm_arm_end_pass(emit->as);    
382
383
384
385
386
387
388
#endif

    // check stack is back to zero size
    if (emit->stack_size != 0) {
        printf("ERROR: stack size not back to zero; got %d\n", emit->stack_size);
    }

389
    if (emit->pass == MP_PASS_EMIT) {
390
#if N_X64
391
        void *f = asm_x64_get_code(emit->as);
392
        mp_uint_t f_len = asm_x64_get_code_size(emit->as);
393
#elif N_THUMB
394
        void *f = asm_thumb_get_code(emit->as);
395
        mp_uint_t f_len = asm_thumb_get_code_size(emit->as);
Fabian Vogt's avatar
Fabian Vogt committed
396
397
398
#elif N_ARM
	void *f = asm_arm_get_code(emit->as);
        mp_uint_t f_len = asm_arm_get_code_size(emit->as);
399
#endif
400
401
402
403
404
405
406
407
408

        // compute type signature
        // TODO check that viper types here convert correctly to valid types for emit glue
        mp_uint_t type_sig = emit->return_vtype & 3;
        for (mp_uint_t i = 0; i < emit->scope->num_pos_args; i++) {
            type_sig |= (emit->local_vtype[i] & 3) << (i * 2 + 2);
        }

        mp_emit_glue_assign_native(emit->scope->raw_code, emit->do_viper_types ? MP_CODE_NATIVE_VIPER : MP_CODE_NATIVE_PY, f, f_len, emit->scope->num_pos_args, type_sig);
409
410
411
    }
}

412
STATIC bool emit_native_last_emit_was_return_value(emit_t *emit) {
413
414
415
    return emit->last_emit_was_return_value;
}

416
417
STATIC void emit_native_adjust_stack_size(emit_t *emit, int delta) {
    emit->stack_size += delta;
418
419
}

420
STATIC void emit_native_set_source_line(emit_t *emit, int source_line) {
421
422
}

423
STATIC void adjust_stack(emit_t *emit, int stack_size_delta) {
424
    DEBUG_printf("adjust stack: stack:%d + delta:%d\n", emit->stack_size, stack_size_delta);
425
    assert((int)emit->stack_size + stack_size_delta >= 0);
426
    emit->stack_size += stack_size_delta;
427
    if (emit->pass > MP_PASS_SCOPE && emit->stack_size > emit->scope->stack_size) {
428
429
430
431
        emit->scope->stack_size = emit->stack_size;
    }
}

432
/*
433
STATIC void emit_pre_raw(emit_t *emit, int stack_size_delta) {
434
435
436
    adjust_stack(emit, stack_size_delta);
    emit->last_emit_was_return_value = false;
}
437
*/
438

439
// this must be called at start of emit functions
440
STATIC void emit_native_pre(emit_t *emit) {
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
    emit->last_emit_was_return_value = false;
    // settle the stack
    /*
    if (regs_needed != 0) {
        for (int i = 0; i < emit->stack_size; i++) {
            switch (emit->stack_info[i].kind) {
                case STACK_VALUE:
                    break;

                case STACK_REG:
                    // TODO only push reg if in regs_needed
                    emit->stack_info[i].kind = STACK_VALUE;
                    ASM_MOV_REG_TO_LOCAL(emit->stack_info[i].u_reg, emit->stack_start + i);
                    break;

                case STACK_IMM:
                    // don't think we ever need to push imms for settling
                    //ASM_MOV_IMM_TO_LOCAL(emit->last_imm, emit->stack_start + i);
                    break;
            }
        }
    }
    */
464
465
}

466
STATIC vtype_kind_t peek_vtype(emit_t *emit) {
467
468
    return emit->stack_info[emit->stack_size - 1].vtype;
}
469

470
471
// pos=1 is TOS, pos=2 is next, etc
// use pos=0 for no skipping
472
STATIC void need_reg_single(emit_t *emit, int reg_needed, int skip_stack_pos) {
473
474
475
476
477
478
479
480
481
482
483
484
    skip_stack_pos = emit->stack_size - skip_stack_pos;
    for (int i = 0; i < emit->stack_size; i++) {
        if (i != skip_stack_pos) {
            stack_info_t *si = &emit->stack_info[i];
            if (si->kind == STACK_REG && si->u_reg == reg_needed) {
                si->kind = STACK_VALUE;
                ASM_MOV_REG_TO_LOCAL(si->u_reg, emit->stack_start + i);
            }
        }
    }
}

485
STATIC void need_reg_all(emit_t *emit) {
486
487
    for (int i = 0; i < emit->stack_size; i++) {
        stack_info_t *si = &emit->stack_info[i];
488
        if (si->kind == STACK_REG) {
489
490
491
492
493
            si->kind = STACK_VALUE;
            ASM_MOV_REG_TO_LOCAL(si->u_reg, emit->stack_start + i);
        }
    }
}
494

495
STATIC void need_stack_settled(emit_t *emit) {
496
497
498
499
500
501
    for (int i = 0; i < emit->stack_size; i++) {
        stack_info_t *si = &emit->stack_info[i];
        if (si->kind == STACK_REG) {
            si->kind = STACK_VALUE;
            ASM_MOV_REG_TO_LOCAL(si->u_reg, emit->stack_start + i);
        }
502
    }
503
504
505
    for (int i = 0; i < emit->stack_size; i++) {
        stack_info_t *si = &emit->stack_info[i];
        if (si->kind == STACK_IMM) {
506
            si->kind = STACK_VALUE;
507
508
509
            ASM_MOV_IMM_TO_LOCAL_USING(si->u_imm, emit->stack_start + i, REG_TEMP0);
        }
    }
510
511
}

512
// pos=1 is TOS, pos=2 is next, etc
513
STATIC void emit_access_stack(emit_t *emit, int pos, vtype_kind_t *vtype, int reg_dest) {
514
515
    need_reg_single(emit, reg_dest, pos);
    stack_info_t *si = &emit->stack_info[emit->stack_size - pos];
516
517
518
    *vtype = si->vtype;
    switch (si->kind) {
        case STACK_VALUE:
519
            ASM_MOV_LOCAL_TO_REG(emit->stack_start + emit->stack_size - pos, reg_dest);
520
521
            break;

522
523
524
        case STACK_REG:
            if (si->u_reg != reg_dest) {
                ASM_MOV_REG_TO_REG(si->u_reg, reg_dest);
525
526
527
            }
            break;

528
529
        case STACK_IMM:
            ASM_MOV_IMM_TO_REG(si->u_imm, reg_dest);
530
531
532
533
            break;
    }
}

534
535
536
537
538
STATIC void emit_pre_pop_discard(emit_t *emit, vtype_kind_t *vtype) {
    emit->last_emit_was_return_value = false;
    adjust_stack(emit, -1);
}

539
STATIC void emit_pre_pop_reg(emit_t *emit, vtype_kind_t *vtype, int reg_dest) {
540
541
542
543
544
    emit->last_emit_was_return_value = false;
    emit_access_stack(emit, 1, vtype, reg_dest);
    adjust_stack(emit, -1);
}

545
STATIC void emit_pre_pop_reg_reg(emit_t *emit, vtype_kind_t *vtypea, int rega, vtype_kind_t *vtypeb, int regb) {
546
    emit_pre_pop_reg(emit, vtypea, rega);
547
    emit_pre_pop_reg(emit, vtypeb, regb);
548
549
}

550
STATIC void emit_pre_pop_reg_reg_reg(emit_t *emit, vtype_kind_t *vtypea, int rega, vtype_kind_t *vtypeb, int regb, vtype_kind_t *vtypec, int regc) {
551
    emit_pre_pop_reg(emit, vtypea, rega);
552
553
    emit_pre_pop_reg(emit, vtypeb, regb);
    emit_pre_pop_reg(emit, vtypec, regc);
554
555
}

556
STATIC void emit_post(emit_t *emit) {
557
558
}

559
STATIC void emit_post_push_reg(emit_t *emit, vtype_kind_t vtype, int reg) {
560
561
562
563
564
    stack_info_t *si = &emit->stack_info[emit->stack_size];
    si->vtype = vtype;
    si->kind = STACK_REG;
    si->u_reg = reg;
    adjust_stack(emit, 1);
565
566
}

567
STATIC void emit_post_push_imm(emit_t *emit, vtype_kind_t vtype, mp_int_t imm) {
568
569
570
571
572
    stack_info_t *si = &emit->stack_info[emit->stack_size];
    si->vtype = vtype;
    si->kind = STACK_IMM;
    si->u_imm = imm;
    adjust_stack(emit, 1);
573
574
}

575
STATIC void emit_post_push_reg_reg(emit_t *emit, vtype_kind_t vtypea, int rega, vtype_kind_t vtypeb, int regb) {
576
577
    emit_post_push_reg(emit, vtypea, rega);
    emit_post_push_reg(emit, vtypeb, regb);
578
579
}

580
STATIC void emit_post_push_reg_reg_reg(emit_t *emit, vtype_kind_t vtypea, int rega, vtype_kind_t vtypeb, int regb, vtype_kind_t vtypec, int regc) {
581
582
583
    emit_post_push_reg(emit, vtypea, rega);
    emit_post_push_reg(emit, vtypeb, regb);
    emit_post_push_reg(emit, vtypec, regc);
584
585
}

586
STATIC void emit_post_push_reg_reg_reg_reg(emit_t *emit, vtype_kind_t vtypea, int rega, vtype_kind_t vtypeb, int regb, vtype_kind_t vtypec, int regc, vtype_kind_t vtyped, int regd) {
587
588
589
590
    emit_post_push_reg(emit, vtypea, rega);
    emit_post_push_reg(emit, vtypeb, regb);
    emit_post_push_reg(emit, vtypec, regc);
    emit_post_push_reg(emit, vtyped, regd);
591
592
}

593
STATIC void emit_call(emit_t *emit, mp_fun_kind_t fun_kind) {
594
    need_reg_all(emit);
595
#if N_X64
596
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
597
#elif N_THUMB
Damien George's avatar
Damien George committed
598
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
Fabian Vogt's avatar
Fabian Vogt committed
599
600
#elif N_ARM
    asm_arm_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
601
602
603
#endif
}

604
STATIC void emit_call_with_imm_arg(emit_t *emit, mp_fun_kind_t fun_kind, mp_int_t arg_val, int arg_reg) {
605
    need_reg_all(emit);
606
    ASM_MOV_IMM_TO_REG(arg_val, arg_reg);
607
#if N_X64
608
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
609
#elif N_THUMB
Damien George's avatar
Damien George committed
610
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
Fabian Vogt's avatar
Fabian Vogt committed
611
612
#elif N_ARM
    asm_arm_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
613
#endif
614
615
}

616
// the first arg is stored in the code aligned on a mp_uint_t boundary
617
STATIC void emit_call_with_imm_arg_aligned(emit_t *emit, mp_fun_kind_t fun_kind, mp_int_t arg_val, int arg_reg) {
618
619
620
    need_reg_all(emit);
    ASM_MOV_ALIGNED_IMM_TO_REG(arg_val, arg_reg);
#if N_X64
621
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
622
623
#elif N_THUMB
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
Fabian Vogt's avatar
Fabian Vogt committed
624
625
#elif N_ARM
    asm_arm_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
626
627
628
#endif
}

629
STATIC void emit_call_with_2_imm_args(emit_t *emit, mp_fun_kind_t fun_kind, mp_int_t arg_val1, int arg_reg1, mp_int_t arg_val2, int arg_reg2) {
630
631
632
633
    need_reg_all(emit);
    ASM_MOV_IMM_TO_REG(arg_val1, arg_reg1);
    ASM_MOV_IMM_TO_REG(arg_val2, arg_reg2);
#if N_X64
634
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
635
#elif N_THUMB
Damien George's avatar
Damien George committed
636
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
Fabian Vogt's avatar
Fabian Vogt committed
637
638
#elif N_ARM
    asm_arm_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
639
640
641
#endif
}

642
// the first arg is stored in the code aligned on a mp_uint_t boundary
643
STATIC void emit_call_with_3_imm_args_and_first_aligned(emit_t *emit, mp_fun_kind_t fun_kind, mp_int_t arg_val1, int arg_reg1, mp_int_t arg_val2, int arg_reg2, mp_int_t arg_val3, int arg_reg3) {
644
    need_reg_all(emit);
645
    ASM_MOV_ALIGNED_IMM_TO_REG(arg_val1, arg_reg1);
646
647
648
    ASM_MOV_IMM_TO_REG(arg_val2, arg_reg2);
    ASM_MOV_IMM_TO_REG(arg_val3, arg_reg3);
#if N_X64
649
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
650
651
#elif N_THUMB
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
Fabian Vogt's avatar
Fabian Vogt committed
652
653
#elif N_ARM
    asm_arm_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
654
655
656
#endif
}

657
658
659
660
661
662
// vtype of all n_pop objects is VTYPE_PYOBJ
// Will convert any items that are not VTYPE_PYOBJ to this type and put them back on the stack.
// If any conversions of non-immediate values are needed, then it uses REG_ARG_1, REG_ARG_2 and REG_RET.
// Otherwise, it does not use any temporary registers (but may use reg_dest before loading it with stack pointer).
STATIC void emit_get_stack_pointer_to_reg_for_pop(emit_t *emit, mp_uint_t reg_dest, mp_uint_t n_pop) {
    need_reg_all(emit);
663

664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
    // First, store any immediate values to their respective place on the stack.
    for (mp_uint_t i = 0; i < n_pop; i++) {
        stack_info_t *si = &emit->stack_info[emit->stack_size - 1 - i];
        // must push any imm's to stack
        // must convert them to VTYPE_PYOBJ for viper code
        if (si->kind == STACK_IMM) {
            si->kind = STACK_VALUE;
            switch (si->vtype) {
                case VTYPE_PYOBJ:
                    ASM_MOV_IMM_TO_LOCAL_USING(si->u_imm, emit->stack_start + emit->stack_size - 1 - i, reg_dest);
                    break;
                case VTYPE_BOOL:
                    if (si->u_imm == 0) {
                        ASM_MOV_IMM_TO_LOCAL_USING((mp_uint_t)mp_const_false, emit->stack_start + emit->stack_size - 1 - i, reg_dest);
                    } else {
                        ASM_MOV_IMM_TO_LOCAL_USING((mp_uint_t)mp_const_true, emit->stack_start + emit->stack_size - 1 - i, reg_dest);
                    }
                    si->vtype = VTYPE_PYOBJ;
                    break;
                case VTYPE_INT:
                case VTYPE_UINT:
                    ASM_MOV_IMM_TO_LOCAL_USING((si->u_imm << 1) | 1, emit->stack_start + emit->stack_size - 1 - i, reg_dest);
                    si->vtype = VTYPE_PYOBJ;
                    break;
                default:
                    // not handled
                    assert(0);
            }
        }

        // verify that this value is on the stack
        assert(si->kind == STACK_VALUE);
    }

    // Second, convert any non-VTYPE_PYOBJ to that type.
    for (mp_uint_t i = 0; i < n_pop; i++) {
        stack_info_t *si = &emit->stack_info[emit->stack_size - 1 - i];
        if (si->vtype != VTYPE_PYOBJ) {
            mp_uint_t local_num = emit->stack_start + emit->stack_size - 1 - i;
            ASM_MOV_LOCAL_TO_REG(local_num, REG_ARG_1);
704
            emit_call_with_imm_arg(emit, MP_F_CONVERT_NATIVE_TO_OBJ, si->vtype, REG_ARG_2); // arg2 = type
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
            ASM_MOV_REG_TO_LOCAL(REG_RET, local_num);
            si->vtype = VTYPE_PYOBJ;
        }
    }

    // Adujust the stack for a pop of n_pop items, and load the stack pointer into reg_dest.
    adjust_stack(emit, -n_pop);
    ASM_MOV_LOCAL_ADDR_TO_REG(emit->stack_start + emit->stack_size, reg_dest);
}

// vtype of all n_push objects is VTYPE_PYOBJ
STATIC void emit_get_stack_pointer_to_reg_for_push(emit_t *emit, mp_uint_t reg_dest, mp_uint_t n_push) {
    need_reg_all(emit);
    for (mp_uint_t i = 0; i < n_push; i++) {
        emit->stack_info[emit->stack_size + i].kind = STACK_VALUE;
        emit->stack_info[emit->stack_size + i].vtype = VTYPE_PYOBJ;
721
    }
722
723
724
725
726
727
    ASM_MOV_LOCAL_ADDR_TO_REG(emit->stack_start + emit->stack_size, reg_dest);
    adjust_stack(emit, n_push);
}

STATIC void emit_native_load_id(emit_t *emit, qstr qstr) {
    emit_common_load_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr);
728
729
}

730
STATIC void emit_native_store_id(emit_t *emit, qstr qstr) {
731
732
733
    emit_common_store_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr);
}

734
STATIC void emit_native_delete_id(emit_t *emit, qstr qstr) {
735
736
737
    emit_common_delete_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr);
}

738
STATIC void emit_native_label_assign(emit_t *emit, uint l) {
739
    emit_native_pre(emit);
740
741
    // need to commit stack because we can jump here from elsewhere
    need_stack_settled(emit);
742
#if N_X64
743
    asm_x64_label_assign(emit->as, l);
744
#elif N_THUMB
745
    asm_thumb_label_assign(emit->as, l);
Fabian Vogt's avatar
Fabian Vogt committed
746
747
#elif N_ARM
    asm_arm_label_assign(emit->as, l);
748
#endif
749
    emit_post(emit);
750
751
}

752
753
754
755
756
757
758
STATIC void emit_native_import_name(emit_t *emit, qstr qst) {
    DEBUG_printf("import_name %s\n", qstr_str(qst));
    vtype_kind_t vtype_fromlist;
    vtype_kind_t vtype_level;
    emit_pre_pop_reg_reg(emit, &vtype_fromlist, REG_ARG_2, &vtype_level, REG_ARG_3); // arg2 = fromlist, arg3 = level
    assert(vtype_fromlist == VTYPE_PYOBJ);
    assert(vtype_level == VTYPE_PYOBJ);
759
    emit_call_with_imm_arg(emit, MP_F_IMPORT_NAME, qst, REG_ARG_1); // arg1 = import name
760
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
761
762
}

763
764
765
766
767
768
STATIC void emit_native_import_from(emit_t *emit, qstr qst) {
    DEBUG_printf("import_from %s\n", qstr_str(qst));
    emit_native_pre(emit);
    vtype_kind_t vtype_module;
    emit_access_stack(emit, 1, &vtype_module, REG_ARG_1); // arg1 = module
    assert(vtype_module == VTYPE_PYOBJ);
769
    emit_call_with_imm_arg(emit, MP_F_IMPORT_FROM, qst, REG_ARG_2); // arg2 = import name
770
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
771
772
}

773
STATIC void emit_native_import_star(emit_t *emit) {
774
775
776
777
    DEBUG_printf("import_star\n");
    vtype_kind_t vtype_module;
    emit_pre_pop_reg(emit, &vtype_module, REG_ARG_1); // arg1 = module
    assert(vtype_module == VTYPE_PYOBJ);
778
    emit_call(emit, MP_F_IMPORT_ALL);
779
    emit_post(emit);
780
781
}

782
STATIC void emit_native_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
783
    DEBUG_printf("load_const_tok %d\n", tok);
784
    emit_native_pre(emit);
785
    int vtype;
786
    mp_uint_t val;
787
788
    if (emit->do_viper_types) {
        switch (tok) {
789
790
791
            case MP_TOKEN_KW_NONE: vtype = VTYPE_PTR_NONE; val = 0; break;
            case MP_TOKEN_KW_FALSE: vtype = VTYPE_BOOL; val = 0; break;
            case MP_TOKEN_KW_TRUE: vtype = VTYPE_BOOL; val = 1; break;
792
793
794
795
796
            default: assert(0); vtype = 0; val = 0; // shouldn't happen
        }
    } else {
        vtype = VTYPE_PYOBJ;
        switch (tok) {
797
798
799
            case MP_TOKEN_KW_NONE: val = (mp_uint_t)mp_const_none; break;
            case MP_TOKEN_KW_FALSE: val = (mp_uint_t)mp_const_false; break;
            case MP_TOKEN_KW_TRUE: val = (mp_uint_t)mp_const_true; break;
800
801
802
803
804
805
            default: assert(0); vtype = 0; val = 0; // shouldn't happen
        }
    }
    emit_post_push_imm(emit, vtype, val);
}

806
STATIC void emit_native_load_const_small_int(emit_t *emit, mp_int_t arg) {
807
    DEBUG_printf("load_const_small_int %d\n", arg);
808
    emit_native_pre(emit);
809
810
811
812
813
814
815
    if (emit->do_viper_types) {
        emit_post_push_imm(emit, VTYPE_INT, arg);
    } else {
        emit_post_push_imm(emit, VTYPE_PYOBJ, (arg << 1) | 1);
    }
}

816
817
818
819
STATIC void emit_native_load_const_int(emit_t *emit, qstr qst) {
    DEBUG_printf("load_const_int %s\n", qstr_str(st));
    // for viper: load integer, check fits in 32 bits
    emit_native_pre(emit);
820
    emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_INT, qst, REG_ARG_1);
821
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
822
823
}

824
STATIC void emit_native_load_const_dec(emit_t *emit, qstr qstr) {
825
    // for viper, a float/complex is just a Python object
826
    emit_native_pre(emit);
827
    emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_DEC, qstr, REG_ARG_1);
828
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
829
830
}

831
STATIC void emit_native_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
832
    emit_native_pre(emit);
833
834
835
836
    if (emit->do_viper_types) {
        // not implemented properly
        // load a pointer to the asciiz string?
        assert(0);
837
        emit_post_push_imm(emit, VTYPE_PTR, (mp_uint_t)qstr_str(qstr));
838
    } else {
839
        if (bytes) {
840
            emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_BYTES, qstr, REG_ARG_1);
841
        } else {
842
            emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_STR, qstr, REG_ARG_1);
843
        }
844
845
846
847
        emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
    }
}

848
849
850
851
852
STATIC void emit_native_load_null(emit_t *emit) {
    emit_native_pre(emit);
    emit_post_push_imm(emit, VTYPE_PYOBJ, 0);
}

853
STATIC void emit_native_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) {
854
855
856
857
    vtype_kind_t vtype = emit->local_vtype[local_num];
    if (vtype == VTYPE_UNBOUND) {
        printf("ViperTypeError: local %s used before type known\n", qstr_str(qstr));
    }
858
    emit_native_pre(emit);
859
#if N_X64
860
861
862
    if (local_num == 0) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_1);
    } else {
863
        need_reg_single(emit, REG_RAX, 0);
864
        asm_x64_mov_local_to_r64(emit->as, local_num - REG_LOCAL_NUM, REG_RAX);
865
866
        emit_post_push_reg(emit, vtype, REG_RAX);
    }
867
#elif N_THUMB
868
869
870
871
872
873
874
    if (local_num == 0) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_1);
    } else if (local_num == 1) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_2);
    } else if (local_num == 2) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_3);
    } else {
875
        need_reg_single(emit, REG_R0, 0);
876
        asm_thumb_mov_reg_local(emit->as, REG_R0, local_num - REG_LOCAL_NUM);
877
878
        emit_post_push_reg(emit, vtype, REG_R0);
    }
Fabian Vogt's avatar
Fabian Vogt committed
879
880
881
882
883
884
885
886
887
888
889
890
#elif N_ARM
    if (local_num == 0) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_1);
    } else if (local_num == 1) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_2);
    } else if (local_num == 2) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_3);
    } else {
        need_reg_single(emit, REG_R0, 0);
        asm_arm_mov_reg_local(emit->as, REG_R0, local_num - REG_LOCAL_NUM);
        emit_post_push_reg(emit, vtype, REG_R0);
    }
891
892
893
#endif
}

894
STATIC void emit_native_load_deref(emit_t *emit, qstr qstr, int local_num) {
Damien's avatar
Damien committed
895
896
897
898
899
    // not implemented
    // in principle could support this quite easily (ldr r0, [r0, #0]) and then get closed over variables!
    assert(0);
}

900
STATIC void emit_native_load_name(emit_t *emit, qstr qstr) {
901
    emit_native_pre(emit);
902
    emit_call_with_imm_arg(emit, MP_F_LOAD_NAME, qstr, REG_ARG_1);
903
904
905
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}

906
STATIC void emit_native_load_global(emit_t *emit, qstr qstr) {
907
    emit_native_pre(emit);
908
    emit_call_with_imm_arg(emit, MP_F_LOAD_GLOBAL, qstr, REG_ARG_1);
909
910
911
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}

912
STATIC void emit_native_load_attr(emit_t *emit, qstr qstr) {
913
914
915
    // depends on type of subject:
    //  - integer, function, pointer to integers: error
    //  - pointer to structure: get member, quite easy
Damien George's avatar
Damien George committed
916
    //  - Python object: call mp_load_attr, and needs to be typed to convert result
917
918
919
    vtype_kind_t vtype_base;
    emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
    assert(vtype_base == VTYPE_PYOBJ);
920
    emit_call_with_imm_arg(emit, MP_F_LOAD_ATTR, qstr, REG_ARG_2); // arg2 = attribute name
921
922
923
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}

924
STATIC void emit_native_load_method(emit_t *emit, qstr qstr) {
925
926
927
928
    vtype_kind_t vtype_base;
    emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
    assert(vtype_base == VTYPE_PYOBJ);
    emit_get_stack_pointer_to_reg_for_push(emit, REG_ARG_3, 2); // arg3 = dest ptr
929
    emit_call_with_imm_arg(emit, MP_F_LOAD_METHOD, qstr, REG_ARG_2); // arg2 = method name
930
931
}

932
STATIC void emit_native_load_build_class(emit_t *emit) {
933
    emit_native_pre(emit);
934
    emit_call(emit, MP_F_LOAD_BUILD_CLASS);
935
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
936
937
}

938
939
940
941
STATIC void emit_native_load_subscr(emit_t *emit) {
    vtype_kind_t vtype_lhs, vtype_rhs;
    emit_pre_pop_reg_reg(emit, &vtype_rhs, REG_ARG_2, &vtype_lhs, REG_ARG_1);
    if (vtype_lhs == VTYPE_PYOBJ && vtype_rhs == VTYPE_PYOBJ) {
942
        emit_call_with_imm_arg(emit, MP_F_OBJ_SUBSCR, (mp_uint_t)MP_OBJ_SENTINEL, REG_ARG_3);
943
944
945
946
947
948
        emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
    } else {
        printf("ViperTypeError: can't do subscr of types %d and %d\n", vtype_lhs, vtype_rhs);
    }
}

949
STATIC void emit_native_store_fast(emit_t *emit, qstr qstr, int local_num) {
950
    vtype_kind_t vtype;
951
#if N_X64
952
953
954
955
    if (local_num == 0) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_1);
    } else {
        emit_pre_pop_reg(emit, &vtype, REG_RAX);
956
        asm_x64_mov_r64_to_local(emit->as, REG_RAX, local_num - REG_LOCAL_NUM);
957
    }
958
#elif N_THUMB
959
960
961
962
963
964
965
966
    if (local_num == 0) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_1);
    } else if (local_num == 1) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_2);
    } else if (local_num == 2) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_3);
    } else {
        emit_pre_pop_reg(emit, &vtype, REG_R0);
967
        asm_thumb_mov_local_reg(emit->as, local_num - REG_LOCAL_NUM, REG_R0);
968
    }
Fabian Vogt's avatar
Fabian Vogt committed
969
970
971
972
973
974
975
976
977
978
979
#elif N_ARM
    if (local_num == 0) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_1);
    } else if (local_num == 1) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_2);
    } else if (local_num == 2) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_3);
    } else {
        emit_pre_pop_reg(emit, &vtype, REG_R0);
        asm_arm_mov_local_reg(emit->as, local_num - REG_LOCAL_NUM, REG_R0);
    }
980
981
982
983
984
985
986
987
988
989
990
991
992
993
#endif

    emit_post(emit);

    // check types
    if (emit->local_vtype[local_num] == VTYPE_UNBOUND) {
        // first time this local is assigned, so give it a type of the object stored in it
        emit->local_vtype[local_num] = vtype;
    } else if (emit->local_vtype[local_num] != vtype) {
        // type of local is not the same as object stored in it
        printf("ViperTypeError: type mismatch, local %s has type %d but source object has type %d\n", qstr_str(qstr), emit->local_vtype[local_num], vtype);
    }
}

994
STATIC void emit_native_store_deref(emit_t *emit, qstr qstr, int local_num) {
Damien's avatar
Damien committed
995
996
997
998
    // not implemented
    assert(0);
}

999
STATIC void emit_native_store_name(emit_t *emit, qstr qstr) {
Damien George's avatar
Damien George committed
1000
    // mp_store_name, but needs conversion of object (maybe have mp_viper_store_name(obj, type))
For faster browsing, not all history is shown. View entire blame