Cross Reference: /external/chromium_org/v8/src/ia32/assembler-ia32.h

Lines Matching defs:Register
55 // "initialization". Also, the Register objects cannot be const as this
67 struct Register {
76   static inline int ToAllocationIndex(Register reg);
78   static inline Register FromAllocationIndex(int index);
80   static Register from_code(int code) {
83     Register r = { code };
87   bool is(Register reg) const { return code_ == reg.code_; }
113 const Register eax = { kRegister_eax_Code };
114 const Register ecx = { kRegister_ecx_Code };
115 const Register edx = { kRegister_edx_Code };
116 const Register ebx = { kRegister_ebx_Code };
117 const Register esp = { kRegister_esp_Code };
118 const Register ebp = { kRegister_ebp_Code };
119 const Register esi = { kRegister_esi_Code };
120 const Register edi = { kRegister_edi_Code };
121 const Register no_reg = { kRegister_no_reg_Code };
124 inline const char* Register::AllocationIndexToString(int index) {
132 inline int Register::ToAllocationIndex(Register reg) {
138 inline Register Register::FromAllocationIndex(int index)  {
327   INLINE(explicit Operand(Register reg));
339   explicit Operand(Register base, int32_t disp,
343   explicit Operand(Register base,
344                    Register index,
350   explicit Operand(Register index,
360   static Operand StaticArray(Register index,
373   static Operand ForRegisterPlusImmediate(Register base, Immediate imm) {
378   bool is_reg(Register reg) const;
385   Register reg() const;
390   inline void set_modrm(int mod, Register rm);
392   inline void set_sib(ScaleFactor scale, Register index, Register base);
578   // the one way to generate the same instruction: The Register argument
579   // can in some cases be replaced with an Operand(Register) argument.
582   // Operand is possible, or should we have a Register (overloaded) form
604   void push(Register src);
607   void pop(Register dst);
614   void mov_b(Register dst, Register src) { mov_b(dst, Operand(src)); }
615   void mov_b(Register dst, const Operand& src);
616   void mov_b(Register dst, int8_t imm8) { mov_b(Operand(dst), imm8); }
618   void mov_b(const Operand& dst, Register src);
620   void mov_w(Register dst, const Operand& src);
621   void mov_w(const Operand& dst, Register src);
624   void mov(Register dst, int32_t imm32);
625   void mov(Register dst, const Immediate& x);
626   void mov(Register dst, Handle<Object> handle);
627   void mov(Register dst, const Operand& src);
628   void mov(Register dst, Register src);
631   void mov(const Operand& dst, Register src);
633   void movsx_b(Register dst, Register src) { movsx_b(dst, Operand(src)); }
634   void movsx_b(Register dst, const Operand& src);
636   void movsx_w(Register dst, Register src) { movsx_w(dst, Operand(src)); }
637   void movsx_w(Register dst, const Operand& src);
639   void movzx_b(Register dst, Register src) { movzx_b(dst, Operand(src)); }
640   void movzx_b(Register dst, const Operand& src);
642   void movzx_w(Register dst, Register src) { movzx_w(dst, Operand(src)); }
643   void movzx_w(Register dst, const Operand& src);
646   void cmov(Condition cc, Register dst, Register src) {
649   void cmov(Condition cc, Register dst, const Operand& src);
660   void xchg(Register dst, Register src);
661   void xchg(Register dst, const Operand& src);
664   void adc(Register dst, int32_t imm32);
665   void adc(Register dst, const Operand& src);
667   void add(Register dst, Register src) { add(dst, Operand(src)); }
668   void add(Register dst, const Operand& src);
669   void add(const Operand& dst, Register src);
670   void add(Register dst, const Immediate& imm) { add(Operand(dst), imm); }
673   void and_(Register dst, int32_t imm32);
674   void and_(Register dst, const Immediate& x);
675   void and_(Register dst, Register src) { and_(dst, Operand(src)); }
676   void and_(Register dst, const Operand& src);
677   void and_(const Operand& dst, Register src);
680   void cmpb(Register reg, int8_t imm8) { cmpb(Operand(reg), imm8); }
682   void cmpb(Register reg, const Operand& op);
683   void cmpb(const Operand& op, Register reg);
687   void cmp(Register reg, int32_t imm32);
688   void cmp(Register reg, Handle<Object> handle);
689   void cmp(Register reg0, Register reg1) { cmp(reg0, Operand(reg1)); }
690   void cmp(Register reg, const Operand& op);
691   void cmp(Register reg, const Immediate& imm) { cmp(Operand(reg), imm); }
695   void dec_b(Register dst);
698   void dec(Register dst);
703   void idiv(Register src) { idiv(Operand(src)); }
705   void div(Register src) { div(Operand(src)); }
709   void imul(Register src);                               // edx:eax = eax * src.
710   void imul(Register dst, Register src) { imul(dst, Operand(src)); }
711   void imul(Register dst, const Operand& src);           // dst = dst * src.
712   void imul(Register dst, Register src, int32_t imm32);  // dst = src * imm32.
713   void imul(Register dst, const Operand& src, int32_t imm32);
715   void inc(Register dst);
718   void lea(Register dst, const Operand& src);
721   void mul(Register src);                                // edx:eax = eax * reg.
723   void neg(Register dst);
726   void not_(Register dst);
729   void or_(Register dst, int32_t imm32);
730   void or_(Register dst, Register src) { or_(dst, Operand(src)); }
731   void or_(Register dst, const Operand& src);
732   void or_(const Operand& dst, Register src);
733   void or_(Register dst, const Immediate& imm) { or_(Operand(dst), imm); }
736   void rcl(Register dst, uint8_t imm8);
737   void rcr(Register dst, uint8_t imm8);
738   void ror(Register dst, uint8_t imm8);
739   void ror_cl(Register dst);
741   void sar(Register dst, uint8_t imm8) { sar(Operand(dst), imm8); }
743   void sar_cl(Register dst) { sar_cl(Operand(dst)); }
746   void sbb(Register dst, const Operand& src);
748   void shld(Register dst, Register src) { shld(dst, Operand(src)); }
749   void shld(Register dst, const Operand& src);
751   void shl(Register dst, uint8_t imm8) { shl(Operand(dst), imm8); }
753   void shl_cl(Register dst) { shl_cl(Operand(dst)); }
756   void shrd(Register dst, Register src) { shrd(dst, Operand(src)); }
757   void shrd(Register dst, const Operand& src);
759   void shr(Register dst, uint8_t imm8) { shr(Operand(dst), imm8); }
761   void shr_cl(Register dst) { shr_cl(Operand(dst)); }
764   void sub(Register dst, const Immediate& imm) { sub(Operand(dst), imm); }
766   void sub(Register dst, Register src) { sub(dst, Operand(src)); }
767   void sub(Register dst, const Operand& src);
768   void sub(const Operand& dst, Register src);
770   void test(Register reg, const Immediate& imm);
771   void test(Register reg0, Register reg1) { test(reg0, Operand(reg1)); }
772   void test(Register reg, const Operand& op);
773   void test_b(Register reg, const Operand& op);
775   void test_b(Register reg, uint8_t imm8);
778   void xor_(Register dst, int32_t imm32);
779   void xor_(Register dst, Register src) { xor_(dst, Operand(src)); }
780   void xor_(Register dst, const Operand& src);
781   void xor_(const Operand& dst, Register src);
782   void xor_(Register dst, const Immediate& imm) { xor_(Operand(dst), imm); }
786   void bt(const Operand& dst, Register src);
787   void bts(Register dst, Register src) { bts(Operand(dst), src); }
788   void bts(const Operand& dst, Register src);
789   void bsr(Register dst, Register src) { bsr(dst, Operand(src)); }
790   void bsr(Register dst, const Operand& src);
819   void call(Register reg) { call(Operand(reg)); }
830   void jmp(Register reg) { jmp(Operand(reg)); }
916   void setcc(Condition cc, Register reg);
941   void cvttss2si(Register dst, const Operand& src);
942   void cvttss2si(Register dst, XMMRegister src) {
945   void cvttsd2si(Register dst, const Operand& src);
946   void cvttsd2si(Register dst, XMMRegister src) {
949   void cvtsd2si(Register dst, XMMRegister src);
951   void cvtsi2sd(XMMRegister dst, Register src) { cvtsi2sd(dst, Operand(src)); }
982   void movmskpd(Register dst, XMMRegister src);
983   void movmskps(Register dst, XMMRegister src);
1000   void movd(XMMRegister dst, Register src) { movd(dst, Operand(src)); }
1002   void movd(Register dst, XMMRegister src) { movd(Operand(dst), src); }
1012   void extractps(Register dst, XMMRegister src, byte imm8);
1024   void pextrd(Register dst, XMMRegister src, int8_t offset) {
1028   void pinsrd(XMMRegister dst, Register src, int8_t offset) {
1099   void emit_sse_operand(Register dst, XMMRegister src);
1100   void emit_sse_operand(XMMRegister dst, Register src);
1130   void emit_arith_b(int op1, int op2, Register dst, int imm8);
1138   void emit_operand(Register reg, const Operand& adr);