1/*
2 * Copyright (c) 2013-2014 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: Andrew Bardsley
38 */
39
40/*
41 * These classes define an expression language over uint64_t with only
42 * a few operators.  This can be used to form expressions for the extra
43 * delay required in variable execution time instructions.
44 *
45 * Expressions, in evaluation, will have access to the ThreadContext and
46 * a StaticInst.
47 */
48
49#ifndef __CPU_TIMING_EXPR_HH__
50#define __CPU_TIMING_EXPR_HH__
51
52#include "cpu/static_inst.hh"
53#include "cpu/thread_context.hh"
54#include "enums/TimingExprOp.hh"
55#include "params/TimingExpr.hh"
56#include "params/TimingExprBin.hh"
57#include "params/TimingExprIf.hh"
58#include "params/TimingExprLet.hh"
59#include "params/TimingExprLiteral.hh"
60#include "params/TimingExprReadIntReg.hh"
61#include "params/TimingExprRef.hh"
62#include "params/TimingExprSrcReg.hh"
63#include "params/TimingExprUn.hh"
64#include "sim/sim_object.hh"
65
66/** These classes are just the C++ counterparts for those in Expr.py and
67 *  are, therefore, documented there */
68
69class TimingExprLet;
70
71/** Object to gather the visible context for evaluation */
72class TimingExprEvalContext
73{
74  public:
75    /** Special visible context */
76    const StaticInstPtr &inst;
77    ThreadContext *thread;
78
79    /** Context visible as sub expressions.  results will hold the results
80     *  of (lazily) evaluating let's expressions.  resultAvailable elements
81     *  are true when a result has actually been evaluated */
82    TimingExprLet *let;
83    std::vector<uint64_t> results;
84    std::vector<bool > resultAvailable;
85
86    TimingExprEvalContext(const StaticInstPtr &inst_,
87        ThreadContext *thread_, TimingExprLet *let_);
88};
89
90class TimingExpr : public SimObject
91{
92  public:
93    TimingExpr(const TimingExprParams *params) :
94        SimObject(params)
95    { }
96
97    virtual uint64_t eval(TimingExprEvalContext &context) = 0;
98};
99
100class TimingExprLiteral : public TimingExpr
101{
102  public:
103    uint64_t value;
104
105    TimingExprLiteral(const TimingExprLiteralParams *params) :
106        TimingExpr(params),
107        value(params->value)
108    { }
109
110    uint64_t eval(TimingExprEvalContext &context) { return value; }
111};
112
113class TimingExprSrcReg : public TimingExpr
114{
115  public:
116    unsigned int index;
117
118    TimingExprSrcReg(const TimingExprSrcRegParams *params) :
119        TimingExpr(params),
120        index(params->index)
121    { }
122
123    uint64_t eval(TimingExprEvalContext &context);
124};
125
126class TimingExprReadIntReg : public TimingExpr
127{
128  public:
129    TimingExpr *reg;
130
131    TimingExprReadIntReg(const TimingExprReadIntRegParams *params) :
132        TimingExpr(params),
133        reg(params->reg)
134    { }
135
136    uint64_t eval(TimingExprEvalContext &context);
137};
138
139class TimingExprLet : public TimingExpr
140{
141  public:
142    std::vector<TimingExpr *> defns;
143    TimingExpr *expr;
144
145    TimingExprLet(const TimingExprLetParams *params) :
146        TimingExpr(params),
147        defns(params->defns),
148        expr(params->expr)
149    { }
150
151    uint64_t eval(TimingExprEvalContext &context);
152};
153
154class TimingExprRef : public TimingExpr
155{
156  public:
157    unsigned int index;
158
159    TimingExprRef(const TimingExprRefParams *params) :
160        TimingExpr(params),
161        index(params->index)
162    { }
163
164    uint64_t eval(TimingExprEvalContext &context);
165};
166
167class TimingExprUn : public TimingExpr
168{
169  public:
170    Enums::TimingExprOp op;
171    TimingExpr *arg;
172
173    TimingExprUn(const TimingExprUnParams *params) :
174        TimingExpr(params),
175        op(params->op),
176        arg(params->arg)
177    { }
178
179    uint64_t eval(TimingExprEvalContext &context);
180};
181
182class TimingExprBin : public TimingExpr
183{
184  public:
185    Enums::TimingExprOp op;
186    TimingExpr *left;
187    TimingExpr *right;
188
189    TimingExprBin(const TimingExprBinParams *params) :
190        TimingExpr(params),
191        op(params->op),
192        left(params->left),
193        right(params->right)
194    { }
195
196    uint64_t eval(TimingExprEvalContext &context);
197};
198
199class TimingExprIf : public TimingExpr
200{
201  public:
202    TimingExpr *cond;
203    TimingExpr *trueExpr;
204    TimingExpr *falseExpr;
205
206    TimingExprIf(const TimingExprIfParams *params) :
207        TimingExpr(params),
208        cond(params->cond),
209        trueExpr(params->trueExpr),
210        falseExpr(params->falseExpr)
211    { }
212
213    uint64_t eval(TimingExprEvalContext &context);
214};
215
216#endif
217