inst_res.hh revision 12107 
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
47class InstResult {
48  public:
49    union MultiResult {
50        uint64_t integer;
51        double dbl;
52        MultiResult() {}
53    };
54
55    enum class ResultType {
56        Scalar,
57        NumResultTypes,
58        Invalid
59    };
60
61  private:
62    MultiResult result;
63    ResultType type;
64
65  public:
66    /** Default constructor creates an invalid result. */
67    InstResult() : type(ResultType::Invalid) { }
68    /** Scalar result from scalar. */
69    template<typename T>
70    explicit InstResult(T i, const ResultType& t) : type(t) {
71        static_assert(std::is_integral<T>::value ^
72                        std::is_floating_point<T>::value,
73                "Parameter type is neither integral nor fp, or it is both");
74        if (std::is_integral<T>::value) {
75            result.integer = i;
76        } else if (std::is_floating_point<T>::value) {
77            result.dbl = i;
78        }
79    }
80
81    /**
82     * Result comparison
83     * Two invalid results always differ.
84     */
85    bool operator==(const InstResult& that) const {
86        if (this->type != that.type)
87            return false;
88        switch (type) {
89        case ResultType::Scalar:
90            return result.integer == that.result.integer;
91        case ResultType::Invalid:
92            return false;
93        default:
94            panic("Unknown type of result: %d\n", (int)type);
95        }
96    }
97
98    bool operator!=(const InstResult& that) const {
99        return !operator==(that);
100    }
101
102    /** Checks */
103    /** @{ */
104    /** Is this a scalar result?. */
105    bool isScalar() const { return type == ResultType::Scalar; }
106    /** Is this a valid result?. */
107    bool isValid() const { return type != ResultType::Invalid; }
108    /** @} */
109
110    /** Explicit cast-like operations. */
111    /** @{ */
112    const uint64_t&
113    asInteger() const
114    {
115        assert(isScalar());
116        return result.integer;
117    }
118
119    /** Cast to integer without checking type.
120     * This is required to have the o3 cpu checker happy, as it
121     * compares results as integers without being fully aware of
122     * their nature. */
123    const uint64_t&
124    asIntegerNoAssert() const
125    {
126        return result.integer;
127    }
128    /** @} */
129};
130
131#endif // __CPU_INST_RES_HH__
132