// for which the map is known.
if (HasNoUses() && dominator->IsStoreNamedField()) {
HStoreNamedField* store = HStoreNamedField::cast(dominator);
- Handle<Map> map = store->transition();
- if (map.is_null() || store->object() != value()) return;
+ UniqueValueId map_unique_id = store->transition_unique_id();
+ if (!map_unique_id.IsInitialized() || store->object() != value()) return;
for (int i = 0; i < map_set()->length(); i++) {
- if (map.is_identical_to(map_set()->at(i))) {
+ if (map_unique_id == map_unique_ids_.at(i)) {
DeleteAndReplaceWith(NULL);
return;
}
HConstant::HConstant(Handle<Object> handle, Representation r)
: handle_(handle),
+ unique_id_(),
has_int32_value_(false),
has_double_value_(false),
is_internalized_string_(false),
HConstant::HConstant(Handle<Object> handle,
+ UniqueValueId unique_id,
Representation r,
HType type,
bool is_internalize_string,
bool boolean_value)
: handle_(handle),
+ unique_id_(unique_id),
has_int32_value_(false),
has_double_value_(false),
is_internalized_string_(is_internalize_string),
HConstant::HConstant(int32_t integer_value,
Representation r,
Handle<Object> optional_handle)
- : has_int32_value_(true),
+ : handle_(optional_handle),
+ unique_id_(),
+ has_int32_value_(true),
has_double_value_(true),
is_internalized_string_(false),
boolean_value_(integer_value != 0),
HConstant::HConstant(double double_value,
Representation r,
Handle<Object> optional_handle)
- : has_int32_value_(IsInteger32(double_value)),
+ : handle_(optional_handle),
+ unique_id_(),
+ has_int32_value_(IsInteger32(double_value)),
has_double_value_(true),
is_internalized_string_(false),
boolean_value_(double_value != 0 && !isnan(double_value)),
if (has_int32_value_) return new(zone) HConstant(int32_value_, r, handle_);
if (has_double_value_) return new(zone) HConstant(double_value_, r, handle_);
ASSERT(!handle_.is_null());
- return new(zone) HConstant(
- handle_, r, type_from_value_, is_internalized_string_, boolean_value_);
+ return new(zone) HConstant(handle_,
+ unique_id_,
+ r,
+ type_from_value_,
+ is_internalized_string_,
+ boolean_value_);
}
Zone* zone)
: types_(Min(types->length(), kMaxLoadPolymorphism), zone),
name_(name),
+ types_unique_ids_(0, zone),
+ name_unique_id_(),
need_generic_(false) {
SetOperandAt(0, context);
SetOperandAt(1, object);
}
+void HCheckMaps::FinalizeUniqueValueId() {
+ if (!map_unique_ids_.is_empty()) return;
+ Zone* zone = block()->zone();
+ map_unique_ids_.Initialize(map_set_.length(), zone);
+ for (int i = 0; i < map_set_.length(); i++) {
+ map_unique_ids_.Add(UniqueValueId(map_set_.at(i)), zone);
+ }
+}
+
+
+void HLoadNamedFieldPolymorphic::FinalizeUniqueValueId() {
+ if (!types_unique_ids_.is_empty()) return;
+ Zone* zone = block()->zone();
+ types_unique_ids_.Initialize(types_.length(), zone);
+ for (int i = 0; i < types_.length(); i++) {
+ types_unique_ids_.Add(UniqueValueId(types_.at(i)), zone);
+ }
+ name_unique_id_ = UniqueValueId(name_);
+}
+
+
bool HLoadNamedFieldPolymorphic::DataEquals(HValue* value) {
+ ASSERT_EQ(types_.length(), types_unique_ids_.length());
HLoadNamedFieldPolymorphic* other = HLoadNamedFieldPolymorphic::cast(value);
- if (types_.length() != other->types()->length()) return false;
- if (!name_.is_identical_to(other->name())) return false;
+ if (name_unique_id_ != other->name_unique_id_) return false;
+ if (types_unique_ids_.length() != other->types_unique_ids_.length()) {
+ return false;
+ }
if (need_generic_ != other->need_generic_) return false;
- for (int i = 0; i < types_.length(); i++) {
+ for (int i = 0; i < types_unique_ids_.length(); i++) {
bool found = false;
- for (int j = 0; j < types_.length(); j++) {
- if (types_.at(j).is_identical_to(other->types()->at(i))) {
+ for (int j = 0; j < types_unique_ids_.length(); j++) {
+ if (types_unique_ids_.at(j) == other->types_unique_ids_.at(i)) {
found = true;
break;
}
virtual Opcode opcode() const { return HValue::k##type; }
-#ifdef DEBUG
-#define ASSERT_ALLOCATION_DISABLED \
- ASSERT(isolate()->optimizing_compiler_thread()->IsOptimizerThread() || \
- !isolate()->heap()->IsAllocationAllowed())
-#else
-#define ASSERT_ALLOCATION_DISABLED do {} while (0)
-#endif
-
class Range: public ZoneObject {
public:
Range()
};
+class UniqueValueId {
+ public:
+ UniqueValueId() : raw_address_(NULL) { }
+
+ explicit UniqueValueId(Object* object) {
+ raw_address_ = reinterpret_cast<Address>(object);
+ ASSERT(IsInitialized());
+ }
+
+ explicit UniqueValueId(Handle<Object> handle) {
+ static const Address kEmptyHandleSentinel = reinterpret_cast<Address>(1);
+ if (handle.is_null()) {
+ raw_address_ = kEmptyHandleSentinel;
+ } else {
+ raw_address_ = reinterpret_cast<Address>(*handle);
+ ASSERT_NE(kEmptyHandleSentinel, raw_address_);
+ }
+ ASSERT(IsInitialized());
+ }
+
+ bool IsInitialized() const { return raw_address_ != NULL; }
+
+ bool operator==(const UniqueValueId& other) const {
+ ASSERT(IsInitialized() && other.IsInitialized());
+ return raw_address_ == other.raw_address_;
+ }
+
+ bool operator!=(const UniqueValueId& other) const {
+ ASSERT(IsInitialized() && other.IsInitialized());
+ return raw_address_ != other.raw_address_;
+ }
+
+ intptr_t Hashcode() const {
+ ASSERT(IsInitialized());
+ return reinterpret_cast<intptr_t>(raw_address_);
+ }
+
+ private:
+ Address raw_address_;
+};
+
+
class HType {
public:
HType() : type_(kUninitialized) { }
bool Equals(HValue* other);
virtual intptr_t Hashcode();
+ // Compute unique ids upfront that is safe wrt GC and parallel recompilation.
+ virtual void FinalizeUniqueValueId() { }
+
// Printing support.
virtual void PrintTo(StringStream* stream) = 0;
void PrintNameTo(StringStream* stream);
class HCheckMaps: public HTemplateInstruction<2> {
public:
HCheckMaps(HValue* value, Handle<Map> map, Zone* zone,
- HValue* typecheck = NULL) {
+ HValue* typecheck = NULL)
+ : map_unique_ids_(0, zone) {
SetOperandAt(0, value);
// If callers don't depend on a typecheck, they can pass in NULL. In that
// case we use a copy of the |value| argument as a dummy value.
SetGVNFlag(kDependsOnElementsKind);
map_set()->Add(map, zone);
}
- HCheckMaps(HValue* value, SmallMapList* maps, Zone* zone) {
+ HCheckMaps(HValue* value, SmallMapList* maps, Zone* zone)
+ : map_unique_ids_(0, zone) {
SetOperandAt(0, value);
SetOperandAt(1, value);
set_representation(Representation::Tagged());
HValue* value() { return OperandAt(0); }
SmallMapList* map_set() { return &map_set_; }
+ virtual void FinalizeUniqueValueId();
+
DECLARE_CONCRETE_INSTRUCTION(CheckMaps)
protected:
virtual bool DataEquals(HValue* other) {
+ ASSERT_EQ(map_set_.length(), map_unique_ids_.length());
HCheckMaps* b = HCheckMaps::cast(other);
// Relies on the fact that map_set has been sorted before.
- if (map_set()->length() != b->map_set()->length()) return false;
- for (int i = 0; i < map_set()->length(); i++) {
- if (!map_set()->at(i).is_identical_to(b->map_set()->at(i))) return false;
+ if (map_unique_ids_.length() != b->map_unique_ids_.length()) {
+ return false;
+ }
+ for (int i = 0; i < map_unique_ids_.length(); i++) {
+ if (map_unique_ids_.at(i) != b->map_unique_ids_.at(i)) {
+ return false;
+ }
}
return true;
}
private:
SmallMapList map_set_;
+ ZoneList<UniqueValueId> map_unique_ids_;
};
class HCheckFunction: public HUnaryOperation {
public:
HCheckFunction(HValue* value, Handle<JSFunction> function)
- : HUnaryOperation(value), target_(function) {
+ : HUnaryOperation(value), target_(function), target_unique_id_() {
set_representation(Representation::Tagged());
SetFlag(kUseGVN);
target_in_new_space_ = Isolate::Current()->heap()->InNewSpace(*function);
virtual void Verify();
#endif
+ virtual void FinalizeUniqueValueId() {
+ target_unique_id_ = UniqueValueId(target_);
+ }
+
Handle<JSFunction> target() const { return target_; }
bool target_in_new_space() const { return target_in_new_space_; }
protected:
virtual bool DataEquals(HValue* other) {
HCheckFunction* b = HCheckFunction::cast(other);
- return target_.is_identical_to(b->target());
+ return target_unique_id_ == b->target_unique_id_;
}
private:
Handle<JSFunction> target_;
+ UniqueValueId target_unique_id_;
bool target_in_new_space_;
};
public:
HCheckPrototypeMaps(Handle<JSObject> prototype,
Handle<JSObject> holder,
- Zone* zone) : prototypes_(2, zone), maps_(2, zone) {
+ Zone* zone)
+ : prototypes_(2, zone),
+ maps_(2, zone),
+ first_prototype_unique_id_(),
+ last_prototype_unique_id_() {
SetFlag(kUseGVN);
SetGVNFlag(kDependsOnMaps);
// Keep a list of all objects on the prototype chain up to the holder
virtual void PrintDataTo(StringStream* stream);
virtual intptr_t Hashcode() {
- ASSERT_ALLOCATION_DISABLED;
- // Dereferencing to use the object's raw address for hashing is safe.
- HandleDereferenceGuard allow_handle_deref(isolate(),
- HandleDereferenceGuard::ALLOW);
- SLOW_ASSERT(Heap::RelocationLock::IsLocked(isolate()->heap()) ||
- !isolate()->optimizing_compiler_thread()->IsOptimizerThread());
- intptr_t hash = 0;
- for (int i = 0; i < prototypes_.length(); i++) {
- hash = 17 * hash + reinterpret_cast<intptr_t>(*prototypes_[i]);
- hash = 17 * hash + reinterpret_cast<intptr_t>(*maps_[i]);
- }
- return hash;
+ return first_prototype_unique_id_.Hashcode() * 17 +
+ last_prototype_unique_id_.Hashcode();
+ }
+
+ virtual void FinalizeUniqueValueId() {
+ first_prototype_unique_id_ = UniqueValueId(prototypes_.first());
+ last_prototype_unique_id_ = UniqueValueId(prototypes_.last());
}
bool CanOmitPrototypeChecks() {
protected:
virtual bool DataEquals(HValue* other) {
HCheckPrototypeMaps* b = HCheckPrototypeMaps::cast(other);
-#ifdef DEBUG
- if (prototypes_.length() != b->prototypes()->length()) return false;
- for (int i = 0; i < prototypes_.length(); i++) {
- if (!prototypes_[i].is_identical_to(b->prototypes()->at(i))) return false;
- if (!maps_[i].is_identical_to(b->maps()->at(i))) return false;
- }
- return true;
-#else
- return prototypes_.first().is_identical_to(b->prototypes()->first()) &&
- prototypes_.last().is_identical_to(b->prototypes()->last());
-#endif // DEBUG
+ return first_prototype_unique_id_ == b->first_prototype_unique_id_ &&
+ last_prototype_unique_id_ == b->last_prototype_unique_id_;
}
private:
ZoneList<Handle<JSObject> > prototypes_;
ZoneList<Handle<Map> > maps_;
+ UniqueValueId first_prototype_unique_id_;
+ UniqueValueId last_prototype_unique_id_;
};
Representation r,
Handle<Object> optional_handle = Handle<Object>::null());
HConstant(Handle<Object> handle,
+ UniqueValueId unique_id,
Representation r,
HType type,
bool is_internalized_string,
return handle_;
}
- bool InOldSpace() const { return !HEAP->InNewSpace(*handle_); }
-
bool IsSpecialDouble() const {
return has_double_value_ &&
(BitCast<int64_t>(double_value_) == BitCast<int64_t>(-0.0) ||
}
ASSERT(!handle_.is_null());
+ HandleDereferenceGuard allow_dereference_for_immovable_check(
+ isolate(), HandleDereferenceGuard::ALLOW);
Heap* heap = isolate()->heap();
- // We should have handled minus_zero_value and nan_value in the
- // has_double_value_ clause above.
- // Dereferencing is safe to compare against immovable singletons.
- HandleDereferenceGuard allow_handle_deref(isolate(),
- HandleDereferenceGuard::ALLOW);
- ASSERT(*handle_ != heap->minus_zero_value());
- ASSERT(*handle_ != heap->nan_value());
- return *handle_ == heap->undefined_value() ||
- *handle_ == heap->null_value() ||
- *handle_ == heap->true_value() ||
- *handle_ == heap->false_value() ||
- *handle_ == heap->the_hole_value() ||
- *handle_ == heap->empty_string();
+ ASSERT(unique_id_ != UniqueValueId(heap->minus_zero_value()));
+ ASSERT(unique_id_ != UniqueValueId(heap->nan_value()));
+ return unique_id_ == UniqueValueId(heap->undefined_value()) ||
+ unique_id_ == UniqueValueId(heap->null_value()) ||
+ unique_id_ == UniqueValueId(heap->true_value()) ||
+ unique_id_ == UniqueValueId(heap->false_value()) ||
+ unique_id_ == UniqueValueId(heap->the_hole_value()) ||
+ unique_id_ == UniqueValueId(heap->empty_string());
}
virtual Representation RequiredInputRepresentation(int index) {
}
virtual intptr_t Hashcode() {
- ASSERT_ALLOCATION_DISABLED;
- intptr_t hash;
-
if (has_int32_value_) {
- hash = static_cast<intptr_t>(int32_value_);
+ return static_cast<intptr_t>(int32_value_);
} else if (has_double_value_) {
- hash = static_cast<intptr_t>(BitCast<int64_t>(double_value_));
+ return static_cast<intptr_t>(BitCast<int64_t>(double_value_));
} else {
ASSERT(!handle_.is_null());
- // Dereferencing to use the object's raw address for hashing is safe.
- HandleDereferenceGuard allow_handle_deref(isolate(),
- HandleDereferenceGuard::ALLOW);
- SLOW_ASSERT(Heap::RelocationLock::IsLocked(isolate()->heap()) ||
- !isolate()->optimizing_compiler_thread()->IsOptimizerThread());
- hash = reinterpret_cast<intptr_t>(*handle_);
+ return unique_id_.Hashcode();
}
+ }
- return hash;
+ virtual void FinalizeUniqueValueId() {
+ if (!has_double_value_) {
+ ASSERT(!handle_.is_null());
+ unique_id_ = UniqueValueId(handle_);
+ }
}
#ifdef DEBUG
} else {
ASSERT(!handle_.is_null());
return !other_constant->handle_.is_null() &&
- handle_.is_identical_to(other_constant->handle_);
+ unique_id_ == other_constant->unique_id_;
}
}
// constant is non-numeric, handle_ always points to a valid
// constant HeapObject.
Handle<Object> handle_;
+ UniqueValueId unique_id_;
// We store the HConstant in the most specific form safely possible.
// The two flags, has_int32_value_ and has_double_value_ tell us if
class HLoadGlobalCell: public HTemplateInstruction<0> {
public:
HLoadGlobalCell(Handle<JSGlobalPropertyCell> cell, PropertyDetails details)
- : cell_(cell), details_(details) {
+ : cell_(cell), details_(details), unique_id_() {
set_representation(Representation::Tagged());
SetFlag(kUseGVN);
SetGVNFlag(kDependsOnGlobalVars);
virtual void PrintDataTo(StringStream* stream);
virtual intptr_t Hashcode() {
- ASSERT_ALLOCATION_DISABLED;
- // Dereferencing to use the object's raw address for hashing is safe.
- HandleDereferenceGuard allow_handle_deref(isolate(),
- HandleDereferenceGuard::ALLOW);
- SLOW_ASSERT(Heap::RelocationLock::IsLocked(isolate()->heap()) ||
- !isolate()->optimizing_compiler_thread()->IsOptimizerThread());
- return reinterpret_cast<intptr_t>(*cell_);
+ return unique_id_.Hashcode();
+ }
+
+ virtual void FinalizeUniqueValueId() {
+ unique_id_ = UniqueValueId(cell_);
}
virtual Representation RequiredInputRepresentation(int index) {
protected:
virtual bool DataEquals(HValue* other) {
HLoadGlobalCell* b = HLoadGlobalCell::cast(other);
- return cell_.is_identical_to(b->cell());
+ return unique_id_ == b->unique_id_;
}
private:
Handle<JSGlobalPropertyCell> cell_;
PropertyDetails details_;
+ UniqueValueId unique_id_;
};
static const int kMaxLoadPolymorphism = 4;
+ virtual void FinalizeUniqueValueId();
+
protected:
virtual bool DataEquals(HValue* value);
private:
SmallMapList types_;
Handle<String> name_;
+ ZoneList<UniqueValueId> types_unique_ids_;
+ UniqueValueId name_unique_id_;
bool need_generic_;
};
: name_(name),
is_in_object_(in_object),
offset_(offset),
+ transition_unique_id_(),
new_space_dominator_(NULL) {
SetOperandAt(0, obj);
SetOperandAt(1, val);
bool is_in_object() const { return is_in_object_; }
int offset() const { return offset_; }
Handle<Map> transition() const { return transition_; }
+ UniqueValueId transition_unique_id() const { return transition_unique_id_; }
void set_transition(Handle<Map> map) { transition_ = map; }
HValue* new_space_dominator() const { return new_space_dominator_; }
return ReceiverObjectNeedsWriteBarrier(object(), new_space_dominator());
}
+ virtual void FinalizeUniqueValueId() {
+ transition_unique_id_ = UniqueValueId(transition_);
+ }
+
private:
Handle<String> name_;
bool is_in_object_;
int offset_;
Handle<Map> transition_;
+ UniqueValueId transition_unique_id_;
HValue* new_space_dominator_;
};
Handle<Map> transitioned_map)
: original_map_(original_map),
transitioned_map_(transitioned_map),
+ original_map_unique_id_(),
+ transitioned_map_unique_id_(),
from_kind_(original_map->elements_kind()),
to_kind_(transitioned_map->elements_kind()) {
SetOperandAt(0, object);
virtual void PrintDataTo(StringStream* stream);
+ virtual void FinalizeUniqueValueId() {
+ original_map_unique_id_ = UniqueValueId(original_map_);
+ transitioned_map_unique_id_ = UniqueValueId(transitioned_map_);
+ }
+
DECLARE_CONCRETE_INSTRUCTION(TransitionElementsKind)
protected:
virtual bool DataEquals(HValue* other) {
HTransitionElementsKind* instr = HTransitionElementsKind::cast(other);
- return original_map_.is_identical_to(instr->original_map()) &&
- transitioned_map_.is_identical_to(instr->transitioned_map());
+ return original_map_unique_id_ == instr->original_map_unique_id_ &&
+ transitioned_map_unique_id_ == instr->transitioned_map_unique_id_;
}
private:
Handle<Map> original_map_;
Handle<Map> transitioned_map_;
+ UniqueValueId original_map_unique_id_;
+ UniqueValueId transitioned_map_unique_id_;
ElementsKind from_kind_;
ElementsKind to_kind_;
};
projects / platform / upstream / v8.git / commitdiff