pike.git / src / code / amd64.c

version» Context lines:

pike.git/src/code/amd64.c:184:   }      static void and_reg_imm( enum amd64_reg reg, int imm32 )   {    rex( 1, 0, 0, reg );       if( imm32 < -0x80 || imm32 > 0x7f )    {    if( reg == REG_RAX )    { -  opcode( 0x25 ); // AND rax,imm32 +  opcode( 0x25 ); /* AND rax,imm32 */    id( imm32 );    }    else    { -  opcode( 0x81 ); // AND REG,imm32 +  opcode( 0x81 ); /* AND REG,imm32 */    modrm( 3,4, reg);    id( imm32 );    }    }    else    { -  add_to_program(0x83); // AND REG,imm8 +  add_to_program(0x83); /* AND REG,imm8 */    modrm( 3, 4, reg );    ib( imm32 );    }   }      static void mov_mem16_reg( enum amd64_reg from_reg, ptrdiff_t offset, enum amd64_reg to_reg )   { -  // FIXME: Really implement.. +  /* FIXME: Really implement... */    mov_mem32_reg( from_reg, offset, to_reg );    and_reg_imm( to_reg, 0xffff );   }      static void add_reg_imm( enum amd64_reg src, int imm32);      static void shl_reg_imm( enum amd64_reg from_reg, int shift )   {    rex( 1, from_reg, 0, 0 );    if( shift == 1 )    { -  opcode( 0xd1 ); // RCL +  opcode( 0xd1 ); /* RCL */    modrm( 3, 2, from_reg );    }    else    {    opcode( 0xc1 );    modrm( 3, 2, from_reg );    ib( shift );    }   }   
pike.git/src/code/amd64.c:384:   static void add_reg_imm( enum amd64_reg reg, int imm32 )   {    if( !imm32 ) return;       rex( 1, 0, 0, reg );       if( imm32 < -0x80 || imm32 > 0x7f )    {    if( reg == REG_RAX )    { -  opcode( 0x05 ); // ADD rax,imm32 +  opcode( 0x05 ); /* ADD rax,imm32 */    id( imm32 );    }    else    { -  opcode( 0x81 ); // ADD REG,imm32 +  opcode( 0x81 ); /* ADD REG,imm32 */    modrm( 3, 0, reg);    id( imm32 );    }    }    else    { -  add_to_program(0x83); // ADD REG,imm8 +  add_to_program(0x83); /* ADD REG,imm8 */    modrm( 3, 0, reg );    ib( imm32 );    }   }      static void add_mem32_imm( enum amd64_reg reg, int offset, int imm32 )   {    int r2 = imm32 == -1 ? 1 : 0;    int large = 0;    if( !imm32 ) return;    rex( 0, 0, 0, reg );       if( r2 ) imm32 = -imm32;       if( imm32 == 1 ) -  opcode( 0xff ); // INCL(DECL) r/m32 +  opcode( 0xff ); /* INCL(DECL) r/m32 */    else if( imm32 >= -128 && imm32 < 128 ) -  opcode( 0x83 ); // ADD imm8,r/m32 +  opcode( 0x83 ); /* ADD imm8,r/m32 */    else    { -  opcode( 0x81 ); // ADD imm32,r/m32 +  opcode( 0x81 ); /* ADD imm32,r/m32 */    large = 1;    }    if( !offset )    {    modrm( 0, r2, reg );    }    else    if( offset < -128 || offset > 127 )    {    modrm( 2, r2, reg );
pike.git/src/code/amd64.c:457:   }      static void add_mem_imm( enum amd64_reg reg, int offset, int imm32 )   {    int r2 = imm32 == -1 ? 1 : 0;    int large = 0;    if( !imm32 ) return;    rex( 1, 0, 0, reg );       if( imm32 == 1 || imm32 == -1 ) -  opcode( 0xff ); // INCL r/m32 +  opcode( 0xff ); /* INCL r/m32 */    else if( imm32 >= -128 && imm32 < 128 ) -  opcode( 0x83 ); // ADD imm8,r/m32 +  opcode( 0x83 ); /* ADD imm8,r/m32 */    else    { -  opcode( 0x81 ); // ADD imm32,r/m32 +  opcode( 0x81 ); /* ADD imm32,r/m32 */    large = 1;    }       if( !offset )    {    modrm( 0, r2, reg );    }    else if( offset < -128 || offset > 127 )    {    modrm( 2, r2, reg );
pike.git/src/code/amd64.c:500:    return add_reg_imm( reg, -imm32 );   #else    if( !imm32 ) return;       rex( 1, 0, 0, reg );       if( imm32 < -0x80 || imm32 > 0x7f )    {    if( reg == REG_RAX )    { -  opcode( 0x2d ); // SUB rax,imm32 +  opcode( 0x2d ); /* SUB rax,imm32 */    id( imm32 );    }    else    { -  opcode( 0x81 ); // SUB REG,imm32 +  opcode( 0x81 ); /* SUB REG,imm32 */    modrm( 3, 5, reg);    id( imm32 );    }    }    else    { -  opcode(0x83); // SUB REG,imm8 +  opcode(0x83); /* SUB REG,imm8 */    modrm( 3, 5, reg );    ib( imm32 );    }   #endif   }      static void test_reg_reg( enum amd64_reg reg1, enum amd64_reg reg2 )   {    rex(1,reg1,0,reg2);    opcode(0x85);
pike.git/src/code/amd64.c:650:    {    modrm(2,dst,src);    id( imm32 );    }    }   }      /* load code adress + imm to reg, always 32bit offset */   static void mov_rip_imm_reg( int imm, enum amd64_reg reg )   { -  imm -= 7; // The size of this instruction +  imm -= 7; /* The size of this instruction. */       rex( 1, reg, 0, 0 ); -  opcode( 0x8d ); // LEA +  opcode( 0x8d ); /* LEA */    modrm( 0, reg, 5 );    id( imm );   }      static void add_imm_mem( int imm32, enum amd64_reg reg, int offset )   {    int r2 = (imm32 == -1) ? 1 : 0;    int large = 0;       /* OPCODE */    rex( 1, 0, 0, reg );    if( imm32 == 1 || imm32 == -1 ) -  opcode( 0xff ); // INCL(decl) r/m32 +  opcode( 0xff ); /* INCL(decl) r/m32 */    else if( -128 <= imm32 && 128 > imm32 ) -  opcode( 0x83 ); // ADD imm8,r/m32 +  opcode( 0x83 ); /* ADD imm8,r/m32 */    else    { -  opcode( 0x81 ); // ADD imm32,r/m32 +  opcode( 0x81 ); /* ADD imm32,r/m32 */    large = 1;    }       /* OFFSET */    if( offset < -128 || offset > 127 )    {    modrm( 2, r2, reg );    id( offset );    }    else if( offset )
pike.git/src/code/amd64.c:987:      void amd64_assign_local( int b )   {    amd64_load_fp_reg();    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 +  /* Free old svalue. */    amd64_free_svalue(ARG1_REG, 0);    -  // Copy sp[-1] -> local +  /* Copy sp[-1] -> local */    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:1271:    }    cmp_reg_imm(REG_RAX, -1);    jne(&label_A);    if( ret_for_func )    {    jmp_rel_imm( ret_for_func - PIKE_PC );    }    else    {    ret_for_func = PIKE_PC; -  pop(REG_RBX); // Stack padding. +  pop(REG_RBX); /* Stack padding. */    pop(REG_RBX);    pop(REG_R12);    pop(REG_R13);    pop(REG_R14);    pop(REG_R15);    pop(REG_RBP);    ret();    }    LABEL_A;   
pike.git/src/code/amd64.c:1317: Inside #if defined(PIKE_DEBUG)
  #ifdef PIKE_DEBUG    if(off>255)    Pike_error("Instruction too big %d\n",off);   #endif    flags = instrs[off].flags;    if (!(flags & I_BRANCH)) return -1;       if (op == F_BRANCH) {    ins_debug_instr_prologue(off, 0, 0);    if (backward_jump) { -  //md64_call_c_function(branch_check_threads_etc); +  /* amd64_call_c_function(branch_check_threads_etc); */    maybe_update_pc();    amd64_ins_branch_check_threads_etc();    }    add_to_program(0xe9);    ret=DO_NOT_WARN( (INT32) PIKE_PC );    PUSH_INT(0);    return ret;    }       maybe_update_pc();
pike.git/src/code/amd64.c:1365:   void ins_f_byte_with_arg(unsigned int a, INT32 b)   {    maybe_update_pc();    switch(a) {    case F_THIS_OBJECT:    if( b == 0 )    {    amd64_push_this_object();    return;    } -  break; // Fallback to C-version +  break; /* Fallback to C-version. */    case F_NUMBER:    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_push_int(b, 0);    return;    case F_NEG_NUMBER:    ins_debug_instr_prologue(a-F_OFFSET, b, 0);    amd64_push_int(-(INT64)b, 0);    return;    case F_STRING:    ins_debug_instr_prologue(a-F_OFFSET, b, 0);