Operator Registers; bitwise math operators
A library of useful classes used to perform logical or bitwise
math on or between other registers. The classes implemented here
include NotRegister, LeftShiftRegister, RightShiftRegister,
AndRegister, OrRegister, and ConstantRegister.
Accompanied with other Register classes and the getBitString()
function, it is possible to perform operations like:
AndRegister reg{<register1>,<register2>};
result = reg.getBitString(<someChip>);
This example will return a BitString containing the result of the
bitwise AND operation applied to register1 and register2.
Signed-off-by: Paul Greenwood <Paul.Greenwood@ibm.com>
Change-Id: I660c540bde1c02520962524b9ffb5fa7faf1d86f
diff --git a/src/register/hei_hardware_register.cpp b/src/register/hei_hardware_register.cpp
index 7629a06..74df35f 100644
--- a/src/register/hei_hardware_register.cpp
+++ b/src/register/hei_hardware_register.cpp
@@ -12,16 +12,6 @@
//------------------------------------------------------------------------------
-#if 0
-void HardwareRegister::setBitString(const BitString *bs)
-{
- BitString& l_string = accessBitString();
- l_string.setString(*bs);
-}
-#endif
-
-//------------------------------------------------------------------------------
-
const BitString* HardwareRegister::getBitString(const Chip& i_chip) const
{
// Verify this register belongs on i_chip.
diff --git a/src/register/hei_hardware_register.hpp b/src/register/hei_hardware_register.hpp
index f79191d..ee57b2a 100644
--- a/src/register/hei_hardware_register.hpp
+++ b/src/register/hei_hardware_register.hpp
@@ -145,15 +145,6 @@
/** Function overloaded from parent Register class. */
const BitString* getBitString(const Chip& i_chip) const;
-#if 0
- /**
- * @brief Updates bit string contents associated with register
- * @param i_bs poiner to bit string
- * @return Nil
- */
- virtual void setBitString(const BitString * i_bs) ;
-#endif
-
/**
* @brief Reads a register from hardware via the user interface APIs.
* @param i_chip The target chip in which this register belongs.
diff --git a/src/register/hei_operator_register.hpp b/src/register/hei_operator_register.hpp
index 02c9b1d..ce9a869 100644
--- a/src/register/hei_operator_register.hpp
+++ b/src/register/hei_operator_register.hpp
@@ -2,6 +2,23 @@
#include <register/hei_register.hpp>
+/**
+ * @file hei_operator_register.hpp
+ *
+ * A library of useful classes used to perform logical or bitwise math on or
+ * between other registers. The classes implemented here include NotRegister,
+ * LeftShiftRegister, RightShiftRegister, AndRegister, OrRegister, and
+ * ConstantRegister.
+ *
+ * Accompanied with other Register classes and the getBitString() function, it
+ * is possible to perform operations like:
+ *
+ * AndRegister reg{<register1>,<register2>};
+ * result = reg.getBitString(<someChip>);
+ *
+ * This example will return a BitString containing the result of the bitwise
+ * AND operation applied to register1 and register2.
+ */
namespace libhei
{
@@ -44,6 +61,13 @@
// Pure virtual destructor must be defined.
inline OperatorRegister::~OperatorRegister() {}
+/**
+ * @brief Using getBitString(), performs a bitwise NOT operation on a register.
+ *
+ * Example:
+ * NotRegister reg{someRegister};
+ * result = reg.getBitString(someChip);
+ */
class NotRegister : public OperatorRegister
{
public:
@@ -90,6 +114,13 @@
Register* iv_child;
};
+/**
+ * @brief Using getBitString(), performs a left shift operation on a register.
+ *
+ * Example:
+ * LeftShiftRegister reg{someRegister1, shiftValue};
+ * result = reg.getBitString(someChip);
+ */
class LeftShiftRegister : public OperatorRegister
{
public:
@@ -140,6 +171,13 @@
uint16_t iv_amount;
};
+/**
+ * @brief Using getBitString(), performs a right shift operation on a register.
+ *
+ * Example:
+ * RightShiftRegister reg{someRegister1, shiftValue};
+ * result = reg.getBitString(someChip);
+ */
class RightShiftRegister : public OperatorRegister
{
public:
@@ -190,6 +228,14 @@
uint16_t iv_amount;
};
+/**
+ * @brief Using getBitString(), performs a bitwise AND operation on a pair
+ * of registers.
+ *
+ * Example:
+ * AndRegister reg{someRegister1, someRegister2};
+ * result = reg.getBitString(someChip);
+ */
class AndRegister : public OperatorRegister
{
public:
@@ -242,6 +288,14 @@
Register* iv_right;
};
+/**
+ * @brief Using getBitString(), performs a bitwise OR operation on a pair
+ * of registers.
+ *
+ * Example:
+ * OrRegister reg{someRegister1, someRegister2};
+ * result = reg.getBitString(someChip);
+ */
class OrRegister : public OperatorRegister
{
public:
@@ -294,6 +348,11 @@
Register* iv_right;
};
+/**
+ * @brief Contains a constant value that can be used within any of the other
+ * register operators. The value can be retrieved using the
+ * getBitString() function.
+ **/
class ConstantRegister : public OperatorRegister
{
public:
diff --git a/src/register/hei_register.hpp b/src/register/hei_register.hpp
index d3435a3..ff8999c 100644
--- a/src/register/hei_register.hpp
+++ b/src/register/hei_register.hpp
@@ -15,15 +15,14 @@
creates a place where these registers can be put together like logical
building blocks. For example, Register makes this possible:
-Register * fir = new HardwareRegister(REG_ADDRESS, REG_WIDTH,
- CHIP_TYPE, ACCESS_RO);
-Register * mask = new ConstantRegister(0xffffffff00000000);
-Register * fir_mask = new AndRegister(fir, mask);
+Register * mask1 = new ConstantRegister(0xffff000000000000);
+Register * mask2 = new ConstantRegister(0xffffffff00000000);
+Register * fir_mask = new AndRegister(mask1, mask2);
const BitString * bs = fir_mask->getBitString(chip);
The getBitString function (defined by each register) provides access to
the BitString that manages each register's data. In this example bs will
-contain the result of fir & mask.
+contain the result of mask1 & mask2.
*/
class Register
{