2012-01-13 07:48:44 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2010-12-07 11:31:57 +00:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
// met:
|
|
|
|
//
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
// with the distribution.
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
#include "v8.h"
|
|
|
|
|
|
|
|
#include "factory.h"
|
|
|
|
#include "hydrogen.h"
|
|
|
|
|
|
|
|
#if V8_TARGET_ARCH_IA32
|
|
|
|
#include "ia32/lithium-ia32.h"
|
|
|
|
#elif V8_TARGET_ARCH_X64
|
|
|
|
#include "x64/lithium-x64.h"
|
|
|
|
#elif V8_TARGET_ARCH_ARM
|
|
|
|
#include "arm/lithium-arm.h"
|
2011-03-28 13:05:36 +00:00
|
|
|
#elif V8_TARGET_ARCH_MIPS
|
|
|
|
#include "mips/lithium-mips.h"
|
2010-12-07 11:31:57 +00:00
|
|
|
#else
|
|
|
|
#error Unsupported target architecture.
|
|
|
|
#endif
|
|
|
|
|
|
|
|
namespace v8 {
|
|
|
|
namespace internal {
|
|
|
|
|
|
|
|
#define DEFINE_COMPILE(type) \
|
|
|
|
LInstruction* H##type::CompileToLithium(LChunkBuilder* builder) { \
|
|
|
|
return builder->Do##type(this); \
|
|
|
|
}
|
|
|
|
HYDROGEN_CONCRETE_INSTRUCTION_LIST(DEFINE_COMPILE)
|
|
|
|
#undef DEFINE_COMPILE
|
|
|
|
|
|
|
|
|
|
|
|
const char* Representation::Mnemonic() const {
|
|
|
|
switch (kind_) {
|
|
|
|
case kNone: return "v";
|
|
|
|
case kTagged: return "t";
|
|
|
|
case kDouble: return "d";
|
|
|
|
case kInteger32: return "i";
|
2011-02-16 13:31:12 +00:00
|
|
|
case kExternal: return "x";
|
2011-05-11 09:19:28 +00:00
|
|
|
default:
|
2010-12-07 11:31:57 +00:00
|
|
|
UNREACHABLE();
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-01 08:49:18 +00:00
|
|
|
int HValue::LoopWeight() const {
|
|
|
|
const int w = FLAG_loop_weight;
|
|
|
|
static const int weights[] = { 1, w, w*w, w*w*w, w*w*w*w };
|
|
|
|
return weights[Min(block()->LoopNestingDepth(),
|
|
|
|
static_cast<int>(ARRAY_SIZE(weights)-1))];
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-13 13:29:02 +00:00
|
|
|
void HValue::AssumeRepresentation(Representation r) {
|
|
|
|
if (CheckFlag(kFlexibleRepresentation)) {
|
|
|
|
ChangeRepresentation(r);
|
|
|
|
// The representation of the value is dictated by type feedback and
|
|
|
|
// will not be changed later.
|
|
|
|
ClearFlag(kFlexibleRepresentation);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-16 18:01:36 +00:00
|
|
|
static int32_t ConvertAndSetOverflow(int64_t result, bool* overflow) {
|
|
|
|
if (result > kMaxInt) {
|
|
|
|
*overflow = true;
|
2010-12-07 11:31:57 +00:00
|
|
|
return kMaxInt;
|
2010-12-16 18:01:36 +00:00
|
|
|
}
|
|
|
|
if (result < kMinInt) {
|
|
|
|
*overflow = true;
|
2010-12-07 11:31:57 +00:00
|
|
|
return kMinInt;
|
|
|
|
}
|
2010-12-16 18:01:36 +00:00
|
|
|
return static_cast<int32_t>(result);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-16 18:01:36 +00:00
|
|
|
static int32_t AddWithoutOverflow(int32_t a, int32_t b, bool* overflow) {
|
|
|
|
int64_t result = static_cast<int64_t>(a) + static_cast<int64_t>(b);
|
|
|
|
return ConvertAndSetOverflow(result, overflow);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-16 18:01:36 +00:00
|
|
|
static int32_t SubWithoutOverflow(int32_t a, int32_t b, bool* overflow) {
|
|
|
|
int64_t result = static_cast<int64_t>(a) - static_cast<int64_t>(b);
|
|
|
|
return ConvertAndSetOverflow(result, overflow);
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
|
2010-12-16 18:01:36 +00:00
|
|
|
static int32_t MulWithoutOverflow(int32_t a, int32_t b, bool* overflow) {
|
|
|
|
int64_t result = static_cast<int64_t>(a) * static_cast<int64_t>(b);
|
|
|
|
return ConvertAndSetOverflow(result, overflow);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int32_t Range::Mask() const {
|
|
|
|
if (lower_ == upper_) return lower_;
|
|
|
|
if (lower_ >= 0) {
|
|
|
|
int32_t res = 1;
|
|
|
|
while (res < upper_) {
|
|
|
|
res = (res << 1) | 1;
|
|
|
|
}
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
return 0xffffffff;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-16 18:01:36 +00:00
|
|
|
void Range::AddConstant(int32_t value) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (value == 0) return;
|
2010-12-16 18:01:36 +00:00
|
|
|
bool may_overflow = false; // Overflow is ignored here.
|
|
|
|
lower_ = AddWithoutOverflow(lower_, value, &may_overflow);
|
|
|
|
upper_ = AddWithoutOverflow(upper_, value, &may_overflow);
|
2011-11-02 08:32:40 +00:00
|
|
|
#ifdef DEBUG
|
2010-12-07 11:31:57 +00:00
|
|
|
Verify();
|
2011-11-02 08:32:40 +00:00
|
|
|
#endif
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-04 12:09:54 +00:00
|
|
|
void Range::Intersect(Range* other) {
|
|
|
|
upper_ = Min(upper_, other->upper_);
|
|
|
|
lower_ = Max(lower_, other->lower_);
|
|
|
|
bool b = CanBeMinusZero() && other->CanBeMinusZero();
|
|
|
|
set_can_be_minus_zero(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Range::Union(Range* other) {
|
|
|
|
upper_ = Max(upper_, other->upper_);
|
|
|
|
lower_ = Min(lower_, other->lower_);
|
|
|
|
bool b = CanBeMinusZero() || other->CanBeMinusZero();
|
|
|
|
set_can_be_minus_zero(b);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Range::Sar(int32_t value) {
|
|
|
|
int32_t bits = value & 0x1F;
|
|
|
|
lower_ = lower_ >> bits;
|
|
|
|
upper_ = upper_ >> bits;
|
|
|
|
set_can_be_minus_zero(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Range::Shl(int32_t value) {
|
|
|
|
int32_t bits = value & 0x1F;
|
|
|
|
int old_lower = lower_;
|
|
|
|
int old_upper = upper_;
|
|
|
|
lower_ = lower_ << bits;
|
|
|
|
upper_ = upper_ << bits;
|
|
|
|
if (old_lower != lower_ >> bits || old_upper != upper_ >> bits) {
|
|
|
|
upper_ = kMaxInt;
|
|
|
|
lower_ = kMinInt;
|
|
|
|
}
|
|
|
|
set_can_be_minus_zero(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
bool Range::AddAndCheckOverflow(Range* other) {
|
2010-12-16 18:01:36 +00:00
|
|
|
bool may_overflow = false;
|
|
|
|
lower_ = AddWithoutOverflow(lower_, other->lower(), &may_overflow);
|
|
|
|
upper_ = AddWithoutOverflow(upper_, other->upper(), &may_overflow);
|
2010-12-07 11:31:57 +00:00
|
|
|
KeepOrder();
|
2011-11-02 08:32:40 +00:00
|
|
|
#ifdef DEBUG
|
2010-12-07 11:31:57 +00:00
|
|
|
Verify();
|
2011-11-02 08:32:40 +00:00
|
|
|
#endif
|
2010-12-16 18:01:36 +00:00
|
|
|
return may_overflow;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool Range::SubAndCheckOverflow(Range* other) {
|
2010-12-16 18:01:36 +00:00
|
|
|
bool may_overflow = false;
|
|
|
|
lower_ = SubWithoutOverflow(lower_, other->upper(), &may_overflow);
|
|
|
|
upper_ = SubWithoutOverflow(upper_, other->lower(), &may_overflow);
|
2010-12-07 11:31:57 +00:00
|
|
|
KeepOrder();
|
2011-11-02 08:32:40 +00:00
|
|
|
#ifdef DEBUG
|
2010-12-07 11:31:57 +00:00
|
|
|
Verify();
|
2011-11-02 08:32:40 +00:00
|
|
|
#endif
|
2010-12-16 18:01:36 +00:00
|
|
|
return may_overflow;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void Range::KeepOrder() {
|
|
|
|
if (lower_ > upper_) {
|
|
|
|
int32_t tmp = lower_;
|
|
|
|
lower_ = upper_;
|
|
|
|
upper_ = tmp;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-02 08:32:40 +00:00
|
|
|
#ifdef DEBUG
|
2010-12-07 11:31:57 +00:00
|
|
|
void Range::Verify() const {
|
|
|
|
ASSERT(lower_ <= upper_);
|
|
|
|
}
|
2011-11-02 08:32:40 +00:00
|
|
|
#endif
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
|
|
|
|
bool Range::MulAndCheckOverflow(Range* other) {
|
|
|
|
bool may_overflow = false;
|
|
|
|
int v1 = MulWithoutOverflow(lower_, other->lower(), &may_overflow);
|
|
|
|
int v2 = MulWithoutOverflow(lower_, other->upper(), &may_overflow);
|
|
|
|
int v3 = MulWithoutOverflow(upper_, other->lower(), &may_overflow);
|
|
|
|
int v4 = MulWithoutOverflow(upper_, other->upper(), &may_overflow);
|
|
|
|
lower_ = Min(Min(v1, v2), Min(v3, v4));
|
|
|
|
upper_ = Max(Max(v1, v2), Max(v3, v4));
|
2011-11-02 08:32:40 +00:00
|
|
|
#ifdef DEBUG
|
2010-12-07 11:31:57 +00:00
|
|
|
Verify();
|
2011-11-02 08:32:40 +00:00
|
|
|
#endif
|
2010-12-07 11:31:57 +00:00
|
|
|
return may_overflow;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const char* HType::ToString() {
|
|
|
|
switch (type_) {
|
|
|
|
case kTagged: return "tagged";
|
|
|
|
case kTaggedPrimitive: return "primitive";
|
|
|
|
case kTaggedNumber: return "number";
|
|
|
|
case kSmi: return "smi";
|
|
|
|
case kHeapNumber: return "heap-number";
|
|
|
|
case kString: return "string";
|
|
|
|
case kBoolean: return "boolean";
|
|
|
|
case kNonPrimitive: return "non-primitive";
|
|
|
|
case kJSArray: return "array";
|
|
|
|
case kJSObject: return "object";
|
|
|
|
case kUninitialized: return "uninitialized";
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
return "Unreachable code";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HType HType::TypeFromValue(Handle<Object> value) {
|
|
|
|
HType result = HType::Tagged();
|
|
|
|
if (value->IsSmi()) {
|
|
|
|
result = HType::Smi();
|
|
|
|
} else if (value->IsHeapNumber()) {
|
|
|
|
result = HType::HeapNumber();
|
|
|
|
} else if (value->IsString()) {
|
|
|
|
result = HType::String();
|
|
|
|
} else if (value->IsBoolean()) {
|
|
|
|
result = HType::Boolean();
|
|
|
|
} else if (value->IsJSObject()) {
|
|
|
|
result = HType::JSObject();
|
|
|
|
} else if (value->IsJSArray()) {
|
|
|
|
result = HType::JSArray();
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-20 10:38:08 +00:00
|
|
|
bool HValue::IsDefinedAfter(HBasicBlock* other) const {
|
|
|
|
return block()->block_id() > other->block_id();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-23 13:59:35 +00:00
|
|
|
HUseListNode* HUseListNode::tail() {
|
|
|
|
// Skip and remove dead items in the use list.
|
|
|
|
while (tail_ != NULL && tail_->value()->CheckFlag(HValue::kIsDead)) {
|
|
|
|
tail_ = tail_->tail_;
|
|
|
|
}
|
|
|
|
return tail_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-29 13:41:18 +00:00
|
|
|
bool HValue::CheckUsesForFlag(Flag f) {
|
|
|
|
for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
|
|
|
|
if (!it.value()->CheckFlag(f)) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-20 10:38:08 +00:00
|
|
|
HUseIterator::HUseIterator(HUseListNode* head) : next_(head) {
|
|
|
|
Advance();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HUseIterator::Advance() {
|
|
|
|
current_ = next_;
|
|
|
|
if (current_ != NULL) {
|
|
|
|
next_ = current_->tail();
|
|
|
|
value_ = current_->value();
|
|
|
|
index_ = current_->index();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-20 10:38:08 +00:00
|
|
|
int HValue::UseCount() const {
|
|
|
|
int count = 0;
|
|
|
|
for (HUseIterator it(uses()); !it.Done(); it.Advance()) ++count;
|
|
|
|
return count;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-20 10:38:08 +00:00
|
|
|
HUseListNode* HValue::RemoveUse(HValue* value, int index) {
|
|
|
|
HUseListNode* previous = NULL;
|
|
|
|
HUseListNode* current = use_list_;
|
|
|
|
while (current != NULL) {
|
|
|
|
if (current->value() == value && current->index() == index) {
|
|
|
|
if (previous == NULL) {
|
|
|
|
use_list_ = current->tail();
|
|
|
|
} else {
|
|
|
|
previous->set_tail(current->tail());
|
|
|
|
}
|
|
|
|
break;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
2011-04-20 10:38:08 +00:00
|
|
|
|
|
|
|
previous = current;
|
|
|
|
current = current->tail();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
2011-04-20 10:38:08 +00:00
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
// Do not reuse use list nodes in debug mode, zap them.
|
|
|
|
if (current != NULL) {
|
|
|
|
HUseListNode* temp =
|
|
|
|
new HUseListNode(current->value(), current->index(), NULL);
|
|
|
|
current->Zap();
|
|
|
|
current = temp;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
return current;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
bool HValue::Equals(HValue* other) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (other->opcode() != opcode()) return false;
|
|
|
|
if (!other->representation().Equals(representation())) return false;
|
|
|
|
if (!other->type_.Equals(type_)) return false;
|
2011-01-31 12:36:54 +00:00
|
|
|
if (other->flags() != flags()) return false;
|
2010-12-07 11:31:57 +00:00
|
|
|
if (OperandCount() != other->OperandCount()) return false;
|
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
|
|
|
if (OperandAt(i)->id() != other->OperandAt(i)->id()) return false;
|
|
|
|
}
|
|
|
|
bool result = DataEquals(other);
|
|
|
|
ASSERT(!result || Hashcode() == other->Hashcode());
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
intptr_t HValue::Hashcode() {
|
2010-12-07 11:31:57 +00:00
|
|
|
intptr_t result = opcode();
|
|
|
|
int count = OperandCount();
|
|
|
|
for (int i = 0; i < count; ++i) {
|
|
|
|
result = result * 19 + OperandAt(i)->id() + (result >> 7);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-19 09:11:21 +00:00
|
|
|
const char* HValue::Mnemonic() const {
|
|
|
|
switch (opcode()) {
|
|
|
|
#define MAKE_CASE(type) case k##type: return #type;
|
|
|
|
HYDROGEN_CONCRETE_INSTRUCTION_LIST(MAKE_CASE)
|
|
|
|
#undef MAKE_CASE
|
|
|
|
case kPhi: return "Phi";
|
|
|
|
default: return "";
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
void HValue::SetOperandAt(int index, HValue* value) {
|
|
|
|
RegisterUse(index, value);
|
|
|
|
InternalSetOperandAt(index, value);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-20 10:38:08 +00:00
|
|
|
void HValue::DeleteAndReplaceWith(HValue* other) {
|
|
|
|
// We replace all uses first, so Delete can assert that there are none.
|
|
|
|
if (other != NULL) ReplaceAllUsesWith(other);
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(HasNoUses());
|
2012-02-24 08:46:10 +00:00
|
|
|
Kill();
|
2010-12-07 11:31:57 +00:00
|
|
|
DeleteFromGraph();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-20 10:38:08 +00:00
|
|
|
void HValue::ReplaceAllUsesWith(HValue* other) {
|
|
|
|
while (use_list_ != NULL) {
|
|
|
|
HUseListNode* list_node = use_list_;
|
|
|
|
HValue* value = list_node->value();
|
|
|
|
ASSERT(!value->block()->IsStartBlock());
|
|
|
|
value->InternalSetOperandAt(list_node->index(), other);
|
|
|
|
use_list_ = list_node->tail();
|
|
|
|
list_node->set_tail(other->use_list_);
|
|
|
|
other->use_list_ = list_node;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-24 08:46:10 +00:00
|
|
|
void HValue::Kill() {
|
|
|
|
// Instead of going through the entire use list of each operand, we only
|
|
|
|
// check the first item in each use list and rely on the tail() method to
|
|
|
|
// skip dead items, removing them lazily next time we traverse the list.
|
|
|
|
SetFlag(kIsDead);
|
2011-04-20 10:38:08 +00:00
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
2012-02-24 08:46:10 +00:00
|
|
|
HValue* operand = OperandAt(i);
|
|
|
|
HUseListNode* first = operand->use_list_;
|
|
|
|
if (first != NULL && first->value() == this && first->index() == i) {
|
|
|
|
operand->use_list_ = first->tail();
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HValue::SetBlock(HBasicBlock* block) {
|
|
|
|
ASSERT(block_ == NULL || block == NULL);
|
|
|
|
block_ = block;
|
|
|
|
if (id_ == kNoNumber && block != NULL) {
|
|
|
|
id_ = block->graph()->GetNextValueID(this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-11 09:19:28 +00:00
|
|
|
void HValue::PrintTypeTo(StringStream* stream) {
|
|
|
|
if (!representation().IsTagged() || type().Equals(HType::Tagged())) return;
|
|
|
|
stream->Add(" type[%s]", type().ToString());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HValue::PrintRangeTo(StringStream* stream) {
|
|
|
|
if (range() == NULL || range()->IsMostGeneric()) return;
|
|
|
|
stream->Add(" range[%d,%d,m0=%d]",
|
|
|
|
range()->lower(),
|
|
|
|
range()->upper(),
|
|
|
|
static_cast<int>(range()->CanBeMinusZero()));
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HValue::PrintChangesTo(StringStream* stream) {
|
2012-01-20 14:08:20 +00:00
|
|
|
GVNFlagSet changes_flags = ChangesFlags();
|
|
|
|
if (changes_flags.IsEmpty()) return;
|
2011-05-11 09:19:28 +00:00
|
|
|
stream->Add(" changes[");
|
2012-01-20 14:08:20 +00:00
|
|
|
if (changes_flags == AllSideEffectsFlagSet()) {
|
2011-05-11 09:19:28 +00:00
|
|
|
stream->Add("*");
|
|
|
|
} else {
|
|
|
|
bool add_comma = false;
|
2012-01-20 14:08:20 +00:00
|
|
|
#define PRINT_DO(type) \
|
|
|
|
if (changes_flags.Contains(kChanges##type)) { \
|
|
|
|
if (add_comma) stream->Add(","); \
|
|
|
|
add_comma = true; \
|
|
|
|
stream->Add(#type); \
|
2011-05-11 09:19:28 +00:00
|
|
|
}
|
|
|
|
GVN_FLAG_LIST(PRINT_DO);
|
|
|
|
#undef PRINT_DO
|
|
|
|
}
|
|
|
|
stream->Add("]");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HValue::PrintNameTo(StringStream* stream) {
|
|
|
|
stream->Add("%s%d", representation_.Mnemonic(), id());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool HValue::UpdateInferredType() {
|
|
|
|
HType type = CalculateInferredType();
|
|
|
|
bool result = (!type.Equals(type_));
|
|
|
|
type_ = type;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HValue::RegisterUse(int index, HValue* new_value) {
|
|
|
|
HValue* old_value = OperandAt(index);
|
|
|
|
if (old_value == new_value) return;
|
2011-04-20 10:38:08 +00:00
|
|
|
|
|
|
|
HUseListNode* removed = NULL;
|
|
|
|
if (old_value != NULL) {
|
|
|
|
removed = old_value->RemoveUse(this, index);
|
|
|
|
}
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
if (new_value != NULL) {
|
2011-04-20 10:38:08 +00:00
|
|
|
if (removed == NULL) {
|
|
|
|
new_value->use_list_ =
|
|
|
|
new HUseListNode(this, index, new_value->use_list_);
|
|
|
|
} else {
|
|
|
|
removed->set_tail(new_value->use_list_);
|
|
|
|
new_value->use_list_ = removed;
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
void HValue::AddNewRange(Range* r, Zone* zone) {
|
|
|
|
if (!HasRange()) ComputeInitialRange(zone);
|
|
|
|
if (!HasRange()) range_ = new(zone) Range();
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(HasRange());
|
|
|
|
r->StackUpon(range_);
|
|
|
|
range_ = r;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HValue::RemoveLastAddedRange() {
|
|
|
|
ASSERT(HasRange());
|
|
|
|
ASSERT(range_->next() != NULL);
|
|
|
|
range_ = range_->next();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
void HValue::ComputeInitialRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(!HasRange());
|
2012-02-28 15:32:58 +00:00
|
|
|
range_ = InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(HasRange());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HInstruction::PrintTo(StringStream* stream) {
|
2011-05-11 09:19:28 +00:00
|
|
|
PrintMnemonicTo(stream);
|
2010-12-07 11:31:57 +00:00
|
|
|
PrintDataTo(stream);
|
2011-05-11 09:19:28 +00:00
|
|
|
PrintRangeTo(stream);
|
|
|
|
PrintChangesTo(stream);
|
|
|
|
PrintTypeTo(stream);
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
|
2011-05-11 09:19:28 +00:00
|
|
|
void HInstruction::PrintMnemonicTo(StringStream* stream) {
|
2011-09-01 11:06:03 +00:00
|
|
|
stream->Add("%s ", Mnemonic());
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HInstruction::Unlink() {
|
|
|
|
ASSERT(IsLinked());
|
|
|
|
ASSERT(!IsControlInstruction()); // Must never move control instructions.
|
2011-02-15 07:58:04 +00:00
|
|
|
ASSERT(!IsBlockEntry()); // Doesn't make sense to delete these.
|
|
|
|
ASSERT(previous_ != NULL);
|
|
|
|
previous_->next_ = next_;
|
|
|
|
if (next_ == NULL) {
|
|
|
|
ASSERT(block()->last() == this);
|
|
|
|
block()->set_last(previous_);
|
|
|
|
} else {
|
|
|
|
next_->previous_ = previous_;
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
clear_block();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HInstruction::InsertBefore(HInstruction* next) {
|
|
|
|
ASSERT(!IsLinked());
|
|
|
|
ASSERT(!next->IsBlockEntry());
|
|
|
|
ASSERT(!IsControlInstruction());
|
|
|
|
ASSERT(!next->block()->IsStartBlock());
|
|
|
|
ASSERT(next->previous_ != NULL);
|
|
|
|
HInstruction* prev = next->previous();
|
|
|
|
prev->next_ = this;
|
|
|
|
next->previous_ = this;
|
|
|
|
next_ = next;
|
|
|
|
previous_ = prev;
|
|
|
|
SetBlock(next->block());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HInstruction::InsertAfter(HInstruction* previous) {
|
|
|
|
ASSERT(!IsLinked());
|
|
|
|
ASSERT(!previous->IsControlInstruction());
|
|
|
|
ASSERT(!IsControlInstruction() || previous->next_ == NULL);
|
|
|
|
HBasicBlock* block = previous->block();
|
|
|
|
// Never insert anything except constants into the start block after finishing
|
|
|
|
// it.
|
|
|
|
if (block->IsStartBlock() && block->IsFinished() && !IsConstant()) {
|
|
|
|
ASSERT(block->end()->SecondSuccessor() == NULL);
|
|
|
|
InsertAfter(block->end()->FirstSuccessor()->first());
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// If we're inserting after an instruction with side-effects that is
|
|
|
|
// followed by a simulate instruction, we need to insert after the
|
|
|
|
// simulate instruction instead.
|
|
|
|
HInstruction* next = previous->next_;
|
2011-10-31 14:15:10 +00:00
|
|
|
if (previous->HasObservableSideEffects() && next != NULL) {
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(next->IsSimulate());
|
|
|
|
previous = next;
|
|
|
|
next = previous->next_;
|
|
|
|
}
|
|
|
|
|
|
|
|
previous_ = previous;
|
|
|
|
next_ = next;
|
|
|
|
SetBlock(block);
|
|
|
|
previous->next_ = this;
|
|
|
|
if (next != NULL) next->previous_ = this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
2011-01-26 14:51:21 +00:00
|
|
|
void HInstruction::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
// Verify that input operands are defined before use.
|
|
|
|
HBasicBlock* cur_block = block();
|
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
|
|
|
HValue* other_operand = OperandAt(i);
|
|
|
|
HBasicBlock* other_block = other_operand->block();
|
|
|
|
if (cur_block == other_block) {
|
|
|
|
if (!other_operand->IsPhi()) {
|
2011-10-17 07:52:20 +00:00
|
|
|
HInstruction* cur = this->previous();
|
2010-12-07 11:31:57 +00:00
|
|
|
while (cur != NULL) {
|
|
|
|
if (cur == other_operand) break;
|
2011-10-17 07:52:20 +00:00
|
|
|
cur = cur->previous();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
// Must reach other operand in the same block!
|
|
|
|
ASSERT(cur == other_operand);
|
|
|
|
}
|
|
|
|
} else {
|
2011-05-16 14:10:56 +00:00
|
|
|
// If the following assert fires, you may have forgotten an
|
|
|
|
// AddInstruction.
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(other_block->Dominates(cur_block));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify that instructions that may have side-effects are followed
|
|
|
|
// by a simulate instruction.
|
2011-10-31 14:15:10 +00:00
|
|
|
if (HasObservableSideEffects() && !IsOsrEntry()) {
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(next()->IsSimulate());
|
|
|
|
}
|
2011-01-26 14:51:21 +00:00
|
|
|
|
|
|
|
// Verify that instructions that can be eliminated by GVN have overridden
|
|
|
|
// HValue::DataEquals. The default implementation is UNREACHABLE. We
|
|
|
|
// don't actually care whether DataEquals returns true or false here.
|
|
|
|
if (CheckFlag(kUseGVN)) DataEquals(this);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HUnaryCall::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
2011-02-23 11:19:50 +00:00
|
|
|
stream->Add("#%d", argument_count());
|
2011-02-11 13:20:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HBinaryCall::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
first()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
second()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
2011-02-23 11:19:50 +00:00
|
|
|
stream->Add("#%d", argument_count());
|
2011-02-11 13:20:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-12 10:13:40 +00:00
|
|
|
void HBoundsCheck::PrintDataTo(StringStream* stream) {
|
|
|
|
index()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
length()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
2011-08-23 07:34:45 +00:00
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCallConstantFunction::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
if (IsApplyFunction()) {
|
|
|
|
stream->Add("optimized apply ");
|
|
|
|
} else {
|
|
|
|
stream->Add("%o ", function()->shared()->DebugName());
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
2011-02-23 11:19:50 +00:00
|
|
|
stream->Add("#%d", argument_count());
|
2011-02-11 13:20:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCallNamed::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
stream->Add("%o ", *name());
|
|
|
|
HUnaryCall::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCallGlobal::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
stream->Add("%o ", *name());
|
|
|
|
HUnaryCall::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCallKnownGlobal::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
stream->Add("o ", target()->shared()->DebugName());
|
2011-02-23 11:19:50 +00:00
|
|
|
stream->Add("#%d", argument_count());
|
2011-02-11 13:20:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCallRuntime::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
stream->Add("%o ", *name());
|
2011-02-23 11:19:50 +00:00
|
|
|
stream->Add("#%d", argument_count());
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-30 14:19:52 +00:00
|
|
|
void HClassOfTestAndBranch::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add("class_of_test(");
|
2011-02-11 13:20:06 +00:00
|
|
|
value()->PrintNameTo(stream);
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add(", \"%o\")", *class_name());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HAccessArgumentsAt::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
arguments()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
index()->PrintNameTo(stream);
|
|
|
|
stream->Add("], length ");
|
|
|
|
length()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HControlInstruction::PrintDataTo(StringStream* stream) {
|
2011-06-10 12:09:48 +00:00
|
|
|
stream->Add(" goto (");
|
|
|
|
bool first_block = true;
|
|
|
|
for (HSuccessorIterator it(this); !it.Done(); it.Advance()) {
|
|
|
|
stream->Add(first_block ? "B%d" : ", B%d", it.Current()->block_id());
|
|
|
|
first_block = false;
|
2011-01-20 12:56:34 +00:00
|
|
|
}
|
2011-06-10 12:09:48 +00:00
|
|
|
stream->Add(")");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HUnaryControlInstruction::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
2011-01-20 12:56:34 +00:00
|
|
|
HControlInstruction::PrintDataTo(stream);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-23 11:51:05 +00:00
|
|
|
void HIsNilAndBranch::PrintDataTo(StringStream* stream) {
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
stream->Add(kind() == kStrictEquality ? " === " : " == ");
|
|
|
|
stream->Add(nil() == kNullValue ? "null" : "undefined");
|
|
|
|
HControlInstruction::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-10 12:09:48 +00:00
|
|
|
void HReturn::PrintDataTo(StringStream* stream) {
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCompareMap::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
2011-01-20 12:56:34 +00:00
|
|
|
stream->Add(" (%p)", *map());
|
|
|
|
HControlInstruction::PrintDataTo(stream);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
const char* HUnaryMathOperation::OpName() const {
|
|
|
|
switch (op()) {
|
|
|
|
case kMathFloor: return "floor";
|
|
|
|
case kMathRound: return "round";
|
|
|
|
case kMathCeil: return "ceil";
|
|
|
|
case kMathAbs: return "abs";
|
|
|
|
case kMathLog: return "log";
|
|
|
|
case kMathSin: return "sin";
|
|
|
|
case kMathCos: return "cos";
|
|
|
|
case kMathTan: return "tan";
|
|
|
|
case kMathASin: return "asin";
|
|
|
|
case kMathACos: return "acos";
|
|
|
|
case kMathATan: return "atan";
|
|
|
|
case kMathExp: return "exp";
|
|
|
|
case kMathSqrt: return "sqrt";
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
return "(unknown operation)";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HUnaryMathOperation::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
const char* name = OpName();
|
|
|
|
stream->Add("%s ", name);
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HUnaryOperation::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-30 14:19:52 +00:00
|
|
|
void HHasInstanceTypeAndBranch::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
switch (from_) {
|
Implement set trap for proxies, and revamp class hierarchy in preparation:
- Introduce a class JSReceiver, that is a common superclass of JSObject and
JSProxy. Use JSReceiver where appropriate (probably lots of places that we
still have to migrate, but we will find those later with proxy test suite).
- Move appropriate methods to JSReceiver class (SetProperty,
GetPropertyAttribute, Get/SetPrototype, Lookup, and so on).
- Introduce new JSFunctionProxy subclass of JSProxy. Currently only a stub.
- Overhaul enum InstanceType:
* Introduce FIRST/LAST_SPEC_OBJECT_TYPE that ranges over all types that
represent JS objects, and use that consistently to check language types.
* Rename FIRST/LAST_JS_OBJECT_TYPE and FIRST/LAST_FUNCTION_CLASS_TYPE
to FIRST/LAST_[NON]CALLABLE_SPEC_OBJECT_TYPE for clarity.
* Eliminate the overlap over JS_REGEXP_TYPE.
* Also replace FIRST_JS_OBJECT with FIRST_JS_RECEIVER, but only use it where
we exclusively talk about the internal representation type.
* Insert JS_PROXY and JS_FUNCTION_PROXY in the appropriate places.
- Fix all checks concerning classification, especially for functions, to
use the CALLABLE_SPEC_OBJECT range (that includes funciton proxies).
- Handle proxies in SetProperty (that was the easiest part :) ).
- A few simple test cases.
R=kmillikin@chromium.org
Review URL: http://codereview.chromium.org/6992072
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@8126 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2011-05-31 16:38:40 +00:00
|
|
|
case FIRST_JS_RECEIVER_TYPE:
|
2010-12-07 11:31:57 +00:00
|
|
|
if (to_ == LAST_TYPE) stream->Add(" spec_object");
|
|
|
|
break;
|
|
|
|
case JS_REGEXP_TYPE:
|
|
|
|
if (to_ == JS_REGEXP_TYPE) stream->Add(" reg_exp");
|
|
|
|
break;
|
|
|
|
case JS_ARRAY_TYPE:
|
|
|
|
if (to_ == JS_ARRAY_TYPE) stream->Add(" array");
|
|
|
|
break;
|
|
|
|
case JS_FUNCTION_TYPE:
|
|
|
|
if (to_ == JS_FUNCTION_TYPE) stream->Add(" function");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-30 14:19:52 +00:00
|
|
|
void HTypeofIsAndBranch::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
2011-10-14 13:16:23 +00:00
|
|
|
stream->Add(" == %o", *type_literal_);
|
2011-09-23 11:51:05 +00:00
|
|
|
HControlInstruction::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-22 12:47:42 +00:00
|
|
|
void HCheckMapValue::PrintDataTo(StringStream* stream) {
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
map()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HForInPrepareMap::PrintDataTo(StringStream* stream) {
|
|
|
|
enumerable()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HForInCacheArray::PrintDataTo(StringStream* stream) {
|
|
|
|
enumerable()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
map()->PrintNameTo(stream);
|
|
|
|
stream->Add("[%d]", idx_);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HLoadFieldByIndex::PrintDataTo(StringStream* stream) {
|
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
index()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-19 07:35:30 +00:00
|
|
|
HValue* HConstant::Canonicalize() {
|
2012-02-29 13:41:18 +00:00
|
|
|
return HasNoUses() ? NULL : this;
|
2011-10-19 07:35:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HTypeof::Canonicalize() {
|
2012-02-29 13:41:18 +00:00
|
|
|
return HasNoUses() ? NULL : this;
|
2011-10-19 07:35:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-11 10:01:59 +00:00
|
|
|
HValue* HBitwise::Canonicalize() {
|
|
|
|
if (!representation().IsInteger32()) return this;
|
|
|
|
// If x is an int32, then x & -1 == x, x | 0 == x and x ^ 0 == x.
|
|
|
|
int32_t nop_constant = (op() == Token::BIT_AND) ? -1 : 0;
|
|
|
|
if (left()->IsConstant() &&
|
|
|
|
HConstant::cast(left())->HasInteger32Value() &&
|
|
|
|
HConstant::cast(left())->Integer32Value() == nop_constant) {
|
|
|
|
return right();
|
|
|
|
}
|
|
|
|
if (right()->IsConstant() &&
|
|
|
|
HConstant::cast(right())->HasInteger32Value() &&
|
|
|
|
HConstant::cast(right())->Integer32Value() == nop_constant) {
|
|
|
|
return left();
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-29 13:41:18 +00:00
|
|
|
HValue* HAdd::Canonicalize() {
|
|
|
|
if (!representation().IsInteger32()) return this;
|
|
|
|
if (CheckUsesForFlag(kTruncatingToInt32)) ClearFlag(kCanOverflow);
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HSub::Canonicalize() {
|
|
|
|
if (!representation().IsInteger32()) return this;
|
|
|
|
if (CheckUsesForFlag(kTruncatingToInt32)) ClearFlag(kCanOverflow);
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-01-13 07:48:44 +00:00
|
|
|
HValue* HChange::Canonicalize() {
|
|
|
|
return (from().Equals(to())) ? value() : this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-12 12:49:41 +00:00
|
|
|
HValue* HWrapReceiver::Canonicalize() {
|
|
|
|
if (HasNoUses()) return NULL;
|
|
|
|
if (receiver()->type().IsJSObject()) {
|
|
|
|
return receiver();
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-23 11:51:05 +00:00
|
|
|
void HTypeof::PrintDataTo(StringStream* stream) {
|
|
|
|
value()->PrintNameTo(stream);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HChange::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
HUnaryOperation::PrintDataTo(stream);
|
2011-09-28 14:01:40 +00:00
|
|
|
stream->Add(" %s to %s", from().Mnemonic(), to().Mnemonic());
|
2010-12-07 11:31:57 +00:00
|
|
|
|
|
|
|
if (CanTruncateToInt32()) stream->Add(" truncating-int32");
|
|
|
|
if (CheckFlag(kBailoutOnMinusZero)) stream->Add(" -0?");
|
2011-09-28 14:01:40 +00:00
|
|
|
if (CheckFlag(kDeoptimizeOnUndefined)) stream->Add(" deopt-on-undefined");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-05 13:28:56 +00:00
|
|
|
void HJSArrayLength::PrintDataTo(StringStream* stream) {
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
typecheck()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-07 12:01:49 +00:00
|
|
|
HValue* HCheckInstanceType::Canonicalize() {
|
|
|
|
if (check_ == IS_STRING &&
|
|
|
|
!value()->type().IsUninitialized() &&
|
|
|
|
value()->type().IsString()) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (check_ == IS_SYMBOL &&
|
|
|
|
value()->IsConstant() &&
|
|
|
|
HConstant::cast(value())->handle()->IsSymbol()) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-10 14:17:23 +00:00
|
|
|
void HCheckInstanceType::GetCheckInterval(InstanceType* first,
|
|
|
|
InstanceType* last) {
|
|
|
|
ASSERT(is_interval_check());
|
|
|
|
switch (check_) {
|
Implement set trap for proxies, and revamp class hierarchy in preparation:
- Introduce a class JSReceiver, that is a common superclass of JSObject and
JSProxy. Use JSReceiver where appropriate (probably lots of places that we
still have to migrate, but we will find those later with proxy test suite).
- Move appropriate methods to JSReceiver class (SetProperty,
GetPropertyAttribute, Get/SetPrototype, Lookup, and so on).
- Introduce new JSFunctionProxy subclass of JSProxy. Currently only a stub.
- Overhaul enum InstanceType:
* Introduce FIRST/LAST_SPEC_OBJECT_TYPE that ranges over all types that
represent JS objects, and use that consistently to check language types.
* Rename FIRST/LAST_JS_OBJECT_TYPE and FIRST/LAST_FUNCTION_CLASS_TYPE
to FIRST/LAST_[NON]CALLABLE_SPEC_OBJECT_TYPE for clarity.
* Eliminate the overlap over JS_REGEXP_TYPE.
* Also replace FIRST_JS_OBJECT with FIRST_JS_RECEIVER, but only use it where
we exclusively talk about the internal representation type.
* Insert JS_PROXY and JS_FUNCTION_PROXY in the appropriate places.
- Fix all checks concerning classification, especially for functions, to
use the CALLABLE_SPEC_OBJECT range (that includes funciton proxies).
- Handle proxies in SetProperty (that was the easiest part :) ).
- A few simple test cases.
R=kmillikin@chromium.org
Review URL: http://codereview.chromium.org/6992072
git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@8126 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2011-05-31 16:38:40 +00:00
|
|
|
case IS_SPEC_OBJECT:
|
|
|
|
*first = FIRST_SPEC_OBJECT_TYPE;
|
|
|
|
*last = LAST_SPEC_OBJECT_TYPE;
|
2011-05-10 14:17:23 +00:00
|
|
|
return;
|
|
|
|
case IS_JS_ARRAY:
|
|
|
|
*first = *last = JS_ARRAY_TYPE;
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HCheckInstanceType::GetCheckMaskAndTag(uint8_t* mask, uint8_t* tag) {
|
|
|
|
ASSERT(!is_interval_check());
|
|
|
|
switch (check_) {
|
|
|
|
case IS_STRING:
|
|
|
|
*mask = kIsNotStringMask;
|
|
|
|
*tag = kStringTag;
|
|
|
|
return;
|
|
|
|
case IS_SYMBOL:
|
|
|
|
*mask = kIsSymbolMask;
|
|
|
|
*tag = kSymbolTag;
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-23 16:37:54 +00:00
|
|
|
void HCheckMaps::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
2012-03-23 16:37:54 +00:00
|
|
|
stream->Add(" [%p", *map_set()->first());
|
|
|
|
for (int i = 1; i < map_set()->length(); ++i) {
|
|
|
|
stream->Add(",%p", *map_set()->at(i));
|
2012-02-09 08:58:19 +00:00
|
|
|
}
|
2012-03-23 16:37:54 +00:00
|
|
|
stream->Add("]");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCheckFunction::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
stream->Add(" %p", *target());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-23 11:51:05 +00:00
|
|
|
const char* HCheckInstanceType::GetCheckName() {
|
|
|
|
switch (check_) {
|
|
|
|
case IS_SPEC_OBJECT: return "object";
|
|
|
|
case IS_JS_ARRAY: return "array";
|
|
|
|
case IS_STRING: return "string";
|
|
|
|
case IS_SYMBOL: return "symbol";
|
|
|
|
}
|
|
|
|
UNREACHABLE();
|
|
|
|
return "";
|
|
|
|
}
|
|
|
|
|
|
|
|
void HCheckInstanceType::PrintDataTo(StringStream* stream) {
|
|
|
|
stream->Add("%s ", GetCheckName());
|
|
|
|
HUnaryOperation::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HCallStub::PrintDataTo(StringStream* stream) {
|
2011-02-11 13:20:06 +00:00
|
|
|
stream->Add("%s ",
|
|
|
|
CodeStub::MajorName(major_key_, false));
|
|
|
|
HUnaryCall::PrintDataTo(stream);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HInstanceOf::PrintDataTo(StringStream* stream) {
|
2011-02-10 09:00:50 +00:00
|
|
|
left()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
right()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
context()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HValue::InferRange(Zone* zone) {
|
2011-08-10 12:32:43 +00:00
|
|
|
// Untagged integer32 cannot be -0, all other representations can.
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* result = new(zone) Range();
|
2011-08-10 12:32:43 +00:00
|
|
|
result->set_can_be_minus_zero(!representation().IsInteger32());
|
|
|
|
return result;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HChange::InferRange(Zone* zone) {
|
2011-08-23 07:34:45 +00:00
|
|
|
Range* input_range = value()->range();
|
|
|
|
if (from().IsInteger32() &&
|
|
|
|
to().IsTagged() &&
|
|
|
|
input_range != NULL && input_range->IsInSmiRange()) {
|
|
|
|
set_type(HType::Smi());
|
|
|
|
}
|
|
|
|
Range* result = (input_range != NULL)
|
2012-02-28 15:32:58 +00:00
|
|
|
? input_range->Copy(zone)
|
|
|
|
: HValue::InferRange(zone);
|
2011-08-23 07:34:45 +00:00
|
|
|
if (to().IsInteger32()) result->set_can_be_minus_zero(false);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HConstant::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (has_int32_value_) {
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* result = new(zone) Range(int32_value_, int32_value_);
|
2011-07-29 09:14:00 +00:00
|
|
|
result->set_can_be_minus_zero(false);
|
|
|
|
return result;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HPhi::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (representation().IsInteger32()) {
|
|
|
|
if (block()->IsLoopHeader()) {
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* range = new(zone) Range(kMinInt, kMaxInt);
|
2011-07-29 09:14:00 +00:00
|
|
|
return range;
|
2010-12-07 11:31:57 +00:00
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* range = OperandAt(0)->range()->Copy(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
for (int i = 1; i < OperandCount(); ++i) {
|
|
|
|
range->Union(OperandAt(i)->range());
|
|
|
|
}
|
|
|
|
return range;
|
|
|
|
}
|
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HAdd::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (representation().IsInteger32()) {
|
|
|
|
Range* a = left()->range();
|
|
|
|
Range* b = right()->range();
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* res = a->Copy(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
if (!res->AddAndCheckOverflow(b)) {
|
|
|
|
ClearFlag(kCanOverflow);
|
|
|
|
}
|
|
|
|
bool m0 = a->CanBeMinusZero() && b->CanBeMinusZero();
|
|
|
|
res->set_can_be_minus_zero(m0);
|
|
|
|
return res;
|
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HSub::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (representation().IsInteger32()) {
|
|
|
|
Range* a = left()->range();
|
|
|
|
Range* b = right()->range();
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* res = a->Copy(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
if (!res->SubAndCheckOverflow(b)) {
|
|
|
|
ClearFlag(kCanOverflow);
|
|
|
|
}
|
|
|
|
res->set_can_be_minus_zero(a->CanBeMinusZero() && b->CanBeZero());
|
|
|
|
return res;
|
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HMul::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (representation().IsInteger32()) {
|
|
|
|
Range* a = left()->range();
|
|
|
|
Range* b = right()->range();
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* res = a->Copy(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
if (!res->MulAndCheckOverflow(b)) {
|
|
|
|
ClearFlag(kCanOverflow);
|
|
|
|
}
|
|
|
|
bool m0 = (a->CanBeZero() && b->CanBeNegative()) ||
|
|
|
|
(a->CanBeNegative() && b->CanBeZero());
|
|
|
|
res->set_can_be_minus_zero(m0);
|
|
|
|
return res;
|
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HDiv::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (representation().IsInteger32()) {
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* result = new(zone) Range();
|
2010-12-07 11:31:57 +00:00
|
|
|
if (left()->range()->CanBeMinusZero()) {
|
|
|
|
result->set_can_be_minus_zero(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (left()->range()->CanBeZero() && right()->range()->CanBeNegative()) {
|
|
|
|
result->set_can_be_minus_zero(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (right()->range()->Includes(-1) && left()->range()->Includes(kMinInt)) {
|
|
|
|
SetFlag(HValue::kCanOverflow);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!right()->range()->CanBeZero()) {
|
|
|
|
ClearFlag(HValue::kCanBeDivByZero);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HMod::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (representation().IsInteger32()) {
|
|
|
|
Range* a = left()->range();
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* result = new(zone) Range();
|
2010-12-07 11:31:57 +00:00
|
|
|
if (a->CanBeMinusZero() || a->CanBeNegative()) {
|
|
|
|
result->set_can_be_minus_zero(true);
|
|
|
|
}
|
|
|
|
if (!right()->range()->CanBeZero()) {
|
|
|
|
ClearFlag(HValue::kCanBeDivByZero);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
} else {
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HPhi::PrintTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add("[");
|
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
|
|
|
HValue* value = OperandAt(i);
|
|
|
|
stream->Add(" ");
|
|
|
|
value->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
}
|
2011-09-01 14:59:47 +00:00
|
|
|
stream->Add(" uses%d_%di_%dd_%dt",
|
2011-04-20 10:38:08 +00:00
|
|
|
UseCount(),
|
2010-12-07 11:31:57 +00:00
|
|
|
int32_non_phi_uses() + int32_indirect_uses(),
|
|
|
|
double_non_phi_uses() + double_indirect_uses(),
|
|
|
|
tagged_non_phi_uses() + tagged_indirect_uses());
|
2011-09-01 14:59:47 +00:00
|
|
|
stream->Add("%s%s]",
|
|
|
|
is_live() ? "_live" : "",
|
|
|
|
IsConvertibleToInteger() ? "" : "_ncti");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HPhi::AddInput(HValue* value) {
|
|
|
|
inputs_.Add(NULL);
|
|
|
|
SetOperandAt(OperandCount() - 1, value);
|
|
|
|
// Mark phis that may have 'arguments' directly or indirectly as an operand.
|
|
|
|
if (!CheckFlag(kIsArguments) && value->CheckFlag(kIsArguments)) {
|
|
|
|
SetFlag(kIsArguments);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-08 10:04:23 +00:00
|
|
|
bool HPhi::HasRealUses() {
|
2011-04-20 10:38:08 +00:00
|
|
|
for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
|
|
|
|
if (!it.value()->IsPhi()) return true;
|
2011-03-08 10:04:23 +00:00
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 13:27:36 +00:00
|
|
|
HValue* HPhi::GetRedundantReplacement() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HValue* candidate = NULL;
|
|
|
|
int count = OperandCount();
|
|
|
|
int position = 0;
|
|
|
|
while (position < count && candidate == NULL) {
|
|
|
|
HValue* current = OperandAt(position++);
|
|
|
|
if (current != this) candidate = current;
|
|
|
|
}
|
|
|
|
while (position < count) {
|
|
|
|
HValue* current = OperandAt(position++);
|
|
|
|
if (current != this && current != candidate) return NULL;
|
|
|
|
}
|
|
|
|
ASSERT(candidate != this);
|
|
|
|
return candidate;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HPhi::DeleteFromGraph() {
|
|
|
|
ASSERT(block() != NULL);
|
|
|
|
block()->RemovePhi(this);
|
|
|
|
ASSERT(block() == NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HPhi::InitRealUses(int phi_id) {
|
|
|
|
// Initialize real uses.
|
|
|
|
phi_id_ = phi_id;
|
2011-04-20 10:38:08 +00:00
|
|
|
for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
|
|
|
|
HValue* value = it.value();
|
|
|
|
if (!value->IsPhi()) {
|
|
|
|
Representation rep = value->RequiredInputRepresentation(it.index());
|
2012-02-01 08:49:18 +00:00
|
|
|
non_phi_uses_[rep.kind()] += value->LoopWeight();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HPhi::AddNonPhiUsesFrom(HPhi* other) {
|
|
|
|
for (int i = 0; i < Representation::kNumRepresentations; i++) {
|
|
|
|
indirect_uses_[i] += other->non_phi_uses_[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HPhi::AddIndirectUsesTo(int* dest) {
|
|
|
|
for (int i = 0; i < Representation::kNumRepresentations; i++) {
|
|
|
|
dest[i] += indirect_uses_[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HSimulate::PrintDataTo(StringStream* stream) {
|
2011-10-20 12:55:31 +00:00
|
|
|
stream->Add("id=%d", ast_id());
|
|
|
|
if (pop_count_ > 0) stream->Add(" pop %d", pop_count_);
|
2010-12-07 11:31:57 +00:00
|
|
|
if (values_.length() > 0) {
|
|
|
|
if (pop_count_ > 0) stream->Add(" /");
|
|
|
|
for (int i = 0; i < values_.length(); ++i) {
|
2011-10-20 12:55:31 +00:00
|
|
|
if (i > 0) stream->Add(",");
|
|
|
|
if (HasAssignedIndexAt(i)) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add(" var[%d] = ", GetAssignedIndexAt(i));
|
2011-10-20 12:55:31 +00:00
|
|
|
} else {
|
|
|
|
stream->Add(" push ");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
values_[i]->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-06 14:57:25 +00:00
|
|
|
void HDeoptimize::PrintDataTo(StringStream* stream) {
|
|
|
|
if (OperandCount() == 0) return;
|
|
|
|
OperandAt(0)->PrintNameTo(stream);
|
|
|
|
for (int i = 1; i < OperandCount(); ++i) {
|
|
|
|
stream->Add(" ");
|
|
|
|
OperandAt(i)->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HEnterInlined::PrintDataTo(StringStream* stream) {
|
2011-09-09 22:39:47 +00:00
|
|
|
SmartArrayPointer<char> name = function()->debug_name()->ToCString();
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add("%s, id=%d", *name, function()->id());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HConstant::HConstant(Handle<Object> handle, Representation r)
|
|
|
|
: handle_(handle),
|
|
|
|
has_int32_value_(false),
|
|
|
|
has_double_value_(false),
|
2011-04-15 06:04:50 +00:00
|
|
|
int32_value_(0),
|
2010-12-07 11:31:57 +00:00
|
|
|
double_value_(0) {
|
|
|
|
set_representation(r);
|
|
|
|
SetFlag(kUseGVN);
|
|
|
|
if (handle_->IsNumber()) {
|
|
|
|
double n = handle_->Number();
|
2011-01-17 13:51:59 +00:00
|
|
|
double roundtrip_value = static_cast<double>(static_cast<int32_t>(n));
|
|
|
|
has_int32_value_ = BitCast<int64_t>(roundtrip_value) == BitCast<int64_t>(n);
|
2010-12-07 11:31:57 +00:00
|
|
|
if (has_int32_value_) int32_value_ = static_cast<int32_t>(n);
|
|
|
|
double_value_ = n;
|
|
|
|
has_double_value_ = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HConstant* HConstant::CopyToRepresentation(Representation r) const {
|
|
|
|
if (r.IsInteger32() && !has_int32_value_) return NULL;
|
|
|
|
if (r.IsDouble() && !has_double_value_) return NULL;
|
|
|
|
return new HConstant(handle_, r);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HConstant* HConstant::CopyToTruncatedInt32() const {
|
|
|
|
if (!has_double_value_) return NULL;
|
|
|
|
int32_t truncated = NumberToInt32(*handle_);
|
2011-03-18 20:35:07 +00:00
|
|
|
return new HConstant(FACTORY->NewNumberFromInt(truncated),
|
2010-12-07 11:31:57 +00:00
|
|
|
Representation::Integer32());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-08 06:54:50 +00:00
|
|
|
bool HConstant::ToBoolean() const {
|
|
|
|
// Converts the constant's boolean value according to
|
|
|
|
// ECMAScript section 9.2 ToBoolean conversion.
|
|
|
|
if (HasInteger32Value()) return Integer32Value() != 0;
|
|
|
|
if (HasDoubleValue()) {
|
|
|
|
double v = DoubleValue();
|
|
|
|
return v != 0 && !isnan(v);
|
|
|
|
}
|
|
|
|
if (handle()->IsTrue()) return true;
|
|
|
|
if (handle()->IsFalse()) return false;
|
|
|
|
if (handle()->IsUndefined()) return false;
|
|
|
|
if (handle()->IsNull()) return false;
|
|
|
|
if (handle()->IsString() &&
|
|
|
|
String::cast(*handle())->length() == 0) return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HConstant::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
handle()->ShortPrint(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool HArrayLiteral::IsCopyOnWrite() const {
|
2011-12-14 13:01:27 +00:00
|
|
|
if (!boilerplate_object_->IsJSObject()) return false;
|
|
|
|
return Handle<JSObject>::cast(boilerplate_object_)->elements()->map() ==
|
|
|
|
HEAP->fixed_cow_array_map();
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HBinaryOperation::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
left()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
right()->PrintNameTo(stream);
|
|
|
|
if (CheckFlag(kCanOverflow)) stream->Add(" !");
|
|
|
|
if (CheckFlag(kBailoutOnMinusZero)) stream->Add(" -0?");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HBitwise::InferRange(Zone* zone) {
|
|
|
|
if (op() == Token::BIT_XOR) return HValue::InferRange(zone);
|
2012-03-08 18:27:39 +00:00
|
|
|
const int32_t kDefaultMask = static_cast<int32_t>(0xffffffff);
|
2011-03-04 12:09:54 +00:00
|
|
|
int32_t left_mask = (left()->range() != NULL)
|
|
|
|
? left()->range()->Mask()
|
2012-03-08 18:27:39 +00:00
|
|
|
: kDefaultMask;
|
2011-03-04 12:09:54 +00:00
|
|
|
int32_t right_mask = (right()->range() != NULL)
|
|
|
|
? right()->range()->Mask()
|
2012-03-08 18:27:39 +00:00
|
|
|
: kDefaultMask;
|
2011-10-31 13:06:26 +00:00
|
|
|
int32_t result_mask = (op() == Token::BIT_AND)
|
|
|
|
? left_mask & right_mask
|
|
|
|
: left_mask | right_mask;
|
2011-03-04 12:09:54 +00:00
|
|
|
return (result_mask >= 0)
|
2012-02-28 15:32:58 +00:00
|
|
|
? new(zone) Range(0, result_mask)
|
|
|
|
: HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HSar::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (right()->IsConstant()) {
|
|
|
|
HConstant* c = HConstant::cast(right());
|
|
|
|
if (c->HasInteger32Value()) {
|
2011-03-04 12:09:54 +00:00
|
|
|
Range* result = (left()->range() != NULL)
|
2012-02-28 15:32:58 +00:00
|
|
|
? left()->range()->Copy(zone)
|
|
|
|
: new(zone) Range();
|
2011-03-04 12:09:54 +00:00
|
|
|
result->Sar(c->Integer32Value());
|
2011-08-23 07:34:45 +00:00
|
|
|
result->set_can_be_minus_zero(false);
|
2010-12-07 11:31:57 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HShr::InferRange(Zone* zone) {
|
2011-07-25 13:28:35 +00:00
|
|
|
if (right()->IsConstant()) {
|
|
|
|
HConstant* c = HConstant::cast(right());
|
|
|
|
if (c->HasInteger32Value()) {
|
|
|
|
int shift_count = c->Integer32Value() & 0x1f;
|
|
|
|
if (left()->range()->CanBeNegative()) {
|
|
|
|
// Only compute bounds if the result always fits into an int32.
|
|
|
|
return (shift_count >= 1)
|
2012-02-28 15:32:58 +00:00
|
|
|
? new(zone) Range(0,
|
|
|
|
static_cast<uint32_t>(0xffffffff) >> shift_count)
|
|
|
|
: new(zone) Range();
|
2011-07-25 13:28:35 +00:00
|
|
|
} else {
|
|
|
|
// For positive inputs we can use the >> operator.
|
|
|
|
Range* result = (left()->range() != NULL)
|
2012-02-28 15:32:58 +00:00
|
|
|
? left()->range()->Copy(zone)
|
|
|
|
: new(zone) Range();
|
2011-07-25 13:28:35 +00:00
|
|
|
result->Sar(c->Integer32Value());
|
2011-08-23 07:34:45 +00:00
|
|
|
result->set_can_be_minus_zero(false);
|
2011-07-25 13:28:35 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2011-07-25 13:28:35 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HShl::InferRange(Zone* zone) {
|
2010-12-07 11:31:57 +00:00
|
|
|
if (right()->IsConstant()) {
|
|
|
|
HConstant* c = HConstant::cast(right());
|
|
|
|
if (c->HasInteger32Value()) {
|
2011-03-04 12:09:54 +00:00
|
|
|
Range* result = (left()->range() != NULL)
|
2012-02-28 15:32:58 +00:00
|
|
|
? left()->range()->Copy(zone)
|
|
|
|
: new(zone) Range();
|
2011-03-04 12:09:54 +00:00
|
|
|
result->Shl(c->Integer32Value());
|
2011-08-23 07:34:45 +00:00
|
|
|
result->set_can_be_minus_zero(false);
|
2010-12-07 11:31:57 +00:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
}
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 15:32:58 +00:00
|
|
|
Range* HLoadKeyedSpecializedArrayElement::InferRange(Zone* zone) {
|
2012-01-23 18:11:36 +00:00
|
|
|
switch (elements_kind()) {
|
|
|
|
case EXTERNAL_PIXEL_ELEMENTS:
|
2012-02-28 15:32:58 +00:00
|
|
|
return new(zone) Range(0, 255);
|
2012-01-23 18:11:36 +00:00
|
|
|
case EXTERNAL_BYTE_ELEMENTS:
|
2012-02-28 15:32:58 +00:00
|
|
|
return new(zone) Range(-128, 127);
|
2012-01-23 18:11:36 +00:00
|
|
|
case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
|
2012-02-28 15:32:58 +00:00
|
|
|
return new(zone) Range(0, 255);
|
2012-01-23 18:11:36 +00:00
|
|
|
case EXTERNAL_SHORT_ELEMENTS:
|
2012-02-28 15:32:58 +00:00
|
|
|
return new(zone) Range(-32768, 32767);
|
2012-01-23 18:11:36 +00:00
|
|
|
case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
|
2012-02-28 15:32:58 +00:00
|
|
|
return new(zone) Range(0, 65535);
|
2012-01-23 18:11:36 +00:00
|
|
|
default:
|
2012-02-28 15:32:58 +00:00
|
|
|
return HValue::InferRange(zone);
|
2012-01-23 18:11:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
|
2011-06-30 14:19:52 +00:00
|
|
|
void HCompareGeneric::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add(Token::Name(token()));
|
|
|
|
stream->Add(" ");
|
|
|
|
HBinaryOperation::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-17 13:57:55 +00:00
|
|
|
void HStringCompareAndBranch::PrintDataTo(StringStream* stream) {
|
|
|
|
stream->Add(Token::Name(token()));
|
|
|
|
stream->Add(" ");
|
|
|
|
HControlInstruction::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-30 14:19:52 +00:00
|
|
|
void HCompareIDAndBranch::PrintDataTo(StringStream* stream) {
|
|
|
|
stream->Add(Token::Name(token()));
|
|
|
|
stream->Add(" ");
|
|
|
|
left()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
right()->PrintNameTo(stream);
|
2011-09-12 09:57:11 +00:00
|
|
|
HControlInstruction::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-23 11:51:05 +00:00
|
|
|
void HCompareObjectEqAndBranch::PrintDataTo(StringStream* stream) {
|
|
|
|
left()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
right()->PrintNameTo(stream);
|
|
|
|
HControlInstruction::PrintDataTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-12 09:57:11 +00:00
|
|
|
void HGoto::PrintDataTo(StringStream* stream) {
|
|
|
|
stream->Add("B%d", SuccessorAt(0)->block_id());
|
2011-06-30 14:19:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HCompareIDAndBranch::SetInputRepresentation(Representation r) {
|
2010-12-07 11:31:57 +00:00
|
|
|
input_representation_ = r;
|
2011-06-30 14:19:52 +00:00
|
|
|
if (r.IsDouble()) {
|
2012-03-02 13:40:14 +00:00
|
|
|
// According to the ES5 spec (11.9.3, 11.8.5), Equality comparisons (==, ===
|
|
|
|
// and !=) have special handling of undefined, e.g. undefined == undefined
|
|
|
|
// is 'true'. Relational comparisons have a different semantic, first
|
|
|
|
// calling ToPrimitive() on their arguments. The standard Crankshaft
|
|
|
|
// tagged-to-double conversion to ensure the HCompareIDAndBranch's inputs
|
|
|
|
// are doubles caused 'undefined' to be converted to NaN. That's compatible
|
|
|
|
// out-of-the box with ordered relational comparisons (<, >, <=,
|
|
|
|
// >=). However, for equality comparisons (and for 'in' and 'instanceof'),
|
|
|
|
// it is not consistent with the spec. For example, it would cause undefined
|
|
|
|
// == undefined (should be true) to be evaluated as NaN == NaN
|
|
|
|
// (false). Therefore, any comparisons other than ordered relational
|
|
|
|
// comparisons must cause a deopt when one of their arguments is undefined.
|
|
|
|
// See also v8:1434
|
|
|
|
if (!Token::IsOrderedRelationalCompareOp(token_)) {
|
|
|
|
SetFlag(kDeoptimizeOnUndefined);
|
|
|
|
}
|
2010-12-07 11:31:57 +00:00
|
|
|
} else {
|
2011-06-30 14:19:52 +00:00
|
|
|
ASSERT(r.IsInteger32());
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HParameter::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add("%u", index());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HLoadNamedField::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add(" @%d%s", offset(), is_in_object() ? "[in-object]" : "");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-04 14:13:08 +00:00
|
|
|
HLoadNamedFieldPolymorphic::HLoadNamedFieldPolymorphic(HValue* context,
|
|
|
|
HValue* object,
|
2011-08-22 14:23:37 +00:00
|
|
|
SmallMapList* types,
|
2011-03-24 10:11:51 +00:00
|
|
|
Handle<String> name)
|
2011-07-04 14:13:08 +00:00
|
|
|
: types_(Min(types->length(), kMaxLoadPolymorphism)),
|
2011-03-24 10:11:51 +00:00
|
|
|
name_(name),
|
|
|
|
need_generic_(false) {
|
2011-07-04 14:13:08 +00:00
|
|
|
SetOperandAt(0, context);
|
|
|
|
SetOperandAt(1, object);
|
2011-03-24 10:11:51 +00:00
|
|
|
set_representation(Representation::Tagged());
|
2012-01-20 14:08:20 +00:00
|
|
|
SetGVNFlag(kDependsOnMaps);
|
2011-03-24 10:11:51 +00:00
|
|
|
for (int i = 0;
|
|
|
|
i < types->length() && types_.length() < kMaxLoadPolymorphism;
|
|
|
|
++i) {
|
|
|
|
Handle<Map> map = types->at(i);
|
2011-10-18 11:18:55 +00:00
|
|
|
LookupResult lookup(map->GetIsolate());
|
2011-03-24 10:11:51 +00:00
|
|
|
map->LookupInDescriptors(NULL, *name, &lookup);
|
2012-01-23 12:01:47 +00:00
|
|
|
if (lookup.IsFound()) {
|
2011-05-05 09:22:09 +00:00
|
|
|
switch (lookup.type()) {
|
|
|
|
case FIELD: {
|
|
|
|
int index = lookup.GetLocalFieldIndexFromMap(*map);
|
|
|
|
if (index < 0) {
|
2012-01-20 14:08:20 +00:00
|
|
|
SetGVNFlag(kDependsOnInobjectFields);
|
2011-05-05 09:22:09 +00:00
|
|
|
} else {
|
2012-01-20 14:08:20 +00:00
|
|
|
SetGVNFlag(kDependsOnBackingStoreFields);
|
2011-05-05 09:22:09 +00:00
|
|
|
}
|
|
|
|
types_.Add(types->at(i));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case CONSTANT_FUNCTION:
|
|
|
|
types_.Add(types->at(i));
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
2011-03-24 10:11:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (types_.length() == types->length() && FLAG_deoptimize_uncommon_cases) {
|
|
|
|
SetFlag(kUseGVN);
|
|
|
|
} else {
|
|
|
|
SetAllSideEffects();
|
|
|
|
need_generic_ = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool HLoadNamedFieldPolymorphic::DataEquals(HValue* value) {
|
|
|
|
HLoadNamedFieldPolymorphic* other = HLoadNamedFieldPolymorphic::cast(value);
|
|
|
|
if (types_.length() != other->types()->length()) return false;
|
|
|
|
if (!name_.is_identical_to(other->name())) return false;
|
|
|
|
if (need_generic_ != other->need_generic_) return false;
|
|
|
|
for (int i = 0; i < types_.length(); i++) {
|
|
|
|
bool found = false;
|
|
|
|
for (int j = 0; j < types_.length(); j++) {
|
|
|
|
if (types_.at(j).is_identical_to(other->types()->at(i))) {
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-08-12 10:13:40 +00:00
|
|
|
void HLoadNamedFieldPolymorphic::PrintDataTo(StringStream* stream) {
|
|
|
|
object()->PrintNameTo(stream);
|
2011-10-20 12:55:31 +00:00
|
|
|
stream->Add(".");
|
2011-08-12 10:13:40 +00:00
|
|
|
stream->Add(*String::cast(*name())->ToCString());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void HLoadNamedGeneric::PrintDataTo(StringStream* stream) {
|
|
|
|
object()->PrintNameTo(stream);
|
2011-10-20 12:55:31 +00:00
|
|
|
stream->Add(".");
|
2011-08-12 10:13:40 +00:00
|
|
|
stream->Add(*String::cast(*name())->ToCString());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-23 11:19:50 +00:00
|
|
|
void HLoadKeyedFastElement::PrintDataTo(StringStream* stream) {
|
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("]");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-09-27 13:03:19 +00:00
|
|
|
bool HLoadKeyedFastElement::RequiresHoleCheck() {
|
2012-02-22 12:47:42 +00:00
|
|
|
if (hole_check_mode_ == OMIT_HOLE_CHECK) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2011-05-09 15:21:40 +00:00
|
|
|
for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
|
|
|
|
HValue* use = it.value();
|
|
|
|
if (!use->IsChange()) return true;
|
|
|
|
}
|
2012-02-22 12:47:42 +00:00
|
|
|
|
2011-05-09 15:21:40 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-19 13:04:00 +00:00
|
|
|
void HLoadKeyedFastDoubleElement::PrintDataTo(StringStream* stream) {
|
|
|
|
elements()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("]");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-23 11:19:50 +00:00
|
|
|
void HLoadKeyedGeneric::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("]");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-22 12:47:42 +00:00
|
|
|
HValue* HLoadKeyedGeneric::Canonicalize() {
|
|
|
|
// Recognize generic keyed loads that use property name generated
|
|
|
|
// by for-in statement as a key and rewrite them into fast property load
|
|
|
|
// by index.
|
|
|
|
if (key()->IsLoadKeyedFastElement()) {
|
|
|
|
HLoadKeyedFastElement* key_load = HLoadKeyedFastElement::cast(key());
|
|
|
|
if (key_load->object()->IsForInCacheArray()) {
|
|
|
|
HForInCacheArray* names_cache =
|
|
|
|
HForInCacheArray::cast(key_load->object());
|
|
|
|
|
|
|
|
if (names_cache->enumerable() == object()) {
|
|
|
|
HForInCacheArray* index_cache =
|
|
|
|
names_cache->index_cache();
|
|
|
|
HCheckMapValue* map_check =
|
|
|
|
new(block()->zone()) HCheckMapValue(object(), names_cache->map());
|
|
|
|
HInstruction* index = new(block()->zone()) HLoadKeyedFastElement(
|
|
|
|
index_cache,
|
|
|
|
key_load->key(),
|
|
|
|
HLoadKeyedFastElement::OMIT_HOLE_CHECK);
|
|
|
|
HLoadFieldByIndex* load = new(block()->zone()) HLoadFieldByIndex(
|
|
|
|
object(), index);
|
|
|
|
map_check->InsertBefore(this);
|
|
|
|
index->InsertBefore(this);
|
|
|
|
load->InsertBefore(this);
|
|
|
|
return load;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-24 22:14:15 +00:00
|
|
|
void HLoadKeyedSpecializedArrayElement::PrintDataTo(
|
|
|
|
StringStream* stream) {
|
2011-02-10 12:02:36 +00:00
|
|
|
external_pointer()->PrintNameTo(stream);
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add(".");
|
2011-06-09 15:19:37 +00:00
|
|
|
switch (elements_kind()) {
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_BYTE_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("byte");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("u_byte");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_SHORT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("short");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("u_short");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_INT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("int");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_UNSIGNED_INT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("u_int");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_FLOAT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("float");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_DOUBLE_ELEMENTS:
|
2011-04-21 07:15:43 +00:00
|
|
|
stream->Add("double");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_PIXEL_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("pixel");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case FAST_ELEMENTS:
|
2011-09-22 11:30:04 +00:00
|
|
|
case FAST_SMI_ONLY_ELEMENTS:
|
2011-09-09 09:35:57 +00:00
|
|
|
case FAST_DOUBLE_ELEMENTS:
|
|
|
|
case DICTIONARY_ELEMENTS:
|
|
|
|
case NON_STRICT_ARGUMENTS_ELEMENTS:
|
2011-06-09 15:19:37 +00:00
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
2011-03-24 22:14:15 +00:00
|
|
|
}
|
2011-02-10 12:02:36 +00:00
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("]");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-23 11:19:50 +00:00
|
|
|
void HStoreNamedGeneric::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add(".");
|
|
|
|
ASSERT(name()->IsString());
|
|
|
|
stream->Add(*String::cast(*name())->ToCString());
|
|
|
|
stream->Add(" = ");
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HStoreNamedField::PrintDataTo(StringStream* stream) {
|
2011-02-23 11:19:50 +00:00
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add(".");
|
|
|
|
stream->Add(*String::cast(*name())->ToCString());
|
|
|
|
stream->Add(" = ");
|
|
|
|
value()->PrintNameTo(stream);
|
2011-10-20 12:55:31 +00:00
|
|
|
stream->Add(" @%d%s", offset(), is_in_object() ? "[in-object]" : "");
|
2010-12-07 11:31:57 +00:00
|
|
|
if (!transition().is_null()) {
|
|
|
|
stream->Add(" (transition map %p)", *transition());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-23 11:19:50 +00:00
|
|
|
void HStoreKeyedFastElement::PrintDataTo(StringStream* stream) {
|
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("] = ");
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-07-19 13:04:00 +00:00
|
|
|
void HStoreKeyedFastDoubleElement::PrintDataTo(StringStream* stream) {
|
|
|
|
elements()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("] = ");
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-23 11:19:50 +00:00
|
|
|
void HStoreKeyedGeneric::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("] = ");
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-03-24 22:14:15 +00:00
|
|
|
void HStoreKeyedSpecializedArrayElement::PrintDataTo(
|
|
|
|
StringStream* stream) {
|
2011-02-16 13:31:12 +00:00
|
|
|
external_pointer()->PrintNameTo(stream);
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add(".");
|
2011-06-09 15:19:37 +00:00
|
|
|
switch (elements_kind()) {
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_BYTE_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("byte");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_UNSIGNED_BYTE_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("u_byte");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_SHORT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("short");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_UNSIGNED_SHORT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("u_short");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_INT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("int");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_UNSIGNED_INT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("u_int");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_FLOAT_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("float");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_DOUBLE_ELEMENTS:
|
2011-04-21 07:15:43 +00:00
|
|
|
stream->Add("double");
|
|
|
|
break;
|
2011-09-09 09:35:57 +00:00
|
|
|
case EXTERNAL_PIXEL_ELEMENTS:
|
2011-03-24 22:14:15 +00:00
|
|
|
stream->Add("pixel");
|
|
|
|
break;
|
2011-09-22 11:30:04 +00:00
|
|
|
case FAST_SMI_ONLY_ELEMENTS:
|
2011-09-09 09:35:57 +00:00
|
|
|
case FAST_ELEMENTS:
|
|
|
|
case FAST_DOUBLE_ELEMENTS:
|
|
|
|
case DICTIONARY_ELEMENTS:
|
|
|
|
case NON_STRICT_ARGUMENTS_ELEMENTS:
|
2011-06-09 15:19:37 +00:00
|
|
|
UNREACHABLE();
|
|
|
|
break;
|
2011-03-24 22:14:15 +00:00
|
|
|
}
|
2011-02-16 13:31:12 +00:00
|
|
|
stream->Add("[");
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add("] = ");
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-19 12:10:18 +00:00
|
|
|
void HTransitionElementsKind::PrintDataTo(StringStream* stream) {
|
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
stream->Add(" %p -> %p", *original_map(), *transitioned_map());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-01 11:54:04 +00:00
|
|
|
void HLoadGlobalCell::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add("[%p]", *cell());
|
2011-09-27 13:03:19 +00:00
|
|
|
if (!details_.IsDontDelete()) stream->Add(" (deleteable)");
|
|
|
|
if (details_.IsReadOnly()) stream->Add(" (read-only)");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
bool HLoadGlobalCell::RequiresHoleCheck() {
|
|
|
|
if (details_.IsDontDelete() && !details_.IsReadOnly()) return false;
|
|
|
|
for (HUseIterator it(uses()); !it.Done(); it.Advance()) {
|
|
|
|
HValue* use = it.value();
|
|
|
|
if (!use->IsChange()) return true;
|
|
|
|
}
|
|
|
|
return false;
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-01 11:54:04 +00:00
|
|
|
void HLoadGlobalGeneric::PrintDataTo(StringStream* stream) {
|
|
|
|
stream->Add("%o ", *name());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-04 15:03:34 +00:00
|
|
|
void HStoreGlobalCell::PrintDataTo(StringStream* stream) {
|
2010-12-07 11:31:57 +00:00
|
|
|
stream->Add("[%p] = ", *cell());
|
|
|
|
value()->PrintNameTo(stream);
|
2011-09-27 13:03:19 +00:00
|
|
|
if (!details_.IsDontDelete()) stream->Add(" (deleteable)");
|
|
|
|
if (details_.IsReadOnly()) stream->Add(" (read-only)");
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-04-04 15:03:34 +00:00
|
|
|
void HStoreGlobalGeneric::PrintDataTo(StringStream* stream) {
|
|
|
|
stream->Add("%o = ", *name());
|
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HLoadContextSlot::PrintDataTo(StringStream* stream) {
|
2011-02-03 13:10:28 +00:00
|
|
|
value()->PrintNameTo(stream);
|
|
|
|
stream->Add("[%d]", slot_index());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
void HStoreContextSlot::PrintDataTo(StringStream* stream) {
|
2011-02-03 13:10:28 +00:00
|
|
|
context()->PrintNameTo(stream);
|
|
|
|
stream->Add("[%d] = ", slot_index());
|
|
|
|
value()->PrintNameTo(stream);
|
2011-01-17 08:11:03 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
// Implementation of type inference and type conversions. Calculates
|
|
|
|
// the inferred type of this instruction based on the input operands.
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HValue::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return type_;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-23 16:37:54 +00:00
|
|
|
HType HCheckMaps::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return value()->type();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HCheckFunction::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return value()->type();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HCheckNonSmi::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
// TODO(kasperl): Is there any way to signal that this isn't a smi?
|
|
|
|
return HType::Tagged();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HCheckSmi::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return HType::Smi();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HPhi::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HType result = HType::Uninitialized();
|
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
|
|
|
HType current = OperandAt(i)->type();
|
|
|
|
result = result.Combine(current);
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HConstant::CalculateInferredType() {
|
2011-04-15 06:04:50 +00:00
|
|
|
return HType::TypeFromValue(handle_);
|
2010-12-07 11:31:57 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-30 14:19:52 +00:00
|
|
|
HType HCompareGeneric::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return HType::Boolean();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-06-15 09:20:24 +00:00
|
|
|
HType HInstanceOf::CalculateInferredType() {
|
|
|
|
return HType::Boolean();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HType HDeleteProperty::CalculateInferredType() {
|
|
|
|
return HType::Boolean();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HType HInstanceOfKnownGlobal::CalculateInferredType() {
|
|
|
|
return HType::Boolean();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-14 07:45:18 +00:00
|
|
|
HType HChange::CalculateInferredType() {
|
|
|
|
if (from().IsDouble() && to().IsTagged()) return HType::HeapNumber();
|
|
|
|
return type();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HBitwiseBinaryOperation::CalculateInferredType() {
|
2011-01-20 12:47:22 +00:00
|
|
|
return HType::TaggedNumber();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HArithmeticBinaryOperation::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return HType::TaggedNumber();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HAdd::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return HType::Tagged();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HBitNot::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return HType::TaggedNumber();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-02-21 12:05:17 +00:00
|
|
|
HType HUnaryMathOperation::CalculateInferredType() {
|
2010-12-07 11:31:57 +00:00
|
|
|
return HType::TaggedNumber();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-14 07:45:18 +00:00
|
|
|
HType HStringCharFromCode::CalculateInferredType() {
|
|
|
|
return HType::String();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-28 09:05:55 +00:00
|
|
|
HType HAllocateObject::CalculateInferredType() {
|
|
|
|
return HType::JSObject();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-16 17:32:30 +00:00
|
|
|
HType HFastLiteral::CalculateInferredType() {
|
|
|
|
// TODO(mstarzinger): Be smarter, could also be JSArray here.
|
|
|
|
return HType::JSObject();
|
2011-10-14 07:45:18 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-16 17:32:30 +00:00
|
|
|
HType HArrayLiteral::CalculateInferredType() {
|
|
|
|
return HType::JSArray();
|
2011-11-24 13:42:52 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-02-16 17:32:30 +00:00
|
|
|
HType HObjectLiteral::CalculateInferredType() {
|
2011-10-14 07:45:18 +00:00
|
|
|
return HType::JSObject();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HType HRegExpLiteral::CalculateInferredType() {
|
|
|
|
return HType::JSObject();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HType HFunctionLiteral::CalculateInferredType() {
|
|
|
|
return HType::JSObject();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
HValue* HUnaryMathOperation::EnsureAndPropagateNotMinusZero(
|
|
|
|
BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
if (representation().IsInteger32() &&
|
|
|
|
!value()->representation().IsInteger32()) {
|
|
|
|
if (value()->range() == NULL || value()->range()->CanBeMinusZero()) {
|
|
|
|
SetFlag(kBailoutOnMinusZero);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (RequiredInputRepresentation(0).IsInteger32() &&
|
|
|
|
representation().IsInteger32()) {
|
|
|
|
return value();
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HChange::EnsureAndPropagateNotMinusZero(BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
if (from().IsInteger32()) return NULL;
|
|
|
|
if (CanTruncateToInt32()) return NULL;
|
|
|
|
if (value()->range() == NULL || value()->range()->CanBeMinusZero()) {
|
|
|
|
SetFlag(kBailoutOnMinusZero);
|
|
|
|
}
|
|
|
|
ASSERT(!from().IsInteger32() || !to().IsInteger32());
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-05-17 11:41:59 +00:00
|
|
|
HValue* HForceRepresentation::EnsureAndPropagateNotMinusZero(
|
|
|
|
BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
return value();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
HValue* HMod::EnsureAndPropagateNotMinusZero(BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
if (range() == NULL || range()->CanBeMinusZero()) {
|
|
|
|
SetFlag(kBailoutOnMinusZero);
|
|
|
|
return left();
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HDiv::EnsureAndPropagateNotMinusZero(BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
if (range() == NULL || range()->CanBeMinusZero()) {
|
|
|
|
SetFlag(kBailoutOnMinusZero);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HMul::EnsureAndPropagateNotMinusZero(BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
if (range() == NULL || range()->CanBeMinusZero()) {
|
|
|
|
SetFlag(kBailoutOnMinusZero);
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HSub::EnsureAndPropagateNotMinusZero(BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
// Propagate to the left argument. If the left argument cannot be -0, then
|
|
|
|
// the result of the add operation cannot be either.
|
|
|
|
if (range() == NULL || range()->CanBeMinusZero()) {
|
|
|
|
return left();
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HValue* HAdd::EnsureAndPropagateNotMinusZero(BitVector* visited) {
|
|
|
|
visited->Add(id());
|
|
|
|
// Propagate to the left argument. If the left argument cannot be -0, then
|
|
|
|
// the result of the sub operation cannot be either.
|
|
|
|
if (range() == NULL || range()->CanBeMinusZero()) {
|
|
|
|
return left();
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-11-21 10:18:47 +00:00
|
|
|
#define H_CONSTANT_INT32(val) \
|
|
|
|
new(zone) HConstant(FACTORY->NewNumberFromInt(val, TENURED), \
|
|
|
|
Representation::Integer32())
|
|
|
|
#define H_CONSTANT_DOUBLE(val) \
|
|
|
|
new(zone) HConstant(FACTORY->NewNumber(val, TENURED), \
|
|
|
|
Representation::Double())
|
|
|
|
|
|
|
|
#define DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HInstr, op) \
|
|
|
|
HInstruction* HInstr::New##HInstr(Zone* zone, \
|
|
|
|
HValue* context, \
|
|
|
|
HValue* left, \
|
|
|
|
HValue* right) { \
|
|
|
|
if (left->IsConstant() && right->IsConstant()) { \
|
|
|
|
HConstant* c_left = HConstant::cast(left); \
|
|
|
|
HConstant* c_right = HConstant::cast(right); \
|
|
|
|
if ((c_left->HasNumberValue() && c_right->HasNumberValue())) { \
|
|
|
|
double double_res = c_left->DoubleValue() op c_right->DoubleValue(); \
|
|
|
|
if (TypeInfo::IsInt32Double(double_res)) { \
|
|
|
|
return H_CONSTANT_INT32(static_cast<int32_t>(double_res)); \
|
|
|
|
} \
|
|
|
|
return H_CONSTANT_DOUBLE(double_res); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
return new(zone) HInstr(context, left, right); \
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HAdd, +)
|
|
|
|
DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HMul, *)
|
|
|
|
DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR(HSub, -)
|
|
|
|
|
|
|
|
#undef DEFINE_NEW_H_SIMPLE_ARITHMETIC_INSTR
|
|
|
|
|
|
|
|
|
|
|
|
HInstruction* HMod::NewHMod(Zone* zone,
|
|
|
|
HValue* context,
|
|
|
|
HValue* left,
|
|
|
|
HValue* right) {
|
|
|
|
if (left->IsConstant() && right->IsConstant()) {
|
|
|
|
HConstant* c_left = HConstant::cast(left);
|
|
|
|
HConstant* c_right = HConstant::cast(right);
|
|
|
|
if (c_left->HasInteger32Value() && c_right->HasInteger32Value()) {
|
|
|
|
int32_t dividend = c_left->Integer32Value();
|
|
|
|
int32_t divisor = c_right->Integer32Value();
|
|
|
|
if (divisor != 0) {
|
|
|
|
int32_t res = dividend % divisor;
|
|
|
|
if ((res == 0) && (dividend < 0)) {
|
|
|
|
return H_CONSTANT_DOUBLE(-0.0);
|
|
|
|
}
|
|
|
|
return H_CONSTANT_INT32(res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return new(zone) HMod(context, left, right);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HInstruction* HDiv::NewHDiv(Zone* zone,
|
|
|
|
HValue* context,
|
|
|
|
HValue* left,
|
|
|
|
HValue* right) {
|
|
|
|
// If left and right are constant values, try to return a constant value.
|
|
|
|
if (left->IsConstant() && right->IsConstant()) {
|
|
|
|
HConstant* c_left = HConstant::cast(left);
|
|
|
|
HConstant* c_right = HConstant::cast(right);
|
|
|
|
if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
|
|
|
|
if (c_right->DoubleValue() != 0) {
|
|
|
|
double double_res = c_left->DoubleValue() / c_right->DoubleValue();
|
|
|
|
if (TypeInfo::IsInt32Double(double_res)) {
|
|
|
|
return H_CONSTANT_INT32(static_cast<int32_t>(double_res));
|
|
|
|
}
|
|
|
|
return H_CONSTANT_DOUBLE(double_res);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return new(zone) HDiv(context, left, right);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HInstruction* HBitwise::NewHBitwise(Zone* zone,
|
|
|
|
Token::Value op,
|
|
|
|
HValue* context,
|
|
|
|
HValue* left,
|
|
|
|
HValue* right) {
|
|
|
|
if (left->IsConstant() && right->IsConstant()) {
|
|
|
|
HConstant* c_left = HConstant::cast(left);
|
|
|
|
HConstant* c_right = HConstant::cast(right);
|
|
|
|
if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
|
|
|
|
int32_t result;
|
|
|
|
int32_t v_left = c_left->NumberValueAsInteger32();
|
|
|
|
int32_t v_right = c_right->NumberValueAsInteger32();
|
|
|
|
switch (op) {
|
|
|
|
case Token::BIT_XOR:
|
|
|
|
result = v_left ^ v_right;
|
|
|
|
break;
|
|
|
|
case Token::BIT_AND:
|
|
|
|
result = v_left & v_right;
|
|
|
|
break;
|
|
|
|
case Token::BIT_OR:
|
|
|
|
result = v_left | v_right;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
result = 0; // Please the compiler.
|
|
|
|
UNREACHABLE();
|
|
|
|
}
|
|
|
|
return H_CONSTANT_INT32(result);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return new(zone) HBitwise(op, context, left, right);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#define DEFINE_NEW_H_BITWISE_INSTR(HInstr, result) \
|
|
|
|
HInstruction* HInstr::New##HInstr(Zone* zone, \
|
|
|
|
HValue* context, \
|
|
|
|
HValue* left, \
|
|
|
|
HValue* right) { \
|
|
|
|
if (left->IsConstant() && right->IsConstant()) { \
|
|
|
|
HConstant* c_left = HConstant::cast(left); \
|
|
|
|
HConstant* c_right = HConstant::cast(right); \
|
|
|
|
if ((c_left->HasNumberValue() && c_right->HasNumberValue())) { \
|
|
|
|
return H_CONSTANT_INT32(result); \
|
|
|
|
} \
|
|
|
|
} \
|
|
|
|
return new(zone) HInstr(context, left, right); \
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
DEFINE_NEW_H_BITWISE_INSTR(HSar,
|
|
|
|
c_left->NumberValueAsInteger32() >> (c_right->NumberValueAsInteger32() & 0x1f))
|
|
|
|
DEFINE_NEW_H_BITWISE_INSTR(HShl,
|
|
|
|
c_left->NumberValueAsInteger32() << (c_right->NumberValueAsInteger32() & 0x1f))
|
|
|
|
|
|
|
|
#undef DEFINE_NEW_H_BITWISE_INSTR
|
|
|
|
|
|
|
|
|
|
|
|
HInstruction* HShr::NewHShr(Zone* zone,
|
|
|
|
HValue* context,
|
|
|
|
HValue* left,
|
|
|
|
HValue* right) {
|
|
|
|
if (left->IsConstant() && right->IsConstant()) {
|
|
|
|
HConstant* c_left = HConstant::cast(left);
|
|
|
|
HConstant* c_right = HConstant::cast(right);
|
|
|
|
if ((c_left->HasNumberValue() && c_right->HasNumberValue())) {
|
|
|
|
int32_t left_val = c_left->NumberValueAsInteger32();
|
|
|
|
int32_t right_val = c_right->NumberValueAsInteger32() & 0x1f;
|
|
|
|
if ((right_val == 0) && (left_val < 0)) {
|
|
|
|
return H_CONSTANT_DOUBLE(
|
|
|
|
static_cast<double>(static_cast<uint32_t>(left_val)));
|
|
|
|
}
|
|
|
|
return H_CONSTANT_INT32(static_cast<uint32_t>(left_val) >> right_val);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return new(zone) HShr(context, left, right);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#undef H_CONSTANT_INT32
|
|
|
|
#undef H_CONSTANT_DOUBLE
|
|
|
|
|
|
|
|
|
2011-04-26 15:22:44 +00:00
|
|
|
void HIn::PrintDataTo(StringStream* stream) {
|
|
|
|
key()->PrintNameTo(stream);
|
|
|
|
stream->Add(" ");
|
|
|
|
object()->PrintNameTo(stream);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-03-14 12:59:49 +00:00
|
|
|
Representation HPhi::InferredRepresentation() {
|
|
|
|
bool double_occurred = false;
|
|
|
|
bool int32_occurred = false;
|
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
|
|
|
HValue* value = OperandAt(i);
|
2012-03-15 12:21:29 +00:00
|
|
|
if (value->IsUnknownOSRValue()) {
|
|
|
|
HPhi* hint_value = HUnknownOSRValue::cast(value)->incoming_value();
|
|
|
|
if (hint_value != NULL) {
|
|
|
|
Representation hint = hint_value->representation();
|
|
|
|
if (hint.IsDouble()) double_occurred = true;
|
|
|
|
if (hint.IsInteger32()) int32_occurred = true;
|
|
|
|
}
|
|
|
|
continue;
|
|
|
|
}
|
2012-03-14 12:59:49 +00:00
|
|
|
if (value->representation().IsDouble()) double_occurred = true;
|
|
|
|
if (value->representation().IsInteger32()) int32_occurred = true;
|
|
|
|
if (value->representation().IsTagged()) {
|
|
|
|
if (value->IsConstant()) {
|
|
|
|
HConstant* constant = HConstant::cast(value);
|
|
|
|
if (constant->IsConvertibleToInteger()) {
|
|
|
|
int32_occurred = true;
|
|
|
|
} else if (constant->HasNumberValue()) {
|
|
|
|
double_occurred = true;
|
|
|
|
} else {
|
|
|
|
return Representation::Tagged();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
return Representation::Tagged();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (double_occurred) return Representation::Double();
|
|
|
|
|
|
|
|
if (int32_occurred) return Representation::Integer32();
|
|
|
|
|
|
|
|
return Representation::None();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-12-07 11:31:57 +00:00
|
|
|
// Node-specific verification code is only included in debug mode.
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
2011-01-26 14:51:21 +00:00
|
|
|
void HPhi::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
ASSERT(OperandCount() == block()->predecessors()->length());
|
|
|
|
for (int i = 0; i < OperandCount(); ++i) {
|
|
|
|
HValue* value = OperandAt(i);
|
|
|
|
HBasicBlock* defining_block = value->block();
|
|
|
|
HBasicBlock* predecessor_block = block()->predecessors()->at(i);
|
|
|
|
ASSERT(defining_block == predecessor_block ||
|
|
|
|
defining_block->Dominates(predecessor_block));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-26 14:51:21 +00:00
|
|
|
void HSimulate::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HInstruction::Verify();
|
|
|
|
ASSERT(HasAstId());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-26 14:51:21 +00:00
|
|
|
void HCheckSmi::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HInstruction::Verify();
|
|
|
|
ASSERT(HasNoUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-26 14:51:21 +00:00
|
|
|
void HCheckNonSmi::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HInstruction::Verify();
|
|
|
|
ASSERT(HasNoUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-26 14:51:21 +00:00
|
|
|
void HCheckFunction::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HInstruction::Verify();
|
|
|
|
ASSERT(HasNoUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-01-26 14:51:21 +00:00
|
|
|
void HCheckPrototypeMaps::Verify() {
|
2010-12-07 11:31:57 +00:00
|
|
|
HInstruction::Verify();
|
|
|
|
ASSERT(HasNoUses());
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
} } // namespace v8::internal
|