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/full-codegen/full-codegen.h b/src/full-codegen/full-codegen.h
index 52eddaf..6ab0231 100644
--- a/src/full-codegen/full-codegen.h
+++ b/src/full-codegen/full-codegen.h
@@ -42,6 +42,7 @@
nesting_stack_(NULL),
loop_depth_(0),
try_catch_depth_(0),
+ operand_stack_depth_(0),
globals_(NULL),
context_(NULL),
bailout_entries_(info->HasDeoptimizationSupport()
@@ -96,9 +97,12 @@
#error Unsupported target architecture.
#endif
+ static Register result_register();
+
private:
class Breakable;
class Iteration;
+ class TryFinally;
class TestContext;
@@ -115,11 +119,13 @@
codegen_->nesting_stack_ = previous_;
}
- virtual Breakable* AsBreakable() { return NULL; }
- virtual Iteration* AsIteration() { return NULL; }
+ virtual Breakable* AsBreakable() { return nullptr; }
+ virtual Iteration* AsIteration() { return nullptr; }
+ virtual TryFinally* AsTryFinally() { return nullptr; }
virtual bool IsContinueTarget(Statement* target) { return false; }
virtual bool IsBreakTarget(Statement* target) { return false; }
+ virtual bool IsTryFinally() { return false; }
// Notify the statement that we are exiting it via break, continue, or
// return and give it a chance to generate cleanup code. Return the
@@ -131,11 +137,6 @@
return previous_;
}
- // Like the Exit() method above, but limited to accumulating stack depth.
- virtual NestedStatement* AccumulateDepth(int* stack_depth) {
- return previous_;
- }
-
protected:
MacroAssembler* masm() { return codegen_->masm(); }
@@ -211,10 +212,43 @@
*stack_depth += kElementCount;
return previous_;
}
- NestedStatement* AccumulateDepth(int* stack_depth) override {
- *stack_depth += kElementCount;
- return previous_;
- }
+ };
+
+ class DeferredCommands {
+ public:
+ enum Command { kReturn, kThrow, kBreak, kContinue };
+ typedef int TokenId;
+ struct DeferredCommand {
+ Command command;
+ TokenId token;
+ Statement* target;
+ };
+
+ DeferredCommands(FullCodeGenerator* codegen, Label* finally_entry)
+ : codegen_(codegen),
+ commands_(codegen->zone()),
+ return_token_(TokenDispenserForFinally::kInvalidToken),
+ throw_token_(TokenDispenserForFinally::kInvalidToken),
+ finally_entry_(finally_entry) {}
+
+ void EmitCommands();
+
+ void RecordBreak(Statement* target);
+ void RecordContinue(Statement* target);
+ void RecordReturn();
+ void RecordThrow();
+ void EmitFallThrough();
+
+ private:
+ MacroAssembler* masm() { return codegen_->masm(); }
+ void EmitJumpToFinally(TokenId token);
+
+ FullCodeGenerator* codegen_;
+ ZoneVector<DeferredCommand> commands_;
+ TokenDispenserForFinally dispenser_;
+ TokenId return_token_;
+ TokenId throw_token_;
+ Label* finally_entry_;
};
// The try block of a try/finally statement.
@@ -222,18 +256,18 @@
public:
static const int kElementCount = TryBlockConstant::kElementCount;
- TryFinally(FullCodeGenerator* codegen, Label* finally_entry)
- : NestedStatement(codegen), finally_entry_(finally_entry) {
- }
+ TryFinally(FullCodeGenerator* codegen, DeferredCommands* commands)
+ : NestedStatement(codegen), deferred_commands_(commands) {}
NestedStatement* Exit(int* stack_depth, int* context_length) override;
- NestedStatement* AccumulateDepth(int* stack_depth) override {
- *stack_depth += kElementCount;
- return previous_;
- }
+
+ bool IsTryFinally() override { return true; }
+ TryFinally* AsTryFinally() override { return this; }
+
+ DeferredCommands* deferred_commands() { return deferred_commands_; }
private:
- Label* finally_entry_;
+ DeferredCommands* deferred_commands_;
};
// The finally block of a try/finally statement.
@@ -247,10 +281,6 @@
*stack_depth += kElementCount;
return previous_;
}
- NestedStatement* AccumulateDepth(int* stack_depth) override {
- *stack_depth += kElementCount;
- return previous_;
- }
};
// The body of a for/in loop.
@@ -266,10 +296,6 @@
*stack_depth += kElementCount;
return previous_;
}
- NestedStatement* AccumulateDepth(int* stack_depth) override {
- *stack_depth += kElementCount;
- return previous_;
- }
};
@@ -354,18 +380,21 @@
MemOperand VarOperand(Variable* var, Register scratch);
void VisitForEffect(Expression* expr) {
+ if (FLAG_verify_operand_stack_depth) EmitOperandStackDepthCheck();
EffectContext context(this);
Visit(expr);
PrepareForBailout(expr, NO_REGISTERS);
}
void VisitForAccumulatorValue(Expression* expr) {
+ if (FLAG_verify_operand_stack_depth) EmitOperandStackDepthCheck();
AccumulatorValueContext context(this);
Visit(expr);
PrepareForBailout(expr, TOS_REG);
}
void VisitForStackValue(Expression* expr) {
+ if (FLAG_verify_operand_stack_depth) EmitOperandStackDepthCheck();
StackValueContext context(this);
Visit(expr);
PrepareForBailout(expr, NO_REGISTERS);
@@ -375,6 +404,7 @@
Label* if_true,
Label* if_false,
Label* fall_through) {
+ if (FLAG_verify_operand_stack_depth) EmitOperandStackDepthCheck();
TestContext context(this, expr, if_true, if_false, fall_through);
Visit(expr);
// For test contexts, we prepare for bailout before branching, not at
@@ -389,6 +419,34 @@
void DeclareGlobals(Handle<FixedArray> pairs);
int DeclareGlobalsFlags();
+ // Push, pop or drop values onto/from the operand stack.
+ void PushOperand(Register reg);
+ void PopOperand(Register reg);
+ void DropOperands(int count);
+
+ // Convenience helpers for pushing onto the operand stack.
+ void PushOperand(MemOperand operand);
+ void PushOperand(Handle<Object> handle);
+ void PushOperand(Smi* smi);
+
+ // Convenience helpers for pushing/popping multiple operands.
+ void PushOperands(Register reg1, Register reg2);
+ void PushOperands(Register reg1, Register reg2, Register reg3);
+ void PushOperands(Register reg1, Register reg2, Register reg3, Register reg4);
+ void PopOperands(Register reg1, Register reg2);
+
+ // Convenience helper for calling a runtime function that consumes arguments
+ // from the operand stack (only usable for functions with known arity).
+ void CallRuntimeWithOperands(Runtime::FunctionId function_id);
+
+ // Static tracking of the operand stack depth.
+ void OperandStackDepthDecrement(int count);
+ void OperandStackDepthIncrement(int count);
+
+ // Generate debug code that verifies that our static tracking of the operand
+ // stack depth is in sync with the actual operand stack during runtime.
+ void EmitOperandStackDepthCheck();
+
// Generate code to create an iterator result object. The "value" property is
// set to a value popped from the stack, and "done" is set according to the
// argument. The result object is left in the result register.
@@ -455,11 +513,13 @@
// Emit code to pop values from the stack associated with nested statements
// like try/catch, try/finally, etc, running the finallies and unwinding the
- // handlers as needed.
- void EmitUnwindBeforeReturn();
+ // handlers as needed. Also emits the return sequence if necessary (i.e.,
+ // if the return is not delayed by a finally block).
+ void EmitUnwindAndReturn();
// Platform-specific return sequence
void EmitReturnSequence();
+ void EmitProfilingCounterHandlingForReturnSequence(bool is_tail_call);
// Platform-specific code sequences for calls
void EmitCall(Call* expr, ConvertReceiverMode = ConvertReceiverMode::kAny);
@@ -477,26 +537,18 @@
F(IsRegExp) \
F(IsJSProxy) \
F(Call) \
- F(ArgumentsLength) \
- F(Arguments) \
F(ValueOf) \
- F(SetValueOf) \
- F(IsDate) \
F(StringCharFromCode) \
F(StringCharAt) \
F(OneByteSeqStringSetChar) \
F(TwoByteSeqStringSetChar) \
- F(ObjectEquals) \
- F(IsFunction) \
F(IsJSReceiver) \
- F(IsSimdValue) \
F(MathPow) \
- F(IsMinusZero) \
F(HasCachedArrayIndex) \
F(GetCachedArrayIndex) \
F(GetSuperConstructor) \
- F(FastOneByteArrayJoin) \
F(GeneratorNext) \
+ F(GeneratorReturn) \
F(GeneratorThrow) \
F(DebugBreakInOptimizedCode) \
F(ClassOf) \
@@ -633,7 +685,7 @@
TypeFeedbackId id = TypeFeedbackId::None());
// Inside typeof reference errors are never thrown.
- void CallLoadIC(TypeofMode typeof_mode, LanguageMode language_mode = SLOPPY,
+ void CallLoadIC(TypeofMode typeof_mode,
TypeFeedbackId id = TypeFeedbackId::None());
void CallStoreIC(TypeFeedbackId id = TypeFeedbackId::None());
@@ -669,6 +721,9 @@
void ExitFinallyBlock();
void ClearPendingMessage();
+ void EmitContinue(Statement* target);
+ void EmitBreak(Statement* target);
+
// Loop nesting counter.
int loop_depth() { return loop_depth_; }
void increment_loop_depth() { loop_depth_++; }
@@ -693,7 +748,6 @@
FunctionLiteral* literal() const { return info_->literal(); }
Scope* scope() { return scope_; }
- static Register result_register();
static Register context_register();
// Set fields in the stack frame. Offsets are the frame pointer relative
@@ -945,6 +999,7 @@
NestedStatement* nesting_stack_;
int loop_depth_;
int try_catch_depth_;
+ int operand_stack_depth_;
ZoneList<Handle<Object> >* globals_;
Handle<FixedArray> modules_;
int module_index_;
@@ -954,7 +1009,6 @@
ZoneVector<HandlerTableEntry> handler_table_;
int ic_total_count_;
Handle<Cell> profiling_counter_;
- bool generate_debug_code_;
friend class NestedStatement;