inst_res.hh revision 12109 
1/*
2 * Copyright (c) 2016 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  public:
52    union MultiResult {
53        uint64_t integer;
54        double dbl;
55        VecRegContainer vector;
56        VecElem vecElem;
57        MultiResult() {}
58    };
59
60    enum class ResultType {
61        Scalar,
62        VecElem,
63        VecReg,
64        NumResultTypes,
65        Invalid
66    };
67
68  private:
69    MultiResult result;
70    ResultType type;
71
72  public:
73    /** Default constructor creates an invalid result. */
74    InstResult() : type(ResultType::Invalid) { }
75    /** Scalar result from scalar. */
76    template<typename T>
77    explicit InstResult(T i, const ResultType& t) : type(t) {
78        static_assert(std::is_integral<T>::value ^
79                        std::is_floating_point<T>::value,
80                "Parameter type is neither integral nor fp, or it is both");
81        if (std::is_integral<T>::value) {
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; }
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;
107        default:
108            panic("Assigning result from unknown result type");
109            break;
110        }
111        return *this;
112    }
113    /**
114     * Result comparison
115     * Two invalid results always differ.
116     */
117    bool operator==(const InstResult& that) const {
118        if (this->type != that.type)
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;
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; }
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
154    {
155        assert(isScalar());
156        return result.integer;
157    }
158
159    /** Cast to integer without checking type.
160     * This is required to have the o3 cpu checker happy, as it
161     * compares results as integers without being fully aware of
162     * their nature. */
163    const uint64_t&
164    asIntegerNoAssert() const
165    {
166        return result.integer;
167    }
168    const VecRegContainer&
169    asVector() const
170    {
171        panic_if(!isVector(), "Converting scalar (or invalid) to vector!!");
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    }
180    /** @} */
181};
182
183#endif // __CPU_INST_RES_HH__
184