pike.git / src / code / amd64.c

version» Context lines:

pike.git/src/code/amd64.c:1066: Inside #if 0
  #if 0   static void jc( struct label *l ) { return jump_rel8( l, 0x72 ); }   static void jnc( struct label *l ) { return jump_rel8( l, 0x73 ); }   #endif   static void jz( struct label *l ) { return jump_rel8( l, 0x74 ); }   static void jnz( struct label *l ) { return jump_rel8( l, 0x75 ); }   static void js( struct label *l ) { return jump_rel8( l, 0x78 ); }   static void jl( struct label *l ) { return jump_rel8( l, 0x7c ); }   static void jge( struct label *l ) { return jump_rel8( l, 0x7d ); }   static void jle( struct label *l ) { return jump_rel8( l, 0x7e ); } - #if 0 +    static void jg( struct label *l ) { return jump_rel8( l, 0x7f ); } -  + #if 0   #endif      #define LABELS() struct label label_A, label_B, label_C, label_D, label_E;label_A.addr = -1;label_A.n_label_uses = 0;label_B.addr = -1;label_B.n_label_uses = 0;label_C.addr = -1;label_C.n_label_uses = 0;label_D.addr = -1;label_D.n_label_uses = 0;label_E.addr=-1;label_E.n_label_uses=0;   #define LABEL_A label(&label_A)   #define LABEL_B label(&label_B)   #define LABEL_C label(&label_C)   #define LABEL_D label(&label_D)   #define LABEL_E label(&label_E)      static void amd64_ins_branch_check_threads_etc(int code_only);
pike.git/src/code/amd64.c:1975:       There is bound to be a better way.    Somehow disable the exception?       Some SSE alternative that does not throw?       Perhaps a 64/64->64 instead of the current 128/64->64?    */    LABEL_C;    div_reg_reg(P_REG_RAX,P_REG_RBX); -  jo(&label_A); +     mov_imm_mem(PIKE_T_INT, sp_reg, SVAL(-2).type);    if( b+F_OFFSET == F_MOD )    mov_reg_mem(P_REG_RDX, sp_reg, SVAL(-2).value);    else    mov_reg_mem(P_REG_RAX, sp_reg, SVAL(-2).value);    amd64_add_sp(-1);    jmp(&label_B);    LABEL_A;    amd64_call_c_opcode(addr, flags);    amd64_load_sp_reg();
pike.git/src/code/amd64.c:2040:    mov_reg_mem(P_REG_RBX,sp_reg,SVAL(-2).value);    amd64_add_sp(-1);    jmp(&label_B);    LABEL_A;    amd64_call_c_opcode(addr, flags);    amd64_load_sp_reg();    LABEL_B;    }    return;    +  case F_XOR: +  { +  LABELS(); +  ins_debug_instr_prologue(b, 0, 0); +  if_not_two_int(&label_A,1); +  xor_reg_reg(P_REG_RAX,P_REG_RBX); +  mov_imm_mem(PIKE_T_INT,sp_reg,SVAL(-2).type); +  mov_reg_mem(P_REG_RBX,sp_reg,SVAL(-2).value); +  amd64_add_sp(-1); +  jmp(&label_B); +  LABEL_A; +  amd64_call_c_opcode(addr, flags); +  amd64_load_sp_reg(); +  LABEL_B; +  } +  return; +     case F_RSH:    {    LABELS();    ins_debug_instr_prologue(b, 0, 0);    if_not_two_int(&label_A,0);    mov_mem_reg(sp_reg, SVAL(-1).value, P_REG_RCX );    cmp_reg_imm(P_REG_RCX,0);    jl( &label_A );    cmp_reg_imm(P_REG_RCX,63);    jl( &label_B );
pike.git/src/code/amd64.c:2833:    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_POP_N_ELEMS: +  { +  int i; +  LABELS(); +  +  ins_debug_instr_prologue(a-F_OFFSET,b, 0); +  amd64_load_sp_reg(); +  if( b < 3 ) +  { +  for(i=0;i<b;i++) +  amd64_free_svalue_off( sp_reg, SVAL(-1-i).off, 0 ); +  amd64_add_sp( -b ); +  return; +  } +  break; /* use c version. */ +  +  /* FIXME: Why does not this work? */ + /* add_reg_imm_reg( sp_reg, -SVAL(b).off, P_REG_RBX ); */ +  + /* LABEL_A; */ + /* amd64_free_svalue_off( sp_reg, SVAL(-1).off,0 ); */ + /* amd64_add_sp( -1 ); */ + /* cmp_reg_reg(P_REG_RBX,sp_reg); */ + /* jne(&label_A); */ +  } +  return;    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;
pike.git/src/code/amd64.c:2972:    LABEL_C;    /* done */    }    return;    case F_MULTIPLY_INT:    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    mov_mem8_reg(sp_reg, SVAL(-1).type, P_REG_RAX ); -  test_reg(P_REG_RAX); +  test_reg32(P_REG_RAX);    jnz(&label_A);       /* FIXME: mul_reg_mem_imm actually exists as an instruction. */    mov_imm_reg(b, P_REG_RAX);    mov_mem_reg(sp_reg, SVAL(-1).value, P_REG_RBX );    mul_reg_reg(P_REG_RBX,P_REG_RAX);    jo(&label_A);       mov_imm_mem(PIKE_T_INT, sp_reg, SVAL(-1).type);    mov_reg_mem(P_REG_RBX, sp_reg, SVAL(-1).value);    jmp(&label_B);    LABEL_A;    update_arg1(b);    amd64_call_c_opcode(instrs[a-F_OFFSET].address,    instrs[a-F_OFFSET].flags);    LABEL_B;    }    return; -  + /* case F_XOR_INT: */ +  case F_DIVIDE_INT: +  if( b == 0 ) +  { +  yyerror("Divide by constant 0\n"); +  break; +  } +  { +  LABELS(); +  ins_debug_instr_prologue(a-F_OFFSET, b, 0); +  amd64_load_sp_reg();    -  +  mov_mem8_reg(sp_reg,SVAL(-1).type, P_REG_RAX); +  test_reg32(P_REG_RAX); +  jnz(&label_A); +  +  mov_mem_reg(sp_reg, SVAL(-1).value, P_REG_RAX); +  if( b == -1 ) +  { +  /* 64bit imm not done. */ +  cmp_reg_imm(P_REG_RAX,-0x80000000); +  jl(&label_A); +  } +  else if( a == F_MOD_INT ) +  { +  cmp_reg_imm(P_REG_RAX, 0); +  jl(&label_A); +  } +  +  mov_imm_reg(b,P_REG_RBX); +  div_reg_reg(P_REG_RAX,P_REG_RBX); +  mov_imm_mem(PIKE_T_INT, sp_reg, SVAL(-1).type); +  if( a == F_MOD_INT ) +  mov_reg_mem(P_REG_RDX, sp_reg, SVAL(-1).value); +  else +  mov_reg_mem(P_REG_RAX, sp_reg, SVAL(-1).value); +  jmp(&label_B); +  LABEL_A; +  update_arg1(b); +  amd64_call_c_opcode(instrs[a-F_OFFSET].address, +  instrs[a-F_OFFSET].flags); +  LABEL_B; +  } +  return; +     case F_AND_INT:    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET,b, 0);    amd64_load_sp_reg();    mov_mem8_reg(sp_reg, SVAL(-1).type, P_REG_RAX ); -  test_reg(P_REG_RAX); +  test_reg32(P_REG_RAX);    jnz(&label_A);       /* FIXME: and_mem_imm */    mov_mem_reg(sp_reg, SVAL(-1).value, P_REG_RAX );    and_reg_imm(P_REG_RAX,b);    mov_imm_mem(PIKE_T_INT,sp_reg,SVAL(-1).type);    mov_reg_mem(P_REG_RAX,sp_reg,SVAL(-1).value);    jmp(&label_B);    LABEL_A;    update_arg1(b);    amd64_call_c_opcode(instrs[a-F_OFFSET].address,    instrs[a-F_OFFSET].flags);    LABEL_B;    }    return;    -  +  case F_XOR_INT: +  { +  LABELS(); +  amd64_load_sp_reg(); +  ins_debug_instr_prologue(a,b,0); +  mov_mem8_reg(sp_reg,SVAL(-1).type, P_REG_RAX); +  test_reg32(P_REG_RAX); +  jnz(&label_A); +  +  mov_mem_reg(sp_reg,SVAL(-1).value, P_REG_RAX); +  mov_imm_reg(b,P_REG_RBX); +  xor_reg_reg(P_REG_RAX,P_REG_RBX); +  mov_imm_mem(PIKE_T_INT,sp_reg,SVAL(-1).type); +  mov_reg_mem(P_REG_RBX,sp_reg,SVAL(-1).value); +  jmp(&label_B); +  LABEL_A; +  update_arg1(b); +  amd64_call_c_opcode(instrs[a-F_OFFSET].address, +  instrs[a-F_OFFSET].flags); +  LABEL_B; +  } +  return; +     case F_OR_INT:    if( !b )    return;    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    mov_mem8_reg(sp_reg, SVAL(-1).type, P_REG_RAX ); -  test_reg(P_REG_RAX); +  test_reg32(P_REG_RAX);    jnz(&label_A);       /* FIXME: or_mem_imm */    mov_mem_reg(sp_reg, SVAL(-1).value, P_REG_RAX );    or_reg_imm(P_REG_RAX,b);    mov_imm_mem(PIKE_T_INT,sp_reg,SVAL(-1).type);    mov_reg_mem(P_REG_RAX,sp_reg,SVAL(-1).value);    jmp(&label_B);    LABEL_A;    update_arg1(b);
pike.git/src/code/amd64.c:3082:    if( b < 0 )    yyerror("<< with negative constant\n");    break;    case F_RSH_INT:    if( b > 0 && b <= 63 )    {    LABELS();    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_load_sp_reg();    mov_mem8_reg(sp_reg, SVAL(-1).type, P_REG_RAX ); -  test_reg(P_REG_RAX); +  test_reg32(P_REG_RAX);    jnz(&label_A);    mov_mem_reg( sp_reg, SVAL(-1).value, P_REG_RAX);    /* FIXME: shr_mem_imm */    mov_imm_mem(PIKE_T_INT,sp_reg,SVAL(-1).type);    shr_reg_imm( P_REG_RAX, b);    mov_reg_mem( P_REG_RAX, sp_reg, SVAL(-1).value);    jmp(&label_B);    LABEL_A;    update_arg1(b);    amd64_call_c_opcode(instrs[a-F_OFFSET].address,
pike.git/src/code/amd64.c:3116:    {    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),    P_REG_RAX ); -  test_reg( P_REG_RAX ); +  test_reg32( P_REG_RAX );    jz( &label_C );       add_reg_imm( P_REG_RAX, b );    jo( &label_A ); /* if overflow, use f_add */    mov_reg_mem( P_REG_RAX,sp_reg,    -sizeof(struct svalue)+OFFSETOF(svalue,u.integer));    jmp(&label_B); /* all done. */       LABEL_A;    amd64_push_int(b,0);