pike.git / src / code / amd64.c

version» Context lines:

pike.git/src/code/amd64.c:38:   #define REG_RDI MISSING_P_   #define REG_R8 MISSING_P_   #define REG_R9 MISSING_P_   #define REG_R10 MISSING_P_   #define REG_R11 MISSING_P_   #define REG_R12 MISSING_P_   #define REG_R13 MISSING_P_   #define REG_R14 MISSING_P_   #define REG_R15 MISSING_P_    + struct soff { int off; int type; int value; };    -  + static struct soff SVAL(int i) + { +  struct soff res; +  res.off = res.type = i*sizeof(struct svalue); +  res.value = res.type + 8; +  return res; + } +    /* Register encodings */   enum amd64_reg {P_REG_RAX = 0, P_REG_RBX = 3, P_REG_RCX = 1, P_REG_RDX = 2,    P_REG_RSP = 4, P_REG_RBP = 5, P_REG_RSI = 6, P_REG_RDI = 7,    P_REG_R8 = 8, P_REG_R9 = 9, P_REG_R10 = 10, P_REG_R11 = 11,    P_REG_R12 = 12, P_REG_R13 = 13, P_REG_R14 = 14, P_REG_R15 = 15,    P_REG_INVALID = -1,       P_REG_XMM0 = 0, P_REG_XMM1 = 1, P_REG_XMM2 = 2, P_REG_XMM3 = 3,    P_REG_XMM4 = 4, P_REG_XMM5 = 5, P_REG_XMM6 = 6, P_REG_XMM7 = 7,    P_REG_XMM8 = 8, P_REG_XMM9 = 9, P_REG_XMM10=10, P_REG_XMM11=11,
pike.git/src/code/amd64.c:207:    add_to_program(0x58 + (reg & 0x07));   }      static void mov_reg_reg(enum amd64_reg from_reg, enum amd64_reg to_reg )   {    rex( 1, from_reg, 0, to_reg );    opcode( 0x89 );    modrm( 3, from_reg, to_reg );   }    + static void mov_reg32_reg(enum amd64_reg from_reg, enum amd64_reg to_reg ) + { +  rex( 0, from_reg, 0, to_reg ); +  opcode( 0x89 ); +  modrm( 3, from_reg, to_reg ); + } +    #define PUSH_INT(X) ins_int((INT32)(X), (void (*)(char))add_to_program)   static void low_mov_mem_reg(enum amd64_reg from_reg, ptrdiff_t offset,    enum amd64_reg to_reg)   {    opcode( 0x8b );    offset_modrm_sib(offset, to_reg, from_reg );   }      static void mov_mem_reg( enum amd64_reg from_reg, ptrdiff_t offset, enum amd64_reg to_reg )   {
pike.git/src/code/amd64.c:639:    }   }      static void test_reg_reg( enum amd64_reg reg1, enum amd64_reg reg2 )   {    rex(1,reg1,0,reg2);    opcode(0x85);    modrm(3, reg1, reg2 );   }    + static void test_reg32_reg( enum amd64_reg reg1, enum amd64_reg reg2 ) + { +  rex(0,reg1,0,reg2); +  opcode(0x85); +  modrm(3, reg1, reg2 ); + } +    static void test_reg( enum amd64_reg reg1 )   {    test_reg_reg( reg1, reg1 );   }    -  + static void test_reg32( enum amd64_reg reg1 ) + { +  test_reg32_reg( reg1, reg1 ); + } +    static void cmp_reg_imm( enum amd64_reg reg, int imm32 )   { -  +  if(!imm32) +  { +  test_reg( reg ); +  return; +  }    rex(1, 0, 0, reg);    if( imm32 > 0x7f || imm32 < -0x80 )    {    if( reg == P_REG_RAX )    {    opcode( 0x3d );    id( imm32 );    }    else    {
pike.git/src/code/amd64.c:671:    else    {    opcode( 0x83 );    modrm( 3,7,reg);    ib( imm32 );    }   }      static void cmp_reg32_imm( enum amd64_reg reg, int imm32 )   { +  if(!imm32) +  { +  test_reg( reg ); +  return; +  }    rex(0, 0, 0, reg);    if( imm32 > 0x7f || imm32 < -0x80 )    {    if( reg == P_REG_RAX )    {    opcode( 0x3d );    id( imm32 );    }    else    {
pike.git/src/code/amd64.c:1049:    mov_mem_reg(Pike_interpreter_reg,    OFFSETOF(Pike_interpreter_struct, mark_stack_pointer),    PIKE_MARK_SP_REG);    mark_sp_reg = PIKE_MARK_SP_REG;    }   }         static void mov_sval_type(enum amd64_reg src, enum amd64_reg dst )   { -  mov_mem8_reg( src, OFFSETOF(svalue, tu.t.type), dst); +  mov_mem8_reg( src, SVAL(0).type, dst);   /* and_reg32_imm( dst, 0x1f );*/   }         #if 0   static void svalue_is_referenced(enum amd64_reg in, struct label *not )   {    /* bit 4 set, and no higher bit set (all with 8bit values). */    /* aka: type & 248 == 8. Incidentally, 248 is equal to -8 in signed 8bit*/    and_reg_imm(in,-8);
pike.git/src/code/amd64.c:1089:      static void update_arg2(INT32 value)   {    mov_imm_reg(value, ARG2_REG);    /* FIXME: Alloc stack space on NT. */   }      static void amd64_add_sp( int num )   {    amd64_load_sp_reg(); -  add_reg_imm( sp_reg, sizeof(struct svalue)*num); +  add_reg_imm( sp_reg, num * sizeof(struct svalue));    dirty_regs |= 1 << PIKE_SP_REG;    flush_dirty_regs(); /* FIXME: Need to change LABEL handling to remove this */   }      static void amd64_add_mark_sp( int num )   {    amd64_load_mark_sp_reg(); -  add_reg_imm( mark_sp_reg, sizeof(struct svalue*)*num); +  add_reg_imm( mark_sp_reg, num * sizeof(struct svalue*));    dirty_regs |= 1 << PIKE_MARK_SP_REG;    flush_dirty_regs(); /* FIXME: Need to change LABEL handling to remove this */   }      /* Note: Uses RAX and RCX internally. reg MUST not be P_REG_RAX. */   static void amd64_push_svaluep_to(int reg, int spoff)   {    LABELS();    if( reg == P_REG_RAX )    Pike_fatal("Using RAX in push_svaluep not supported\n" );    amd64_load_sp_reg();    mov_mem_reg(reg, OFFSETOF(svalue, tu.t.type), P_REG_RAX);    mov_mem_reg(reg, OFFSETOF(svalue, u.refs), P_REG_RCX); -  mov_reg_mem(P_REG_RAX, sp_reg, -  spoff*sizeof(struct svalue)+OFFSETOF(svalue, tu.t.type)); -  mov_reg_mem(P_REG_RCX, sp_reg, -  spoff*sizeof(struct svalue)+OFFSETOF(svalue, u.refs)); +  mov_reg_mem(P_REG_RAX, sp_reg, SVAL(spoff).type); +  mov_reg_mem(P_REG_RCX, sp_reg, SVAL(spoff).value);    and_reg32_imm(P_REG_RAX, MIN_REF_TYPE);    jz(&label_A);    add_imm_mem( 1, P_REG_RCX, OFFSETOF(pike_string, refs));    LABEL_A;   }      static void amd64_push_svaluep(int reg)   {    amd64_push_svaluep_to( reg, 0 );    amd64_add_sp( 1 );   }      static void amd64_push_int(INT64 value, int subtype)   {    amd64_load_sp_reg(); -  mov_imm_mem((subtype<<16) + PIKE_T_INT, sp_reg, OFFSETOF(svalue, tu.t.type)); -  mov_imm_mem(value, sp_reg, OFFSETOF(svalue, u.integer)); +  mov_imm_mem((subtype<<16) + PIKE_T_INT, sp_reg, SVAL(0).type); +  mov_imm_mem(value, sp_reg, SVAL(0).value);    amd64_add_sp( 1 );   }      static void amd64_push_int_reg(enum amd64_reg reg )   {    amd64_load_sp_reg();    mov_imm_mem( PIKE_T_INT, sp_reg, OFFSETOF(svalue, tu.t.type));    mov_reg_mem( reg, sp_reg, OFFSETOF(svalue, u.integer));    amd64_add_sp( 1 );   }
pike.git/src/code/amd64.c:1182:    }    amd64_add_mark_sp( 1 );   }      static void amd64_call_c_function(void *addr)   {    flush_dirty_regs();    call_imm(addr);   }    - static void amd64_free_svalue(enum amd64_reg src, int guaranteed_ref ) + static void amd64_free_svalue_off(enum amd64_reg src, int off, int guaranteed_ref )   {    LABELS();    if( src == P_REG_RAX )    Pike_fatal("Clobbering RAX for free-svalue\n");    /* load type -> RAX */ -  mov_sval_type( src, P_REG_RAX ); -  +  mov_mem8_reg( src, off, P_REG_RAX );    and_reg_imm(P_REG_RAX, MIN_REF_TYPE);    jz( &label_A );       /* Load pointer to refs -> RAX */ -  mov_mem_reg( src, OFFSETOF(svalue, u.refs), P_REG_RAX); +  mov_mem_reg( src,off+OFFSETOF(svalue, u.refs), P_REG_RAX);    /* if( !--*RAX ) */    add_mem32_imm( P_REG_RAX, OFFSETOF(pike_string,refs), -1);    if( !guaranteed_ref )    {    /* We need to see if refs got to 0. */    jnz( &label_A );    /* if so, call really_free_svalue */ -  if( src != ARG1_REG ) -  mov_reg_reg( src, ARG1_REG ); +  add_reg_imm_reg( src, off, ARG1_REG );    amd64_call_c_function(really_free_svalue);    }    LABEL_A;   }    -  + static void amd64_free_svalue(enum amd64_reg src, int guaranteed_ref ) + { +  amd64_free_svalue_off(src,0,guaranteed_ref); + } +    /* Type already in register. Note: Clobbers the type register. */   static void amd64_free_svalue_type(enum amd64_reg src, enum amd64_reg type,    int guaranteed_ref )   {    LABELS();    /* if type < MIN_REF_TYPE+1 */    if( src == P_REG_RAX )    Pike_fatal("Clobbering RAX for free-svalue\n");       and_reg32_imm(type, MIN_REF_TYPE);
pike.git/src/code/amd64.c:1507: Inside #if undefined(USE_VALGRIND)
   call_rel_imm32( branch_check_threads_update_etc );   #ifndef USE_VALGRIND    LABEL_B;   #endif    }   }         void amd64_init_interpreter_state(void)   { + #ifdef PIKE_DEBUG +  if( PIKE_T_INT != 0 ) +  Pike_fatal("assumption failed: pike_t_int == 0\n"); +  if( sizeof(struct svalue) != 16 ) +  Pike_fatal("assumption failed: sizeof svalue != 16\n"); +  if( OFFSETOF(svalue,tu.t.type) != 0 ) +  Pike_fatal("assumption failed: offsetof(svalue.tu.t.type) != 0\n"); +  if( OFFSETOF(svalue,u.integer) != 8 ) +  Pike_fatal("assumption failed: offsetof(svalue.u.integer) != 8\n"); + #endif    instrs[F_CATCH - F_OFFSET].address = inter_return_opcode_F_CATCH;   }      static void amd64_return_from_function()   {    if( ret_for_func )    {    jmp_rel_imm( ret_for_func );    }    else
pike.git/src/code/amd64.c:1896:    }    return;    case F_CATCH:    {    /* 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; +  +  /* sp-1 = undefinedp(sp-1) */ +  case F_UNDEFINEDP: +  { +  LABELS(); +  ins_debug_instr_prologue(b, 0, 0); +  amd64_load_sp_reg(); +  +  mov_mem32_reg( sp_reg, SVAL(-1).type, P_REG_RAX ); +  cmp_reg32_imm( P_REG_RAX, 1<<16 | PIKE_T_INT ); +  jne( &label_A ); +  mov_imm_mem( 1, sp_reg,SVAL(-1).value); +  jmp( &label_B ); +  LABEL_A; +  amd64_free_svalue_off( sp_reg, SVAL(-1).off,0 ); +  mov_imm_mem( 0, sp_reg,SVAL(-1).value); +  LABEL_B; +  mov_imm_mem( PIKE_T_INT, sp_reg,SVAL(-1).type); +  } +  return; +     case F_ZERO_TYPE:    {    LABELS();    ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem32_reg( sp_reg, -sizeof(struct svalue), P_REG_RAX );    /* Rax now has type + subtype. */ -  mov_reg_reg( P_REG_RAX, P_REG_RBX ); -  and_reg_imm( P_REG_RAX, 0x1f ); +  mov_reg32_reg( P_REG_RAX, P_REG_RBX ); +  and_reg32_imm( P_REG_RAX, 0x1f );    cmp_reg32_imm( P_REG_RAX, PIKE_T_INT );    jne( &label_A );    /* It is an integer. */    shr_reg_imm( P_REG_RBX, 16 );    /* subtype in RBX. */    mov_imm_mem( PIKE_T_INT, sp_reg, -sizeof(struct svalue) );    mov_reg_mem( P_REG_RBX, sp_reg,    -sizeof(struct svalue)+OFFSETOF(svalue,u.integer) );    jmp( &label_B );    LABEL_A;    /* not an integer. Use C version for simplicitly.. */    amd64_call_c_opcode( addr, flags );    LABEL_B;    }    return; -  +  +  case F_ADD: +  { +  addr = f_add; +  update_arg1(2); +  amd64_call_c_opcode(addr, flags); +  amd64_load_sp_reg(); +  } +  return; +     case F_INC:    {    LABELS();    ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg(sp_reg, -16, P_REG_RAX ); -  cmp_reg32_imm(P_REG_RAX, PIKE_T_INT); -  jne(&label_A); +  test_reg32(P_REG_RAX); +  jnz(&label_A);    add_imm_mem(1, sp_reg, -8);    jno(&label_B);    add_imm_mem(-1, sp_reg, -8);    LABEL_A;    amd64_call_c_opcode(addr, flags);    LABEL_B;    }    return;    -  case F_ADD: +  case F_DEC:    {    LABELS();    ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg(); -  mov_mem8_reg(sp_reg, -1*sizeof(struct svalue), P_REG_RAX ); -  mov_mem8_reg(sp_reg, -2*sizeof(struct svalue), P_REG_RBX ); -  add_reg_reg(P_REG_RAX,P_REG_RBX); -  test_reg(P_REG_RAX); /* int == 0 */ - #ifdef PIKE_DEBUG -  if( PIKE_T_INT ) -  Pike_fatal("Assertion failed\n"); - #endif +  mov_mem8_reg(sp_reg, -16, P_REG_RAX ); +  test_reg32(P_REG_RAX);    jnz(&label_A); -  amd64_add_sp(-1); -  mov_mem_reg(sp_reg, OFFSETOF(svalue,u.integer), -  P_REG_RAX ); -  add_reg_mem(P_REG_RAX, sp_reg, -  -1*sizeof(struct svalue)+OFFSETOF(svalue,u.integer)); +  add_imm_mem(-1, sp_reg, -8);    jno(&label_B); -  amd64_add_sp(1); -  sub_reg_mem(P_REG_RAX, sp_reg, -  -1*sizeof(struct svalue)+OFFSETOF(svalue,u.integer)); +  add_imm_mem(1, sp_reg, -8);    LABEL_A; -  addr = f_add; -  update_arg1(2); +     amd64_call_c_opcode(addr, flags);    LABEL_B;    }    return;    -  +     case F_SUBTRACT:    {    LABELS();    ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem8_reg(sp_reg, -1*sizeof(struct svalue), P_REG_RAX );    mov_mem8_reg(sp_reg, -2*sizeof(struct svalue), P_REG_RBX );    add_reg_reg(P_REG_RAX,P_REG_RBX); -  test_reg(P_REG_RAX); /* int == 0 */ +  test_reg32(P_REG_RAX); /* int == 0 */    jnz(&label_A);      #ifdef PIKE_DEBUG    if( PIKE_T_INT )    Pike_fatal("Assertion failed\n");   #endif    mov_mem_reg(sp_reg, -1*sizeof(struct svalue)+OFFSETOF(svalue,u.integer),    P_REG_RAX );    mov_mem_reg(sp_reg, -2*sizeof(struct svalue)+OFFSETOF(svalue,u.integer),    P_REG_RCX );
pike.git/src/code/amd64.c:2001:    amd64_load_sp_reg();    jmp(&label_C);    LABEL_B;    mov_reg_mem( P_REG_RCX, sp_reg,    -2*sizeof(struct svalue)+OFFSETOF(svalue,u.integer));    amd64_add_sp(-1);    LABEL_C;    }    return;    -  case F_DEC: -  { -  LABELS(); -  ins_debug_instr_prologue(b, 0, 0); -  amd64_load_sp_reg(); -  mov_mem8_reg(sp_reg, -16, P_REG_RAX ); -  cmp_reg32_imm(P_REG_RAX, PIKE_T_INT); -  jne(&label_A); -  add_imm_mem(-1, sp_reg, -8); -  jno(&label_B); -  add_imm_mem(1, sp_reg, -8); -  LABEL_A; -  amd64_call_c_opcode(addr, flags); -  LABEL_B; -  } -  return; +     case F_UNDEFINED:    ins_debug_instr_prologue(b, 0, 0);    amd64_push_int(0, 1);    return;    case F_CONST0:    ins_debug_instr_prologue(b, 0, 0);    amd64_push_int(0, 0);    return;    case F_CONST1:    ins_debug_instr_prologue(b, 0, 0);
pike.git/src/code/amd64.c:2091:    /* 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), P_REG_RAX ); -  and_reg_imm( P_REG_RAX, PIKE_FRAME_RETURN_INTERNAL); +  and_reg32_imm( P_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();    /* */    LABEL_A;    /* We should jump to the given address. */    mov_mem32_reg( fp_reg, OFFSETOF(pike_frame, flags), P_REG_RAX ); -  and_reg_imm( P_REG_RAX, PIKE_FRAME_RETURN_POP ); +  and_reg32_imm( P_REG_RAX, PIKE_FRAME_RETURN_POP );    jnz( &label_C );    amd64_call_c_function( low_return );    jmp( &label_D );       LABEL_C;    amd64_call_c_function( low_return_pop );       LABEL_D;    fp_reg = -1;    amd64_load_fp_reg();
pike.git/src/code/amd64.c:2126:    return;       case F_CLEAR_STRING_SUBTYPE:    ins_debug_instr_prologue(b, 0, 0);    amd64_load_sp_reg();    mov_mem32_reg(sp_reg, OFFSETOF(svalue, tu.t.type) - sizeof(struct svalue),    P_REG_RAX);    /* NB: We only care about subtype 1! */    cmp_reg32_imm(P_REG_RAX, (1<<16)|PIKE_T_STRING);    jne(&label_A); -  and_reg_imm(P_REG_RAX, 0x1f); +  and_reg32_imm(P_REG_RAX, 0x1f);    mov_reg_mem32(P_REG_RAX,    sp_reg, OFFSETOF(svalue, tu.t.type) - sizeof(struct svalue));    LABEL_A;    return;    }    amd64_call_c_opcode(addr,flags);       if (instrs[b].flags & I_RETURN) {    LABELS();   
pike.git/src/code/amd64.c:2197:    } while(0)       switch( op )    {    case F_QUICK_BRANCH_WHEN_ZERO:    case F_QUICK_BRANCH_WHEN_NON_ZERO:    START_JUMP();    amd64_load_sp_reg();    amd64_add_sp( -1 );    mov_mem_reg( sp_reg, 8, P_REG_RAX ); -  test_reg(P_REG_RAX); +  test_reg32(P_REG_RAX);    if( op == F_QUICK_BRANCH_WHEN_ZERO )    return jz_imm_rel32(0);    return jnz_imm_rel32(0);       case F_BRANCH_WHEN_ZERO:    case F_BRANCH_WHEN_NON_ZERO:    START_JUMP();    amd64_load_sp_reg();    mov_mem8_reg( sp_reg, -sizeof(struct svalue), P_REG_RCX );    cmp_reg32_imm( P_REG_RCX, PIKE_T_INT ); je( &label_C );
pike.git/src/code/amd64.c:2601:    amd64_call_c_opcode(instrs[a-F_OFFSET].address,    instrs[a-F_OFFSET].flags);    LABEL_C;    /* done */    }    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), P_REG_RAX );    cmp_reg32_imm( P_REG_RAX,PIKE_T_INT );    jne( &label_A );    mov_mem_reg(sp_reg,    -sizeof(struct svalue)+OFFSETOF(svalue,u.integer),
pike.git/src/code/amd64.c:2988:    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 */ +  ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_call_c_opcode(Pike_compiler->new_program->constants[b].sval.u.efun->function,    I_UPDATE_SP);    return;       case F_CONSTANT:    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_fp_reg();    amd64_load_sp_reg();    mov_mem_reg( fp_reg, OFFSETOF(pike_frame,context), P_REG_RCX );    mov_mem_reg( P_REG_RCX, OFFSETOF(inherit,prog), P_REG_RCX );
pike.git/src/code/amd64.c:3107:    u.integer -> RAX    else if( type == PIKE_T_OBJECT || type == PIKE_T_FUNCTION )    call svalue_is_true(&local)    else    1 -> RAX       The tests are ordered assuming integers are most commonly    checked. That is not nessasarily true.    */    mov_sval_type( ARG1_REG, P_REG_RCX ); -  cmp_reg32_imm( P_REG_RCX, PIKE_T_INT ); je( &label_C ); +  cmp_reg32_imm( P_REG_RCX, PIKE_T_INT ); +  je( &label_C );    mov_imm_reg( 1, P_REG_RAX );    shl_reg32_reg( P_REG_RAX, P_REG_RCX );    and_reg32_imm( P_REG_RAX, BIT_FUNCTION|BIT_OBJECT );    jnz( &label_A );    /* Not object, int or function. Always true. */    mov_imm_reg( 1, P_REG_RAX );    jmp( &label_B );    LABEL_A;    amd64_call_c_function(svalue_is_true);    jmp( &label_B );
pike.git/src/code/amd64.c:3151:    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_CLEAR_N_LOCAL:    {    LABELS(); -  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), P_REG_RBX);    add_reg_imm(P_REG_RBX, b*sizeof(struct svalue));    if( c > 1 )    add_reg_imm_reg(P_REG_RBX, c*sizeof(struct svalue), P_REG_RBP );       LABEL_A;    amd64_free_svalue(P_REG_RBX, 0);    mov_imm_mem(PIKE_T_INT, P_REG_RBX, OFFSETOF(svalue, tu.t.type));    mov_imm_mem(0, P_REG_RBX, OFFSETOF(svalue, u.integer));
pike.git/src/code/amd64.c:3229:    LABEL_B;    /* something else. */    update_arg1(b);    update_arg2(c);    amd64_call_c_opcode(instrs[a-F_OFFSET].address,    instrs[a-F_OFFSET].flags);    LABEL_C;    /* done */    }    return; +     case F_PRIVATE_IF_DIRECT_GLOBAL:    {    LABELS();    amd64_load_sp_reg();    ins_debug_instr_prologue(a-F_OFFSET, b, c);    /* do not assign if this object is destructed. */    mov_mem_reg( fp_reg, OFFSETOF(pike_frame,current_object), ARG2_REG );    mov_mem_reg( fp_reg, OFFSETOF(pike_frame,context), ARG3_REG );    /* if ctx->prog != arg1->prog */    mov_mem_reg( ARG3_REG, OFFSETOF(inherit,prog), P_REG_R8 );
pike.git/src/code/amd64.c:3291:    LABEL_A;    mov_mem_reg(ARG1_REG, OFFSETOF(object,storage), P_REG_RBX );    add_reg_mem(P_REG_RBX, ARG2_REG, OFFSETOF(inherit,storage_offset));    add_reg_imm(P_REG_RBX, b );    amd64_free_svalue( P_REG_RBX, 0 );    amd64_assign_svalue_no_free( P_REG_RBX, sp_reg, -sizeof(struct svalue));    amd64_ref_svalue(P_REG_RBX,0);    LABEL_B;    }    return; +     case F_ASSIGN_PRIVATE_TYPED_GLOBAL_AND_POP:    case F_ASSIGN_PRIVATE_TYPED_GLOBAL:    {    LABELS();    amd64_load_sp_reg();    -  ins_debug_instr_prologue(a-F_OFFSET, b, 0); +  ins_debug_instr_prologue(a-F_OFFSET, b, c);       amd64_get_storage( P_REG_RBX, b );       /* do not assign anything if this object is destructed. */       /* we really only need to redo this check after we have called    some other function. It is sort of hard to know when that    happens while generating the code, however. Simply assigning    the global could in theory actually destruct this object (old    value includes something with a destroy that calls destruct on
pike.git/src/code/amd64.c:3411:    mov_imm_mem( c, sp_reg, 0 );    mov_reg_mem( P_REG_RBX, sp_reg, 8 );    amd64_add_sp(1);    LABEL_B;    }    return;    case F_ADD_LOCAL_INT:    case F_ADD_LOCAL_INT_AND_POP:    {    LABELS(); -  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) );       /* arg1 = dst    arg2 = int    */    mov_sval_type( ARG1_REG, P_REG_RAX );    cmp_reg32_imm( P_REG_RAX, PIKE_T_INT );    jne(&label_A); /* Fallback */
pike.git/src/code/amd64.c:3451:    mov_mem_reg( ARG1_REG, OFFSETOF(svalue,u.integer), P_REG_RAX );    amd64_push_int_reg( P_REG_RAX );    }    LABEL_C;    return;    }      #if 0    /* this is a: nonworking, and b: not really all that more efficient anyway.. */    case F_APPLY_N: +  ins_debug_instr_prologue(a-F_OFFSET, b, c);    mov_imm_reg( APPLY_SVALUE_STRICT, ARG1_REG );    mov_imm_reg( c, ARG2_REG );    mov_ptr_reg( &((Pike_fp->context->prog->constants + b)->sval), ARG3_REG );    clear_reg( ARG4_REG );    amd64_call_c_opcode(mega_apply, I_UPDATE_SP);    return;   #endif    case F_CALL_BUILTIN_N: -  +  ins_debug_instr_prologue(a-F_OFFSET, b, c);    mov_imm_reg( c, ARG1_REG );    amd64_call_c_opcode(Pike_compiler->new_program->constants[b].sval.u.efun->function,    I_UPDATE_SP);    return;          case F_ADD_LOCALS_AND_POP:    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);
pike.git/src/code/amd64.c:3526:    mov_mem_reg(fp_reg, OFFSETOF(pike_frame, current_object), ARG1_REG);    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 );    amd64_call_c_function( object_low_set_index );    return;       case F_LEXICAL_LOCAL:    if( c < 5 )    { +  ins_debug_instr_prologue(a-F_OFFSET, b, c);    amd64_load_fp_reg();    mov_reg_reg( fp_reg, P_REG_RAX );    while(c--)    mov_mem_reg( P_REG_RAX, OFFSETOF(pike_frame,scope), P_REG_RAX );    mov_mem_reg( P_REG_RAX, OFFSETOF(pike_frame,locals), P_REG_RAX );    add_reg_imm_reg( P_REG_RAX, b*sizeof(struct svalue), P_REG_RBX );    amd64_push_svaluep( P_REG_RBX );    return;    }    /* use c version. Could have a loop version here. */    break;       case F_LEXICAL_LOCAL_LVALUE:    if( c < 5 )    { -  +  ins_debug_instr_prologue(a-F_OFFSET, b, c);    amd64_load_fp_reg();    amd64_load_sp_reg();    mov_reg_reg( fp_reg, P_REG_RAX );    while(c--)    mov_mem_reg( P_REG_RAX, OFFSETOF(pike_frame,scope), P_REG_RAX );    mov_mem_reg( P_REG_RAX, OFFSETOF(pike_frame,locals), P_REG_RAX );    add_reg_imm_reg( P_REG_RAX, b*sizeof(struct svalue), P_REG_RAX );    mov_imm_mem( T_SVALUE_PTR, sp_reg, OFFSETOF(svalue, tu.t.type));    mov_reg_mem( P_REG_RAX, sp_reg, OFFSETOF(svalue,u.lval) );    mov_imm_mem( T_VOID, sp_reg,