X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Fcpu%2Fstatic_inst.hh;h=375b7d0bacad8c5b7e20d09b882edf3d5572b514;hb=0e8a90f06bd3db00f700891a33458353478cce76;hp=adda82c491f56c5e6c69dd9b31026d77c47c50d4;hpb=49a7ed0397954f555f5fb4272334e606a3048c59;p=gem5.git diff --git a/src/cpu/static_inst.hh b/src/cpu/static_inst.hh index adda82c49..375b7d0ba 100644 --- a/src/cpu/static_inst.hh +++ b/src/cpu/static_inst.hh @@ -1,5 +1,6 @@ /* * Copyright (c) 2003-2005 The Regents of The University of Michigan + * Copyright (c) 2013 Advanced Micro Devices, Inc. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -42,27 +43,27 @@ #include "config/the_isa.hh" #include "cpu/op_class.hh" #include "cpu/static_inst_fwd.hh" +#include "cpu/thread_context.hh" +#include "enums/StaticInstFlags.hh" #include "sim/fault_fwd.hh" // forward declarations -struct AlphaSimpleImpl; -struct OzoneImpl; -struct SimpleImpl; -class ThreadContext; -class DynInst; class Packet; -class O3CPUImpl; +struct O3CPUImpl; template class BaseO3DynInst; typedef BaseO3DynInst O3DynInst; -template class OzoneDynInst; class InOrderDynInst; class CheckerCPU; -class FastCPU; class AtomicSimpleCPU; class TimingSimpleCPU; class InorderCPU; +namespace Minor +{ + class ExecContext; +}; + class SymbolTable; namespace Trace { @@ -77,7 +78,7 @@ namespace Trace { * solely on these flags can process instructions without being * recompiled for multiple ISAs. */ -class StaticInst : public RefCounted +class StaticInst : public RefCounted, public StaticInstFlags { public: /// Binary extended machine instruction type. @@ -87,91 +88,13 @@ class StaticInst : public RefCounted enum { MaxInstSrcRegs = TheISA::MaxInstSrcRegs, //< Max source regs - MaxInstDestRegs = TheISA::MaxInstDestRegs, //< Max dest regs - }; - - /// Set of boolean static instruction properties. - /// - /// Notes: - /// - The IsInteger and IsFloating flags are based on the class of - /// registers accessed by the instruction. Although most - /// instructions will have exactly one of these two flags set, it - /// is possible for an instruction to have neither (e.g., direct - /// unconditional branches, memory barriers) or both (e.g., an - /// FP/int conversion). - /// - If IsMemRef is set, then exactly one of IsLoad or IsStore - /// will be set. - /// - If IsControl is set, then exactly one of IsDirectControl or - /// IsIndirect Control will be set, and exactly one of - /// IsCondControl or IsUncondControl will be set. - /// - IsSerializing, IsMemBarrier, and IsWriteBarrier are - /// implemented as flags since in the current model there's no - /// other way for instructions to inject behavior into the - /// pipeline outside of fetch. Once we go to an exec-in-exec CPU - /// model we should be able to get rid of these flags and - /// implement this behavior via the execute() methods. - /// - enum Flags { - IsNop, ///< Is a no-op (no effect at all). - - IsInteger, ///< References integer regs. - IsFloating, ///< References FP regs. - - IsMemRef, ///< References memory (load, store, or prefetch). - IsLoad, ///< Reads from memory (load or prefetch). - IsStore, ///< Writes to memory. - IsStoreConditional, ///< Store conditional instruction. - IsIndexed, ///< Accesses memory with an indexed address computation - IsInstPrefetch, ///< Instruction-cache prefetch. - IsDataPrefetch, ///< Data-cache prefetch. - - IsControl, ///< Control transfer instruction. - IsDirectControl, ///< PC relative control transfer. - IsIndirectControl, ///< Register indirect control transfer. - IsCondControl, ///< Conditional control transfer. - IsUncondControl, ///< Unconditional control transfer. - IsCall, ///< Subroutine call. - IsReturn, ///< Subroutine return. - - IsCondDelaySlot,///< Conditional Delay-Slot Instruction - - IsThreadSync, ///< Thread synchronization operation. - - IsSerializing, ///< Serializes pipeline: won't execute until all - /// older instructions have committed. - IsSerializeBefore, - IsSerializeAfter, - IsMemBarrier, ///< Is a memory barrier - IsWriteBarrier, ///< Is a write barrier - IsReadBarrier, ///< Is a read barrier - IsERET, /// <- Causes the IFU to stall (MIPS ISA) - - IsNonSpeculative, ///< Should not be executed speculatively - IsQuiesce, ///< Is a quiesce instruction - - IsIprAccess, ///< Accesses IPRs - IsUnverifiable, ///< Can't be verified by a checker - - IsSyscall, ///< Causes a system call to be emulated in syscall - /// emulation mode. - - //Flags for microcode - IsMacroop, ///< Is a macroop containing microops - IsMicroop, ///< Is a microop - IsDelayedCommit, ///< This microop doesn't commit right away - IsLastMicroop, ///< This microop ends a microop sequence - IsFirstMicroop, ///< This microop begins a microop sequence - //This flag doesn't do anything yet - IsMicroBranch, ///< This microop branches within the microcode for a macroop - IsDspOp, - IsSquashAfter, ///< Squash all uncommitted state after executed - NumFlags + MaxInstDestRegs = TheISA::MaxInstDestRegs //< Max dest regs }; protected: /// Flag values for this instruction. - std::bitset flags; + std::bitset flags; /// See opClass(). OpClass _opClass; @@ -187,6 +110,7 @@ class StaticInst : public RefCounted //@{ int8_t _numFPDestRegs; int8_t _numIntDestRegs; + int8_t _numCCDestRegs; //@} public: @@ -226,6 +150,7 @@ class StaticInst : public RefCounted bool isInteger() const { return flags[IsInteger]; } bool isFloating() const { return flags[IsFloating]; } + bool isCC() const { return flags[IsCC]; } bool isControl() const { return flags[IsControl]; } bool isCall() const { return flags[IsCall]; } @@ -389,6 +314,12 @@ class StaticInst : public RefCounted virtual const std::string &disassemble(Addr pc, const SymbolTable *symtab = 0) const; + /** + * Print a separator separated list of this instruction's set flag + * names on the given stream. + */ + void printFlags(std::ostream &outs, const std::string &separator) const; + /// Return name of machine instruction std::string getName() { return mnemonic; } };