Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / lib / cpu / src / SS_Opcode.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: SS_Opcode.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 __SS_Opcode_h__
#define __SS_Opcode_h__

#include "SS_Types.h"

class SS_Opcode
{
  public:
    bool operator==( const SS_Opcode& o ) { return opc == o.opc; }
    bool operator!=( const SS_Opcode& o ) { return opc != o.opc; }

    SS_Opcode& operator=( uint32_t o )	  { opc = o; return *this; }

    uint32_t operator()()	{ return opc; }

    void     set ( uint32_t o )	{ opc = o; } 
    uint32_t get()		{ return opc; }

    uint_t   get_op()		{ return (opc >> 30) & 3; }
    uint_t   get_op2()		{ return (opc >> 22) & 0x7; }
    uint_t   get_op2cc()	{ return (opc >> 20) & 0x1f; }
    uint_t   get_op3()		{ return (opc >> 19) & 0x3f; }
    uint_t   get_opf()		{ return (opc >>  5) & 0x1ff; }
    uint_t   get_i() 		{ return (opc >> 13) & 1; }
    uint_t   get_a()		{ return (opc >> 29) & 1; }
    uint_t   get_cond()		{ return (opc >> 25) & 0xf; }
    uint_t   get_fcn()		{ return (opc >> 25) & 0x1f; }
    uint_t   get_cc()		{ return (opc >> 20) & 3; }
    uint_t   get_x()		{ return (opc >> 12) & 1; }
    uint_t   get_ccr() 		{ return (opc >> 11) & 3; }

    int_t    get_rs1()		{ return (opc >> 14) & 0x1f; }
    int_t    get_rs2()		{ return  opc        & 0x1f; }
    int_t    get_rd()		{ return (opc >> 25) & 0x1f; }

    int_t    get_rs1_irf()	{ return (opc >> 11) & 0xf8; }
    int_t    get_rs2_irf()	{ return (opc <<  3) & 0xf8; }
    int_t    get_rd_irf()	{ return (opc >> 22) & 0xf8; }
    int_t    get_p()	        { return (opc >> 19) & 1; }

    int_t    get_rs1_frf()
    {
#if defined (ARCH_X64)
      return ((opc >> 12) & 0x7c) ^ 0x4;
#else
      return (opc >> 12) & 0x7c;
#endif
    }  
    int_t    get_rs2_frf()
    {
#if defined (ARCH_X64)
      return ((opc <<  2) & 0x7c) ^ 0x4;
#else
      return (opc <<  2) & 0x7c;
#endif
    } 
    int_t    get_rs3_frf()
    {
#if defined (ARCH_X64)
      return ((opc >>  7) & 0x7c) ^ 0x4;
#else
      return (opc >>  7) & 0x7c;
#endif
    } 
    int_t    get_rd_frf()
    {
#if defined (ARCH_X64)
      return ((opc >> 23) & 0x7c) ^ 0x4;
#else
      return (opc >> 23) & 0x7c;
#endif
    }

    int_t    get_rs1_drf()	{ return (((opc) >> 7) & 0x80) | (((opc) >> 12) & 0x78); }	
    int_t    get_rs2_drf()	{ return (((opc) << 7) & 0x80) | (((opc) << 2) & 0x78); }	
    int_t    get_rs3_drf()	{ return (((opc) >> 2) & 0x80) | (((opc) >> 7) & 0x78); }	
    int_t    get_rd_drf()	{ return (((opc) >> 18) & 0x80) | (((opc) >> 23) & 0x78); }	

    int64_t  get_simm10()	{ return (int64_t(opc) << 54) >> 54; }
    int64_t  get_simm11()	{ return (int64_t(opc) << 53) >> 53; }
    int64_t  get_simm13()	{ return (int64_t(opc) << 51) >> 51; }

    uint64_t get_imm3()		{ return  opc & 0x7; }
    uint64_t get_imm5()		{ return  opc & 0x1f; }
    uint64_t get_imm6()		{ return  opc & 0x3f; }
    uint64_t get_imm7()		{ return  opc & 0x7f; }
    uint64_t get_imm8()		{ return  opc & 0xff; }
    uint64_t get_imm16()	{ return  ((opc >> 6) & 0xc000) | (opc & 0x3fff); }
    uint64_t get_imm22()	{ return  opc << 10; }

    uint32_t get_imm_asi()	{ return (opc >>  5) & 0xff; }

    int64_t  get_disp16()	{ return int64_t(((uint64_t(opc)>>20)<<62)|((uint64_t(opc)<<50)>>2)) >> 46; }
    int64_t  get_disp19()	{ return (int64_t(opc) << 45) >> 43; }
    int64_t  get_disp22()	{ return (int64_t(opc) << 42) >> 40; }
    int64_t  get_disp30()	{ return (int64_t(opc) << 34) >> 32; }
   
    // is_zero_<to>_<from>() returns true when bits <from> to <to> (inclusive) are
    // zero. False is returned otherwise. The methods are used in decoding.
 
    bool     is_zero_29_25()	{ return 0 == ((opc >> 25) & 0x1f); }
    bool     is_zero_18_0()	{ return 0 == (opc & 0x7ffff); }
    bool     is_zero_18_14()	{ return 0 == ((opc >> 14) & 0x1f); }
    bool     is_zero_18_18()	{ return 0 == (opc & 0x40000); }
    bool     is_zero_13_0()	{ return 0 == (opc & 0x3fff); }
    bool     is_zero_12_8()	{ return 0 == ((opc >> 8) & 0x1f); }
    bool     is_zero_12_7()	{ return 0 == ((opc >> 7) & 0x3f); }
    bool     is_zero_12_5()	{ return 0 == ((opc >> 5) & 0xff); }
    bool     is_zero_11_7()	{ return 0 == (opc & 0xf80); }
    bool     is_zero_11_6()	{ return 0 == (opc & 0xfc0); }
    bool     is_zero_11_5()	{ return 0 == (opc & 0xfe0); }
    bool     is_zero_10_8()	{ return 0 == (opc & 0x700); }
    bool     is_zero_10_5()	{ return 0 == (opc & 0x7e0); }
    bool     is_zero_9_5()	{ return 0 == (opc & 0x3e0); }
    bool     is_zero_4_0()	{ return 0 == (opc & 0x1f); }
    bool     is_zero_4_3()	{ return 0 == (opc & 0x18); }

    void set_rs1( uint32_t v )	{ opc = (opc & ~(0x1f << 14)) | ((v & 0x1f) << 14); }
    void set_rs2( uint32_t v )	{ opc = (opc & ~ 0x1f       ) | ( v & 0x1f       ); }
    void set_rd ( uint32_t v )	{ opc = (opc & ~(0x1f << 25)) | ((v & 0x1f) << 25); }
    void set_imm( uint32_t v )	{ opc = (opc & ~0x3fff) | (v & 0x3fff); }

  protected:
    uint32_t opc;
};

#endif