src/v8/src/compiler/js-operator.h

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef V8_COMPILER_JS_OPERATOR_H_
   6 #define V8_COMPILER_JS_OPERATOR_H_
   7
   8 #include "src/compiler/linkage.h"
   9 #include "src/compiler/opcodes.h"
  10 #include "src/compiler/operator.h"
  11 #include "src/unique.h"
  12 #include "src/zone.h"
  13
  14 namespace v8 {
  15 namespace internal {
  16 namespace compiler {
  17
  18 // Defines the location of a context slot relative to a specific scope. This is
  19 // used as a parameter by JSLoadContext and JSStoreContext operators and allows
  20 // accessing a context-allocated variable without keeping track of the scope.
  21 class ContextAccess {
  22  public:
  23   ContextAccess(int depth, int index, bool immutable)
  24       : immutable_(immutable), depth_(depth), index_(index) {
  25     DCHECK(0 <= depth && depth <= kMaxUInt16);
  26     DCHECK(0 <= index && static_cast<uint32_t>(index) <= kMaxUInt32);
  27   }
  28   int depth() const { return depth_; }
  29   int index() const { return index_; }
  30   bool immutable() const { return immutable_; }
  31
  32  private:
  33   // For space reasons, we keep this tightly packed, otherwise we could just use
  34   // a simple int/int/bool POD.
  35   const bool immutable_;
  36   const uint16_t depth_;
  37   const uint32_t index_;
  38 };
  39
  40 // Defines the property being loaded from an object by a named load. This is
  41 // used as a parameter by JSLoadNamed operators.
  42 struct LoadNamedParameters {
  43   Unique<Name> name;
  44   ContextualMode contextual_mode;
  45 };
  46
  47 // Defines the arity and the call flags for a JavaScript function call. This is
  48 // used as a parameter by JSCall operators.
  49 struct CallParameters {
  50   int arity;
  51   CallFunctionFlags flags;
  52 };
  53
  54 // Defines the property being stored to an object by a named store. This is
  55 // used as a parameter by JSStoreNamed operators.
  56 struct StoreNamedParameters {
  57   StrictMode strict_mode;
  58   Unique<Name> name;
  59 };
  60
  61 // Interface for building JavaScript-level operators, e.g. directly from the
  62 // AST. Most operators have no parameters, thus can be globally shared for all
  63 // graphs.
  64 class JSOperatorBuilder {
  65  public:
  66   explicit JSOperatorBuilder(Zone* zone) : zone_(zone) {}
  67
  68 #define SIMPLE(name, properties, inputs, outputs) \
  69   return new (zone_)                              \
  70       SimpleOperator(IrOpcode::k##name, properties, inputs, outputs, #name);
  71
  72 #define NOPROPS(name, inputs, outputs) \
  73   SIMPLE(name, Operator::kNoProperties, inputs, outputs)
  74
  75 #define OP1(name, ptype, pname, properties, inputs, outputs)                 \
  76   return new (zone_) Operator1<ptype>(IrOpcode::k##name, properties, inputs, \
  77                                       outputs, #name, pname)
  78
  79 #define BINOP(name) NOPROPS(name, 2, 1)
  80 #define UNOP(name) NOPROPS(name, 1, 1)
  81
  82 #define PURE_BINOP(name) SIMPLE(name, Operator::kPure, 2, 1)
  83
  84   const Operator* Equal() { BINOP(JSEqual); }
  85   const Operator* NotEqual() { BINOP(JSNotEqual); }
  86   const Operator* StrictEqual() { PURE_BINOP(JSStrictEqual); }
  87   const Operator* StrictNotEqual() { PURE_BINOP(JSStrictNotEqual); }
  88   const Operator* LessThan() { BINOP(JSLessThan); }
  89   const Operator* GreaterThan() { BINOP(JSGreaterThan); }
  90   const Operator* LessThanOrEqual() { BINOP(JSLessThanOrEqual); }
  91   const Operator* GreaterThanOrEqual() { BINOP(JSGreaterThanOrEqual); }
  92   const Operator* BitwiseOr() { BINOP(JSBitwiseOr); }
  93   const Operator* BitwiseXor() { BINOP(JSBitwiseXor); }
  94   const Operator* BitwiseAnd() { BINOP(JSBitwiseAnd); }
  95   const Operator* ShiftLeft() { BINOP(JSShiftLeft); }
  96   const Operator* ShiftRight() { BINOP(JSShiftRight); }
  97   const Operator* ShiftRightLogical() { BINOP(JSShiftRightLogical); }
  98   const Operator* Add() { BINOP(JSAdd); }
  99   const Operator* Subtract() { BINOP(JSSubtract); }
 100   const Operator* Multiply() { BINOP(JSMultiply); }
 101   const Operator* Divide() { BINOP(JSDivide); }
 102   const Operator* Modulus() { BINOP(JSModulus); }
 103
 104   const Operator* UnaryNot() { UNOP(JSUnaryNot); }
 105   const Operator* ToBoolean() { UNOP(JSToBoolean); }
 106   const Operator* ToNumber() { UNOP(JSToNumber); }
 107   const Operator* ToString() { UNOP(JSToString); }
 108   const Operator* ToName() { UNOP(JSToName); }
 109   const Operator* ToObject() { UNOP(JSToObject); }
 110   const Operator* Yield() { UNOP(JSYield); }
 111
 112   const Operator* Create() { SIMPLE(JSCreate, Operator::kEliminatable, 0, 1); }
 113
 114   const Operator* Call(int arguments, CallFunctionFlags flags) {
 115     CallParameters parameters = {arguments, flags};
 116     OP1(JSCallFunction, CallParameters, parameters, Operator::kNoProperties,
 117         arguments, 1);
 118   }
 119
 120   const Operator* CallNew(int arguments) {
 121     return new (zone_)
 122         Operator1<int>(IrOpcode::kJSCallConstruct, Operator::kNoProperties,
 123                        arguments, 1, "JSCallConstruct", arguments);
 124   }
 125
 126   const Operator* LoadProperty() { BINOP(JSLoadProperty); }
 127   const Operator* LoadNamed(Unique<Name> name,
 128                             ContextualMode contextual_mode = NOT_CONTEXTUAL) {
 129     LoadNamedParameters parameters = {name, contextual_mode};
 130     OP1(JSLoadNamed, LoadNamedParameters, parameters, Operator::kNoProperties,
 131         1, 1);
 132   }
 133
 134   const Operator* StoreProperty(StrictMode strict_mode) {
 135     OP1(JSStoreProperty, StrictMode, strict_mode, Operator::kNoProperties, 3,
 136         0);
 137   }
 138
 139   const Operator* StoreNamed(StrictMode strict_mode, Unique<Name> name) {
 140     StoreNamedParameters parameters = {strict_mode, name};
 141     OP1(JSStoreNamed, StoreNamedParameters, parameters, Operator::kNoProperties,
 142         2, 0);
 143   }
 144
 145   const Operator* DeleteProperty(StrictMode strict_mode) {
 146     OP1(JSDeleteProperty, StrictMode, strict_mode, Operator::kNoProperties, 2,
 147         1);
 148   }
 149
 150   const Operator* HasProperty() { NOPROPS(JSHasProperty, 2, 1); }
 151
 152   const Operator* LoadContext(uint16_t depth, uint32_t index, bool immutable) {
 153     ContextAccess access(depth, index, immutable);
 154     OP1(JSLoadContext, ContextAccess, access,
 155         Operator::kEliminatable | Operator::kNoWrite, 1, 1);
 156   }
 157   const Operator* StoreContext(uint16_t depth, uint32_t index) {
 158     ContextAccess access(depth, index, false);
 159     OP1(JSStoreContext, ContextAccess, access, Operator::kNoProperties, 2, 0);
 160   }
 161
 162   const Operator* TypeOf() { SIMPLE(JSTypeOf, Operator::kPure, 1, 1); }
 163   const Operator* InstanceOf() { NOPROPS(JSInstanceOf, 2, 1); }
 164   const Operator* Debugger() { NOPROPS(JSDebugger, 0, 0); }
 165
 166   // TODO(titzer): nail down the static parts of each of these context flavors.
 167   const Operator* CreateFunctionContext() {
 168     NOPROPS(JSCreateFunctionContext, 1, 1);
 169   }
 170   const Operator* CreateCatchContext(Unique<String> name) {
 171     OP1(JSCreateCatchContext, Unique<String>, name, Operator::kNoProperties, 1,
 172         1);
 173   }
 174   const Operator* CreateWithContext() { NOPROPS(JSCreateWithContext, 2, 1); }
 175   const Operator* CreateBlockContext() { NOPROPS(JSCreateBlockContext, 2, 1); }
 176   const Operator* CreateModuleContext() {
 177     NOPROPS(JSCreateModuleContext, 2, 1);
 178   }
 179   const Operator* CreateGlobalContext() {
 180     NOPROPS(JSCreateGlobalContext, 2, 1);
 181   }
 182
 183   const Operator* Runtime(Runtime::FunctionId function, int arguments) {
 184     const Runtime::Function* f = Runtime::FunctionForId(function);
 185     DCHECK(f->nargs == -1 || f->nargs == arguments);
 186     OP1(JSCallRuntime, Runtime::FunctionId, function, Operator::kNoProperties,
 187         arguments, f->result_size);
 188   }
 189
 190 #undef SIMPLE
 191 #undef NOPROPS
 192 #undef OP1
 193 #undef BINOP
 194 #undef UNOP
 195
 196  private:
 197   Zone* zone_;
 198 };
 199
 200 // Specialization for static parameters of type {ContextAccess}.
 201 template <>
 202 struct StaticParameterTraits<ContextAccess> {
 203   static OStream& PrintTo(OStream& os, ContextAccess val) {  // NOLINT
 204     return os << val.depth() << "," << val.index()
 205               << (val.immutable() ? ",imm" : "");
 206   }
 207   static int HashCode(ContextAccess val) {
 208     return (val.depth() << 16) | (val.index() & 0xffff);
 209   }
 210   static bool Equals(ContextAccess a, ContextAccess b) {
 211     return a.immutable() == b.immutable() && a.depth() == b.depth() &&
 212            a.index() == b.index();
 213   }
 214 };
 215
 216 // Specialization for static parameters of type {Runtime::FunctionId}.
 217 template <>
 218 struct StaticParameterTraits<Runtime::FunctionId> {
 219   static OStream& PrintTo(OStream& os, Runtime::FunctionId val) {  // NOLINT
 220     const Runtime::Function* f = Runtime::FunctionForId(val);
 221     return os << (f->name ? f->name : "?Runtime?");
 222   }
 223   static int HashCode(Runtime::FunctionId val) { return static_cast<int>(val); }
 224   static bool Equals(Runtime::FunctionId a, Runtime::FunctionId b) {
 225     return a == b;
 226   }
 227 };
 228
 229 }  // namespace compiler
 230 }  // namespace internal
 231 }  // namespace v8
 232
 233 #endif  // V8_COMPILER_JS_OPERATOR_H_