tests,base: Added GTests for base/condcodes.hh

The documentation for the "findParity" and "findCarry" functions in
base/condcodes.hh has been enhanced to better explain their behavior.

Change-Id: I9ba3bf68eb56529a3030e965ec21e41d2dacfad6
Reviewed-on: https://gem5-review.googlesource.com/c/public/gem5/+/21639
Reviewed-by: Gabe Black <gabeblack@google.com>
Reviewed-by: Bobby R. Bruce <bbruce@ucdavis.edu>
Maintainer: Bobby R. Bruce <bbruce@ucdavis.edu>
Tested-by: kokoro <noreply+kokoro@google.com>

1 files changed, 263 insertions, 0 deletions

diff --git a/src/base/condcodes.test.cc b/src/base/condcodes.test.cc
new file mode 100644
index 000000000..d9863be78
--- /dev/null
+++ b/src/base/condcodes.test.cc
@@ -0,0 +1,263 @@
+/*
+ * Copyright (c) 2019 The Regents of the University of California
+ * All rights reserved
+ *
+ * Redistribution and use in source and binary forms,  with or without
+ * modification,  are permitted provided that the following conditions are
+ * met: redistributions of source code must retain the above copyright
+ * notice,  this list of conditions and the following disclaimer;
+ * redistributions in binary form must reproduce the above copyright
+ * notice,  this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution;
+ * neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,  INCLUDING,  BUT NOT
+ * LIMITED TO,  THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,  INDIRECT,  INCIDENTAL,
+ * SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL DAMAGES (INCLUDING,  BUT NOT
+ * LIMITED TO,  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA,  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY,  WHETHER IN CONTRACT,  STRICT LIABILITY,  OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE,  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Authors: Bobby R. Bruce
+ *          Jared J. Barocsi
+ */
+
+#include <gtest/gtest.h>
+
+#include "base/condcodes.hh"
+
+/*
+ * Add 0x80 + 0x80 to get 0x100. findCarry should report a carry flag after
+ * this operation.
+ */
+TEST(CondCodes, FindCarryWithNoCarryIn8Bit)
+{
+    EXPECT_TRUE(findCarry(8, 0x100, 0x80, 0x80));
+}
+
+/*
+ * Add 0xf0 + 0x0f to get 0xff. findCarry should not report a carry flag after
+ * this operation.
+ */
+TEST(CondCodes, FindNoCarryWithNoCarryIn8Bit)
+{
+    EXPECT_FALSE(findCarry(8, 0xff, 0xf0, 0x0f));
+}
+
+/*
+ * Add 0x7f + 0x80 + 0x01 to get 0x100. findCarry should report a carry flag
+ * after this operation.
+ */
+TEST(CondCodes, FindCarryWithCarryIn8Bit)
+{
+    EXPECT_TRUE(findCarry(8, 0x100, 0x80, 0x7f));
+}
+
+/*
+ * Add 0x80 + 0x7e + 0x01 to get 0xff. findCarry should not report a carry
+ * flag after this operation.
+ */
+TEST(CondCodes, FindNoCarryWithCarryIn8Bit)
+{
+    EXPECT_FALSE(findCarry(8, 0xff, 0x80, 0x7e));
+}
+
+/*
+ * Add 0x80000000 + 0x80000000 to get 0x100000000. findCarry should report a
+ * carry flag after this operation.
+ */
+TEST(CondCodes, FindCarryWithNoCarryIn32Bit)
+{
+    EXPECT_TRUE(findCarry(32, 0x100000000, 0x80000000, 0x80000000));
+}
+
+/*
+ * Add 0xffff0000 + 0x0000ffff to get 0xffffffff. findCarry should not report a
+ * carry flag after this operation.
+ */
+TEST(CondCodes, FindNoCarryWithNoCarryIn32Bit)
+{
+    EXPECT_FALSE(findCarry(32, 0xffffffff, 0xffff0000, 0x0000ffff));
+}
+
+TEST(CondCodes, FindCarryWithCarryIn32Bit)
+{
+    /*
+     * Add 0x80000000 + 0x7fffffff + 0x00000001 to get 0x100000000,
+     * resulting in a carry
+     */
+    EXPECT_TRUE(findCarry(32, 0x100000000, 0x80000000, 0x7fffffff));
+    // Add 0x80000000 + 0x7ffffffe + 0x00000001 to get 0xffffffff,
+    // resulting in no carry
+    EXPECT_FALSE(findCarry(32, 0xffffffff, 0x80000000, 0x7ffffffe));
+    // Add 0xffffffff + 0x00000000 + 0x00000001 to get 0x100000000,
+    // resulting in a carry
+    EXPECT_TRUE(findCarry(32, 0x100000000, 0xffffffff, 0x00000000));
+}
+
+TEST(CondCodes, FindCarryWithNoCarryIn64Bit)
+{
+    // Add 0x8000000000000000 + 0x8000000000000000 to get 0x10000000000000000,
+    // (unrepresentable with uint64_t),  resulting in a carry
+    EXPECT_TRUE(findCarry(64, 0x0000000000000000,
+                              0x8000000000000000,
+                              0x8000000000000000));
+    /*
+     * Add 0x0000000000000000 + 0x0000000000000000 to get 0x0000000000000000
+     * resulting in no carry
+     * We get the same sum as above case due to unrepresentability,  but we
+     * should still expect no carry
+     */
+    EXPECT_FALSE(findCarry(64, 0x0000000000000000,
+                               0x0000000000000000,
+                               0x0000000000000000));
+    /*
+     * Add 0x8000000000000000 + 0x7fffffffffffffff to get 0xffffffffffffffff,
+     * resulting in no carry
+     */
+    EXPECT_FALSE(findCarry(64, 0xffffffffffffffff,
+                               0x8000000000000000,
+                               0x7fffffffffffffff));
+    /*
+     * Add 0xffffffff00000000 + 0x00000000ffffffff to get 0xffffffffffffffff,
+     * resulting in no carry
+     */
+    EXPECT_FALSE(findCarry(64, 0xffffffffffffffff,
+                               0xffffffff00000000,
+                               0x00000000ffffffff));
+}
+
+TEST(CondCodes, FindCarryWithCarryIn64Bit)
+{
+    /* Add 0x8000000000000000 + 0x8000000000000000 + 0x0000000000000001
+     * to get 0x1 000000000000001 (unrepresentable with uint64_t),
+     * resulting in a carry
+     */
+    EXPECT_TRUE(findCarry(64, 0x0000000000000000,
+                              0x8000000000000000,
+                              0x7fffffffffffffff));
+    /*
+     * Add 0x0000000000000000 + 0x0000000000000000 + 0x0000000000000001
+     * resulting in no carry
+     * We get the same sum as the above case due to unrepresentability, but we
+     * should still expect no carry
+     */
+    EXPECT_FALSE(findCarry(64, 0x0000000000000001,
+                               0x0000000000000000,
+                               0x0000000000000000));
+    /*
+     * Add 0x8000000000000000 + 0x7fffffffffffffff + 0x0000000000000001
+     * to get 0x1 0000000000000000 (unrepresentable with uint64_t),
+     * resulting in a carry
+     */
+    EXPECT_TRUE(findCarry(64, 0x0000000000000000,
+                              0x8000000000000000,
+                              0x7fffffffffffffff));
+    /*
+     * Add 0xffffffff00000000 + 0x000000000000000 + 0x0000000000000001
+     * to get 0x1 0000000000000000 (unrepresentable with uint64_t),
+     * resulting in a carry
+     */
+    EXPECT_TRUE(findCarry(64, 0x0000000000000000,
+                              0xffffffffffffffff,
+                              0x0000000000000001));
+}
+
+TEST(CondCodes, FindOverflow8Bit)
+{
+    /*
+     * Addition of 127 + 1 = 128 or -128 as signed two's complement.
+     * Overflow occurs in this case
+     */
+    EXPECT_TRUE(findOverflow(8, 0x80, 0x7f, 0x01));
+    /*
+     * Addition of 64 + 63 = 127,  or 127 as signed two's complement.
+     * No overflow occurs
+     */
+    EXPECT_FALSE(findOverflow(8, 0x7f, 0x40, 0x3f));
+}
+
+TEST(CondCodes, FindOverflow32Bit)
+{
+    /*
+     * Addition of 2,147,483,647 + 1 = 2,147,483,648, or -2,147,483,648 as
+     * signed two's complement. Overflow occurs in this case
+     */
+    EXPECT_TRUE(findOverflow(32, 0x80000000, 0x7fffffff, 0x00000001));
+    /*
+     * Addition of 1,073,741,824 + 1,073,741,823 = 2,147,483,647, or
+     * 2,147,483,647 as signed two's complement. No overflow occurs
+     */
+    EXPECT_FALSE(findOverflow(32, 0x7fffffff, 0x40000000, 0x3fffffff));
+}
+
+TEST(CondCodes, FindOverflow64Bit)
+{
+    /*
+     * Addition of 0x7fffffffffffffff + 0x0000000000000001 =
+     * 0x8000000000000000, or -9,223,372,036,854,775,808 as signed two's
+     * complement. Overflow occurs in this case
+     */
+    EXPECT_TRUE(findOverflow(64, 0x8000000000000000,
+                                 0x7fffffffffffffff,
+                                 0x0000000000000001));
+    /* Addition of 0x4000000000000000 + 0x3fffffffffffffff =
+     * 0x7fffffffffffffff, or 9,223,372,036,854,775,807 as signed two's
+     * complement. No overflow occurs
+     */
+    EXPECT_FALSE(findOverflow(64, 0x7fffffffffffffff,
+                                  0x4000000000000000,
+                                  0x3fffffffffffffff));
+}
+
+TEST(CondCodes, OddParity)
+{
+    EXPECT_EQ(1, findParity(8, 1));
+}
+
+TEST(CondCodes, EvenParity)
+{
+    EXPECT_EQ(0, findParity(8, 3));
+}
+
+TEST(CondCodes, OddParityOverflow)
+{
+    EXPECT_EQ(1, findParity(8, 0x102));
+}
+
+TEST(CondCodes, EvenParityOverflow)
+{
+    EXPECT_EQ(0, findParity(4,0x43));
+}
+
+TEST(CondCodes, IsNegative)
+{
+    EXPECT_EQ(1, findNegative(8, 128));
+}
+
+TEST(CondCodes, IsNotNegative)
+{
+    EXPECT_EQ(0, findNegative(8, 127));
+}
+
+TEST(CondCodes, IsZero)
+{
+    EXPECT_EQ(1, findZero(8, 0));
+}
+
+TEST(CondCodes, IsNotZero)
+{
+    EXPECT_EQ(0, findZero(8, 1));
+}
+
+TEST(CondCodes, IsZeroOverflow)
+{
+    EXPECT_EQ(1, findZero(8,0x100));
+}