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
11 * unmodified and in its entirety in all distributions of the software,
12 * modified or unmodified, in source code or in binary form.
13 *
14 * Redistribution and use in source and binary forms, with or without
15 * modification, are permitted provided that the following conditions are
16 * met: redistributions of source code must retain the above copyright
17 * notice, this list of conditions and the following disclaimer;
18 * redistributions in binary form must reproduce the above copyright
19 * notice, this list of conditions and the following disclaimer in the
20 * documentation and/or other materials provided with the distribution;
21 * neither the name of the copyright holders nor the names of its
22 * contributors may be used to endorse or promote products derived from
23 * this software without specific prior written permission.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
26 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
27 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
28 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
29 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
30 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
31 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
32 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
33 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
35 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 *
37 * Authors: Nathanael Premillieu
38 */
39
40#ifndef __CPU_INST_RES_HH__
41#define __CPU_INST_RES_HH__
42
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
75  public:
76    /** Default constructor creates an invalid result. */
77    InstResult() : type(ResultType::Invalid) { }
78    /** Scalar result from scalar. */
79    template<typename T>
80    explicit InstResult(T i, const ResultType& t) : type(t) {
81        static_assert(std::is_integral<T>::value ^
82                        std::is_floating_point<T>::value,
83                "Parameter type is neither integral nor fp, or it is both");
84        if (std::is_integral<T>::value) {
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
125     * Two invalid results always differ.
126     */
127    bool operator==(const InstResult& that) const {
128        if (this->type != that.type)
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
168    {
169        assert(isScalar());
170        return result.integer;
171    }
172
173    /** Cast to integer without checking type.
174     * This is required to have the o3 cpu checker happy, as it
175     * compares results as integers without being fully aware of
176     * their nature. */
177    const uint64_t&
178    asIntegerNoAssert() const
179    {
180        return result.integer;
181    }
182    const VecRegContainer&
183    asVector() const
184    {
185        panic_if(!isVector(), "Converting scalar (or invalid) to vector!!");
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__
206