pike.git / src / code / amd64.c

version» Context lines:

pike.git/src/code/amd64.c:42:   #else   /* From SysV ABI for AMD64 draft 0.99.5. */   #define ARG1_REG REG_RDI   #define ARG2_REG REG_RSI   #define ARG3_REG REG_RDX   #define ARG4_REG REG_RCX   #define ARG5_REG REG_R8   #define ARG6_REG REG_R9   #endif    + static enum amd64_reg sp_reg = -1, fp_reg = -1, mark_sp_reg = -1; + static int dirty_regs = 0, ret_for_func = 0; + ptrdiff_t amd64_prev_stored_pc = -1; /* PROG_PC at the last point Pike_fp->pc was updated. */ + static int branch_check_threads_update_etc = -1;    -  +    #define MAX_LABEL_USES 6   struct label {    int n_label_uses;    ptrdiff_t addr;    ptrdiff_t offset[MAX_LABEL_USES];   };      static void label( struct label *l )   {    int i;
pike.git/src/code/amd64.c:887:    push(REG_R13);    push(REG_R12);    push(REG_RBX);    sub_reg_imm(REG_RSP, 8); /* Align on 16 bytes. */       mov_reg_reg(ARG1_REG, Pike_interpreter_reg);       amd64_flush_code_generator_state();   }    - static enum amd64_reg sp_reg = -1, fp_reg = -1, mark_sp_reg = -1; - static int dirty_regs = 0, ret_for_func = 0; - ptrdiff_t amd64_prev_stored_pc = -1; /* PROG_PC at the last point Pike_fp->pc was updated. */ - static int branch_check_threads_update_etc = -1; -  -  +    void amd64_flush_code_generator_state(void)   {    sp_reg = -1;    fp_reg = -1;    mark_sp_reg = -1;    dirty_regs = 0;    ret_for_func = 0;    amd64_prev_stored_pc = -1;    branch_check_threads_update_etc = -1;   }
pike.git/src/code/amd64.c:1135:    amd64_load_sp_reg();       mov_mem_reg( fp_reg, OFFSETOF(pike_frame, locals), ARG1_REG);    add_reg_imm( ARG1_REG,b*sizeof(struct svalue) );    mov_reg_reg( ARG1_REG, REG_RBX );       /* Free old svalue. */    amd64_free_svalue(ARG1_REG, 0);       /* Copy sp[-1] -> local */ +  amd64_load_sp_reg();    mov_mem_reg(sp_reg, -1*sizeof(struct svalue), REG_RAX);    mov_mem_reg(sp_reg, -1*sizeof(struct svalue)+sizeof(long), REG_RCX);       mov_reg_mem( REG_RAX, REG_RBX, 0 );    mov_reg_mem( REG_RCX, REG_RBX, sizeof(long) );   }      static void amd64_pop_mark(void)   {    amd64_add_mark_sp( -1 );
pike.git/src/code/amd64.c:1188:   }      static void amd64_stack_error(void)   {    Pike_fatal("Stack error\n");   }      void amd64_update_pc(void)   {    INT32 tmp = PIKE_PC, disp; +  const enum amd64_reg tmp_reg = REG_RAX;       if(amd64_prev_stored_pc == - 1)    { -  enum amd64_reg tmp_reg = REG_RAX; +     amd64_load_fp_reg();    mov_rip_imm_reg(tmp - PIKE_PC, tmp_reg);    mov_reg_mem(tmp_reg, fp_reg, OFFSETOF(pike_frame, pc));   #ifdef PIKE_DEBUG    if (a_flag >= 60)    fprintf (stderr, "pc %d update pc via lea\n", tmp);   #endif    amd64_prev_stored_pc = tmp;    }    else if ((disp = tmp - amd64_prev_stored_pc))
pike.git/src/code/amd64.c:1399:    Pike_error("Instruction too big %d\n",b);   #endif    maybe_update_pc();       flags = instrs[b].flags;       addr=instrs[b].address;    switch(b + F_OFFSET)    {    case F_DUP: -  amd64_load_sp_reg(); +     ins_debug_instr_prologue(b, 0, 0); -  +  amd64_load_sp_reg();    add_reg_imm_reg(sp_reg, -sizeof(struct svalue), REG_R10 );    amd64_push_svaluep( REG_R10 );    return;      #if 0    case F_ESCAPE_CATCH:       case F_EXIT_CATCH: -  +  ins_debug_instr_prologue(b, 0, 0);    ins_f_byte( F_ESCAPE_CATCH );    amd64_load_sp_reg();    amd64_push_int( 0, 1 );    return;   #endif    /* -3 -2 -1 0    * lval[0], lval[1], <RANDOM>, **SP**    * ->    * -4 -3 -2 -1 0    * lval[0], lval[1], *lval, <RANDOM>, *SP**    *    * This will also free *lval iff it has type    * array,multiset,mapping or string.    */    case F_LTOSVAL2_AND_FREE:    { -  +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -3*sizeof(struct svalue), REG_RBX );    cmp_reg_imm( REG_RBX, T_SVALUE_PTR );    jne( &label_A );       /* inline version for SVALUE_PTR. */       /* First, make room for the result, move top and inc sp */    mov_mem_reg( sp_reg, -sizeof(struct svalue), REG_RAX );    mov_mem_reg( sp_reg, -sizeof(struct svalue)+8, REG_RCX );
pike.git/src/code/amd64.c:1470:    LABEL_A;    /* So, not a svalueptr. Use C-version */    amd64_call_c_opcode( addr, flags );    amd64_load_sp_reg();    LABEL_B;    }    return;       case F_LTOSVAL:    { +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -sizeof(struct svalue)*2, REG_RAX );    /* lval type in RAX. */    /*    if( rax == T_SVALUE_PTR )    push( *l->u.lval )       possibly:    if( rax == T_OBJECT )    object_index_no_free( to, lval->u.object, lval->subtype, &lval[1])       if( rax == T_ARRAY && lval[1].type == PIKE_T_INT )    push( l->u.array->item[&lval[1].u.integer] )    */    cmp_reg_imm( REG_RAX, T_SVALUE_PTR );    je( &label_A );    /* So, not a svalueptr */    mov_reg_reg( sp_reg, ARG1_REG );    add_reg_imm_reg( sp_reg, -2*sizeof(struct svalue), ARG2_REG );    amd64_call_c_function(lvalue_to_svalue_no_free); -  +  amd64_load_sp_reg();    amd64_add_sp(1);    jmp(&label_B);    LABEL_A;    mov_mem_reg( sp_reg, -sizeof(struct svalue)*2+OFFSETOF(svalue,u.lval),    REG_RCX );    amd64_push_svaluep(REG_RCX);    LABEL_B;    }    return;    case F_ASSIGN:    { -  +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -3*sizeof(struct svalue), REG_RAX );    cmp_reg_imm( REG_RAX, T_SVALUE_PTR );       je( &label_A );    /* So, not a svalueptr. Use C-version for simplicity */    amd64_call_c_opcode( addr, flags );    amd64_load_sp_reg();    jmp( &label_B );    amd64_align();
pike.git/src/code/amd64.c:1536:    /*    Note: For SVALUEPTR we know we do not have to free    the lvalue.    */    amd64_add_sp( -2 );    LABEL_B;    }    return;    case F_ASSIGN_AND_POP:    { +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -3*sizeof(struct svalue), REG_RAX );    cmp_reg_imm( REG_RAX, T_SVALUE_PTR );       je( &label_A );    /* So, not a svalueptr. Use C-version for simplicity */    amd64_call_c_opcode( addr, flags );    amd64_load_sp_reg();    jmp( &label_B );    amd64_align();
pike.git/src/code/amd64.c:1569:    Note: For SVALUEPTR we know we do not have to free    the lvalue.    */    amd64_add_sp( -3 );    LABEL_B;    }    return;    return;    case F_ADD_INTS:    { -  amd64_load_sp_reg(); +     ins_debug_instr_prologue(b, 0, 0); -  +  amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -sizeof(struct svalue)*2, REG_RAX );    shl_reg_imm( REG_RAX, 8 );    mov_mem8_reg( sp_reg,-sizeof(struct svalue), REG_RBX );    /* and_reg_imm( REG_RBX, 0x1f );*/    add_reg_reg( REG_RAX, REG_RBX );    /* and_reg_imm( REG_RAX, 0x1f1f ); */    cmp_reg32_imm( REG_RAX, (PIKE_T_INT<<8)|PIKE_T_INT );    jne( &label_A );    /* So. Both are actually integers. */    mov_mem_reg( sp_reg,
pike.git/src/code/amd64.c:1609:    amd64_call_c_opcode( f_add, I_UPDATE_SP );    amd64_load_sp_reg();    LABEL_B;    }    return;       case F_SWAP:    /*    pike_sp[-1] = pike_sp[-2]    */ +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    add_reg_imm_reg( sp_reg, -2*sizeof(struct svalue), REG_RCX );    mov_mem128_reg( REG_RCX, 0, REG_XMM0 );    mov_mem128_reg( REG_RCX, 16, REG_XMM1 );    mov_reg_mem128( REG_XMM1, REG_RCX, 0 );    mov_reg_mem128( REG_XMM0, REG_RCX, 16 );   #if 0    add_reg_imm_reg( sp_reg, -2*sizeof(struct svalue), REG_R10);    mov_mem_reg( REG_R10, 0, REG_RAX );    mov_mem_reg( REG_R10, 8, REG_RCX );
pike.git/src/code/amd64.c:1634: Inside #if 0
   mov_reg_mem(REG_RAX, REG_R10,sizeof(struct svalue));    mov_reg_mem(REG_RCX, REG_R10,8+sizeof(struct svalue));    /* save done. */   #endif    return;       case F_INDEX:    /*    pike_sp[-2][pike_sp[-1]]    */ +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -2*sizeof(struct svalue), REG_RAX );    mov_mem8_reg( sp_reg, -1*sizeof(struct svalue), REG_RBX );    shl_reg_imm( REG_RAX, 8 );    add_reg_reg( REG_RAX, REG_RBX );    mov_mem_reg( sp_reg, -1*sizeof(struct svalue)+8, REG_RBX ); /* int */    mov_mem_reg( sp_reg, -2*sizeof(struct svalue)+8, REG_RCX ); /* value */    cmp_reg32_imm( REG_RAX, (PIKE_T_ARRAY<<8)|PIKE_T_INT );    jne( &label_A );   
pike.git/src/code/amd64.c:1740:    {    /* Special argument for the F_CATCH instruction. */    addr = inter_return_opcode_F_CATCH;    mov_rip_imm_reg(0, ARG1_REG); /* Address for the POINTER. */    rel_addr = PIKE_PC;    }    break;    case F_ZERO_TYPE:    {    LABELS(); +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem32_reg( sp_reg, -sizeof(struct svalue), REG_RAX );    /* Rax now has type + subtype. */    mov_reg_reg( REG_RAX, REG_RBX );    and_reg_imm( REG_RAX, 0x1f );    cmp_reg32_imm( REG_RAX, PIKE_T_INT );    jne( &label_A );    /* It is an integer. */    shr_reg_imm( REG_RBX, 16 );    /* subtype in RBX. */
pike.git/src/code/amd64.c:1824:    case F_POP_TO_MARK:    ins_debug_instr_prologue(b, 0, 0);    amd64_load_mark_sp_reg();    amd64_load_sp_reg();    amd64_pop_mark();    mov_mem_reg(mark_sp_reg, 0, REG_RBX);    jmp(&label_A);    LABEL_B;    amd64_add_sp( -1 );    amd64_free_svalue( sp_reg, 0 ); +  amd64_load_sp_reg();    LABEL_A;    cmp_reg_reg(REG_RBX, sp_reg);    jl(&label_B);    return;    /* If we are compiling with debug, F_RETURN does extra checks */       case F_RETURN:    case F_DUMB_RETURN:    {    LABELS(); -  +  ins_debug_instr_prologue(b, 0, 0);    amd64_load_fp_reg();    /* Note: really mem16, but we & with PIKE_FRAME_RETURN_INTERNAL anyway */    mov_mem32_reg( fp_reg, OFFSETOF(pike_frame, flags), REG_RAX );    and_reg_imm( REG_RAX, PIKE_FRAME_RETURN_INTERNAL);    jnz( &label_A );    /* So, it is just a normal return. */    LABEL_B;    /* Actually return */    flush_dirty_regs();    amd64_return_from_function();
pike.git/src/code/amd64.c:1964:    /* string, array, mapping or float. Always true */    amd64_add_sp(-1);    amd64_free_svalue_type( sp_reg, REG_RCX, 0 );    mov_imm_reg( 1, REG_RBX );    jmp( &label_B );       LABEL_A;    /* function or object. Use svalue_is_true. */    add_reg_imm_reg(sp_reg, -sizeof(struct svalue), ARG1_REG );    amd64_call_c_function(svalue_is_true); +  amd64_load_sp_reg();    mov_reg_reg( REG_RAX, REG_RBX );    amd64_add_sp( -1 );    amd64_free_svalue( sp_reg, 0 ); /* Pop the stack. */    jmp( &label_B );       LABEL_C;    /* integer */    mov_mem_reg( sp_reg,    -sizeof(struct svalue)+OFFSETOF(svalue,u.integer),    REG_RBX );    amd64_add_sp(-1);       LABEL_B; /* Branch or not? */    test_reg( REG_RBX );    if( op == F_BRANCH_WHEN_ZERO )    return jz_imm_rel32(0);    return jnz_imm_rel32(0);       case F_FOREACH: -  +  START_JUMP();    /* -4: array    -3: lvalue[0]    -2: lvalue[1]    -1: counter    */    amd64_load_sp_reg();    mov_mem_reg( sp_reg, -1*sizeof(struct svalue)+8, REG_RAX );    mov_mem_reg( sp_reg, -4*sizeof(struct svalue)+8, REG_RBX );    mov_mem32_reg( REG_RBX, OFFSETOF(array,size), REG_RCX );    cmp_reg_reg( REG_RAX, REG_RCX );
pike.git/src/code/amd64.c:2040:    amd64_call_c_function( assign_lvalue );    jmp(&label_B);       LABEL_A;    mov_imm_reg( 0, REG_RBX );    LABEL_B;    test_reg(REG_RBX);    return jnz_imm_rel32(0);       case F_LOOP: +  START_JUMP();    /* counter in pike_sp-1 */    /* decrement until 0. */    /* if not 0, branch */    /* otherwise, pop */ -  START_JUMP(); +     amd64_load_sp_reg();    mov_mem32_reg( sp_reg, -sizeof(struct svalue), REG_RAX );    /* Is it a normal integer? subtype -> 0, type -> PIKE_T_INT */    cmp_reg32_imm( REG_RAX, PIKE_T_INT );    jne( &label_A );       /* if it is, is it 0? */    mov_mem_reg( sp_reg, -sizeof(struct svalue)+8, REG_RAX );    test_reg(REG_RAX);    jz( &label_B ); /* it is. */
pike.git/src/code/amd64.c:2083:    amd64_add_sp( -1 );    mov_imm_reg(0, REG_RAX );       LABEL_C; /* Branch or not? */    test_reg( REG_RAX );    return jnz_imm_rel32(0);       case F_BRANCH_WHEN_EQ: /* sp[-2] != sp[-1] */    case F_BRANCH_WHEN_NE: /* sp[-2] != sp[-1] */   /* START_JUMP();*/ +  ins_debug_instr_prologue(op, 0, 0);    amd64_load_sp_reg();    mov_mem16_reg( sp_reg, -sizeof(struct svalue), REG_RAX );    mov_mem16_reg( sp_reg, -sizeof(struct svalue)*2,REG_RBX );    cmp_reg_reg( REG_RAX, REG_RBX );    jnz( &label_A ); /* Types differ */    cmp_reg32_imm( REG_RAX, PIKE_T_OBJECT );    je( &label_A ); /* Do not even bother with objects.. */       mov_mem_reg( sp_reg, -sizeof(struct svalue)+8, REG_RBX );    sub_reg_mem( REG_RBX, sp_reg, -sizeof(struct svalue)*2+8);
pike.git/src/code/amd64.c:2120:       LABEL_B; /* comparison done, pop stack x2, reftypes */    amd64_add_sp( -2 );       mov_mem_reg( sp_reg, OFFSETOF(svalue,u.refs), REG_RAX );    add_mem32_imm( REG_RAX, OFFSETOF(pike_string,refs), -1 );    jnz( &label_C );    /* Free sp_reg */    mov_reg_reg( sp_reg, ARG1_REG );    amd64_call_c_function( really_free_svalue ); +  amd64_load_sp_reg();    LABEL_C;    add_reg_imm_reg( sp_reg, sizeof(struct svalue), ARG1_REG );    mov_mem_reg( ARG1_REG, OFFSETOF(svalue,u.refs), REG_RAX );    add_mem32_imm( REG_RAX, OFFSETOF(pike_string,refs), -1 );    jnz( &label_D );    amd64_call_c_function( really_free_svalue );    /* free sp[-2] */    LABEL_D;    test_reg(REG_RBX);    if( op == F_BRANCH_WHEN_EQ )
pike.git/src/code/amd64.c:2186:    return ret;   }      void ins_f_byte_with_arg(unsigned int a, INT32 b)   {    maybe_update_pc();    switch(a) {    case F_THIS_OBJECT:    if( b == 0 )    { +  ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_push_this_object();    return;    }    break; /* Fallback to C-version. */    -  +     case F_RETURN_LOCAL:    /* FIXME: The C version has a trick:    if locals+b < expendibles, pop to there    and return.       This saves a push, and the poping has to be done anyway.    */    ins_f_byte_with_arg( F_LOCAL, b );    ins_f_byte( F_DUMB_RETURN );    return;       case F_NEG_INT_INDEX:    {    LABELS(); -  +  ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -1*sizeof(struct svalue), REG_RAX );    cmp_reg32_imm( REG_RAX, PIKE_T_ARRAY );    jne( &label_A );       mov_mem_reg( sp_reg, -1*sizeof(struct svalue)+8, REG_RDX ); /* u.array */    /* -> arr[sizeof(arr)-b] */    mov_mem32_reg( REG_RDX, OFFSETOF(array,size), REG_RBX );    sub_reg_imm( REG_RBX, b );    js( &label_A ); /* if signed result, index outside array */
pike.git/src/code/amd64.c:2241:    update_arg1( b );    amd64_call_c_opcode(instrs[a-F_OFFSET].address,    instrs[a-F_OFFSET].flags);    LABEL_C;    }    return;       case F_POS_INT_INDEX:    {    LABELS(); +  ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -1*sizeof(struct svalue), REG_RAX );    cmp_reg32_imm( REG_RAX, PIKE_T_ARRAY );    jne( &label_A );       mov_mem_reg( sp_reg, -1*sizeof(struct svalue)+8, REG_RDX ); /* u.array */    /* -> arr[sizeof(arr)-b] */    mov_mem32_reg( REG_RDX, OFFSETOF(array,size), REG_RCX );    mov_imm_reg( b, REG_RBX);    cmp_reg_reg( REG_RCX, REG_RBX );
pike.git/src/code/amd64.c:2279:    LABEL_C;    }    return;       case F_LOCAL_INDEX:    {    LABELS();    /*    pike_sp[-2][pike_sp[-1]]    */ +  ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    amd64_load_fp_reg();       mov_mem_reg( fp_reg, OFFSETOF(pike_frame,locals), REG_RDX);    add_reg_imm( REG_RDX, b*sizeof(struct svalue));    mov_mem8_reg( REG_RDX, 0, REG_RAX );    mov_mem8_reg( sp_reg, -1*sizeof(struct svalue), REG_RBX );    shl_reg_imm( REG_RAX, 8 );    add_reg_reg( REG_RAX, REG_RBX );    mov_mem_reg( sp_reg, -1*sizeof(struct svalue)+8, REG_RBX ); /* int */
pike.git/src/code/amd64.c:2332:    }    return;          case F_ADD_NEG_INT:    b = -b;       case F_ADD_INT:    {    LABELS(); +  ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    mov_mem16_reg( sp_reg, -sizeof(struct svalue), REG_RAX );    cmp_reg32_imm( REG_RAX,PIKE_T_INT );    jne( &label_A );    mov_mem_reg(sp_reg,    -sizeof(struct svalue)+OFFSETOF(svalue,u.integer),    REG_RAX );    test_reg( REG_RAX );    jz( &label_C );   
pike.git/src/code/amd64.c:2450:    mov_mem_reg(fp_reg, OFFSETOF(pike_frame,context), ARG2_REG);    mov_mem16_reg(ARG2_REG, OFFSETOF(inherit, identifier_level), ARG2_REG);       add_reg_imm( ARG2_REG, b );    add_reg_imm_reg( sp_reg, -sizeof(struct svalue), ARG3_REG );    amd64_call_c_function( object_low_set_index );       if( a == F_ASSIGN_GLOBAL_AND_POP )    {    /* assign done, pop. */ +  amd64_load_sp_reg();    amd64_add_sp( -1 );    amd64_free_svalue( sp_reg, 1 );    }    return;       case F_SIZEOF_LOCAL:    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_fp_reg();
pike.git/src/code/amd64.c:2486:    jne( &label_B );    /* It's a string */    /* move arg to point to the string */    mov_mem_reg( ARG1_REG, OFFSETOF(svalue, u.string ), ARG1_REG);    /* load size ->RAX*/    mov_mem32_reg( ARG1_REG,OFFSETOF(pike_string, len ), REG_RAX );    jmp( &label_C );    LABEL_B;    /* It's something else, svalue already in ARG1. */    amd64_call_c_function( pike_sizeof ); -  amd64_load_sp_reg(); +     LABEL_C;/* all done, res in RAX */    /* Store result on stack */    amd64_push_int_reg( REG_RAX );    }    return;       case F_GLOBAL:    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_fp_reg();    amd64_load_sp_reg();
pike.git/src/code/amd64.c:2663:    mov_mem_reg( mark_sp_reg, -sizeof(struct svalue*), REG_RAX );    amd64_add_mark_sp( -1 );    mov_reg_reg( sp_reg, ARG1_REG );    sub_reg_reg( ARG1_REG, REG_RAX );    shr_reg_imm( ARG1_REG, 4 );    /* arg1 = (sp_reg - *--mark_sp)/16 (sizeof(svalue)) */       case F_MARK_CALL_BUILTIN:    if(a == F_MARK_CALL_BUILTIN )    { +  /* Note: It is not actually possible to do ins_debug_instr_prologue +  here.    ins_debug_instr_prologue(a-F_OFFSET, b, 0); -  +  */    mov_imm_reg( 0, ARG1_REG );    }       case F_CALL_BUILTIN1:    if(a == F_CALL_BUILTIN1 )    { -  +  /* Note: It is not actually possible to do ins_debug_instr_prologue +  here.    ins_debug_instr_prologue(a-F_OFFSET, b, 0); -  +  */    mov_imm_reg( 1, ARG1_REG );    }    /* Get function pointer */   #if 0    amd64_load_fp_reg();    /* Ok.. This is.. interresting.    Let's trust that the efun really is constant, ok?    */    mov_mem_reg( fp_reg, OFFSETOF(pike_frame,context), REG_RAX );    mov_mem_reg( REG_RAX, OFFSETOF(inherit,prog), REG_RAX );
pike.git/src/code/amd64.c:2828:    case F_NUMBER64:    ins_debug_instr_prologue(a-F_OFFSET, b, c);    amd64_push_int((((unsigned INT64)b)<<32)|(unsigned INT32)c, 0);    return;    case F_MARK_AND_EXTERNAL:    ins_f_byte(F_MARK);    ins_f_byte_with_2_args(F_EXTERNAL, b, c);    return;       case F_ADD_LOCAL_INT: -  amd64_load_sp_reg(); +     case F_ADD_LOCAL_INT_AND_POP:    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_fp_reg();    mov_mem_reg( fp_reg, OFFSETOF(pike_frame, locals), ARG1_REG);    add_reg_imm( ARG1_REG, b*sizeof(struct svalue) );       /* arg1 = dst    arg2 = int
pike.git/src/code/amd64.c:2861:    ins_f_byte(a);    /* Push already done by C version. */    if( a == F_ADD_LOCAL_INT )    jmp( &label_C );       LABEL_B;    if( a == F_ADD_LOCAL_INT )    {    /* push the local. */    /* We know it's an integer (since we did not use the fallback) */ +  amd64_load_sp_reg();    mov_mem_reg( ARG1_REG, OFFSETOF(svalue,u.integer), REG_RAX );    amd64_push_int_reg( REG_RAX );    }    LABEL_C;    return;    }    case F_ADD_LOCALS_AND_POP:    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);
pike.git/src/code/amd64.c:2902:       LABEL_A;    update_arg2(c);    update_arg1(b);    ins_f_byte(a); /* Will call C version */    LABEL_B;    return;    }       case F_ASSIGN_LOCAL_NUMBER_AND_POP: -  ins_debug_instr_prologue(a-F_OFFSET, b, 0); +  ins_debug_instr_prologue(a-F_OFFSET, b, c);    amd64_load_fp_reg();    mov_mem_reg( fp_reg, OFFSETOF(pike_frame, locals), ARG1_REG);    add_reg_imm( ARG1_REG,b*sizeof(struct svalue) );    mov_reg_reg( ARG1_REG, REG_RBX );    amd64_free_svalue(ARG1_REG, 0);    mov_imm_mem(c, REG_RBX, OFFSETOF(svalue, u.integer));    mov_imm_mem32(PIKE_T_INT, REG_RBX, OFFSETOF(svalue, type));    return;       case F_LOCAL_2_LOCAL: