src/arch/x86/insts/microop_args.hh

/*
 * Copyright 2021 Google Inc.
 *
 * 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.
 */

#ifndef __ARCH_X86_INSTS_MICROOP_ARGS_HH__
#define __ARCH_X86_INSTS_MICROOP_ARGS_HH__

#include <cstdint>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>

#include "arch/x86/insts/static_inst.hh"
#include "arch/x86/regs/int.hh"
#include "arch/x86/types.hh"
#include "base/compiler.hh"
#include "base/cprintf.hh"
#include "cpu/reg_class.hh"
#include "sim/faults.hh"

namespace gem5
{

namespace X86ISA
{

struct DestOp
{
    const RegIndex dest;
    const size_t size;
    RegIndex opIndex() const { return dest; }

    DestOp(RegIndex _dest, size_t _size) : dest(_dest), size(_size) {}
};

struct Src1Op
{
    const RegIndex src1;
    const size_t size;
    RegIndex opIndex() const { return src1; }

    Src1Op(RegIndex _src1, size_t _size) : src1(_src1), size(_size) {}
};

struct Src2Op
{
    const RegIndex src2;
    const size_t size;
    RegIndex opIndex() const { return src2; }

    Src2Op(RegIndex _src2, size_t _size) : src2(_src2), size(_size) {}
};

struct DataOp
{
    const RegIndex data;
    const size_t size;
    RegIndex opIndex() const { return data; }

    DataOp(RegIndex _data, size_t _size) : data(_data), size(_size) {}
};

struct DataHiOp
{
    const RegIndex dataHi;
    const size_t size;
    RegIndex opIndex() const { return dataHi; }

    DataHiOp(RegIndex data_hi, size_t _size) : dataHi(data_hi), size(_size) {}
};

struct DataLowOp
{
    const RegIndex dataLow;
    const size_t size;
    RegIndex opIndex() const { return dataLow; }

    DataLowOp(RegIndex data_low, size_t _size) : dataLow(data_low), size(_size)
    {}
};

template <class Base>
struct IntOp : public Base
{
    using ArgType = GpRegIndex;

    template <class InstType>
    IntOp(InstType *inst, ArgType idx) : Base(idx.index, inst->dataSize) {}

    void
    print(std::ostream &os) const
    {
        X86StaticInst::printReg(os, RegId(IntRegClass, this->opIndex()),
                this->size);
    }
};

template <class Base>
struct FoldedOp : public Base
{
    using ArgType = GpRegIndex;

    template <class InstType>
    FoldedOp(InstType *inst, ArgType idx) :
        Base(INTREG_FOLDED(idx.index, inst->foldOBit), inst->dataSize)
    {}

    void
    print(std::ostream &os) const
    {
        X86StaticInst::printReg(os, RegId(IntRegClass, this->opIndex()),
                this->size);
    }
};

template <class Base>
struct CrOp : public Base
{
    using ArgType = CrRegIndex;

    template <class InstType>
    CrOp(InstType *inst, ArgType idx) : Base(idx.index, 0) {}

    void
    print(std::ostream &os) const
    {
        ccprintf(os, "cr%d", this->opIndex());
    }
};

template <class Base>
struct DbgOp : public Base
{
    using ArgType = DbgRegIndex;

    template <class InstType>
    DbgOp(InstType *inst, ArgType idx) : Base(idx.index, 0) {}

    void
    print(std::ostream &os) const
    {
        ccprintf(os, "dr%d", this->opIndex());
    }

};

template <class Base>
struct SegOp : public Base
{
    using ArgType = SegRegIndex;

    template <class InstType>
    SegOp(InstType *inst, ArgType idx) : Base(idx.index, 0) {}

    void
    print(std::ostream &os) const
    {
        X86StaticInst::printSegment(os, this->opIndex());
    }
};

template <class Base>
struct MiscOp : public Base
{
    using ArgType = CtrlRegIndex;

    template <class InstType>
    MiscOp(InstType *inst, ArgType idx) : Base(idx.index, inst->dataSize) {}

    void
    print(std::ostream &os) const
    {
        X86StaticInst::printReg(os, RegId(MiscRegClass, this->opIndex()),
                this->size);
    }
};

template <class Base>
struct FloatOp : public Base
{
    using ArgType = FpRegIndex;

    template <class InstType>
    FloatOp(InstType *inst, ArgType idx) : Base(idx.index, inst->dataSize) {}

    void
    print(std::ostream &os) const
    {
        X86StaticInst::printReg(os, RegId(FloatRegClass, this->opIndex()),
                this->size);
    }
};

using FoldedDestOp = FoldedOp<DestOp>;
using DbgDestOp = DbgOp<DestOp>;
using CrDestOp = CrOp<DestOp>;
using SegDestOp = SegOp<DestOp>;
using MiscDestOp = MiscOp<DestOp>;
using FloatDestOp = FloatOp<DestOp>;
using IntDestOp = IntOp<DestOp>;

using FoldedSrc1Op = FoldedOp<Src1Op>;
using DbgSrc1Op = DbgOp<Src1Op>;
using CrSrc1Op = CrOp<Src1Op>;
using SegSrc1Op = SegOp<Src1Op>;
using MiscSrc1Op = MiscOp<Src1Op>;
using FloatSrc1Op = FloatOp<Src1Op>;
using IntSrc1Op = IntOp<Src1Op>;

using FoldedSrc2Op = FoldedOp<Src2Op>;
using FloatSrc2Op = FloatOp<Src2Op>;
using IntSrc2Op = IntOp<Src2Op>;

using FoldedDataOp = FoldedOp<DataOp>;
using FloatDataOp = FloatOp<DataOp>;
using FoldedDataHiOp = FoldedOp<DataHiOp>;
using FoldedDataLowOp = FoldedOp<DataLowOp>;

struct Imm8Op
{
    using ArgType = uint8_t;

    uint8_t imm8;

    template <class InstType>
    Imm8Op(InstType *inst, ArgType _imm8) : imm8(_imm8) {}

    void
    print(std::ostream &os) const
    {
        ccprintf(os, "%#x", imm8);
    }
};

struct Imm64Op
{
    using ArgType = uint64_t;

    uint64_t imm64;

    template <class InstType>
    Imm64Op(InstType *inst, ArgType _imm64) : imm64(_imm64) {}

    void
    print(std::ostream &os) const
    {
        ccprintf(os, "%#x", imm64);
    }
};

struct UpcOp
{
    using ArgType = MicroPC;

    MicroPC target;

    template <class InstType>
    UpcOp(InstType *inst, ArgType _target) : target(_target) {}

    void
    print(std::ostream &os) const
    {
        ccprintf(os, "%#x", target);
    }
};

struct FaultOp
{
    using ArgType = Fault;

    Fault fault;

    template <class InstType>
    FaultOp(InstType *inst, ArgType _fault) : fault(_fault) {}

    void
    print(std::ostream &os) const
    {
        ccprintf(os, fault ? fault->name() : "NoFault");
    }
};

struct AddrOp
{
    struct ArgType
    {
        uint8_t scale;
        GpRegIndex index;
        GpRegIndex base;
        uint64_t disp;
        SegRegIndex segment;
    };

    const uint8_t scale;
    const RegIndex index;
    const RegIndex base;
    const uint64_t disp;
    const uint8_t segment;
    const size_t size;

    template <class InstType>
    AddrOp(InstType *inst, const ArgType &args) : scale(args.scale),
        index(INTREG_FOLDED(args.index.index, inst->foldABit)),
        base(INTREG_FOLDED(args.base.index, inst->foldABit)),
        disp(args.disp), segment(args.segment.index),
        size(inst->addressSize)
    {
        assert(segment < NUM_SEGMENTREGS);
    }

    void
    print(std::ostream &os) const
    {
        X86StaticInst::printMem(
                os, segment, scale, index, base, disp, size, false);
    }
};

template <typename Base, typename ...Operands>
class InstOperands : public Base, public Operands...
{
  private:
    using ArgTuple = std::tuple<typename Operands::ArgType...>;

    template <std::size_t ...I, typename ...CTorArgs>
    InstOperands(std::index_sequence<I...>, ExtMachInst mach_inst,
            const char *mnem, const char *inst_mnem, uint64_t set_flags,
            OpClass op_class, GEM5_VAR_USED ArgTuple args,
            CTorArgs... ctor_args) :
        Base(mach_inst, mnem, inst_mnem, set_flags, op_class, ctor_args...),
        Operands(this, std::get<I>(args))...
    {}

  protected:
    template <typename ...CTorArgs>
    InstOperands(ExtMachInst mach_inst, const char *mnem,
            const char *inst_mnem, uint64_t set_flags, OpClass op_class,
            ArgTuple args, CTorArgs... ctor_args) :
        InstOperands(std::make_index_sequence<sizeof...(Operands)>{},
                mach_inst, mnem, inst_mnem, set_flags, op_class,
                std::move(args), ctor_args...)
    {}

    std::string
    generateDisassembly(Addr pc,
            const loader::SymbolTable *symtab) const override
    {
        std::stringstream response;
        Base::printMnemonic(response, this->instMnem, this->mnemonic);
        int count = 0;
        GEM5_FOR_EACH_IN_PACK(ccprintf(response, count++ ? ", " : ""),
                              Operands::print(response));
        return response.str();
    }
};

} // namespace X86ISA
} // namespace gem5

#endif //__ARCH_X86_INSTS_MICROOP_ARGS_HH__