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) {
319 INLINE(explicit Operand(Register reg));
328 explicit Operand(Register base, int32_t disp,
332 explicit Operand(Register base,
333 Register index,
339 explicit Operand(Register index,
349 static Operand StaticArray(Register index,
362 static Operand ForRegisterPlusImmediate(Register base, Immediate imm) {
367 bool is_reg(Register reg) const;
374 Register reg() const;
379 inline void set_modrm(int mod, Register rm);
381 inline void set_sib(ScaleFactor scale, Register index, Register base);
567 // the one way to generate the same instruction: The Register argument
568 // can in some cases be replaced with an Operand(Register) argument.
571 // Operand is possible, or should we have a Register (overloaded) form
593 void push(Register src);
596 void pop(Register dst);
603 void mov_b(Register dst, Register src) { mov_b(dst, Operand(src)); }
604 void mov_b(Register dst, const Operand& src);
605 void mov_b(Register dst, int8_t imm8) { mov_b(Operand(dst), imm8); }
607 void mov_b(const Operand& dst, Register src);
609 void mov_w(Register dst, const Operand& src);
610 void mov_w(const Operand& dst, Register src);
613 void mov(Register dst, int32_t imm32);
614 void mov(Register dst, const Immediate& x);
615 void mov(Register dst, Handle<Object> handle);
616 void mov(Register dst, const Operand& src);
617 void mov(Register dst, Register src);
620 void mov(const Operand& dst, Register src);
622 void movsx_b(Register dst, Register src) { movsx_b(dst, Operand(src)); }
623 void movsx_b(Register dst, const Operand& src);
625 void movsx_w(Register dst, Register src) { movsx_w(dst, Operand(src)); }
626 void movsx_w(Register dst, const Operand& src);
628 void movzx_b(Register dst, Register src) { movzx_b(dst, Operand(src)); }
629 void movzx_b(Register dst, const Operand& src);
631 void movzx_w(Register dst, Register src) { movzx_w(dst, Operand(src)); }
632 void movzx_w(Register dst, const Operand& src);
643 void xchg(Register dst, Register src);
644 void xchg(Register dst, const Operand& src);
647 void adc(Register dst, int32_t imm32);
648 void adc(Register dst, const Operand& src);
650 void add(Register dst, Register src) { add(dst, Operand(src)); }
651 void add(Register dst, const Operand& src);
652 void add(const Operand& dst, Register src);
653 void add(Register dst, const Immediate& imm) { add(Operand(dst), imm); }
656 void and_(Register dst, int32_t imm32);
657 void and_(Register dst, const Immediate& x);
658 void and_(Register dst, Register src) { and_(dst, Operand(src)); }
659 void and_(Register dst, const Operand& src);
660 void and_(const Operand& dst, Register src);
663 void cmpb(Register reg, int8_t imm8) { cmpb(Operand(reg), imm8); }
665 void cmpb(Register reg, const Operand& op);
666 void cmpb(const Operand& op, Register reg);
670 void cmp(Register reg, int32_t imm32);
671 void cmp(Register reg, Handle<Object> handle);
672 void cmp(Register reg0, Register reg1) { cmp(reg0, Operand(reg1)); }
673 void cmp(Register reg, const Operand& op);
674 void cmp(Register reg, const Immediate& imm) { cmp(Operand(reg), imm); }
678 void dec_b(Register dst);
681 void dec(Register dst);
686 void idiv(Register src) { idiv(Operand(src)); }
688 void div(Register src) { div(Operand(src)); }
692 void imul(Register src); // edx:eax = eax * src.
693 void imul(Register dst, Register src) { imul(dst, Operand(src)); }
694 void imul(Register dst, const Operand& src); // dst = dst * src.
695 void imul(Register dst, Register src, int32_t imm32); // dst = src * imm32.
696 void imul(Register dst, const Operand& src, int32_t imm32);
698 void inc(Register dst);
701 void lea(Register dst, const Operand& src);
704 void mul(Register src); // edx:eax = eax * reg.
706 void neg(Register dst);
709 void not_(Register dst);
712 void or_(Register dst, int32_t imm32);
713 void or_(Register dst, Register src) { or_(dst, Operand(src)); }
714 void or_(Register dst, const Operand& src);
715 void or_(const Operand& dst, Register src);
716 void or_(Register dst, const Immediate& imm) { or_(Operand(dst), imm); }
719 void rcl(Register dst, uint8_t imm8);
720 void rcr(Register dst, uint8_t imm8);
721 void ror(Register dst, uint8_t imm8);
722 void ror_cl(Register dst);
724 void sar(Register dst, uint8_t imm8) { sar(Operand(dst), imm8); }
726 void sar_cl(Register dst) { sar_cl(Operand(dst)); }
729 void sbb(Register dst, const Operand& src);
731 void shld(Register dst, Register src) { shld(dst, Operand(src)); }
732 void shld(Register dst, const Operand& src);
734 void shl(Register dst, uint8_t imm8) { shl(Operand(dst), imm8); }
736 void shl_cl(Register dst) { shl_cl(Operand(dst)); }
739 void shrd(Register dst, Register src) { shrd(dst, Operand(src)); }
740 void shrd(Register dst, const Operand& src);
742 void shr(Register dst, uint8_t imm8) { shr(Operand(dst), imm8); }
744 void shr_cl(Register dst) { shr_cl(Operand(dst)); }
747 void sub(Register dst, const Immediate& imm) { sub(Operand(dst), imm); }
749 void sub(Register dst, Register src) { sub(dst, Operand(src)); }
750 void sub(Register dst, const Operand& src);
751 void sub(const Operand& dst, Register src);
753 void test(Register reg, const Immediate& imm);
754 void test(Register reg0, Register reg1) { test(reg0, Operand(reg1)); }
755 void test(Register reg, const Operand& op);
756 void test_b(Register reg, const Operand& op);
758 void test_b(Register reg, uint8_t imm8);
761 void xor_(Register dst, int32_t imm32);
762 void xor_(Register dst, Register src) { xor_(dst, Operand(src)); }
763 void xor_(Register dst, const Operand& src);
764 void xor_(const Operand& dst, Register src);
765 void xor_(Register dst, const Immediate& imm) { xor_(Operand(dst), imm); }
769 void bt(const Operand& dst, Register src);
770 void bts(Register dst, Register src) { bts(Operand(dst), src); }
771 void bts(const Operand& dst, Register src);
772 void bsr(Register dst, Register src) { bsr(dst, Operand(src)); }
773 void bsr(Register dst, const Operand& src);
802 void call(Register reg) { call(Operand(reg)); }
813 void jmp(Register reg) { jmp(Operand(reg)); }
906 void setcc(Condition cc, Register reg);
995 void emit_arith_b(int op1, int op2, Register dst, int imm8);
1003 void emit_operand(Register reg, const Operand& adr);