1/* |
2 * Copyright (c) 2016-2017 ARM Limited |
3 * All rights reserved 4 * 5 * The license below extends only to copyright in the software and shall 6 * not be construed as granting a license to any other intellectual 7 * property including but not limited to intellectual property relating 8 * to a hardware implementation of the functionality of the software 9 * licensed hereunder. You may use the software subject to the license 10 * terms below provided that you ensure that this notice is replicated --- 32 unchanged lines hidden (view full) --- 43#include <type_traits> 44 45#include "arch/generic/types.hh" 46#include "arch/generic/vec_reg.hh" 47 48class InstResult { 49 using VecRegContainer = TheISA::VecRegContainer; 50 using VecElem = TheISA::VecElem; |
51 using VecPredRegContainer = TheISA::VecPredRegContainer; |
52 public: 53 union MultiResult { 54 uint64_t integer; 55 double dbl; 56 VecRegContainer vector; 57 VecElem vecElem; |
58 VecPredRegContainer pred; |
59 MultiResult() {} 60 }; 61 62 enum class ResultType { 63 Scalar, 64 VecElem, 65 VecReg, |
66 VecPredReg, |
67 NumResultTypes, 68 Invalid 69 }; 70 71 private: 72 MultiResult result; 73 ResultType type; 74 --- 10 unchanged lines hidden (view full) --- 85 result.integer = i; 86 } else if (std::is_floating_point<T>::value) { 87 result.dbl = i; 88 } 89 } 90 /** Vector result. */ 91 explicit InstResult(const VecRegContainer& v, const ResultType& t) 92 : type(t) { result.vector = v; } |
93 /** Predicate result. */ 94 explicit InstResult(const VecPredRegContainer& v, const ResultType& t) 95 : type(t) { result.pred = v; } |
96 97 InstResult& operator=(const InstResult& that) { 98 type = that.type; 99 switch (type) { 100 /* Given that misc regs are not written to, there may be invalids in 101 * the result stack. */ 102 case ResultType::Invalid: 103 break; 104 case ResultType::Scalar: 105 result.integer = that.result.integer; 106 break; 107 case ResultType::VecElem: 108 result.vecElem = that.result.vecElem; 109 break; 110 case ResultType::VecReg: 111 result.vector = that.result.vector; 112 break; |
113 case ResultType::VecPredReg: 114 result.pred = that.result.pred; 115 break; 116 |
117 default: 118 panic("Assigning result from unknown result type"); 119 break; 120 } 121 return *this; 122 } 123 /** 124 * Result comparison --- 4 unchanged lines hidden (view full) --- 129 return false; 130 switch (type) { 131 case ResultType::Scalar: 132 return result.integer == that.result.integer; 133 case ResultType::VecElem: 134 return result.vecElem == that.result.vecElem; 135 case ResultType::VecReg: 136 return result.vector == that.result.vector; |
137 case ResultType::VecPredReg: 138 return result.pred == that.result.pred; |
139 case ResultType::Invalid: 140 return false; 141 default: 142 panic("Unknown type of result: %d\n", (int)type); 143 } 144 } 145 146 bool operator!=(const InstResult& that) const { 147 return !operator==(that); 148 } 149 150 /** Checks */ 151 /** @{ */ 152 /** Is this a scalar result?. */ 153 bool isScalar() const { return type == ResultType::Scalar; } 154 /** Is this a vector result?. */ 155 bool isVector() const { return type == ResultType::VecReg; } 156 /** Is this a vector element result?. */ 157 bool isVecElem() const { return type == ResultType::VecElem; } |
158 /** Is this a predicate result?. */ 159 bool isPred() const { return type == ResultType::VecPredReg; } |
160 /** Is this a valid result?. */ 161 bool isValid() const { return type != ResultType::Invalid; } 162 /** @} */ 163 164 /** Explicit cast-like operations. */ 165 /** @{ */ 166 const uint64_t& 167 asInteger() const --- 18 unchanged lines hidden (view full) --- 186 return result.vector; 187 } 188 const VecElem& 189 asVectorElem() const 190 { 191 panic_if(!isVecElem(), "Converting scalar (or invalid) to vector!!"); 192 return result.vecElem; 193 } |
194 195 const VecPredRegContainer& 196 asPred() const 197 { 198 panic_if(!isPred(), "Converting scalar (or invalid) to predicate!!"); 199 return result.pred; 200 } 201 |
202 /** @} */ 203}; 204 205#endif // __CPU_INST_RES_HH__ |