| /* |
| * Copyright 2016 WebAssembly Community Group participants |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #ifndef wasm_ast_cost_h |
| #define wasm_ast_cost_h |
| |
| namespace wasm { |
| |
| // Measure the execution cost of an AST. Very handwave-ey |
| |
| struct CostAnalyzer : public Visitor<CostAnalyzer, Index> { |
| CostAnalyzer(Expression *ast) { |
| assert(ast); |
| cost = visit(ast); |
| } |
| |
| Index cost; |
| |
| Index maybeVisit(Expression* curr) { |
| return curr ? visit(curr) : 0; |
| } |
| |
| Index visitBlock(Block *curr) { |
| Index ret = 0; |
| for (auto* child : curr->list) ret += visit(child); |
| return ret; |
| } |
| Index visitIf(If *curr) { |
| return 1 + visit(curr->condition) + std::max(visit(curr->ifTrue), maybeVisit(curr->ifFalse)); |
| } |
| Index visitLoop(Loop *curr) { |
| return 5 * visit(curr->body); |
| } |
| Index visitBreak(Break *curr) { |
| return 1 + maybeVisit(curr->value) + maybeVisit(curr->condition); |
| } |
| Index visitSwitch(Switch *curr) { |
| return 2 + visit(curr->condition) + maybeVisit(curr->value); |
| } |
| Index visitCall(Call *curr) { |
| Index ret = 4; |
| for (auto* child : curr->operands) ret += visit(child); |
| return ret; |
| } |
| Index visitCallImport(CallImport *curr) { |
| Index ret = 15; |
| for (auto* child : curr->operands) ret += visit(child); |
| return ret; |
| } |
| Index visitCallIndirect(CallIndirect *curr) { |
| Index ret = 6 + visit(curr->target); |
| for (auto* child : curr->operands) ret += visit(child); |
| return ret; |
| } |
| Index visitGetLocal(GetLocal *curr) { |
| return 0; |
| } |
| Index visitSetLocal(SetLocal *curr) { |
| return 1; |
| } |
| Index visitGetGlobal(GetGlobal *curr) { |
| return 1; |
| } |
| Index visitSetGlobal(SetGlobal *curr) { |
| return 2; |
| } |
| Index visitLoad(Load *curr) { |
| return 1 + visit(curr->ptr); |
| } |
| Index visitStore(Store *curr) { |
| return 2 + visit(curr->ptr) + visit(curr->value); |
| } |
| Index visitConst(Const *curr) { |
| return 1; |
| } |
| Index visitUnary(Unary *curr) { |
| Index ret = 0; |
| switch (curr->op) { |
| case ClzInt32: |
| case CtzInt32: |
| case PopcntInt32: |
| case NegFloat32: |
| case AbsFloat32: |
| case CeilFloat32: |
| case FloorFloat32: |
| case TruncFloat32: |
| case NearestFloat32: |
| case ClzInt64: |
| case CtzInt64: |
| case PopcntInt64: |
| case NegFloat64: |
| case AbsFloat64: |
| case CeilFloat64: |
| case FloorFloat64: |
| case TruncFloat64: |
| case NearestFloat64: |
| case EqZInt32: |
| case EqZInt64: |
| case ExtendSInt32: |
| case ExtendUInt32: |
| case WrapInt64: |
| case PromoteFloat32: |
| case DemoteFloat64: |
| case TruncSFloat32ToInt32: |
| case TruncUFloat32ToInt32: |
| case TruncSFloat64ToInt32: |
| case TruncUFloat64ToInt32: |
| case ReinterpretFloat32: |
| case TruncSFloat32ToInt64: |
| case TruncUFloat32ToInt64: |
| case TruncSFloat64ToInt64: |
| case TruncUFloat64ToInt64: |
| case ReinterpretFloat64: |
| case ReinterpretInt32: |
| case ConvertSInt32ToFloat32: |
| case ConvertUInt32ToFloat32: |
| case ConvertSInt64ToFloat32: |
| case ConvertUInt64ToFloat32: |
| case ReinterpretInt64: |
| case ConvertSInt32ToFloat64: |
| case ConvertUInt32ToFloat64: |
| case ConvertSInt64ToFloat64: |
| case ConvertUInt64ToFloat64: ret = 1; break; |
| case SqrtFloat32: |
| case SqrtFloat64: ret = 2; break; |
| default: WASM_UNREACHABLE(); |
| } |
| return ret + visit(curr->value); |
| } |
| Index visitBinary(Binary *curr) { |
| Index ret = 0; |
| switch (curr->op) { |
| case AddInt32: ret = 1; break; |
| case SubInt32: ret = 1; break; |
| case MulInt32: ret = 2; break; |
| case DivSInt32: ret = 3; break; |
| case DivUInt32: ret = 3; break; |
| case RemSInt32: ret = 3; break; |
| case RemUInt32: ret = 3; break; |
| case AndInt32: ret = 1; break; |
| case OrInt32: ret = 1; break; |
| case XorInt32: ret = 1; break; |
| case ShlInt32: ret = 1; break; |
| case ShrUInt32: ret = 1; break; |
| case ShrSInt32: ret = 1; break; |
| case RotLInt32: ret = 1; break; |
| case RotRInt32: ret = 1; break; |
| case AddInt64: ret = 1; break; |
| case SubInt64: ret = 1; break; |
| case MulInt64: ret = 2; break; |
| case DivSInt64: ret = 3; break; |
| case DivUInt64: ret = 3; break; |
| case RemSInt64: ret = 3; break; |
| case RemUInt64: ret = 3; break; |
| case AndInt64: ret = 1; break; |
| case OrInt64: ret = 1; break; |
| case XorInt64: ret = 1; break; |
| case ShlInt64: ret = 1; break; |
| case ShrUInt64: ret = 1; break; |
| case ShrSInt64: ret = 1; break; |
| case RotLInt64: ret = 1; break; |
| case RotRInt64: ret = 1; break; |
| case AddFloat32: ret = 1; break; |
| case SubFloat32: ret = 1; break; |
| case MulFloat32: ret = 2; break; |
| case DivFloat32: ret = 3; break; |
| case CopySignFloat32: ret = 1; break; |
| case MinFloat32: ret = 1; break; |
| case MaxFloat32: ret = 1; break; |
| case AddFloat64: ret = 1; break; |
| case SubFloat64: ret = 1; break; |
| case MulFloat64: ret = 2; break; |
| case DivFloat64: ret = 3; break; |
| case CopySignFloat64: ret = 1; break; |
| case MinFloat64: ret = 1; break; |
| case MaxFloat64: ret = 1; break; |
| case LtUInt32: ret = 1; break; |
| case LtSInt32: ret = 1; break; |
| case LeUInt32: ret = 1; break; |
| case LeSInt32: ret = 1; break; |
| case GtUInt32: ret = 1; break; |
| case GtSInt32: ret = 1; break; |
| case GeUInt32: ret = 1; break; |
| case GeSInt32: ret = 1; break; |
| case LtUInt64: ret = 1; break; |
| case LtSInt64: ret = 1; break; |
| case LeUInt64: ret = 1; break; |
| case LeSInt64: ret = 1; break; |
| case GtUInt64: ret = 1; break; |
| case GtSInt64: ret = 1; break; |
| case GeUInt64: ret = 1; break; |
| case GeSInt64: ret = 1; break; |
| case LtFloat32: ret = 1; break; |
| case GtFloat32: ret = 1; break; |
| case LeFloat32: ret = 1; break; |
| case GeFloat32: ret = 1; break; |
| case LtFloat64: ret = 1; break; |
| case GtFloat64: ret = 1; break; |
| case LeFloat64: ret = 1; break; |
| case GeFloat64: ret = 1; break; |
| case EqInt32: ret = 1; break; |
| case NeInt32: ret = 1; break; |
| case EqInt64: ret = 1; break; |
| case NeInt64: ret = 1; break; |
| case EqFloat32: ret = 1; break; |
| case NeFloat32: ret = 1; break; |
| case EqFloat64: ret = 1; break; |
| case NeFloat64: ret = 1; break; |
| default: WASM_UNREACHABLE(); |
| } |
| return ret + visit(curr->left) + visit(curr->right); |
| } |
| Index visitSelect(Select *curr) { |
| return 2 + visit(curr->condition) + visit(curr->ifTrue) + visit(curr->ifFalse); |
| } |
| Index visitDrop(Drop *curr) { |
| return visit(curr->value); |
| } |
| Index visitReturn(Return *curr) { |
| return maybeVisit(curr->value); |
| } |
| Index visitHost(Host *curr) { |
| return 100; |
| } |
| Index visitNop(Nop *curr) { |
| return 0; |
| } |
| Index visitUnreachable(Unreachable *curr) { |
| return 0; |
| } |
| }; |
| |
| } // namespace wasm |
| |
| #endif // wasm_ast_cost_h |
| |
