src/base/condcodes.test.cc - public/gem5 - Git at Google

 /*
  * 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));
 }
	/*
	* 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));
	}