Revert "Revert "Upgrade to 5.0.71.48"" DO NOT MERGE
This reverts commit f2e3994fa5148cc3d9946666f0b0596290192b0e,
and updates the x64 makefile properly so it doesn't break that
build.
FPIIM-449
Change-Id: Ib83e35bfbae6af627451c926a9650ec57c045605
(cherry picked from commit 109988c7ccb6f3fd1a58574fa3dfb88beaef6632)
diff --git a/src/interpreter/bytecode-generator.h b/src/interpreter/bytecode-generator.h
index 8bda7be..4ef1738 100644
--- a/src/interpreter/bytecode-generator.h
+++ b/src/interpreter/bytecode-generator.h
@@ -13,6 +13,8 @@
namespace internal {
namespace interpreter {
+class LoopBuilder;
+
class BytecodeGenerator final : public AstVisitor {
public:
BytecodeGenerator(Isolate* isolate, Zone* zone);
@@ -32,6 +34,9 @@
class ControlScope;
class ControlScopeForBreakable;
class ControlScopeForIteration;
+ class ControlScopeForTopLevel;
+ class ControlScopeForTryCatch;
+ class ControlScopeForTryFinally;
class ExpressionResultScope;
class EffectResultScope;
class AccumulatorResultScope;
@@ -39,7 +44,6 @@
class RegisterAllocationScope;
void MakeBytecodeBody();
- Register NextContextRegister() const;
DEFINE_AST_VISITOR_SUBCLASS_MEMBERS();
@@ -61,6 +65,20 @@
// Helper visitors which perform common operations.
Register VisitArguments(ZoneList<Expression*>* arguments);
+ // Visit a keyed super property load. The optional
+ // |opt_receiver_out| register will have the receiver stored to it
+ // if it's a valid register. The loaded value is placed in the
+ // accumulator.
+ void VisitKeyedSuperPropertyLoad(Property* property,
+ Register opt_receiver_out);
+
+ // Visit a named super property load. The optional
+ // |opt_receiver_out| register will have the receiver stored to it
+ // if it's a valid register. The loaded value is placed in the
+ // accumulator.
+ void VisitNamedSuperPropertyLoad(Property* property,
+ Register opt_receiver_out);
+
void VisitPropertyLoad(Register obj, Property* expr);
void VisitPropertyLoadForAccumulator(Register obj, Property* expr);
@@ -72,14 +90,41 @@
MUST_USE_RESULT Register
VisitVariableLoadForRegisterValue(Variable* variable, FeedbackVectorSlot slot,
TypeofMode typeof_mode = NOT_INSIDE_TYPEOF);
- void VisitVariableAssignment(Variable* variable, FeedbackVectorSlot slot);
+ void VisitVariableAssignment(Variable* variable, Token::Value op,
+ FeedbackVectorSlot slot);
+
+ void BuildNamedSuperPropertyStore(Register receiver, Register home_object,
+ Register name, Register value);
+ void BuildKeyedSuperPropertyStore(Register receiver, Register home_object,
+ Register key, Register value);
+ void BuildNamedSuperPropertyLoad(Register receiver, Register home_object,
+ Register name);
+ void BuildKeyedSuperPropertyLoad(Register receiver, Register home_object,
+ Register key);
+
+ void BuildThrowIfHole(Handle<String> name);
+ void BuildThrowIfNotHole(Handle<String> name);
+ void BuildThrowReassignConstant(Handle<String> name);
+ void BuildThrowReferenceError(Handle<String> name);
+ void BuildHoleCheckForVariableLoad(VariableMode mode, Handle<String> name);
+ void BuildHoleCheckForVariableAssignment(Variable* variable, Token::Value op);
void VisitArgumentsObject(Variable* variable);
+ void VisitRestArgumentsArray(Variable* rest);
+ void VisitCallSuper(Call* call);
+ void VisitClassLiteralContents(ClassLiteral* expr);
+ void VisitClassLiteralForRuntimeDefinition(ClassLiteral* expr);
+ void VisitClassLiteralProperties(ClassLiteral* expr, Register literal,
+ Register prototype);
+ void VisitClassLiteralStaticPrototypeWithComputedName(Register name);
void VisitThisFunctionVariable(Variable* variable);
void VisitNewTargetVariable(Variable* variable);
void VisitNewLocalFunctionContext();
void VisitBuildLocalActivationContext();
+ void VisitBlockDeclarationsAndStatements(Block* stmt);
void VisitNewLocalBlockContext(Scope* scope);
+ void VisitNewLocalCatchContext(Variable* variable);
+ void VisitNewLocalWithContext();
void VisitFunctionClosureForContext();
void VisitSetHomeObject(Register value, Register home_object,
ObjectLiteralProperty* property, int slot_number = 0);
@@ -88,17 +133,34 @@
Register value_out);
void VisitForInAssignment(Expression* expr, FeedbackVectorSlot slot);
+ // Visit the body of a loop iteration.
+ void VisitIterationBody(IterationStatement* stmt, LoopBuilder* loop_builder);
+
+ // Visit a statement and switch scopes, the context is in the accumulator.
+ void VisitInScope(Statement* stmt, Scope* scope);
+
// Visitors for obtaining expression result in the accumulator, in a
// register, or just getting the effect.
- void VisitForAccumulatorValue(Expression* expression);
- MUST_USE_RESULT Register VisitForRegisterValue(Expression* expression);
- void VisitForEffect(Expression* node);
+ void VisitForAccumulatorValue(Expression* expr);
+ void VisitForAccumulatorValueOrTheHole(Expression* expr);
+ MUST_USE_RESULT Register VisitForRegisterValue(Expression* expr);
+ void VisitForRegisterValue(Expression* expr, Register destination);
+ void VisitForEffect(Expression* expr);
// Methods for tracking and remapping register.
void RecordStoreToRegister(Register reg);
Register LoadFromAliasedRegister(Register reg);
- inline BytecodeArrayBuilder* builder() { return &builder_; }
+ // Methods for tracking try-block nesting.
+ bool IsInsideTryCatch() const { return try_catch_nesting_level_ > 0; }
+ bool IsInsideTryFinally() const { return try_finally_nesting_level_ > 0; }
+
+ // Initialize an array of temporary registers with consecutive registers.
+ template <size_t N>
+ void InitializeWithConsecutiveRegisters(Register (®isters)[N]);
+
+ inline void set_builder(BytecodeArrayBuilder* builder) { builder_ = builder; }
+ inline BytecodeArrayBuilder* builder() const { return builder_; }
inline Isolate* isolate() const { return isolate_; }
inline Zone* zone() const { return zone_; }
@@ -130,12 +192,11 @@
ZoneVector<Handle<Object>>* globals() { return &globals_; }
inline LanguageMode language_mode() const;
- Strength language_mode_strength() const;
int feedback_index(FeedbackVectorSlot slot) const;
Isolate* isolate_;
Zone* zone_;
- BytecodeArrayBuilder builder_;
+ BytecodeArrayBuilder* builder_;
CompilationInfo* info_;
Scope* scope_;
ZoneVector<Handle<Object>> globals_;
@@ -143,6 +204,8 @@
ContextScope* execution_context_;
ExpressionResultScope* execution_result_;
RegisterAllocationScope* register_allocator_;
+ int try_catch_nesting_level_;
+ int try_finally_nesting_level_;
};
} // namespace interpreter