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

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
72
#if (MICROPY_EMIT_X64 && N_X64) || (MICROPY_EMIT_THUMB && N_THUMB)
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
120
121
122
#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))

#endif

typedef enum {
123
124
125
126
    STACK_VALUE,
    STACK_REG,
    STACK_IMM,
} stack_info_kind_t;
127
128

typedef enum {
129
130
131
132
    VTYPE_PYOBJ = MP_NATIVE_TYPE_OBJ,
    VTYPE_BOOL = MP_NATIVE_TYPE_BOOL,
    VTYPE_INT = MP_NATIVE_TYPE_INT,
    VTYPE_UINT = MP_NATIVE_TYPE_UINT,
133
134
135
136
137
138
    VTYPE_UNBOUND,
    VTYPE_PTR,
    VTYPE_PTR_NONE,
    VTYPE_BUILTIN_V_INT,
} vtype_kind_t;

139
140
141
142
143
typedef struct _stack_info_t {
    vtype_kind_t vtype;
    stack_info_kind_t kind;
    union {
        int u_reg;
144
        mp_int_t u_imm;
145
146
147
    };
} stack_info_t;

148
149
150
151
struct _emit_t {
    int pass;

    bool do_viper_types;
152

153
154
    vtype_kind_t return_vtype;

155
    uint local_vtype_alloc;
156
    vtype_kind_t *local_vtype;
157

158
    uint stack_info_alloc;
159
160
    stack_info_t *stack_info;

161
162
163
164
165
166
167
    int stack_start;
    int stack_size;

    bool last_emit_was_return_value;

    scope_t *scope;

168
#if N_X64
169
    asm_x64_t *as;
170
#elif N_THUMB
171
172
173
174
175
    asm_thumb_t *as;
#endif
};

emit_t *EXPORT_FUN(new)(uint max_num_labels) {
176
    emit_t *emit = m_new0(emit_t, 1);
177
#if N_X64
178
    emit->as = asm_x64_new(max_num_labels);
179
#elif N_THUMB
180
181
182
183
184
    emit->as = asm_thumb_new(max_num_labels);
#endif
    return emit;
}

185
void EXPORT_FUN(free)(emit_t *emit) {
186
187
188
189
190
#if N_X64
    asm_x64_free(emit->as, false);
#elif N_THUMB
    asm_thumb_free(emit->as, false);
#endif
191
192
    m_del(vtype_kind_t, emit->local_vtype, emit->local_vtype_alloc);
    m_del(stack_info_t, emit->stack_info, emit->stack_info_alloc);
193
194
195
    m_del_obj(emit_t, emit);
}

196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
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;
        }
    }
220
221
}

222
STATIC void emit_native_start_pass(emit_t *emit, pass_kind_t pass, scope_t *scope) {
223
224
225
226
227
228
    emit->pass = pass;
    emit->stack_start = 0;
    emit->stack_size = 0;
    emit->last_emit_was_return_value = false;
    emit->scope = scope;

229
230
231
232
    // 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;
233
    }
234
235
236

    // 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
237
    if (emit->stack_info == NULL) {
238
        emit->stack_info_alloc = scope->stack_size + 50;
239
        emit->stack_info = m_new(stack_info_t, emit->stack_info_alloc);
240
241
    }

242
243
    // set default type for return and arguments
    emit->return_vtype = VTYPE_PYOBJ;
244
    for (mp_uint_t i = 0; i < emit->scope->num_pos_args; i++) {
245
246
        emit->local_vtype[i] = VTYPE_PYOBJ;
    }
247
248
249
250
251
252
253
254

    // 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++) {
255
        emit->stack_info[i].kind = STACK_VALUE;
256
        emit->stack_info[i].vtype = VTYPE_UNBOUND;
257
258
    }

259
#if N_X64
260
    asm_x64_start_pass(emit->as, pass == MP_PASS_EMIT ? ASM_X64_PASS_EMIT : ASM_X64_PASS_COMPUTE);
261
#elif N_THUMB
262
    asm_thumb_start_pass(emit->as, pass == MP_PASS_EMIT ? ASM_THUMB_PASS_EMIT : ASM_THUMB_PASS_COMPUTE);
263
264
265
266
#endif

    // entry to function
    int num_locals = 0;
267
    if (pass > MP_PASS_SCOPE) {
268
269
270
271
272
273
274
        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;
    }
275
#if N_X64
276
    asm_x64_entry(emit->as, num_locals);
277
#elif N_THUMB
278
279
280
281
    asm_thumb_entry(emit->as, num_locals);
#endif

    // initialise locals from parameters
282
#if N_X64
283
    for (int i = 0; i < scope->num_pos_args; i++) {
284
285
286
        if (i == 0) {
            asm_x64_mov_r64_to_r64(emit->as, REG_ARG_1, REG_LOCAL_1);
        } else if (i == 1) {
287
            asm_x64_mov_r64_to_local(emit->as, REG_ARG_2, i - REG_LOCAL_NUM);
288
        } else if (i == 2) {
289
            asm_x64_mov_r64_to_local(emit->as, REG_ARG_3, i - REG_LOCAL_NUM);
290
291
292
293
294
        } else {
            // TODO not implemented
            assert(0);
        }
    }
295
#elif N_THUMB
296
    for (int i = 0; i < scope->num_pos_args; i++) {
297
298
299
300
301
302
303
304
305
306
307
308
309
310
        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);
        }
    }

311
    asm_thumb_mov_reg_i32(emit->as, REG_R7, (mp_uint_t)mp_fun_table);
312
313
314
#endif
}

315
STATIC void emit_native_end_pass(emit_t *emit) {
316
#if N_X64
317
318
319
320
    if (!emit->last_emit_was_return_value) {
        asm_x64_exit(emit->as);
    }
    asm_x64_end_pass(emit->as);
321
#elif N_THUMB
322
323
324
325
326
327
328
329
330
331
332
    if (!emit->last_emit_was_return_value) {
        asm_thumb_exit(emit->as);
    }
    asm_thumb_end_pass(emit->as);
#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);
    }

333
    if (emit->pass == MP_PASS_EMIT) {
334
#if N_X64
335
        void *f = asm_x64_get_code(emit->as);
336
        mp_uint_t f_len = asm_x64_get_code_size(emit->as);
337
#elif N_THUMB
338
        void *f = asm_thumb_get_code(emit->as);
339
        mp_uint_t f_len = asm_thumb_get_code_size(emit->as);
340
#endif
341
342
343
344
345
346
347
348
349

        // 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);
350
351
352
    }
}

353
STATIC bool emit_native_last_emit_was_return_value(emit_t *emit) {
354
355
356
    return emit->last_emit_was_return_value;
}

357
358
STATIC void emit_native_adjust_stack_size(emit_t *emit, int delta) {
    emit->stack_size += delta;
359
360
}

361
STATIC void emit_native_set_source_line(emit_t *emit, int source_line) {
362
363
}

364
STATIC void adjust_stack(emit_t *emit, int stack_size_delta) {
365
    DEBUG_printf("adjust stack: stack:%d + delta:%d\n", emit->stack_size, stack_size_delta);
366
    assert((int)emit->stack_size + stack_size_delta >= 0);
367
    emit->stack_size += stack_size_delta;
368
    if (emit->pass > MP_PASS_SCOPE && emit->stack_size > emit->scope->stack_size) {
369
370
371
372
        emit->scope->stack_size = emit->stack_size;
    }
}

373
/*
374
STATIC void emit_pre_raw(emit_t *emit, int stack_size_delta) {
375
376
377
    adjust_stack(emit, stack_size_delta);
    emit->last_emit_was_return_value = false;
}
378
*/
379

380
// this must be called at start of emit functions
381
STATIC void emit_native_pre(emit_t *emit) {
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
    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;
            }
        }
    }
    */
405
406
}

407
STATIC vtype_kind_t peek_vtype(emit_t *emit) {
408
409
    return emit->stack_info[emit->stack_size - 1].vtype;
}
410

411
412
// pos=1 is TOS, pos=2 is next, etc
// use pos=0 for no skipping
413
STATIC void need_reg_single(emit_t *emit, int reg_needed, int skip_stack_pos) {
414
415
416
417
418
419
420
421
422
423
424
425
    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);
            }
        }
    }
}

426
STATIC void need_reg_all(emit_t *emit) {
427
428
    for (int i = 0; i < emit->stack_size; i++) {
        stack_info_t *si = &emit->stack_info[i];
429
        if (si->kind == STACK_REG) {
430
431
432
433
434
            si->kind = STACK_VALUE;
            ASM_MOV_REG_TO_LOCAL(si->u_reg, emit->stack_start + i);
        }
    }
}
435

436
STATIC void need_stack_settled(emit_t *emit) {
437
438
439
440
441
442
    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);
        }
443
    }
444
445
446
447
448
449
    for (int i = 0; i < emit->stack_size; i++) {
        stack_info_t *si = &emit->stack_info[i];
        if (si->kind == STACK_IMM) {
            ASM_MOV_IMM_TO_LOCAL_USING(si->u_imm, emit->stack_start + i, REG_TEMP0);
        }
    }
450
451
}

452
// pos=1 is TOS, pos=2 is next, etc
453
STATIC void emit_access_stack(emit_t *emit, int pos, vtype_kind_t *vtype, int reg_dest) {
454
455
    need_reg_single(emit, reg_dest, pos);
    stack_info_t *si = &emit->stack_info[emit->stack_size - pos];
456
457
458
    *vtype = si->vtype;
    switch (si->kind) {
        case STACK_VALUE:
459
            ASM_MOV_LOCAL_TO_REG(emit->stack_start + emit->stack_size - pos, reg_dest);
460
461
            break;

462
463
464
        case STACK_REG:
            if (si->u_reg != reg_dest) {
                ASM_MOV_REG_TO_REG(si->u_reg, reg_dest);
465
466
467
            }
            break;

468
469
        case STACK_IMM:
            ASM_MOV_IMM_TO_REG(si->u_imm, reg_dest);
470
471
472
473
            break;
    }
}

474
475
476
477
478
STATIC void emit_pre_pop_discard(emit_t *emit, vtype_kind_t *vtype) {
    emit->last_emit_was_return_value = false;
    adjust_stack(emit, -1);
}

479
STATIC void emit_pre_pop_reg(emit_t *emit, vtype_kind_t *vtype, int reg_dest) {
480
481
482
483
484
    emit->last_emit_was_return_value = false;
    emit_access_stack(emit, 1, vtype, reg_dest);
    adjust_stack(emit, -1);
}

485
STATIC void emit_pre_pop_reg_reg(emit_t *emit, vtype_kind_t *vtypea, int rega, vtype_kind_t *vtypeb, int regb) {
486
    emit_pre_pop_reg(emit, vtypea, rega);
487
    emit_pre_pop_reg(emit, vtypeb, regb);
488
489
}

490
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) {
491
    emit_pre_pop_reg(emit, vtypea, rega);
492
493
    emit_pre_pop_reg(emit, vtypeb, regb);
    emit_pre_pop_reg(emit, vtypec, regc);
494
495
}

496
STATIC void emit_post(emit_t *emit) {
497
498
}

499
STATIC void emit_post_push_reg(emit_t *emit, vtype_kind_t vtype, int reg) {
500
501
502
503
504
    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);
505
506
}

507
STATIC void emit_post_push_imm(emit_t *emit, vtype_kind_t vtype, mp_int_t imm) {
508
509
510
511
512
    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);
513
514
}

515
STATIC void emit_post_push_reg_reg(emit_t *emit, vtype_kind_t vtypea, int rega, vtype_kind_t vtypeb, int regb) {
516
517
    emit_post_push_reg(emit, vtypea, rega);
    emit_post_push_reg(emit, vtypeb, regb);
518
519
}

520
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) {
521
522
523
    emit_post_push_reg(emit, vtypea, rega);
    emit_post_push_reg(emit, vtypeb, regb);
    emit_post_push_reg(emit, vtypec, regc);
524
525
}

526
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) {
527
528
529
530
    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);
531
532
}

533
STATIC void emit_call(emit_t *emit, mp_fun_kind_t fun_kind) {
534
    need_reg_all(emit);
535
#if N_X64
536
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
537
#elif N_THUMB
Damien George's avatar
Damien George committed
538
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
539
540
541
#endif
}

542
STATIC void emit_call_with_imm_arg(emit_t *emit, mp_fun_kind_t fun_kind, mp_int_t arg_val, int arg_reg) {
543
    need_reg_all(emit);
544
    ASM_MOV_IMM_TO_REG(arg_val, arg_reg);
545
#if N_X64
546
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
547
#elif N_THUMB
Damien George's avatar
Damien George committed
548
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
549
#endif
550
551
}

552
// the first arg is stored in the code aligned on a mp_uint_t boundary
553
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) {
554
555
556
    need_reg_all(emit);
    ASM_MOV_ALIGNED_IMM_TO_REG(arg_val, arg_reg);
#if N_X64
557
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
558
559
560
561
562
#elif N_THUMB
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
#endif
}

563
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) {
564
565
566
567
    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
568
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
569
#elif N_THUMB
Damien George's avatar
Damien George committed
570
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
571
572
573
#endif
}

574
// the first arg is stored in the code aligned on a mp_uint_t boundary
575
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) {
576
    need_reg_all(emit);
577
    ASM_MOV_ALIGNED_IMM_TO_REG(arg_val1, arg_reg1);
578
579
580
    ASM_MOV_IMM_TO_REG(arg_val2, arg_reg2);
    ASM_MOV_IMM_TO_REG(arg_val3, arg_reg3);
#if N_X64
581
    asm_x64_call_ind(emit->as, mp_fun_table[fun_kind], REG_RAX);
582
583
584
585
586
#elif N_THUMB
    asm_thumb_bl_ind(emit->as, mp_fun_table[fun_kind], fun_kind, REG_R3);
#endif
}

587
588
589
590
591
592
// 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);
593

594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
    // 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);
634
            emit_call_with_imm_arg(emit, MP_F_CONVERT_NATIVE_TO_OBJ, si->vtype, REG_ARG_2); // arg2 = type
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
            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;
651
    }
652
653
654
655
656
657
    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);
658
659
}

660
STATIC void emit_native_store_id(emit_t *emit, qstr qstr) {
661
662
663
    emit_common_store_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr);
}

664
STATIC void emit_native_delete_id(emit_t *emit, qstr qstr) {
665
666
667
    emit_common_delete_id(emit, &EXPORT_FUN(method_table), emit->scope, qstr);
}

668
STATIC void emit_native_label_assign(emit_t *emit, uint l) {
669
    emit_native_pre(emit);
670
671
    // need to commit stack because we can jump here from elsewhere
    need_stack_settled(emit);
672
#if N_X64
673
    asm_x64_label_assign(emit->as, l);
674
#elif N_THUMB
675
676
    asm_thumb_label_assign(emit->as, l);
#endif
677
    emit_post(emit);
678
679
}

680
681
682
683
684
685
686
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);
687
    emit_call_with_imm_arg(emit, MP_F_IMPORT_NAME, qst, REG_ARG_1); // arg1 = import name
688
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
689
690
}

691
692
693
694
695
696
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);
697
    emit_call_with_imm_arg(emit, MP_F_IMPORT_FROM, qst, REG_ARG_2); // arg2 = import name
698
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
699
700
}

701
STATIC void emit_native_import_star(emit_t *emit) {
702
703
704
705
    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);
706
    emit_call(emit, MP_F_IMPORT_ALL);
707
    emit_post(emit);
708
709
}

710
STATIC void emit_native_load_const_tok(emit_t *emit, mp_token_kind_t tok) {
711
    DEBUG_printf("load_const_tok %d\n", tok);
712
    emit_native_pre(emit);
713
    int vtype;
714
    mp_uint_t val;
715
716
    if (emit->do_viper_types) {
        switch (tok) {
717
718
719
            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;
720
721
722
723
724
            default: assert(0); vtype = 0; val = 0; // shouldn't happen
        }
    } else {
        vtype = VTYPE_PYOBJ;
        switch (tok) {
725
726
727
            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;
728
729
730
731
732
733
            default: assert(0); vtype = 0; val = 0; // shouldn't happen
        }
    }
    emit_post_push_imm(emit, vtype, val);
}

734
STATIC void emit_native_load_const_small_int(emit_t *emit, mp_int_t arg) {
735
    DEBUG_printf("load_const_small_int %d\n", arg);
736
    emit_native_pre(emit);
737
738
739
740
741
742
743
    if (emit->do_viper_types) {
        emit_post_push_imm(emit, VTYPE_INT, arg);
    } else {
        emit_post_push_imm(emit, VTYPE_PYOBJ, (arg << 1) | 1);
    }
}

744
745
746
747
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);
748
    emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_INT, qst, REG_ARG_1);
749
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
750
751
}

752
STATIC void emit_native_load_const_dec(emit_t *emit, qstr qstr) {
753
    // for viper, a float/complex is just a Python object
754
    emit_native_pre(emit);
755
    emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_DEC, qstr, REG_ARG_1);
756
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
757
758
}

759
STATIC void emit_native_load_const_str(emit_t *emit, qstr qstr, bool bytes) {
760
    emit_native_pre(emit);
761
762
763
764
    if (emit->do_viper_types) {
        // not implemented properly
        // load a pointer to the asciiz string?
        assert(0);
765
        emit_post_push_imm(emit, VTYPE_PTR, (mp_uint_t)qstr_str(qstr));
766
    } else {
767
        if (bytes) {
768
            emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_BYTES, qstr, REG_ARG_1);
769
        } else {
770
            emit_call_with_imm_arg(emit, MP_F_LOAD_CONST_STR, qstr, REG_ARG_1);
771
        }
772
773
774
775
        emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
    }
}

776
777
778
779
780
STATIC void emit_native_load_null(emit_t *emit) {
    emit_native_pre(emit);
    emit_post_push_imm(emit, VTYPE_PYOBJ, 0);
}

781
STATIC void emit_native_load_fast(emit_t *emit, qstr qstr, uint id_flags, int local_num) {
782
783
784
785
    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));
    }
786
    emit_native_pre(emit);
787
#if N_X64
788
789
790
    if (local_num == 0) {
        emit_post_push_reg(emit, vtype, REG_LOCAL_1);
    } else {
791
        need_reg_single(emit, REG_RAX, 0);
792
        asm_x64_mov_local_to_r64(emit->as, local_num - REG_LOCAL_NUM, REG_RAX);
793
794
        emit_post_push_reg(emit, vtype, REG_RAX);
    }
795
#elif N_THUMB
796
797
798
799
800
801
802
    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 {
803
        need_reg_single(emit, REG_R0, 0);
804
        asm_thumb_mov_reg_local(emit->as, REG_R0, local_num - REG_LOCAL_NUM);
805
806
807
808
809
        emit_post_push_reg(emit, vtype, REG_R0);
    }
#endif
}

810
STATIC void emit_native_load_deref(emit_t *emit, qstr qstr, int local_num) {
Damien's avatar
Damien committed
811
812
813
814
815
    // not implemented
    // in principle could support this quite easily (ldr r0, [r0, #0]) and then get closed over variables!
    assert(0);
}

816
STATIC void emit_native_load_name(emit_t *emit, qstr qstr) {
817
    emit_native_pre(emit);
818
    emit_call_with_imm_arg(emit, MP_F_LOAD_NAME, qstr, REG_ARG_1);
819
820
821
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}

822
STATIC void emit_native_load_global(emit_t *emit, qstr qstr) {
823
    emit_native_pre(emit);
824
    emit_call_with_imm_arg(emit, MP_F_LOAD_GLOBAL, qstr, REG_ARG_1);
825
826
827
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}

828
STATIC void emit_native_load_attr(emit_t *emit, qstr qstr) {
829
830
831
    // 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
832
    //  - Python object: call mp_load_attr, and needs to be typed to convert result
833
834
835
    vtype_kind_t vtype_base;
    emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
    assert(vtype_base == VTYPE_PYOBJ);
836
    emit_call_with_imm_arg(emit, MP_F_LOAD_ATTR, qstr, REG_ARG_2); // arg2 = attribute name
837
838
839
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
}

840
STATIC void emit_native_load_method(emit_t *emit, qstr qstr) {
841
842
843
844
    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
845
    emit_call_with_imm_arg(emit, MP_F_LOAD_METHOD, qstr, REG_ARG_2); // arg2 = method name
846
847
}

848
STATIC void emit_native_load_build_class(emit_t *emit) {
849
    emit_native_pre(emit);
850
    emit_call(emit, MP_F_LOAD_BUILD_CLASS);
851
    emit_post_push_reg(emit, VTYPE_PYOBJ, REG_RET);
852
853
}

854
855
856
857
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) {
858
        emit_call_with_imm_arg(emit, MP_F_OBJ_SUBSCR, (mp_uint_t)MP_OBJ_SENTINEL, REG_ARG_3);
859
860
861
862
863
864
        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);
    }
}

865
STATIC void emit_native_store_fast(emit_t *emit, qstr qstr, int local_num) {
866
    vtype_kind_t vtype;
867
#if N_X64
868
869
870
871
    if (local_num == 0) {
        emit_pre_pop_reg(emit, &vtype, REG_LOCAL_1);
    } else {
        emit_pre_pop_reg(emit, &vtype, REG_RAX);
872
        asm_x64_mov_r64_to_local(emit->as, REG_RAX, local_num - REG_LOCAL_NUM);
873
    }
874
#elif N_THUMB
875
876
877
878
879
880
881
882
    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);
883
        asm_thumb_mov_local_reg(emit->as, local_num - REG_LOCAL_NUM, REG_R0);
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
    }
#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);
    }
}

899
STATIC void emit_native_store_deref(emit_t *emit, qstr qstr, int local_num) {
Damien's avatar
Damien committed
900
901
902
903
    // not implemented
    assert(0);
}

904
STATIC void emit_native_store_name(emit_t *emit, qstr qstr) {
Damien George's avatar
Damien George committed
905
    // mp_store_name, but needs conversion of object (maybe have mp_viper_store_name(obj, type))
906
907
908
    vtype_kind_t vtype;
    emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
    assert(vtype == VTYPE_PYOBJ);
909
    emit_call_with_imm_arg(emit, MP_F_STORE_NAME, qstr, REG_ARG_1); // arg1 = name
910
911
912
    emit_post(emit);
}

913
STATIC void emit_native_store_global(emit_t *emit, qstr qstr) {
914
915
916
917
918
    vtype_kind_t vtype = peek_vtype(emit);
    if (vtype == VTYPE_PYOBJ) {
        emit_pre_pop_reg(emit, &vtype, REG_ARG_2);
    } else {
        emit_pre_pop_reg(emit, &vtype, REG_ARG_1);
919
        emit_call_with_imm_arg(emit, MP_F_CONVERT_NATIVE_TO_OBJ, vtype, REG_ARG_2); // arg2 = type
920
921
        ASM_MOV_REG_TO_REG(REG_RET, REG_ARG_2);
    }
922
    emit_call_with_imm_arg(emit, MP_F_STORE_GLOBAL, qstr, REG_ARG_1); // arg1 = name
923
    emit_post(emit);
924
925
}

926
STATIC void emit_native_store_attr(emit_t *emit, qstr qstr) {
927
928
929
930
    vtype_kind_t vtype_base, vtype_val;
    emit_pre_pop_reg_reg(emit, &vtype_base, REG_ARG_1, &vtype_val, REG_ARG_3); // arg1 = base, arg3 = value
    assert(vtype_base == VTYPE_PYOBJ);
    assert(vtype_val == VTYPE_PYOBJ);
931
    emit_call_with_imm_arg(emit, MP_F_STORE_ATTR, qstr, REG_ARG_2); // arg2 = attribute name
932
    emit_post(emit);
933
934
}

935
STATIC void emit_native_store_subscr(emit_t *emit) {
936
937
938
939
940
941
942
943
944
    // depends on type of subject:
    //  - integer, function, pointer to structure: error
    //  - pointer to integers: store as per array
    //  - Python object: call runtime with converted object or type info
    vtype_kind_t vtype_index, vtype_base, vtype_value;
    emit_pre_pop_reg_reg_reg(emit, &vtype_index, REG_ARG_2, &vtype_base, REG_ARG_1, &vtype_value, REG_ARG_3); // index, base, value to store
    assert(vtype_index == VTYPE_PYOBJ);
    assert(vtype_base == VTYPE_PYOBJ);
    assert(vtype_value == VTYPE_PYOBJ);
945
    emit_call(emit, MP_F_OBJ_SUBSCR);
946
947
}

948
STATIC void emit_native_delete_fast(emit_t *emit, qstr qstr, int local_num) {
949
950
951
952
953
    // not implemented
    // could support for Python types, just set to None (so GC can reclaim it)
    assert(0);
}

954
STATIC void emit_native_delete_deref(emit_t *emit, qstr qstr, int local_num) {
Damien's avatar
Damien committed
955
956
957
958
    // not supported
    assert(0);
}

959
STATIC void emit_native_delete_name(emit_t *emit, qstr qstr) {
960
    // not implemented
Damien George's avatar
Damien George committed
961
    // use mp_delete_name
962
963
964
    assert(0);
}

965
STATIC void emit_native_delete_global(emit_t *emit, qstr qstr) {
966
    // not implemented
Damien George's avatar
Damien George committed
967
    // use mp_delete_global
968
969
970
    assert(0);
}

971
STATIC void emit_native_delete_attr(emit_t *emit, qstr qstr) {
972
973
974
    vtype_kind_t vtype_base;
    emit_pre_pop_reg(emit, &vtype_base, REG_ARG_1); // arg1 = base
    assert(vtype_base == VTYPE_PYOBJ);
975
    emit_call_with_2_imm_args(emit, MP_F_STORE_ATTR, qstr, REG_ARG_2, (mp_uint_t)MP_OBJ_NULL, REG_ARG_3); // arg2 = attribute name, arg3 = value (null for delete)
976
    emit_post(emit);
977
978
}

979
STATIC void emit_native_delete_subscr(emit_t *emit) {
980
981
982
983
    vtype_kind_t vtype_index, vtype_base;
    emit_pre_pop_reg_reg(emit, &vtype_index, REG_ARG_2, &vtype_base, REG_ARG_1); // index, base
    assert(vtype_index == VTYPE_PYOBJ);
    assert(vtype_base == VTYPE_PYOBJ);
984
    emit_call_with_imm_arg(emit, MP_F_OBJ_SUBSCR, (mp_uint_t)MP_OBJ_NULL, REG_ARG_3);
985
986
}

987
STATIC void emit_native_dup_top(emit_t *emit) {
988
989
990
991
992
    vtype_kind_t vtype;
    emit_pre_pop_reg(emit, &vtype, REG_TEMP0);
    emit_post_push_reg_reg(emit, vtype, REG_TEMP0, vtype, REG_TEMP0);
}

993
STATIC void emit_native_dup_top_two(emit_t *emit) {
994
995
996
997
998
    vtype_kind_t vtype0, vtype1;
    emit_pre_pop_reg_reg(emit, &vtype0, REG_TEMP0, &vtype1, REG_TEMP1);
    emit_post_push_reg_reg_reg_reg(emit, vtype1, REG_TEMP1, vtype0, REG_TEMP0, vtype1, REG_TEMP1, vtype0, REG_TEMP0);
}

999
STATIC void emit_native_pop_top(emit_t *emit) {
1000
    vtype_kind_t vtype;
For faster browsing, not all history is shown. View entire blame