[gem5-dev] changeset in gem5: base: Fix assigning between identical bitfields.

[Gabe Black via gem5-dev]

changeset edbc52a43cd8 in /z/repo/gem5
details: http://repo.gem5.org/gem5?cmd=changeset;node=edbc52a43cd8
description:
        base: Fix assigning between identical bitfields.

        If two bitfields are of the same type, also implying that they have the 
same
        first and last bit positions, the existing implementation would copy the
        entire bitfield. That includes the __data member which is shared among 
all the
        bitfields, effectively overwritting the entire bitunion.

        This change also adjusts the write only signed bitfield assignment 
operator to
        be like the unsigned version, using "using" instead of implementing it 
again
        and calling down to the underlying implementation.

diffstat:

 src/base/bitunion.hh |  31 ++++++++++++++++++++++++++-----
 1 files changed, 26 insertions(+), 5 deletions(-)

diffs (76 lines):

diff -r 469cf1ea40f5 -r edbc52a43cd8 src/base/bitunion.hh
--- a/src/base/bitunion.hh      Wed Jan 07 00:31:09 2015 -0800
+++ b/src/base/bitunion.hh      Wed Jan 07 00:31:46 2015 -0800
@@ -100,6 +100,12 @@
                 this->setBits(first, last, _data);
                 return _data;
             }
+
+            uint64_t
+            operator=(Bitfield<first, last> const & other)
+            {
+                return *this = (uint64_t)other;
+            }
         };
 
         //A class which specializes the above so that it can only be read
@@ -113,6 +119,9 @@
           private:
             uint64_t
             operator=(const uint64_t _data);
+
+            uint64_t
+            operator=(const Bitfield<first, last>& other);
         };
 
         //Similar to the above, but only allows writing.
@@ -150,6 +159,12 @@
                 this->setBits(first, last, _data);
                 return _data;
             }
+
+            int64_t
+            operator=(SignedBitfield<first, last> const & other)
+            {
+                return *this = (int64_t)other;
+            }
         };
 
         //A class which specializes the above so that it can only be read
@@ -163,6 +178,9 @@
           private:
             int64_t
             operator=(const int64_t _data);
+
+            int64_t
+            operator=(const SignedBitfield<first, last>& other);
         };
 
         //Similar to the above, but only allows writing.
@@ -173,11 +191,7 @@
             operator const int64_t () const;
 
           public:
-            int64_t operator=(const int64_t _data)
-            {
-                *((SignedBitfield<first, last> *)this) = _data;
-                return _data;
-            }
+            using SignedBitfield<first, last>::operator=;
         };
     };
 
@@ -215,6 +229,13 @@
             return _data;
         }
 
+        Type
+        operator=(BitUnionOperators const & other)
+        {
+            Base::__data = other;
+            return Base::__data;
+        }
+
         bool
         operator<(Base const & base) const
         {
_______________________________________________
gem5-dev mailing list
gem5-dev@gem5.org
http://m5sim.org/mailman/listinfo/gem5-dev