Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / bl / lib / utl / src / BL_Types.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: BL_Types.h
* Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
* 
* The above named program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public
* License version 2 as published by the Free Software Foundation.
* 
* The above named program is distributed in the hope that it will be 
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
* General Public License for more details.
* 
* You should have received a copy of the GNU General Public
* License along with this work; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
* 
* ========== Copyright Header End ============================================
*/
#ifndef __BL_Types_h__
#define __BL_Types_h__

#include <stdio.h>
#include <stdlib.h>

#include <sys/types.h>
#include <assert.h>


typedef   signed int  int_t;
typedef unsigned int uint_t;

// Unsigned 256_bit type
class BL_Uint256 {
  public:
    BL_Uint256()
    {
      array[0] = 0;
      array[1] = 0;
      array[2] = 0;
      array[3] = 0;
    }

    // Create a BL_Uint256 from 4 uint64_t.  The first argument is the
    // least significant uint64_t, the last argument the most
    // significant, etc.
    BL_Uint256(uint64_t _ls_val, uint64_t _lms_val,
            uint64_t _mms_val, uint64_t _ms_val)
    {
      array[0] = _ls_val;
      array[1] = _lms_val;
      array[2] = _mms_val;
      array[3] = _ms_val;
    }

    uint64_t get(uint_t ndx) const { return array[ndx]; }
    BL_Uint256& set(uint_t ndx, uint64_t val)
    {
      array[ndx] = val;
      return *this;
    }

    BL_Uint256& invert(uint_t bit)
    {
      const uint_t nr_bits_in_ull = sizeof(uint64_t) * 8;
      uint_t array_ndx = bit/nr_bits_in_ull;
      if (array_ndx >= 4)
      {
        fprintf(stderr, "BL_Uint256::invert(): bad bit number: %d\n", bit);
        exit(-1);
      }
      array[array_ndx] ^= (1ULL << (bit%nr_bits_in_ull));
      return *this;
    }

    BL_Uint256 operator&(const BL_Uint256& op2) const
    {
      BL_Uint256 result;
      for (uint_t ndx = 0; ndx < 4; ++ndx)
        result.array[ndx] = array[ndx] & op2.array[ndx];
      return result;
    }

    ~BL_Uint256() {}

  private: 
    uint64_t    array[4];
};

#endif /* __BL_Types_h__ */