x86

## x86 x86 — code generation for x86 |

## Synopsis

    #define             orc_x86_emit_add_imm_memoffset      (p,
                                                             size,
                                                             value,
                                                             offset,
                                                             reg)
    void                orc_x86_emit_add_imm_reg            (OrcCompiler *compiler,
                                                             int size,
                                                             int value,
                                                             int reg,
                                                             orc_bool record);
    #define             orc_x86_emit_add_reg_memoffset      (p,
                                                             size,
                                                             src,
                                                             offset,
                                                             dest)
    #define             orc_x86_emit_align                  (p,
                                                             align_shift)
    #define             orc_x86_emit_and_imm_memoffset      (p,
                                                             size,
                                                             value,
                                                             offset,
                                                             reg)
    #define             orc_x86_emit_and_imm_reg            (p,
                                                             size,
                                                             value,
                                                             reg)
    void                orc_x86_emit_cmp_imm_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int value,
                                                             int offset,
                                                             int reg);
    #define             orc_x86_emit_cmp_reg_memoffset      (p,
                                                             size,
                                                             src,
                                                             offset,
                                                             dest)
    void                orc_x86_emit_dec_memoffset          (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg);
    #define             orc_x86_emit_emms                   (p)
    void                orc_x86_emit_epilogue               (OrcCompiler *compiler);
    #define             orc_x86_emit_je                     (p,
                                                             label)
    #define             orc_x86_emit_jle                    (p,
                                                             label)
    #define             orc_x86_emit_jmp                    (p,
                                                             label)
    #define             orc_x86_emit_jne                    (p,
                                                             label)
    #define             orc_x86_emit_label                  (p,
                                                             label)
    void                orc_x86_emit_modrm_memoffset        (OrcCompiler *compiler,
                                                             int offset,
                                                             int reg1,
                                                             int reg2);
    void                orc_x86_emit_modrm_reg              (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);
    #define             orc_x86_emit_mov_imm_reg            (p,
                                                             size,
                                                             value,
                                                             reg)
    void                orc_x86_emit_mov_memoffset_mmx      (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg1,
                                                             int reg2,
                                                             int is_aligned);
    void                orc_x86_emit_mov_memoffset_reg      (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg1,
                                                             int reg2);
    void                orc_x86_emit_mov_memoffset_sse      (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg1,
                                                             int reg2,
                                                             int is_aligned);
    void                orc_x86_emit_mov_mmx_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int offset,
                                                             int reg2,
                                                             int aligned,
                                                             int uncached);
    void                orc_x86_emit_mov_mmx_reg            (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);
    void                orc_x86_emit_mov_mmx_reg_reg        (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);
    void                orc_x86_emit_mov_reg_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int offset,
                                                             int reg2);
    void                orc_x86_emit_mov_reg_mmx            (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);
    #define             orc_x86_emit_mov_reg_reg            (p,
                                                             size,
                                                             src,
                                                             dest)
    void                orc_x86_emit_mov_sse_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int offset,
                                                             int reg2,
                                                             int aligned,
                                                             int uncached);
    void                orc_x86_emit_pop                    (OrcCompiler *compiler,
                                                             int size,
                                                             int reg);
    void                orc_x86_emit_prologue               (OrcCompiler *compiler);
    void                orc_x86_emit_push                   (OrcCompiler *compiler,
                                                             int size,
                                                             int reg);
    #define             orc_x86_emit_ret                    (p)
    void                orc_x86_emit_rex                    (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int reg2,
                                                             int reg3);
    #define             orc_x86_emit_sar_imm_reg            (p,
                                                             size,
                                                             value,
                                                             reg)
    #define             orc_x86_emit_sub_memoffset_reg      (p,
                                                             size,
                                                             offset,
                                                             src,
                                                             dest)
    #define             orc_x86_emit_sub_reg_reg            (p,
                                                             size,
                                                             src,
                                                             dest)
    #define             orc_x86_emit_test_reg_reg           (p,
                                                             size,
                                                             src,
                                                             dest)
    const char *        orc_x86_get_regname                 (int i);
    const char *        orc_x86_get_regname_16              (int i);
    const char *        orc_x86_get_regname_64              (int i);
    const char *        orc_x86_get_regname_mmx             (int i);
    const char *        orc_x86_get_regname_ptr             (OrcCompiler *compiler,
                                                             int i);
    const char *        orc_x86_get_regname_sse             (int i);
    int                 orc_x86_get_regnum                  (int i);
    void                orc_x86_do_fixups                   (OrcCompiler *compiler);

## Description

## Details

### orc_x86_emit_add_imm_memoffset()

    #define             orc_x86_emit_add_imm_memoffset(p,size,value,offset,reg)

### orc_x86_emit_add_imm_reg ()

    void                orc_x86_emit_add_imm_reg            (OrcCompiler *compiler,
                                                             int size,
                                                             int value,
                                                             int reg,
                                                             orc_bool record);

### orc_x86_emit_add_reg_memoffset()

    #define             orc_x86_emit_add_reg_memoffset(p,size,src,offset,dest)

### orc_x86_emit_align()

    #define             orc_x86_emit_align(p,align_shift)

### orc_x86_emit_and_imm_memoffset()

    #define             orc_x86_emit_and_imm_memoffset(p,size,value,offset,reg)

### orc_x86_emit_and_imm_reg()

    #define             orc_x86_emit_and_imm_reg(p,size,value,reg)

### orc_x86_emit_cmp_imm_memoffset ()

    void                orc_x86_emit_cmp_imm_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int value,
                                                             int offset,
                                                             int reg);

### orc_x86_emit_cmp_reg_memoffset()

    #define             orc_x86_emit_cmp_reg_memoffset(p,size,src,offset,dest)

### orc_x86_emit_dec_memoffset ()

    void                orc_x86_emit_dec_memoffset          (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg);

### orc_x86_emit_emms()

    #define             orc_x86_emit_emms(p)

### orc_x86_emit_epilogue ()

    void                orc_x86_emit_epilogue               (OrcCompiler *compiler);

### orc_x86_emit_je()

    #define             orc_x86_emit_je(p,label)

### orc_x86_emit_jle()

    #define             orc_x86_emit_jle(p,label)

### orc_x86_emit_jmp()

    #define             orc_x86_emit_jmp(p,label)

### orc_x86_emit_jne()

    #define             orc_x86_emit_jne(p,label)

### orc_x86_emit_label()

    #define             orc_x86_emit_label(p,label)

### orc_x86_emit_modrm_memoffset ()

    void                orc_x86_emit_modrm_memoffset        (OrcCompiler *compiler,
                                                             int offset,
                                                             int reg1,
                                                             int reg2);

### orc_x86_emit_modrm_reg ()

    void                orc_x86_emit_modrm_reg              (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);

### orc_x86_emit_mov_imm_reg()

    #define             orc_x86_emit_mov_imm_reg(p,size,value,reg)

### orc_x86_emit_mov_memoffset_mmx ()

    void                orc_x86_emit_mov_memoffset_mmx      (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg1,
                                                             int reg2,
                                                             int is_aligned);

### orc_x86_emit_mov_memoffset_reg ()

    void                orc_x86_emit_mov_memoffset_reg      (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg1,
                                                             int reg2);

### orc_x86_emit_mov_memoffset_sse ()

    void                orc_x86_emit_mov_memoffset_sse      (OrcCompiler *compiler,
                                                             int size,
                                                             int offset,
                                                             int reg1,
                                                             int reg2,
                                                             int is_aligned);

### orc_x86_emit_mov_mmx_memoffset ()

    void                orc_x86_emit_mov_mmx_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int offset,
                                                             int reg2,
                                                             int aligned,
                                                             int uncached);

### orc_x86_emit_mov_mmx_reg ()

    void                orc_x86_emit_mov_mmx_reg            (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);

### orc_x86_emit_mov_mmx_reg_reg ()

    void                orc_x86_emit_mov_mmx_reg_reg        (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);

### orc_x86_emit_mov_reg_memoffset ()

    void                orc_x86_emit_mov_reg_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int offset,
                                                             int reg2);

### orc_x86_emit_mov_reg_mmx ()

    void                orc_x86_emit_mov_reg_mmx            (OrcCompiler *compiler,
                                                             int reg1,
                                                             int reg2);

### orc_x86_emit_mov_reg_reg()

    #define             orc_x86_emit_mov_reg_reg(p,size,src,dest)

### orc_x86_emit_mov_sse_memoffset ()

    void                orc_x86_emit_mov_sse_memoffset      (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int offset,
                                                             int reg2,
                                                             int aligned,
                                                             int uncached);

### orc_x86_emit_pop ()

    void                orc_x86_emit_pop                    (OrcCompiler *compiler,
                                                             int size,
                                                             int reg);

### orc_x86_emit_prologue ()

    void                orc_x86_emit_prologue               (OrcCompiler *compiler);

### orc_x86_emit_push ()

    void                orc_x86_emit_push                   (OrcCompiler *compiler,
                                                             int size,
                                                             int reg);

### orc_x86_emit_ret()

    #define             orc_x86_emit_ret(p)

### orc_x86_emit_rex ()

    void                orc_x86_emit_rex                    (OrcCompiler *compiler,
                                                             int size,
                                                             int reg1,
                                                             int reg2,
                                                             int reg3);

### orc_x86_emit_sar_imm_reg()

    #define             orc_x86_emit_sar_imm_reg(p,size,value,reg)

### orc_x86_emit_sub_memoffset_reg()

    #define             orc_x86_emit_sub_memoffset_reg(p,size,offset,src,dest)

### orc_x86_emit_sub_reg_reg()

    #define             orc_x86_emit_sub_reg_reg(p,size,src,dest)

### orc_x86_emit_test_reg_reg()

    #define             orc_x86_emit_test_reg_reg(p,size,src,dest)

### orc_x86_get_regname ()

    const char *        orc_x86_get_regname                 (int i);

### orc_x86_get_regname_16 ()

    const char *        orc_x86_get_regname_16              (int i);

### orc_x86_get_regname_64 ()

    const char *        orc_x86_get_regname_64              (int i);

### orc_x86_get_regname_mmx ()

    const char *        orc_x86_get_regname_mmx             (int i);

### orc_x86_get_regname_ptr ()

    const char *        orc_x86_get_regname_ptr             (OrcCompiler *compiler,
                                                             int i);

### orc_x86_get_regname_sse ()

    const char *        orc_x86_get_regname_sse             (int i);

### orc_x86_get_regnum ()

    int                 orc_x86_get_regnum                  (int i);

### orc_x86_do_fixups ()

    void                orc_x86_do_fixups                   (OrcCompiler *compiler);