inst_res.hh (12109:f29e9c5418aa) | inst_res.hh (13610:5d5404ac6288) |
---|---|
1/* | 1/* |
2 * Copyright (c) 2016 ARM Limited | 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; | 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; |
|
51 public: 52 union MultiResult { 53 uint64_t integer; 54 double dbl; 55 VecRegContainer vector; 56 VecElem vecElem; | 52 public: 53 union MultiResult { 54 uint64_t integer; 55 double dbl; 56 VecRegContainer vector; 57 VecElem vecElem; |
58 VecPredRegContainer pred; |
|
57 MultiResult() {} 58 }; 59 60 enum class ResultType { 61 Scalar, 62 VecElem, 63 VecReg, | 59 MultiResult() {} 60 }; 61 62 enum class ResultType { 63 Scalar, 64 VecElem, 65 VecReg, |
66 VecPredReg, |
|
64 NumResultTypes, 65 Invalid 66 }; 67 68 private: 69 MultiResult result; 70 ResultType type; 71 --- 10 unchanged lines hidden (view full) --- 82 result.integer = i; 83 } else if (std::is_floating_point<T>::value) { 84 result.dbl = i; 85 } 86 } 87 /** Vector result. */ 88 explicit InstResult(const VecRegContainer& v, const ResultType& t) 89 : type(t) { result.vector = v; } | 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; } |
|
90 91 InstResult& operator=(const InstResult& that) { 92 type = that.type; 93 switch (type) { 94 /* Given that misc regs are not written to, there may be invalids in 95 * the result stack. */ 96 case ResultType::Invalid: 97 break; 98 case ResultType::Scalar: 99 result.integer = that.result.integer; 100 break; 101 case ResultType::VecElem: 102 result.vecElem = that.result.vecElem; 103 break; 104 case ResultType::VecReg: 105 result.vector = that.result.vector; 106 break; | 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 |
|
107 default: 108 panic("Assigning result from unknown result type"); 109 break; 110 } 111 return *this; 112 } 113 /** 114 * Result comparison --- 4 unchanged lines hidden (view full) --- 119 return false; 120 switch (type) { 121 case ResultType::Scalar: 122 return result.integer == that.result.integer; 123 case ResultType::VecElem: 124 return result.vecElem == that.result.vecElem; 125 case ResultType::VecReg: 126 return result.vector == that.result.vector; | 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; |
|
127 case ResultType::Invalid: 128 return false; 129 default: 130 panic("Unknown type of result: %d\n", (int)type); 131 } 132 } 133 134 bool operator!=(const InstResult& that) const { 135 return !operator==(that); 136 } 137 138 /** Checks */ 139 /** @{ */ 140 /** Is this a scalar result?. */ 141 bool isScalar() const { return type == ResultType::Scalar; } 142 /** Is this a vector result?. */ 143 bool isVector() const { return type == ResultType::VecReg; } 144 /** Is this a vector element result?. */ 145 bool isVecElem() const { return type == ResultType::VecElem; } | 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; } |
|
146 /** Is this a valid result?. */ 147 bool isValid() const { return type != ResultType::Invalid; } 148 /** @} */ 149 150 /** Explicit cast-like operations. */ 151 /** @{ */ 152 const uint64_t& 153 asInteger() const --- 18 unchanged lines hidden (view full) --- 172 return result.vector; 173 } 174 const VecElem& 175 asVectorElem() const 176 { 177 panic_if(!isVecElem(), "Converting scalar (or invalid) to vector!!"); 178 return result.vecElem; 179 } | 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 |
|
180 /** @} */ 181}; 182 183#endif // __CPU_INST_RES_HH__ | 202 /** @} */ 203}; 204 205#endif // __CPU_INST_RES_HH__ |