src/cpu/timing_expr.hh

   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
  69 class TimingExprLet;
  70
  71 /** Object to gather the visible context for evaluation */
  72 class 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
  90 class 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
 100 class 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
 113 class 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
 126 class 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
 139 class 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
 154 class 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
 167 class 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
 182 class 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
 199 class 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