timing_expr.cc revision 10259
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#include "base/intmath.hh" 41#include "cpu/timing_expr.hh" 42 43TimingExprEvalContext::TimingExprEvalContext (StaticInstPtr inst_, 44 ThreadContext *thread_, 45 TimingExprLet *let_) : 46 inst(inst_), thread(thread_), let(let_) 47{ 48 /* Reserve space to hold the results of evaluating the 49 * let expressions */ 50 if (let) { 51 unsigned int num_defns = let->defns.size(); 52 53 results.resize(num_defns, 0); 54 resultAvailable.resize(num_defns, false); 55 } 56} 57 58uint64_t TimingExprSrcReg::eval(TimingExprEvalContext &context) 59{ 60 return context.inst->srcRegIdx(index); 61} 62 63uint64_t TimingExprReadIntReg::eval(TimingExprEvalContext &context) 64{ 65 return context.thread->readIntReg(reg->eval(context)); 66} 67 68uint64_t TimingExprLet::eval(TimingExprEvalContext &context) 69{ 70 TimingExprEvalContext new_context(context.inst, 71 context.thread, this); 72 73 return expr->eval(new_context); 74} 75 76uint64_t TimingExprRef::eval(TimingExprEvalContext &context) 77{ 78 /* Lookup the result, evaluating if necessary. @todo, this 79 * should have more error checking */ 80 if (!context.resultAvailable[index]) { 81 context.results[index] = context.let->defns[index]->eval(context); 82 context.resultAvailable[index] = true; 83 } 84 85 return context.results[index]; 86} 87 88uint64_t TimingExprUn::eval(TimingExprEvalContext &context) 89{ 90 uint64_t arg_value = arg->eval(context); 91 uint64_t ret = 0; 92 93 switch (op) { 94 case Enums::timingExprSizeInBits: 95 if (arg_value == 0) 96 ret = 0; 97 else 98 ret = ceilLog2(arg_value); 99 break; 100 case Enums::timingExprNot: 101 ret = arg_value != 0; 102 break; 103 case Enums::timingExprInvert: 104 ret = ~arg_value; 105 break; 106 case Enums::timingExprSignExtend32To64: 107 ret = static_cast<int64_t>( 108 static_cast<int32_t>(arg_value)); 109 break; 110 case Enums::timingExprAbs: 111 if (static_cast<int64_t>(arg_value) < 0) 112 ret = -arg_value; 113 else 114 ret = arg_value; 115 break; 116 default: 117 break; 118 } 119 120 return ret; 121} 122 123uint64_t TimingExprBin::eval(TimingExprEvalContext &context) 124{ 125 uint64_t left_value = left->eval(context); 126 uint64_t right_value = right->eval(context); 127 uint64_t ret = 0; 128 129 switch (op) { 130 case Enums::timingExprAdd: 131 ret = left_value + right_value; 132 break; 133 case Enums::timingExprSub: 134 ret = left_value - right_value; 135 break; 136 case Enums::timingExprUMul: 137 ret = left_value * right_value; 138 break; 139 case Enums::timingExprUDiv: 140 if (right_value != 0) { 141 ret = left_value / right_value; 142 } 143 break; 144 case Enums::timingExprUCeilDiv: 145 if (right_value != 0) { 146 ret = (left_value + (right_value - 1)) / right_value; 147 } 148 break; 149 case Enums::timingExprSMul: 150 ret = static_cast<int64_t>(left_value) * 151 static_cast<int64_t>(right_value); 152 break; 153 case Enums::timingExprSDiv: 154 if (right_value != 0) { 155 ret = static_cast<int64_t>(left_value) / 156 static_cast<int64_t>(right_value); 157 } 158 break; 159 case Enums::timingExprEqual: 160 ret = left_value == right_value; 161 break; 162 case Enums::timingExprNotEqual: 163 ret = left_value != right_value; 164 break; 165 case Enums::timingExprULessThan: 166 ret = left_value < right_value; 167 break; 168 case Enums::timingExprUGreaterThan: 169 ret = left_value > right_value; 170 break; 171 case Enums::timingExprSLessThan: 172 ret = static_cast<int64_t>(left_value) < 173 static_cast<int64_t>(right_value); 174 break; 175 case Enums::timingExprSGreaterThan: 176 ret = static_cast<int64_t>(left_value) > 177 static_cast<int64_t>(right_value); 178 break; 179 case Enums::timingExprAnd: 180 ret = (left_value != 0) && (right_value != 0); 181 break; 182 case Enums::timingExprOr: 183 ret = (left_value != 0) || (right_value != 0); 184 break; 185 default: 186 break; 187 } 188 189 return ret; 190} 191 192uint64_t TimingExprIf::eval(TimingExprEvalContext &context) 193{ 194 uint64_t cond_value = cond->eval(context); 195 196 if (cond_value != 0) 197 return trueExpr->eval(context); 198 else 199 return falseExpr->eval(context); 200} 201 202TimingExprLiteral * 203TimingExprLiteralParams::create() 204{ 205 return new TimingExprLiteral(this); 206} 207 208TimingExprSrcReg * 209TimingExprSrcRegParams::create() 210{ 211 return new TimingExprSrcReg(this); 212} 213 214TimingExprReadIntReg * 215TimingExprReadIntRegParams::create() 216{ 217 return new TimingExprReadIntReg(this); 218} 219 220TimingExprLet * 221TimingExprLetParams::create() 222{ 223 return new TimingExprLet(this); 224} 225 226TimingExprRef * 227TimingExprRefParams::create() 228{ 229 return new TimingExprRef(this); 230} 231 232TimingExprUn * 233TimingExprUnParams::create() 234{ 235 return new TimingExprUn(this); 236} 237 238TimingExprBin * 239TimingExprBinParams::create() 240{ 241 return new TimingExprBin(this); 242} 243 244TimingExprIf * 245TimingExprIfParams::create() 246{ 247 return new TimingExprIf(this); 248} 249