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 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(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