diff options
Diffstat (limited to 'src/usr/diag/prdf/framework/register/prdfOperatorRegister.H')
-rwxr-xr-x | src/usr/diag/prdf/framework/register/prdfOperatorRegister.H | 584 |
1 files changed, 584 insertions, 0 deletions
diff --git a/src/usr/diag/prdf/framework/register/prdfOperatorRegister.H b/src/usr/diag/prdf/framework/register/prdfOperatorRegister.H new file mode 100755 index 000000000..b7bce1f55 --- /dev/null +++ b/src/usr/diag/prdf/framework/register/prdfOperatorRegister.H @@ -0,0 +1,584 @@ +/* IBM_PROLOG_BEGIN_TAG */ +/* This is an automatically generated prolog. */ +/* */ +/* $Source: src/usr/diag/prdf/framework/register/prdfOperatorRegister.H $ */ +/* */ +/* IBM CONFIDENTIAL */ +/* */ +/* COPYRIGHT International Business Machines Corp. 2004,2012 */ +/* */ +/* p1 */ +/* */ +/* Object Code Only (OCO) source materials */ +/* Licensed Internal Code Source Materials */ +/* IBM HostBoot Licensed Internal Code */ +/* */ +/* The source code for this program is not published or otherwise */ +/* divested of its trade secrets, irrespective of what has been */ +/* deposited with the U.S. Copyright Office. */ +/* */ +/* Origin: 30 */ +/* */ +/* IBM_PROLOG_END_TAG */ + +#ifndef __PRDFOPERATORREGISTER_H +#define __PRDFOPERATORREGISTER_H + +#include <algorithm> + +#include <iipscr.h> +#include <prdrCommon.H> + +class PrdfNotRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfNotRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_child(NULL), iv_iBS(0) + { + iv_bs = &iv_iBS; + } + + PrdfNotRegister(SCAN_COMM_REGISTER_CLASS & i_arg) : + SCAN_COMM_REGISTER_CLASS(0), iv_child(&i_arg), + iv_iBS(i_arg.GetBitString()->GetLength()) + { + iv_bs = &iv_iBS; + } + + PrdfNotRegister & operator=(const PrdfNotRegister & r) + { + iv_child = r.iv_child; + iv_iBS = r.iv_iBS; + //iv_bs = r.iv_bs; <-- don't do this! + return *this; + } + + virtual uint32_t Read() { return iv_child->Read(); } + virtual uint32_t Write() { return iv_child->Write(); } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + (*iv_bs) = ~(*iv_child->GetBitString(i_type)); + return iv_bs; + } + + virtual uint16_t GetId() const { return iv_child->GetId(); } + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfNotRegister & r) const + { return r.iv_child == iv_child; } + + bool operator<(const PrdfNotRegister & r) const + { return iv_child < r.iv_child; } + + bool operator>=(const PrdfNotRegister & r) const + { return iv_child >= r.iv_child; } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + SCAN_COMM_REGISTER_CLASS * iv_child; + + prdfBitStringBuffer * iv_bs; + prdfBitStringBuffer iv_iBS; +}; + +class PrdfLeftShiftRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfLeftShiftRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_child(NULL), iv_amount(0), iv_iBS(0) + { + iv_bs = &iv_iBS; + } + + PrdfLeftShiftRegister(SCAN_COMM_REGISTER_CLASS & i_arg, uint16_t i_amount) : + SCAN_COMM_REGISTER_CLASS(0), iv_child(&i_arg), iv_amount(i_amount), + iv_iBS(i_arg.GetBitString()->GetLength()) + { + iv_bs = &iv_iBS; + } + + PrdfLeftShiftRegister & operator=(const PrdfLeftShiftRegister & r) + { + iv_child = r.iv_child; + iv_amount = r.iv_amount; + iv_iBS = r.iv_iBS; + //iv_bs = r.iv_bs; <-- don't do this! + return *this; + } + + virtual uint32_t Read() { return iv_child->Read(); } + virtual uint32_t Write() { return iv_child->Write(); } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + (*iv_bs) = (*iv_child->GetBitString(i_type)) << iv_amount; + return iv_bs; + } + + virtual uint16_t GetId() const { return iv_child->GetId(); } + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfLeftShiftRegister & r) const + { return (r.iv_child == iv_child) && (r.iv_amount == iv_amount); } + + bool operator<(const PrdfLeftShiftRegister & r) const + { + if (iv_child == r.iv_child) + return iv_amount < r.iv_amount; + return iv_child < r.iv_child; + } + + bool operator>=(const PrdfLeftShiftRegister & r) const + { + if (iv_child == r.iv_child) + return iv_amount >= r.iv_amount; + return iv_child >= r.iv_child; + } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + SCAN_COMM_REGISTER_CLASS * iv_child; + uint16_t iv_amount; + + prdfBitStringBuffer * iv_bs; + prdfBitStringBuffer iv_iBS; +}; + +class PrdfRightShiftRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfRightShiftRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_child(NULL), iv_amount(0), iv_iBS(0) + { + iv_bs = &iv_iBS; + } + + PrdfRightShiftRegister(SCAN_COMM_REGISTER_CLASS & i_arg, + uint16_t i_amount) : + SCAN_COMM_REGISTER_CLASS(0), iv_child(&i_arg), iv_amount(i_amount), + iv_iBS(i_arg.GetBitString()->GetLength()) + { + iv_bs = &iv_iBS; + } + + PrdfRightShiftRegister & operator=(const PrdfRightShiftRegister & r) + { + iv_child = r.iv_child; + iv_amount = r.iv_amount; + iv_iBS = r.iv_iBS; + //iv_bs = r.iv_bs; <-- don't do this! + return *this; + } + + virtual uint32_t Read() { return iv_child->Read(); } + virtual uint32_t Write() { return iv_child->Write(); } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + (*iv_bs) = (*iv_child->GetBitString(i_type)) >> iv_amount; + return iv_bs; + } + + virtual uint16_t GetId() const { return iv_child->GetId(); } + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfRightShiftRegister & r) const + { return (r.iv_child == iv_child) && (r.iv_amount == iv_amount); } + + bool operator<(const PrdfRightShiftRegister & r) const + { + if (iv_child == r.iv_child) + return iv_amount < r.iv_amount; + return iv_child < r.iv_child; + } + + bool operator>=(const PrdfRightShiftRegister & r) const + { + if (iv_child == r.iv_child) + return iv_amount >= r.iv_amount; + return iv_child >= r.iv_child; + } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + SCAN_COMM_REGISTER_CLASS * iv_child; + uint16_t iv_amount; + + prdfBitStringBuffer * iv_bs; + prdfBitStringBuffer iv_iBS; +}; + + +class PrdfAndRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfAndRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_left(NULL), iv_right(NULL), iv_iBS(0) + { + iv_bs = &iv_iBS; + } + + PrdfAndRegister(SCAN_COMM_REGISTER_CLASS & i_left, + SCAN_COMM_REGISTER_CLASS & i_right) : + SCAN_COMM_REGISTER_CLASS(0), iv_left(&i_left), iv_right(&i_right), + iv_iBS(std::min(i_left.GetBitString()->GetLength(), + i_right.GetBitString()->GetLength())) + { + iv_bs = &iv_iBS; + } + + PrdfAndRegister & operator=(const PrdfAndRegister & r) + { + iv_left = r.iv_left; + iv_right = r.iv_right; + iv_iBS = r.iv_iBS; + //iv_bs = r.iv_bs; <-- don't do this! + return *this; + } + + virtual uint32_t Read() + { + return iv_left->Read() | iv_right->Read(); + } + virtual uint32_t Write() + { + return iv_left->Write() | iv_right->Write(); + } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + (*iv_bs) = *iv_left->GetBitString(i_type); + (*iv_bs) = (*iv_bs) & (*iv_right->GetBitString(i_type)); + return iv_bs; + } + + virtual uint16_t GetId() const + { + return Prdr::PrdrSignatureOp::combineSig(iv_left->GetId(), + iv_right->GetId()); + } + + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfAndRegister & r) const + { return (r.iv_left == iv_left) && (r.iv_right == iv_right); } + + bool operator<(const PrdfAndRegister & r) const + { + if (iv_left == r.iv_left) + return iv_right < r.iv_right; + return iv_left < r.iv_left; + } + + bool operator>=(const PrdfAndRegister & r) const + { + if (iv_left == r.iv_left) + return iv_right >= r.iv_right; + return iv_left >= r.iv_left; + } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + SCAN_COMM_REGISTER_CLASS * iv_left; + SCAN_COMM_REGISTER_CLASS * iv_right; + + prdfBitStringBuffer * iv_bs; + prdfBitStringBuffer iv_iBS; +}; + +class PrdfOrRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfOrRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_left(NULL), iv_right(NULL), iv_iBS(0) + { + iv_bs = &iv_iBS; + } + + PrdfOrRegister(SCAN_COMM_REGISTER_CLASS & i_left, + SCAN_COMM_REGISTER_CLASS & i_right) : + SCAN_COMM_REGISTER_CLASS(0), iv_left(&i_left), iv_right(&i_right), + iv_iBS(std::min(i_left.GetBitString()->GetLength(), + i_right.GetBitString()->GetLength())) + { + iv_bs = &iv_iBS; + } + + PrdfOrRegister & operator=(const PrdfOrRegister & r) + { + iv_left = r.iv_left; + iv_right = r.iv_right; + iv_iBS = r.iv_iBS; + //iv_bs = r.iv_bs; <-- don't do this! + return *this; + } + + virtual uint32_t Read() + { + return iv_left->Read() | iv_right->Read(); + } + virtual uint32_t Write() + { + return iv_left->Write() | iv_right->Write(); + } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + (*iv_bs) = *iv_left->GetBitString(i_type); + (*iv_bs) = (*iv_bs) | (*iv_right->GetBitString(i_type)); + return iv_bs; + } + + virtual uint16_t GetId() const + { + return Prdr::PrdrSignatureOp::combineSig(iv_left->GetId(), + iv_right->GetId()); + } + + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfOrRegister & r) const + { return (r.iv_left == iv_left) && (r.iv_right == iv_right); } + + bool operator<(const PrdfOrRegister & r) const + { + if (iv_left == r.iv_left) + return iv_right < r.iv_right; + return iv_left < r.iv_left; + } + + bool operator>=(const PrdfOrRegister & r) const + { + if (iv_left == r.iv_left) + return iv_right >= r.iv_right; + return iv_left >= r.iv_left; + } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + SCAN_COMM_REGISTER_CLASS * iv_left; + SCAN_COMM_REGISTER_CLASS * iv_right; + + prdfBitStringBuffer * iv_bs; + prdfBitStringBuffer iv_iBS; +}; + +class PrdfNullRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfNullRegister(int size) : + SCAN_COMM_REGISTER_CLASS(0), iv_iBS(size) + {} + + PrdfNullRegister & operator=(const PrdfNullRegister & r) + { + iv_iBS = r.iv_iBS; + return *this; + } + + virtual uint32_t Read() { return 0; } + virtual uint32_t Write() { return 0; } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + return &iv_iBS; + } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + prdfBitStringBuffer iv_iBS; + + virtual uint16_t GetId() const + { return Prdr::PrdrSignatureOp::DEFAULT_SIGNATURE; } + + virtual void SetId(uint16_t i_id) {} + +}; + +class PrdfAttnTypeRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfAttnTypeRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_check(&cv_null), iv_recov(&cv_null), + iv_special(&cv_null), iv_proccs(&cv_null), iv_iBS(0) + { + iv_bs = &iv_iBS; + } + + PrdfAttnTypeRegister( SCAN_COMM_REGISTER_CLASS & i_check, + SCAN_COMM_REGISTER_CLASS & i_recov, + SCAN_COMM_REGISTER_CLASS & i_special, + SCAN_COMM_REGISTER_CLASS & i_proccs ) : + SCAN_COMM_REGISTER_CLASS(0), + iv_check( NULL == &i_check ? &cv_null : &i_check), + iv_recov( NULL == &i_recov ? &cv_null : &i_recov), + iv_special(NULL == &i_special ? &cv_null : &i_special), + iv_proccs( NULL == &i_proccs ? &cv_null : &i_proccs), + iv_iBS(0) // will fully initialize this inside ctor. + { + uint32_t l_length = 1024; + l_length = std::min(l_length, iv_check->GetBitString()->GetLength()); + l_length = std::min(l_length, iv_recov->GetBitString()->GetLength()); + l_length = std::min(l_length, iv_special->GetBitString()->GetLength()); + l_length = std::min(l_length, iv_proccs->GetBitString()->GetLength()); + iv_iBS = prdfBitStringBuffer(l_length); + iv_bs = &iv_iBS; + } + + PrdfAttnTypeRegister & operator=(const PrdfAttnTypeRegister & r) + { + //iv_null = r.iv_null; <-- don't do this! + iv_check = (r.iv_check == &r.cv_null ? &cv_null : r.iv_check); + iv_recov = (r.iv_recov == &r.cv_null ? &cv_null : r.iv_recov); + iv_special = (r.iv_special == &r.cv_null ? &cv_null : r.iv_special); + iv_proccs = (r.iv_proccs == &r.cv_null ? &cv_null : r.iv_proccs); + iv_iBS = r.iv_iBS; + //iv_bs = r.iv_bs; <-- don't do this! + return *this; + } + + virtual uint32_t Read() + { + return iv_check->Read() | iv_recov->Read() | + iv_special->Read() | iv_proccs->Read(); + } + + virtual uint32_t Write() + { + return iv_check->Write() | iv_recov->Write() | + iv_special->Write() | iv_proccs->Write(); + } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + using namespace PRDF; + switch (i_type) + { + case CHECK_STOP: + (*iv_bs) = BIT_STRING_BUFFER_CLASS( + *iv_check->GetBitString(i_type)); + break; + + case RECOVERABLE: + (*iv_bs) = BIT_STRING_BUFFER_CLASS( + *iv_recov->GetBitString(i_type)); + break; + + case SPECIAL: + (*iv_bs) = BIT_STRING_BUFFER_CLASS( + *iv_special->GetBitString(i_type)); + break; + + case PROC_CS: + (*iv_bs) = BIT_STRING_BUFFER_CLASS( + *iv_proccs->GetBitString(i_type)); + break; + } + + return iv_bs; + } + + virtual uint16_t GetId() const + { + using Prdr::PrdrSignatureOp; + uint16_t l_rc = PrdrSignatureOp::DEFAULT_SIGNATURE; + l_rc = PrdrSignatureOp::combineSig(l_rc, iv_check->GetId()); + l_rc = PrdrSignatureOp::combineSig(l_rc, iv_recov->GetId()); + l_rc = PrdrSignatureOp::combineSig(l_rc, iv_special->GetId()); + l_rc = PrdrSignatureOp::combineSig(l_rc, iv_proccs->GetId()); + return l_rc; + } + + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfAttnTypeRegister & r) const + { + return (r.iv_check == iv_check) && (r.iv_recov == iv_recov) && + (r.iv_special == iv_special) && (r.iv_proccs == iv_proccs); + } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + static PrdfNullRegister cv_null; + + SCAN_COMM_REGISTER_CLASS * iv_check; + SCAN_COMM_REGISTER_CLASS * iv_recov; + SCAN_COMM_REGISTER_CLASS * iv_special; + SCAN_COMM_REGISTER_CLASS * iv_proccs; + + prdfBitStringBuffer * iv_bs; + prdfBitStringBuffer iv_iBS; +}; + +class PrdfConstantRegister : public SCAN_COMM_REGISTER_CLASS +{ + public: + PrdfConstantRegister() : + SCAN_COMM_REGISTER_CLASS(0), iv_iBS(0) + {} + + PrdfConstantRegister(BIT_STRING_CLASS i_arg) : + SCAN_COMM_REGISTER_CLASS(0), iv_iBS(i_arg) + {} + + PrdfConstantRegister & operator=(const PrdfConstantRegister & r) + { + iv_iBS = r.iv_iBS; + return *this; + } + + virtual uint32_t Read() { return SUCCESS; } + virtual uint32_t Write() { return SUCCESS; } + + const BIT_STRING_CLASS * GetBitString( + ATTENTION_TYPE i_type = PRDF::INVALID_ATTENTION_TYPE) const + { + return &iv_iBS; + } + + virtual uint16_t GetId() const + { return Prdr::PrdrSignatureOp::DEFAULT_SIGNATURE; } + + virtual void SetId(uint16_t i_id) {} + + bool operator==(const PrdfConstantRegister & r) const + { return r.iv_iBS == iv_iBS; } + + protected: + BIT_STRING_CLASS & AccessBitString(void) { return iv_iBS; } + void SetBitString(const BIT_STRING_CLASS *) {} + + private: + prdfBitStringBuffer iv_iBS; +}; + +#endif |