Xbyak::RegExp Class Reference

#include <xbyak.h>

Public Types
enum	{ i32e = 32 }

Public Member Functions
	RegExp (size_t disp=0)
	RegExp (const Reg &r, int scale=1)
bool	isVsib (int bit=128|256|512) const
RegExp	optimize () const
bool	operator== (const RegExp &rhs) const
const Reg &	getBase () const
const Reg &	getIndex () const
int	getScale () const
size_t	getDisp () const
void	verify () const
uint8	getRex () const

Friends
RegExp	operator+ (const RegExp &a, const RegExp &b)
RegExp	operator- (const RegExp &e, size_t disp)

Detailed Description

Definition at line 690 of file xbyak.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
i32e

Definition at line 695 of file xbyak.h.

{ i32e = 32 };

Constructor & Destructor Documentation

RegExp() [1/2]

Xbyak::RegExp::RegExp ( size_t disp = 0 )

inline

Definition at line 697 of file xbyak.h.

: scale_(0), disp_(disp) { }

RegExp() [2/2]

Xbyak::RegExp::RegExp ( const Reg & r, int scale = 1 )

inline

Definition at line 698 of file xbyak.h.

        : scale_(scale)
        , disp_(0)
    {
        if (!r.isREG(i32e) && !r.is(Reg::XMM|Reg::YMM|Reg::ZMM)) throw Error(ERR_BAD_SIZE_OF_REGISTER);
        if (scale == 0) return;
        if (scale != 1 && scale != 2 && scale != 4 && scale != 8) throw Error(ERR_BAD_SCALE);
        if (r.getBit() >= 128 || scale != 1) { // xmm/ymm is always index
            index_ = r;
        } else {
            base_ = r;
        }
    }

Member Function Documentation

getBase()

const Reg & Xbyak::RegExp::getBase ( ) const

inline

Definition at line 726 of file xbyak.h.

{ return base_; }

Here is the caller graph for this function:

getDisp()

size_t Xbyak::RegExp::getDisp ( ) const

inline

Definition at line 729 of file xbyak.h.

{ return disp_; }

Here is the caller graph for this function:

getIndex()

const Reg & Xbyak::RegExp::getIndex ( ) const

inline

Definition at line 727 of file xbyak.h.

{ return index_; }

Here is the caller graph for this function:

getRex()

uint8 Xbyak::RegExp::getRex ( ) const

inline

Definition at line 740 of file xbyak.h.

    {
        uint8 rex = index_.getRexX() | base_.getRexB();
        return rex ? uint8(rex | 0x40) : 0;
    }

getScale()

int Xbyak::RegExp::getScale ( ) const

inline

Definition at line 728 of file xbyak.h.

{ return scale_; }

isVsib()

bool Xbyak::RegExp::isVsib ( int bit = 128 | 256 | 512 ) const

inline

Definition at line 711 of file xbyak.h.

{ return index_.isBit(bit); }

Here is the call graph for this function:

Here is the caller graph for this function:

operator==()

bool Xbyak::RegExp::operator== ( const RegExp & rhs ) const

inline

Definition at line 722 of file xbyak.h.

    {
        return base_ == rhs.base_ && index_ == rhs.index_ && disp_ == rhs.disp_ && scale_ == rhs.scale_;
    }

optimize()

RegExp Xbyak::RegExp::optimize ( ) const

inline

Definition at line 712 of file xbyak.h.

    {
        RegExp exp = *this;
        // [reg * 2] => [reg + reg]
        if (index_.isBit(i32e) && !base_.getBit() && scale_ == 2) {
            exp.base_ = index_;
            exp.scale_ = 1;
        }
        return exp;
    }

verify()

void Xbyak::RegExp::verify ( ) const

inline

Definition at line 730 of file xbyak.h.

    {
        if (base_.getBit() >= 128) throw Error(ERR_BAD_SIZE_OF_REGISTER);
        if (index_.getBit() && index_.getBit() <= 64) {
            if (index_.getIdx() == Operand::ESP) throw Error(ERR_ESP_CANT_BE_INDEX);
            if (base_.getBit() && base_.getBit() != index_.getBit()) throw Error(ERR_BAD_SIZE_OF_REGISTER);
        }
    }

Friends And Related Symbol Documentation

operator+

RegExp operator+ ( const RegExp & a, const RegExp & b )

friend

Definition at line 756 of file xbyak.h.

{
    if (a.index_.getBit() && b.index_.getBit()) throw Error(ERR_BAD_ADDRESSING);
    RegExp ret = a;
    if (!ret.index_.getBit()) { ret.index_ = b.index_; ret.scale_ = b.scale_; }
    if (b.base_.getBit()) {
        if (ret.base_.getBit()) {
            if (ret.index_.getBit()) throw Error(ERR_BAD_ADDRESSING);
            // base + base => base + index * 1
            ret.index_ = b.base_;
            // [reg + esp] => [esp + reg]
            if (ret.index_.getIdx() == Operand::ESP) std::swap(ret.base_, ret.index_);
            ret.scale_ = 1;
        } else {
            ret.base_ = b.base_;
        }
    }
    ret.disp_ += b.disp_;
    return ret;
}

operator-

RegExp operator- ( const RegExp & e, size_t disp )

friend

Definition at line 780 of file xbyak.h.

{
    RegExp ret = e;
    ret.disp_ -= disp;
    return ret;
}

---

The documentation for this class was generated from the following file:

• libraries/fc/libraries/ff/depends/xbyak/xbyak/xbyak.h