AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Revert "Use constant types to represent the fixed right arg of a MOD."

Browse Source 
This reverts commit r18228 for crashing on Windows.

TBR=mvstanton@chromium.org

Review URL: https://codereview.chromium.org/101663002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@18229 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
bmeurer@chromium.org 2013-12-03 11:24:56 +00:00
parent 5c6b9500aa
commit 7e540e6b8a
9 changed files with 59 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/ast.h
View File

@ -1952,6 +1952,8 @@ class BinaryOperation V8_FINAL : public Expression {
BailoutId RightId() const { return right_id_; }
TypeFeedbackId BinaryOperationFeedbackId() const { return reuse(id()); }
Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
void set_fixed_right_arg(Maybe<int> arg) { fixed_right_arg_ = arg; }
virtual void RecordToBooleanTypeFeedback(
TypeFeedbackOracle* oracle) V8_OVERRIDE;
@ -1975,6 +1977,10 @@ class BinaryOperation V8_FINAL : public Expression {
Expression* left_;
Expression* right_;
// TODO(rossberg): the fixed arg should probably be represented as a Constant
// type for the RHS.
Maybe<int> fixed_right_arg_;
// The short-circuit logical operations need an AST ID for their
// right-hand subexpression.
const BailoutId right_id_;

13
src/code-stubs-hydrogen.cc
View File

@ -922,13 +922,14 @@ HValue* CodeStubGraphBuilder<BinaryOpICStub>::BuildCodeInitializedStub() {
Push(BuildBinaryOperation(
state.op(), left, right,
handle(Type::String(), isolate()), right_type,
result_type));
result_type, state.fixed_right_arg()));
}
if_leftisstring.Else();
{
Push(BuildBinaryOperation(
state.op(), left, right,
left_type, right_type, result_type));
left_type, right_type, result_type,
state.fixed_right_arg()));
}
if_leftisstring.End();
result = Pop();
@ -940,13 +941,14 @@ HValue* CodeStubGraphBuilder<BinaryOpICStub>::BuildCodeInitializedStub() {
Push(BuildBinaryOperation(
state.op(), left, right,
left_type, handle(Type::String(), isolate()),
result_type));
result_type, state.fixed_right_arg()));
}
if_rightisstring.Else();
{
Push(BuildBinaryOperation(
state.op(), left, right,
left_type, right_type, result_type));
left_type, right_type, result_type,
state.fixed_right_arg()));
}
if_rightisstring.End();
result = Pop();
@ -954,7 +956,8 @@ HValue* CodeStubGraphBuilder<BinaryOpICStub>::BuildCodeInitializedStub() {
} else {
result = BuildBinaryOperation(
state.op(), left, right,
left_type, right_type, result_type);
left_type, right_type, result_type,
state.fixed_right_arg());
}
// If we encounter a generic argument, the number conversion is

60
src/hydrogen.cc
View File

@ -8732,9 +8732,11 @@ HValue* HOptimizedGraphBuilder::BuildBinaryOperation(
Handle<Type> left_type = expr->left()->bounds().lower;
Handle<Type> right_type = expr->right()->bounds().lower;
Handle<Type> result_type = expr->bounds().lower;
Maybe<int> fixed_right_arg = expr->fixed_right_arg();
HValue* result = HGraphBuilder::BuildBinaryOperation(
expr->op(), left, right, left_type, right_type, result_type);
expr->op(), left, right, left_type, right_type,
result_type, fixed_right_arg);
// Add a simulate after instructions with observable side effects, and
// after phis, which are the result of BuildBinaryOperation when we
// inlined some complex subgraph.
@ -8753,45 +8755,34 @@ HValue* HGraphBuilder::BuildBinaryOperation(
HValue* right,
Handle<Type> left_type,
Handle<Type> right_type,
Handle<Type> result_type) {
Handle<Type> result_type,
Maybe<int> fixed_right_arg) {
Representation left_rep = Representation::FromType(left_type);
Representation right_rep = Representation::FromType(right_type);
bool maybe_string_add = op == Token::ADD &&
(left_type->Maybe(Type::String()) ||
right_type->Maybe(Type::String()));
if (left_type->Is(Type::None())) {
Add<HDeoptimize>("Insufficient type feedback for LHS of binary operation",
Deoptimizer::SOFT);
// TODO(rossberg): we should be able to get rid of non-continuous
// defaults.
left_type = handle(Type::Any(), isolate());
} else if (left_type->IsConstant()) {
HConstant* c_left = Add<HConstant>(left_type->AsConstant());
IfBuilder if_same(this);
if (c_left->HasDoubleValue()) {
if_same.If<HCompareNumericAndBranch>(left, c_left, Token::EQ);
} else {
if_same.If<HCompareObjectEqAndBranch>(left, c_left);
}
if_same.Then();
if_same.ElseDeopt("Unexpected LHS of binary operation");
left = c_left;
} else {
if (!maybe_string_add) left = TruncateToNumber(left, &left_type);
left_rep = Representation::FromType(left_type);
}
if (right_type->Is(Type::None())) {
Add<HDeoptimize>("Insufficient type feedback for RHS of binary operation",
Deoptimizer::SOFT);
right_type = handle(Type::Any(), isolate());
} else if (right_type->IsConstant()) {
HConstant* c_right = Add<HConstant>(right_type->AsConstant());
IfBuilder if_same(this);
if (c_right->HasDoubleValue()) {
if_same.If<HCompareNumericAndBranch>(right, c_right, Token::EQ);
} else {
if_same.If<HCompareObjectEqAndBranch>(right, c_right);
}
if_same.Then();
if_same.ElseDeopt("Unexpected RHS of binary operation");
right = c_right;
} else {
if (!maybe_string_add) right = TruncateToNumber(right, &right_type);
right_rep = Representation::FromType(right_type);
}
// Special case for string addition here.
@ -8834,11 +8825,6 @@ HValue* HGraphBuilder::BuildBinaryOperation(
return AddUncasted<HStringAdd>(left, right, STRING_ADD_CHECK_NONE);
}
left = TruncateToNumber(left, &left_type);
left_rep = Representation::FromType(left_type);
right = TruncateToNumber(right, &right_type);
right_rep = Representation::FromType(right_type);
if (graph()->info()->IsStub()) {
left = EnforceNumberType(left, left_type);
right = EnforceNumberType(right, right_type);
@ -8870,6 +8856,22 @@ HValue* HGraphBuilder::BuildBinaryOperation(
instr = AddUncasted<HMul>(left, right);
break;
case Token::MOD: {
if (fixed_right_arg.has_value) {
if (right->IsConstant()) {
HConstant* c_right = HConstant::cast(right);
if (c_right->HasInteger32Value()) {
ASSERT_EQ(fixed_right_arg.value, c_right->Integer32Value());
}
} else {
HConstant* fixed_right = Add<HConstant>(
static_cast<int>(fixed_right_arg.value));
IfBuilder if_same(this);
if_same.If<HCompareNumericAndBranch>(right, fixed_right, Token::EQ);
if_same.Then();
if_same.ElseDeopt("Unexpected RHS of binary operation");
right = fixed_right;
}
}
instr = AddUncasted<HMod>(left, right);
break;
}

3
src/hydrogen.h
View File

@ -1351,7 +1351,8 @@ class HGraphBuilder {
HValue* right,
Handle<Type> left_type,
Handle<Type> right_type,
Handle<Type> result_type);
Handle<Type> result_type,
Maybe<int> fixed_right_arg);
HLoadNamedField* AddLoadFixedArrayLength(HValue *object);

16
src/ic.cc
View File

@ -2329,10 +2329,7 @@ BinaryOpIC::State::State(ExtraICState extra_ic_state) {
1 << FixedRightArgValueField::decode(extra_ic_state));
left_kind_ = LeftKindField::decode(extra_ic_state);
if (fixed_right_arg_.has_value) {
// We have only 4 bits to encode the log2 of the fixed right arg, so the
// max value is 2^(2^4), which is always a SMI.
ASSERT(Smi::IsValid(fixed_right_arg_.value));
right_kind_ = SMI;
right_kind_ = Smi::IsValid(fixed_right_arg_.value) ? SMI : INT32;
} else {
right_kind_ = RightKindField::decode(extra_ic_state);
}
@ -2585,17 +2582,6 @@ void BinaryOpIC::State::GenerateAheadOfTime(
}
Handle<Type> BinaryOpIC::State::GetRightType(Isolate* isolate) const {
if (fixed_right_arg_.has_value) {
Handle<Smi> value = handle(Smi::FromInt(fixed_right_arg_.value), isolate);
Handle<Type> type = handle(Type::Constant(value, isolate), isolate);
ASSERT(type->Is(KindToType(right_kind_, isolate)));
return type;
}
return KindToType(right_kind_, isolate);
}
Handle<Type> BinaryOpIC::State::GetResultType(Isolate* isolate) const {
Kind result_kind = result_kind_;
if (HasSideEffects()) {

5
src/ic.h
View File

@ -866,11 +866,14 @@ class BinaryOpIC: public IC {
Token::Value op() const { return op_; }
OverwriteMode mode() const { return mode_; }
Maybe<int> fixed_right_arg() const { return fixed_right_arg_; }
Handle<Type> GetLeftType(Isolate* isolate) const {
return KindToType(left_kind_, isolate);
}
Handle<Type> GetRightType(Isolate* isolate) const;
Handle<Type> GetRightType(Isolate* isolate) const {
return KindToType(right_kind_, isolate);
}
Handle<Type> GetResultType(Isolate* isolate) const;
void Print(StringStream* stream) const;

3
src/type-info.cc
View File

@ -407,6 +407,7 @@ void TypeFeedbackOracle::BinaryType(TypeFeedbackId id,
Handle<Type>* left,
Handle<Type>* right,
Handle<Type>* result,
Maybe<int>* fixed_right_arg,
Token::Value op) {
Handle<Object> object = GetInfo(id);
if (!object->IsCode()) {
@ -415,6 +416,7 @@ void TypeFeedbackOracle::BinaryType(TypeFeedbackId id,
ASSERT(op < BinaryOpIC::State::FIRST_TOKEN ||
op > BinaryOpIC::State::LAST_TOKEN);
*left = *right = *result = handle(Type::None(), isolate_);
*fixed_right_arg = Maybe<int>();
return;
}
Handle<Code> code = Handle<Code>::cast(object);
@ -425,6 +427,7 @@ void TypeFeedbackOracle::BinaryType(TypeFeedbackId id,
*left = state.GetLeftType(isolate());
*right = state.GetRightType(isolate());
*result = state.GetResultType(isolate());
*fixed_right_arg = state.fixed_right_arg();
}

1
src/type-info.h
View File

@ -312,6 +312,7 @@ class TypeFeedbackOracle: public ZoneObject {
Handle<Type>* left,
Handle<Type>* right,
Handle<Type>* result,
Maybe<int>* fixed_right_arg,
Token::Value operation);
void CompareType(TypeFeedbackId id,

4
src/typing.cc
View File

@ -571,11 +571,13 @@ void AstTyper::VisitCountOperation(CountOperation* expr) {
void AstTyper::VisitBinaryOperation(BinaryOperation* expr) {
// Collect type feedback.
Handle<Type> type, left_type, right_type;
Maybe<int> fixed_right_arg;
oracle()->BinaryType(expr->BinaryOperationFeedbackId(),
&left_type, &right_type, &type, expr->op());
&left_type, &right_type, &type, &fixed_right_arg, expr->op());
NarrowLowerType(expr, type);
NarrowLowerType(expr->left(), left_type);
NarrowLowerType(expr->right(), right_type);
expr->set_fixed_right_arg(fixed_right_arg);
if (expr->op() == Token::OR || expr->op() == Token::AND) {
expr->left()->RecordToBooleanTypeFeedback(oracle());
}