/* IBM_PROLOG_BEGIN_TAG                                                   */
/* This is an automatically generated prolog.                             */
/*                                                                        */
/* $Source: src/usr/diag/prdf/common/rule/prdrCommon.H $                  */
/*                                                                        */
/* OpenPOWER HostBoot Project                                             */
/*                                                                        */
/* Contributors Listed Below - COPYRIGHT 2016,2017                        */
/* [+] International Business Machines Corp.                              */
/*                                                                        */
/*                                                                        */
/* Licensed under the Apache License, Version 2.0 (the "License");        */
/* you may not use this file except in compliance with the License.       */
/* You may obtain a copy of the License at                                */
/*                                                                        */
/*     http://www.apache.org/licenses/LICENSE-2.0                         */
/*                                                                        */
/* Unless required by applicable law or agreed to in writing, software    */
/* distributed under the License is distributed on an "AS IS" BASIS,      */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or        */
/* implied. See the License for the specific language governing           */
/* permissions and limitations under the License.                         */
/*                                                                        */
/* IBM_PROLOG_END_TAG                                                     */

#ifndef __PRDRCOMMON_H
#define __PRDRCOMMON_H

/**
 * @file prdrCommon.H
 * @brief Common enums, typedefs, etc. between compiler and loader for rule
 * table code.
 */

#include <map>
#include <stdint.h>

#ifdef __PRD_RULE_COMPILE
  #include <string>
#endif

/**
 * @namespace Prdr
 * @brief Namespace to encapsulate Prdr specific enums, classes, and typedefs.
 */
namespace Prdr
{

    enum NumberOfAttentions
    {
        MAX_NUM_ATTN_TYPES = 5,
    };

    /**
     * @enum RegisterFlags
     * @brief Flags for which register attributes are contained in a register
     * definition.
     *
     * When loading the .prf file, each register entry will contain a set of
     * these flags that describe what attributes are non-default (and therefore
     * contained in the file).
     */
    enum RegisterFlags
    {
        PRDR_REGISTER_SCOMLEN       = 0x01, ///< Non-default scomlen
        PRDR_REGISTER_RESETS        = 0x02, ///< Resets defined
        PRDR_REGISTER_MASKS         = 0x04, ///< Masks defined
        PRDR_REGISTER_CAPTURE       = 0x08, ///< Capture requirements
        PRDR_REGISTER_ACCESS_NIL    = 0x10, ///< FFDC only register
        PRDR_REGISTER_READ          = 0x20, ///< Read only register
        PRDR_REGISTER_WRITE         = 0x40, ///< Write only register
    };

    /**
     * @enum GroupFlags
     * @brief Flags for which group attributes are contained in a group
     * definition.
     *
     * When loading the .prf file, each group entry will contain a set of
     * these flags that describe what attributes are non-default (and therefore
     * contained in the file).
     */
    enum GroupFlags
    {
            /** Single Bit Filter */
        PRDR_GROUP_FILTER_SINGLE_BIT         = 0x1,
            /** Priority Bit Filter */
        PRDR_GROUP_FILTER_PRIORITY           = 0x2,
            /** CS Root Cause Filter */
        PRDR_GROUP_FILTER_CS_ROOT_CAUSE      = 0x8,
            /** CS Root Cause Null Filter */
        PRDR_GROUP_FILTER_CS_ROOT_CAUSE_NULL = 0x10,
    };

    /**
     * @enum TimeBaseFlags
     * @brief Enums for time base
     *
     * When reading rule file, these flags can be used to write in prf files
     * for time base values.
     */
    enum TimeBaseFlags
    {
        PRDR_TIME_BASE_SEC  = 1,
        PRDR_TIME_BASE_MIN  = PRDR_TIME_BASE_SEC  * 60,
        PRDR_TIME_BASE_HOUR = PRDR_TIME_BASE_MIN  * 60,
        PRDR_TIME_BASE_DAY  = PRDR_TIME_BASE_HOUR * 24,
    };

    /**
     * @enum ExprOps
     * @brief Single char op's defined for .prf files.
     *
     * Needed for properly reading/writing .prf files.
     */
    enum ExprOps
    {
        REF_RULE  = 'r',
        REF_REG   = 'e',
        REF_GRP   = 'g',
        REF_ACT   = 'a',
        INTEGER   = 'I',
        INT_SHORT = 'i',
        BIT_STR   = 'B',
        NOT       = '~',
        AND       = '&',
        OR        = '|',
        XOR       = '^',
        LSHIFT    = 174, // ASCII left-shift
        RSHIFT    = 175, // ASCII right-shift
        RULE      = 'R',
        GROUP     = 'G',
        ACTION    = 'A',
        SUMMARY   = 'S',

        ATTNLINK  = 'L',

        ACT_THRES = 't',
        ACT_ANALY = 'y',
        ACT_TRY   = '{',
        ACT_DUMP  = 'd',
        ACT_CALL  = 'c',
        ACT_FUNC  = 'f',
        ACT_FLAG  = 'F',
        ACT_CAPT  = 'C',
    };

    enum Callout_type
    {
        CALLOUT_PROC        =  0x00000001,  // for procedure callout
        CALLOUT_GARD_SELF   =  0x00000002,  // for self callout and gard
        CALLOUT_GARD_CHIP   =  0x00000003,  // for connected callout and gard
        CALLOUT_GARD_PEER   =  0x00000004,  // for callout and gard of connected
                                            // peer
    };
    class SignatureOp
    {
      public:
        enum { DEFAULT_SIGNATURE = 0x0 };

        static uint16_t combineSig( uint16_t a, uint16_t b )
        {
            // The two signature will be XOR'd together and there is a
            // possibility that the signature could be the same, which would
            // result in 0. So, rotate the first signature to essentially
            // scramble it. This should be able to create a unique signature.
            a = ((a & 0xff80) >> 7) | ((a & 0x007f) << 9); // rotate left 9 bits
            return ( (a ^ b) & 0xffff );
        };
    };

    #ifdef __PRD_RULE_COMPILE
    typedef std::map<uint16_t, std::string> HashCollisionMap;
    #endif

} // end namespace Prdr

#endif