Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/compiler/js-operator.h b/src/compiler/js-operator.h
index e716a8e..ca7c7ea 100644
--- a/src/compiler/js-operator.h
+++ b/src/compiler/js-operator.h
@@ -5,8 +5,8 @@
#ifndef V8_COMPILER_JS_OPERATOR_H_
#define V8_COMPILER_JS_OPERATOR_H_
+#include "src/compiler/type-hints.h"
#include "src/runtime/runtime.h"
-#include "src/unique.h"
namespace v8 {
namespace internal {
@@ -17,23 +17,148 @@
struct JSOperatorGlobalCache;
-// Defines the arity and the call flags for a JavaScript function call. This is
-// used as a parameter by JSCallFunction operators.
-class CallFunctionParameters FINAL {
+// Defines a pair of {TypeFeedbackVector} and {TypeFeedbackVectorSlot}, which
+// is used to access the type feedback for a certain {Node}.
+class VectorSlotPair {
public:
- CallFunctionParameters(size_t arity, CallFunctionFlags flags)
- : arity_(arity), flags_(flags) {}
+ VectorSlotPair();
+ VectorSlotPair(Handle<TypeFeedbackVector> vector, FeedbackVectorSlot slot)
+ : vector_(vector), slot_(slot) {}
- size_t arity() const { return arity_; }
- CallFunctionFlags flags() const { return flags_; }
+ bool IsValid() const { return !vector_.is_null() && !slot_.IsInvalid(); }
+
+ Handle<TypeFeedbackVector> vector() const { return vector_; }
+ FeedbackVectorSlot slot() const { return slot_; }
+
+ int index() const;
private:
- const size_t arity_;
- const CallFunctionFlags flags_;
+ const Handle<TypeFeedbackVector> vector_;
+ const FeedbackVectorSlot slot_;
};
-bool operator==(CallFunctionParameters const&, CallFunctionParameters const&);
-bool operator!=(CallFunctionParameters const&, CallFunctionParameters const&);
+bool operator==(VectorSlotPair const&, VectorSlotPair const&);
+bool operator!=(VectorSlotPair const&, VectorSlotPair const&);
+
+size_t hash_value(VectorSlotPair const&);
+
+
+// The ConvertReceiverMode is used as parameter by JSConvertReceiver operators.
+ConvertReceiverMode ConvertReceiverModeOf(Operator const* op);
+
+
+// The ToBooleanHints are used as parameter by JSToBoolean operators.
+ToBooleanHints ToBooleanHintsOf(Operator const* op);
+
+
+// Defines whether tail call optimization is allowed.
+enum class TailCallMode : unsigned { kAllow, kDisallow };
+
+size_t hash_value(TailCallMode);
+
+std::ostream& operator<<(std::ostream&, TailCallMode);
+
+
+// Defines the language mode and hints for a JavaScript binary operations.
+// This is used as parameter by JSAdd, JSSubtract, etc. operators.
+class BinaryOperationParameters final {
+ public:
+ BinaryOperationParameters(LanguageMode language_mode,
+ BinaryOperationHints hints)
+ : language_mode_(language_mode), hints_(hints) {}
+
+ LanguageMode language_mode() const { return language_mode_; }
+ BinaryOperationHints hints() const { return hints_; }
+
+ private:
+ LanguageMode const language_mode_;
+ BinaryOperationHints const hints_;
+};
+
+bool operator==(BinaryOperationParameters const&,
+ BinaryOperationParameters const&);
+bool operator!=(BinaryOperationParameters const&,
+ BinaryOperationParameters const&);
+
+size_t hash_value(BinaryOperationParameters const&);
+
+std::ostream& operator<<(std::ostream&, BinaryOperationParameters const&);
+
+BinaryOperationParameters const& BinaryOperationParametersOf(Operator const*);
+
+
+// Defines the arity and the feedback for a JavaScript constructor call. This is
+// used as a parameter by JSCallConstruct operators.
+class CallConstructParameters final {
+ public:
+ CallConstructParameters(size_t arity, VectorSlotPair const& feedback)
+ : arity_(arity), feedback_(feedback) {}
+
+ size_t arity() const { return arity_; }
+ VectorSlotPair const& feedback() const { return feedback_; }
+
+ private:
+ size_t const arity_;
+ VectorSlotPair const feedback_;
+};
+
+bool operator==(CallConstructParameters const&, CallConstructParameters const&);
+bool operator!=(CallConstructParameters const&, CallConstructParameters const&);
+
+size_t hash_value(CallConstructParameters const&);
+
+std::ostream& operator<<(std::ostream&, CallConstructParameters const&);
+
+CallConstructParameters const& CallConstructParametersOf(Operator const*);
+
+
+// Defines the arity and the call flags for a JavaScript function call. This is
+// used as a parameter by JSCallFunction operators.
+class CallFunctionParameters final {
+ public:
+ CallFunctionParameters(size_t arity, LanguageMode language_mode,
+ VectorSlotPair const& feedback,
+ TailCallMode tail_call_mode,
+ ConvertReceiverMode convert_mode)
+ : bit_field_(ArityField::encode(arity) |
+ ConvertReceiverModeField::encode(convert_mode) |
+ LanguageModeField::encode(language_mode) |
+ TailCallModeField::encode(tail_call_mode)),
+ feedback_(feedback) {}
+
+ size_t arity() const { return ArityField::decode(bit_field_); }
+ LanguageMode language_mode() const {
+ return LanguageModeField::decode(bit_field_);
+ }
+ ConvertReceiverMode convert_mode() const {
+ return ConvertReceiverModeField::decode(bit_field_);
+ }
+ TailCallMode tail_call_mode() const {
+ return TailCallModeField::decode(bit_field_);
+ }
+ VectorSlotPair const& feedback() const { return feedback_; }
+
+ bool operator==(CallFunctionParameters const& that) const {
+ return this->bit_field_ == that.bit_field_ &&
+ this->feedback_ == that.feedback_;
+ }
+ bool operator!=(CallFunctionParameters const& that) const {
+ return !(*this == that);
+ }
+
+ private:
+ friend size_t hash_value(CallFunctionParameters const& p) {
+ return base::hash_combine(p.bit_field_, p.feedback_);
+ }
+
+ typedef BitField<size_t, 0, 27> ArityField;
+ typedef BitField<ConvertReceiverMode, 27, 2> ConvertReceiverModeField;
+ typedef BitField<LanguageMode, 29, 2> LanguageModeField;
+ typedef BitField<TailCallMode, 31, 1> TailCallModeField;
+
+ const uint32_t bit_field_;
+ const VectorSlotPair feedback_;
+};
size_t hash_value(CallFunctionParameters const&);
@@ -44,7 +169,7 @@
// Defines the arity and the ID for a runtime function call. This is used as a
// parameter by JSCallRuntime operators.
-class CallRuntimeParameters FINAL {
+class CallRuntimeParameters final {
public:
CallRuntimeParameters(Runtime::FunctionId id, size_t arity)
: id_(id), arity_(arity) {}
@@ -70,7 +195,7 @@
// Defines the location of a context slot relative to a specific scope. This is
// used as a parameter by JSLoadContext and JSStoreContext operators and allows
// accessing a context-allocated variable without keeping track of the scope.
-class ContextAccess FINAL {
+class ContextAccess final {
public:
ContextAccess(size_t depth, size_t index, bool immutable);
@@ -96,106 +221,253 @@
ContextAccess const& ContextAccessOf(Operator const*);
-class VectorSlotPair {
+// Defines the name for a dynamic variable lookup. This is used as a parameter
+// by JSLoadDynamic and JSStoreDynamic operators.
+class DynamicAccess final {
public:
- VectorSlotPair(Handle<TypeFeedbackVector> vector, FeedbackVectorICSlot slot)
- : vector_(vector), slot_(slot) {}
+ DynamicAccess(const Handle<String>& name, TypeofMode typeof_mode);
- Handle<TypeFeedbackVector> vector() const { return vector_; }
- FeedbackVectorICSlot slot() const { return slot_; }
-
- int index() const { return vector_->GetIndex(slot_); }
+ const Handle<String>& name() const { return name_; }
+ TypeofMode typeof_mode() const { return typeof_mode_; }
private:
- const Handle<TypeFeedbackVector> vector_;
- const FeedbackVectorICSlot slot_;
+ const Handle<String> name_;
+ const TypeofMode typeof_mode_;
};
+size_t hash_value(DynamicAccess const&);
-bool operator==(VectorSlotPair const& lhs, VectorSlotPair const& rhs);
+bool operator==(DynamicAccess const&, DynamicAccess const&);
+bool operator!=(DynamicAccess const&, DynamicAccess const&);
+
+std::ostream& operator<<(std::ostream&, DynamicAccess const&);
+
+DynamicAccess const& DynamicAccessOf(Operator const*);
+
+
+// Defines the property of an object for a named access. This is
+// used as a parameter by the JSLoadNamed and JSStoreNamed operators.
+class NamedAccess final {
+ public:
+ NamedAccess(LanguageMode language_mode, Handle<Name> name,
+ VectorSlotPair const& feedback)
+ : name_(name), feedback_(feedback), language_mode_(language_mode) {}
+
+ Handle<Name> name() const { return name_; }
+ LanguageMode language_mode() const { return language_mode_; }
+ VectorSlotPair const& feedback() const { return feedback_; }
+
+ private:
+ Handle<Name> const name_;
+ VectorSlotPair const feedback_;
+ LanguageMode const language_mode_;
+};
+
+bool operator==(NamedAccess const&, NamedAccess const&);
+bool operator!=(NamedAccess const&, NamedAccess const&);
+
+size_t hash_value(NamedAccess const&);
+
+std::ostream& operator<<(std::ostream&, NamedAccess const&);
+
+const NamedAccess& NamedAccessOf(const Operator* op);
// Defines the property being loaded from an object by a named load. This is
-// used as a parameter by JSLoadNamed operators.
-class LoadNamedParameters FINAL {
+// used as a parameter by JSLoadGlobal operator.
+class LoadGlobalParameters final {
public:
- LoadNamedParameters(const Unique<Name>& name, const VectorSlotPair& feedback,
- ContextualMode contextual_mode)
- : name_(name), contextual_mode_(contextual_mode), feedback_(feedback) {}
+ LoadGlobalParameters(const Handle<Name>& name, const VectorSlotPair& feedback,
+ TypeofMode typeof_mode)
+ : name_(name), feedback_(feedback), typeof_mode_(typeof_mode) {}
- const Unique<Name>& name() const { return name_; }
- ContextualMode contextual_mode() const { return contextual_mode_; }
+ const Handle<Name>& name() const { return name_; }
+ TypeofMode typeof_mode() const { return typeof_mode_; }
const VectorSlotPair& feedback() const { return feedback_; }
private:
- const Unique<Name> name_;
- const ContextualMode contextual_mode_;
+ const Handle<Name> name_;
const VectorSlotPair feedback_;
+ const TypeofMode typeof_mode_;
};
-bool operator==(LoadNamedParameters const&, LoadNamedParameters const&);
-bool operator!=(LoadNamedParameters const&, LoadNamedParameters const&);
+bool operator==(LoadGlobalParameters const&, LoadGlobalParameters const&);
+bool operator!=(LoadGlobalParameters const&, LoadGlobalParameters const&);
-size_t hash_value(LoadNamedParameters const&);
+size_t hash_value(LoadGlobalParameters const&);
-std::ostream& operator<<(std::ostream&, LoadNamedParameters const&);
+std::ostream& operator<<(std::ostream&, LoadGlobalParameters const&);
-const LoadNamedParameters& LoadNamedParametersOf(const Operator* op);
-
-
-// Defines the property being loaded from an object. This is
-// used as a parameter by JSLoadProperty operators.
-class LoadPropertyParameters FINAL {
- public:
- explicit LoadPropertyParameters(const VectorSlotPair& feedback)
- : feedback_(feedback) {}
-
- const VectorSlotPair& feedback() const { return feedback_; }
-
- private:
- const VectorSlotPair feedback_;
-};
-
-bool operator==(LoadPropertyParameters const&, LoadPropertyParameters const&);
-bool operator!=(LoadPropertyParameters const&, LoadPropertyParameters const&);
-
-size_t hash_value(LoadPropertyParameters const&);
-
-std::ostream& operator<<(std::ostream&, LoadPropertyParameters const&);
-
-const LoadPropertyParameters& LoadPropertyParametersOf(const Operator* op);
+const LoadGlobalParameters& LoadGlobalParametersOf(const Operator* op);
// Defines the property being stored to an object by a named store. This is
-// used as a parameter by JSStoreNamed operators.
-class StoreNamedParameters FINAL {
+// used as a parameter by JSStoreGlobal operator.
+class StoreGlobalParameters final {
public:
- StoreNamedParameters(StrictMode strict_mode, const Unique<Name>& name)
- : strict_mode_(strict_mode), name_(name) {}
+ StoreGlobalParameters(LanguageMode language_mode,
+ const VectorSlotPair& feedback,
+ const Handle<Name>& name)
+ : language_mode_(language_mode), name_(name), feedback_(feedback) {}
- StrictMode strict_mode() const { return strict_mode_; }
- const Unique<Name>& name() const { return name_; }
+ LanguageMode language_mode() const { return language_mode_; }
+ const VectorSlotPair& feedback() const { return feedback_; }
+ const Handle<Name>& name() const { return name_; }
private:
- const StrictMode strict_mode_;
- const Unique<Name> name_;
+ const LanguageMode language_mode_;
+ const Handle<Name> name_;
+ const VectorSlotPair feedback_;
};
-bool operator==(StoreNamedParameters const&, StoreNamedParameters const&);
-bool operator!=(StoreNamedParameters const&, StoreNamedParameters const&);
+bool operator==(StoreGlobalParameters const&, StoreGlobalParameters const&);
+bool operator!=(StoreGlobalParameters const&, StoreGlobalParameters const&);
-size_t hash_value(StoreNamedParameters const&);
+size_t hash_value(StoreGlobalParameters const&);
-std::ostream& operator<<(std::ostream&, StoreNamedParameters const&);
+std::ostream& operator<<(std::ostream&, StoreGlobalParameters const&);
-const StoreNamedParameters& StoreNamedParametersOf(const Operator* op);
+const StoreGlobalParameters& StoreGlobalParametersOf(const Operator* op);
+
+
+// Defines the property of an object for a keyed access. This is used
+// as a parameter by the JSLoadProperty and JSStoreProperty operators.
+class PropertyAccess final {
+ public:
+ PropertyAccess(LanguageMode language_mode, VectorSlotPair const& feedback)
+ : feedback_(feedback), language_mode_(language_mode) {}
+
+ LanguageMode language_mode() const { return language_mode_; }
+ VectorSlotPair const& feedback() const { return feedback_; }
+
+ private:
+ VectorSlotPair const feedback_;
+ LanguageMode const language_mode_;
+};
+
+bool operator==(PropertyAccess const&, PropertyAccess const&);
+bool operator!=(PropertyAccess const&, PropertyAccess const&);
+
+size_t hash_value(PropertyAccess const&);
+
+std::ostream& operator<<(std::ostream&, PropertyAccess const&);
+
+PropertyAccess const& PropertyAccessOf(const Operator* op);
+
+
+// Defines specifics about arguments object or rest parameter creation. This is
+// used as a parameter by JSCreateArguments operators.
+class CreateArgumentsParameters final {
+ public:
+ enum Type { kMappedArguments, kUnmappedArguments, kRestArray };
+ CreateArgumentsParameters(Type type, int start_index)
+ : type_(type), start_index_(start_index) {}
+
+ Type type() const { return type_; }
+ int start_index() const { return start_index_; }
+
+ private:
+ const Type type_;
+ const int start_index_;
+};
+
+bool operator==(CreateArgumentsParameters const&,
+ CreateArgumentsParameters const&);
+bool operator!=(CreateArgumentsParameters const&,
+ CreateArgumentsParameters const&);
+
+size_t hash_value(CreateArgumentsParameters const&);
+
+std::ostream& operator<<(std::ostream&, CreateArgumentsParameters const&);
+
+const CreateArgumentsParameters& CreateArgumentsParametersOf(
+ const Operator* op);
+
+
+// Defines shared information for the array that should be created. This is
+// used as parameter by JSCreateArray operators.
+class CreateArrayParameters final {
+ public:
+ explicit CreateArrayParameters(size_t arity, Handle<AllocationSite> site)
+ : arity_(arity), site_(site) {}
+
+ size_t arity() const { return arity_; }
+ Handle<AllocationSite> site() const { return site_; }
+
+ private:
+ size_t const arity_;
+ Handle<AllocationSite> const site_;
+};
+
+bool operator==(CreateArrayParameters const&, CreateArrayParameters const&);
+bool operator!=(CreateArrayParameters const&, CreateArrayParameters const&);
+
+size_t hash_value(CreateArrayParameters const&);
+
+std::ostream& operator<<(std::ostream&, CreateArrayParameters const&);
+
+const CreateArrayParameters& CreateArrayParametersOf(const Operator* op);
+
+
+// Defines shared information for the closure that should be created. This is
+// used as a parameter by JSCreateClosure operators.
+class CreateClosureParameters final {
+ public:
+ CreateClosureParameters(Handle<SharedFunctionInfo> shared_info,
+ PretenureFlag pretenure)
+ : shared_info_(shared_info), pretenure_(pretenure) {}
+
+ Handle<SharedFunctionInfo> shared_info() const { return shared_info_; }
+ PretenureFlag pretenure() const { return pretenure_; }
+
+ private:
+ const Handle<SharedFunctionInfo> shared_info_;
+ const PretenureFlag pretenure_;
+};
+
+bool operator==(CreateClosureParameters const&, CreateClosureParameters const&);
+bool operator!=(CreateClosureParameters const&, CreateClosureParameters const&);
+
+size_t hash_value(CreateClosureParameters const&);
+
+std::ostream& operator<<(std::ostream&, CreateClosureParameters const&);
+
+const CreateClosureParameters& CreateClosureParametersOf(const Operator* op);
+
+
+// Defines shared information for the literal that should be created. This is
+// used as parameter by JSCreateLiteralArray, JSCreateLiteralObject and
+// JSCreateLiteralRegExp operators.
+class CreateLiteralParameters final {
+ public:
+ CreateLiteralParameters(Handle<HeapObject> constant, int flags, int index)
+ : constant_(constant), flags_(flags), index_(index) {}
+
+ Handle<HeapObject> constant() const { return constant_; }
+ int flags() const { return flags_; }
+ int index() const { return index_; }
+
+ private:
+ Handle<HeapObject> const constant_;
+ int const flags_;
+ int const index_;
+};
+
+bool operator==(CreateLiteralParameters const&, CreateLiteralParameters const&);
+bool operator!=(CreateLiteralParameters const&, CreateLiteralParameters const&);
+
+size_t hash_value(CreateLiteralParameters const&);
+
+std::ostream& operator<<(std::ostream&, CreateLiteralParameters const&);
+
+const CreateLiteralParameters& CreateLiteralParametersOf(const Operator* op);
// Interface for building JavaScript-level operators, e.g. directly from the
// AST. Most operators have no parameters, thus can be globally shared for all
// graphs.
-class JSOperatorBuilder FINAL : public ZoneObject {
+class JSOperatorBuilder final : public ZoneObject {
public:
explicit JSOperatorBuilder(Zone* zone);
@@ -203,24 +475,33 @@
const Operator* NotEqual();
const Operator* StrictEqual();
const Operator* StrictNotEqual();
- const Operator* LessThan();
- const Operator* GreaterThan();
- const Operator* LessThanOrEqual();
- const Operator* GreaterThanOrEqual();
- const Operator* BitwiseOr();
- const Operator* BitwiseXor();
- const Operator* BitwiseAnd();
- const Operator* ShiftLeft();
- const Operator* ShiftRight();
- const Operator* ShiftRightLogical();
- const Operator* Add();
- const Operator* Subtract();
- const Operator* Multiply();
- const Operator* Divide();
- const Operator* Modulus();
+ const Operator* LessThan(LanguageMode language_mode);
+ const Operator* GreaterThan(LanguageMode language_mode);
+ const Operator* LessThanOrEqual(LanguageMode language_mode);
+ const Operator* GreaterThanOrEqual(LanguageMode language_mode);
+ const Operator* BitwiseOr(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* BitwiseXor(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* BitwiseAnd(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* ShiftLeft(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* ShiftRight(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* ShiftRightLogical(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* Add(LanguageMode language_mode, BinaryOperationHints hints);
+ const Operator* Subtract(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* Multiply(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* Divide(LanguageMode language_mode,
+ BinaryOperationHints hints);
+ const Operator* Modulus(LanguageMode language_mode,
+ BinaryOperationHints hints);
- const Operator* UnaryNot();
- const Operator* ToBoolean();
+ const Operator* ToBoolean(ToBooleanHints hints);
const Operator* ToNumber();
const Operator* ToString();
const Operator* ToName();
@@ -228,38 +509,75 @@
const Operator* Yield();
const Operator* Create();
+ const Operator* CreateArguments(CreateArgumentsParameters::Type type,
+ int start_index);
+ const Operator* CreateArray(size_t arity, Handle<AllocationSite> site);
+ const Operator* CreateClosure(Handle<SharedFunctionInfo> shared_info,
+ PretenureFlag pretenure);
+ const Operator* CreateIterResultObject();
+ const Operator* CreateLiteralArray(Handle<FixedArray> constant_elements,
+ int literal_flags, int literal_index);
+ const Operator* CreateLiteralObject(Handle<FixedArray> constant_properties,
+ int literal_flags, int literal_index);
+ const Operator* CreateLiteralRegExp(Handle<String> constant_pattern,
+ int literal_flags, int literal_index);
- const Operator* CallFunction(size_t arity, CallFunctionFlags flags);
+ const Operator* CallFunction(
+ size_t arity, LanguageMode language_mode,
+ VectorSlotPair const& feedback = VectorSlotPair(),
+ ConvertReceiverMode convert_mode = ConvertReceiverMode::kAny,
+ TailCallMode tail_call_mode = TailCallMode::kDisallow);
const Operator* CallRuntime(Runtime::FunctionId id, size_t arity);
+ const Operator* CallConstruct(size_t arity, VectorSlotPair const& feedback);
- const Operator* CallConstruct(int arguments);
+ const Operator* ConvertReceiver(ConvertReceiverMode convert_mode);
- const Operator* LoadProperty(const VectorSlotPair& feedback);
- const Operator* LoadNamed(const Unique<Name>& name,
- const VectorSlotPair& feedback,
- ContextualMode contextual_mode = NOT_CONTEXTUAL);
+ const Operator* LoadProperty(LanguageMode language_mode,
+ VectorSlotPair const& feedback);
+ const Operator* LoadNamed(LanguageMode language_mode, Handle<Name> name,
+ VectorSlotPair const& feedback);
- const Operator* StoreProperty(StrictMode strict_mode);
- const Operator* StoreNamed(StrictMode strict_mode, const Unique<Name>& name);
+ const Operator* StoreProperty(LanguageMode language_mode,
+ VectorSlotPair const& feedback);
+ const Operator* StoreNamed(LanguageMode language_mode, Handle<Name> name,
+ VectorSlotPair const& feedback);
- const Operator* DeleteProperty(StrictMode strict_mode);
+ const Operator* DeleteProperty(LanguageMode language_mode);
const Operator* HasProperty();
+ const Operator* LoadGlobal(const Handle<Name>& name,
+ const VectorSlotPair& feedback,
+ TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
+ const Operator* StoreGlobal(LanguageMode language_mode,
+ const Handle<Name>& name,
+ const VectorSlotPair& feedback);
+
const Operator* LoadContext(size_t depth, size_t index, bool immutable);
const Operator* StoreContext(size_t depth, size_t index);
+ const Operator* LoadDynamic(const Handle<String>& name,
+ TypeofMode typeof_mode);
+
const Operator* TypeOf();
const Operator* InstanceOf();
- const Operator* Debugger();
- // TODO(titzer): nail down the static parts of each of these context flavors.
- const Operator* CreateFunctionContext();
- const Operator* CreateCatchContext(const Unique<String>& name);
+ const Operator* ForInDone();
+ const Operator* ForInNext();
+ const Operator* ForInPrepare();
+ const Operator* ForInStep();
+
+ const Operator* LoadMessage();
+ const Operator* StoreMessage();
+
+ const Operator* StackCheck();
+
+ const Operator* CreateFunctionContext(int slot_count);
+ const Operator* CreateCatchContext(const Handle<String>& name);
const Operator* CreateWithContext();
- const Operator* CreateBlockContext();
+ const Operator* CreateBlockContext(const Handle<ScopeInfo>& scpope_info);
const Operator* CreateModuleContext();
- const Operator* CreateScriptContext();
+ const Operator* CreateScriptContext(const Handle<ScopeInfo>& scpope_info);
private:
Zone* zone() const { return zone_; }