// -*- mode:c++ -*-

// Copyright (c) 2007-2008 The Florida State University
// 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: Stephen Hines

////////////////////////////////////////////////////////////////////
//
// Predicated Instruction Execution
//

output header {{
#include <iostream>

    inline uint32_t
    rotate_imm(uint32_t immValue, int rotateValue)
    {
        return ((immValue >> (rotateValue & 31)) |
                (immValue << (32 - (rotateValue & 31))));
    }

    /**
     * Base class for predicated integer operations.
     */
    class PredOp : public ArmStaticInst
    {
      protected:

        ArmISA::ConditionCode condCode;

        /// Constructor
        PredOp(const char *mnem, MachInst _machInst, OpClass __opClass) :
                        ArmStaticInst(mnem, _machInst, __opClass),
                        condCode((ArmISA::ConditionCode)COND_CODE)
        {
        }

        std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
    };

    /**
     * Base class for predicated immediate operations.
     */
    class PredImmOp : public PredOp
    {
            protected:

            uint32_t imm;
            uint32_t rotate;
            uint32_t rotated_imm;
            uint32_t rotated_carry;

            /// Constructor
            PredImmOp(const char *mnem, MachInst _machInst, OpClass __opClass) :
                            PredOp(mnem, _machInst, __opClass),
                            imm(IMM), rotate(ROTATE << 1), rotated_imm(0),
                            rotated_carry(0)
            {
                rotated_imm = rotate_imm(imm, rotate);
                if (rotate != 0)
                    rotated_carry = (rotated_imm >> 31) & 1;
            }

            std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
    };

    /**
     * Base class for predicated integer operations.
     */
    class PredIntOp : public PredOp
    {
            protected:

            uint32_t shift_size;
            uint32_t shift;

            /// Constructor
            PredIntOp(const char *mnem, MachInst _machInst, OpClass __opClass) :
                            PredOp(mnem, _machInst, __opClass),
                            shift_size(SHIFT_SIZE), shift(SHIFT)
            {
            }

            std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
    };

    /**
     * Base class for predicated macro-operations.
     */
    class PredMacroOp : public PredOp
    {
            protected:

            uint32_t numMicroops;
            StaticInstPtr * microOps;

            /// Constructor
            PredMacroOp(const char *mnem, MachInst _machInst, OpClass __opClass) :
                            PredOp(mnem, _machInst, __opClass),
                            numMicroops(0)
            {
                // We rely on the subclasses of this object to handle the
                // initialization of the micro-operations, since they are
                // all of variable length
                flags[IsMacroop] = true;
            }

            ~PredMacroOp()
            {
                if (numMicroops)
                    delete [] microOps;
            }

            StaticInstPtr fetchMicroop(MicroPC microPC)
            {
                assert(microPC < numMicroops);
                return microOps[microPC];
            }

            %(BasicExecPanic)s

            std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
    };

    /**
     * Base class for predicated micro-operations.
     */
    class PredMicroop : public PredOp
    {
            /// Constructor
            PredMicroop(const char *mnem, MachInst _machInst, OpClass __opClass) :
                            PredOp(mnem, _machInst, __opClass)
            {
                flags[IsMicroop] = true;
            }
    };

}};

let {{
    predicateTest = 'testPredicate(Cpsr, condCode)'
}};

def template PredOpExecute {{
    Fault %(class_name)s::execute(%(CPU_exec_context)s *xc, Trace::InstRecord *traceData) const
    {
        Fault fault = NoFault;
        %(op_decl)s;
        %(op_rd)s;

        if (%(predicate_test)s)
        {
            %(code)s;
            if (fault == NoFault)
            {
                %(op_wb)s;
            }
        }

        return fault;
    }
}};

//Outputs to decoder.cc
output decoder {{
    std::string PredOp::generateDisassembly(Addr pc, const SymbolTable *symtab) const
    {
        std::stringstream ss;

        ccprintf(ss, "%-10s ", mnemonic);

        if (_numDestRegs > 0) {
            printReg(ss, _destRegIdx[0]);
        }

        ss << ", ";

        if (_numSrcRegs > 0) {
            printReg(ss, _srcRegIdx[0]);
            ss << ", ";
        }

        return ss.str();
    }

    std::string PredImmOp::generateDisassembly(Addr pc, const SymbolTable *symtab) const
    {
        std::stringstream ss;

        ccprintf(ss, "%-10s ", mnemonic);

        if (_numDestRegs > 0) {
            printReg(ss, _destRegIdx[0]);
        }

        ss << ", ";

        if (_numSrcRegs > 0) {
            printReg(ss, _srcRegIdx[0]);
            ss << ", ";
        }

        return ss.str();
    }

    std::string PredIntOp::generateDisassembly(Addr pc, const SymbolTable *symtab) const
    {
        std::stringstream ss;

        ccprintf(ss, "%-10s ", mnemonic);

        if (_numDestRegs > 0) {
            printReg(ss, _destRegIdx[0]);
        }

        ss << ", ";

        if (_numSrcRegs > 0) {
            printReg(ss, _srcRegIdx[0]);
            ss << ", ";
        }

        return ss.str();
    }

    std::string PredMacroOp::generateDisassembly(Addr pc, const SymbolTable *symtab) const
    {
        std::stringstream ss;

        ccprintf(ss, "%-10s ", mnemonic);

        return ss.str();
    }

}};

let {{

    calcCcCode = '''
        uint16_t _ic, _iv, _iz, _in;

        _in = (resTemp >> 31) & 1;
        _iz = (resTemp == 0);
        _iv = %(ivValue)s & 1;
        _ic = %(icValue)s & 1;

        Cpsr =  _in << 31 | _iz << 30 | _ic << 29 | _iv << 28 |
            (Cpsr & 0x0FFFFFFF);

        DPRINTF(Arm, "in = %%d\\n", _in);
        DPRINTF(Arm, "iz = %%d\\n", _iz);
        DPRINTF(Arm, "ic = %%d\\n", _ic);
        DPRINTF(Arm, "iv = %%d\\n", _iv);
        '''

}};

def format PredOp(code, *opt_flags) {{
    iop = InstObjParams(name, Name, 'PredOp',
                        {"code": code,
                         "predicate_test": predicateTest},
                        opt_flags)
    header_output = BasicDeclare.subst(iop)
    decoder_output = BasicConstructor.subst(iop)
    decode_block = BasicDecode.subst(iop)
    exec_output = PredOpExecute.subst(iop)
}};

def format PredImmOp(code, *opt_flags) {{
    iop = InstObjParams(name, Name, 'PredImmOp',
                        {"code": code,
                         "predicate_test": predicateTest},
                        opt_flags)
    header_output = BasicDeclare.subst(iop)
    decoder_output = BasicConstructor.subst(iop)
    decode_block = BasicDecode.subst(iop)
    exec_output = PredOpExecute.subst(iop)
}};

def format PredImmOpCc(code, icValue, ivValue, *opt_flags) {{
    ccCode = calcCcCode % vars()
    code += ccCode;
    iop = InstObjParams(name, Name, 'PredImmOp',
                        {"code": code,
                         "cc_code": ccCode,
                         "predicate_test": predicateTest},
                        opt_flags)
    header_output = BasicDeclare.subst(iop)
    decoder_output = BasicConstructor.subst(iop)
    decode_block = BasicDecode.subst(iop)
    exec_output = PredOpExecute.subst(iop)
}};

def format PredIntOp(code, *opt_flags) {{
    new_code = ArmGenericCodeSubs(code)
    iop = InstObjParams(name, Name, 'PredIntOp',
                        {"code": new_code,
                         "predicate_test": predicateTest},
                        opt_flags)
    header_output = BasicDeclare.subst(iop)
    decoder_output = BasicConstructor.subst(iop)
    decode_block = BasicDecode.subst(iop)
    exec_output = PredOpExecute.subst(iop)
}};

def format PredIntOpCc(code, icValue, ivValue, *opt_flags) {{
    ccCode = calcCcCode % vars()
    code += ccCode;
    new_code = ArmGenericCodeSubs(code)
    iop = InstObjParams(name, Name, 'PredIntOp',
                        {"code": new_code,
                         "cc_code": ccCode,
                         "predicate_test": predicateTest},
                        opt_flags)
    header_output = BasicDeclare.subst(iop)
    decoder_output = BasicConstructor.subst(iop)
    decode_block = BasicDecode.subst(iop)
    exec_output = PredOpExecute.subst(iop)
}};