"src/codegen.h",
"src/compilation-cache.cc",
"src/compilation-cache.h",
- "src/compilation-dependencies.cc",
- "src/compilation-dependencies.h",
"src/compilation-statistics.cc",
"src/compilation-statistics.h",
"src/compiler/access-builder.cc",
+++ /dev/null
-// Copyright 2015 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "src/factory.h"
-#include "src/handles-inl.h"
-#include "src/isolate.h"
-#include "src/objects-inl.h"
-#include "src/zone.h"
-
-#include "src/compilation-dependencies.h"
-
-namespace v8 {
-namespace internal {
-
-DependentCode* CompilationDependencies::Get(Handle<Object> object) {
- if (object->IsMap()) {
- return Handle<Map>::cast(object)->dependent_code();
- } else if (object->IsPropertyCell()) {
- return Handle<PropertyCell>::cast(object)->dependent_code();
- } else if (object->IsAllocationSite()) {
- return Handle<AllocationSite>::cast(object)->dependent_code();
- }
- UNREACHABLE();
- return nullptr;
-}
-
-
-void CompilationDependencies::Set(Handle<Object> object,
- Handle<DependentCode> dep) {
- if (object->IsMap()) {
- Handle<Map>::cast(object)->set_dependent_code(*dep);
- } else if (object->IsPropertyCell()) {
- Handle<PropertyCell>::cast(object)->set_dependent_code(*dep);
- } else if (object->IsAllocationSite()) {
- Handle<AllocationSite>::cast(object)->set_dependent_code(*dep);
- } else {
- UNREACHABLE();
- }
-}
-
-
-void CompilationDependencies::Insert(DependentCode::DependencyGroup group,
- Handle<HeapObject> object) {
- if (groups_[group] == nullptr) {
- groups_[group] = new (zone_) ZoneList<Handle<HeapObject>>(2, zone_);
- }
- groups_[group]->Add(object, zone_);
-
- if (object_wrapper_.is_null()) {
- // Allocate the wrapper if necessary.
- object_wrapper_ =
- isolate_->factory()->NewForeign(reinterpret_cast<Address>(this));
- }
-
- // Get the old dependent code list.
- Handle<DependentCode> old_dependent_code =
- Handle<DependentCode>(Get(object), isolate_);
- Handle<DependentCode> new_dependent_code =
- DependentCode::InsertCompilationDependencies(old_dependent_code, group,
- object_wrapper_);
-
- // Set the new dependent code list if the head of the list changed.
- if (!new_dependent_code.is_identical_to(old_dependent_code)) {
- Set(object, new_dependent_code);
- }
-}
-
-
-void CompilationDependencies::Commit(Handle<Code> code) {
- if (IsEmpty()) return;
-
- DCHECK(!object_wrapper_.is_null());
- Handle<WeakCell> cell = Code::WeakCellFor(code);
- AllowDeferredHandleDereference get_wrapper;
- for (int i = 0; i < DependentCode::kGroupCount; i++) {
- ZoneList<Handle<HeapObject>>* group_objects = groups_[i];
- if (group_objects == nullptr) continue;
- DependentCode::DependencyGroup group =
- static_cast<DependentCode::DependencyGroup>(i);
- for (int j = 0; j < group_objects->length(); j++) {
- DependentCode* dependent_code = Get(group_objects->at(j));
- dependent_code->UpdateToFinishedCode(group, *object_wrapper_, *cell);
- }
- groups_[i] = nullptr; // Zone-allocated, no need to delete.
- }
-}
-
-
-void CompilationDependencies::Rollback() {
- if (IsEmpty()) return;
-
- AllowDeferredHandleDereference get_wrapper;
- // Unregister from all dependent maps if not yet committed.
- for (int i = 0; i < DependentCode::kGroupCount; i++) {
- ZoneList<Handle<HeapObject>>* group_objects = groups_[i];
- if (group_objects == nullptr) continue;
- DependentCode::DependencyGroup group =
- static_cast<DependentCode::DependencyGroup>(i);
- for (int j = 0; j < group_objects->length(); j++) {
- DependentCode* dependent_code = Get(group_objects->at(j));
- dependent_code->RemoveCompilationDependencies(group, *object_wrapper_);
- }
- groups_[i] = nullptr; // Zone-allocated, no need to delete.
- }
-}
-
-
-void CompilationDependencies::AssumeTransitionStable(
- Handle<AllocationSite> site) {
- // Do nothing if the object doesn't have any useful element transitions left.
- ElementsKind kind =
- site->SitePointsToLiteral()
- ? JSObject::cast(site->transition_info())->GetElementsKind()
- : site->GetElementsKind();
- if (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE) {
- Insert(DependentCode::kAllocationSiteTransitionChangedGroup, site);
- }
-}
-}
-} // namespace v8::internal
+++ /dev/null
-// Copyright 2015 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_DEPENDENCIES_H_
-#define V8_DEPENDENCIES_H_
-
-namespace v8 {
-namespace internal {
-
-// Collects dependencies for this compilation, e.g. assumptions about
-// stable maps, constant globals, etc.
-class CompilationDependencies {
- public:
- CompilationDependencies(Isolate* isolate, Zone* zone)
- : isolate_(isolate),
- zone_(zone),
- object_wrapper_(Handle<Foreign>::null()),
- aborted_(false) {
- std::fill_n(groups_, DependentCode::kGroupCount, nullptr);
- }
-
- void Insert(DependentCode::DependencyGroup group, Handle<HeapObject> handle);
-
- void AssumeInitialMapCantChange(Handle<Map> map) {
- Insert(DependentCode::kInitialMapChangedGroup, map);
- }
- void AssumeElementsCantBeAdded(Handle<Map> map) {
- Insert(DependentCode::kElementsCantBeAddedGroup, map);
- }
- void AssumeFieldType(Handle<Map> map) {
- Insert(DependentCode::kFieldTypeGroup, map);
- }
- void AssumePropertyCell(Handle<PropertyCell> cell) {
- Insert(DependentCode::kPropertyCellChangedGroup, cell);
- }
- void AssumeTenuringDecision(Handle<AllocationSite> site) {
- Insert(DependentCode::kAllocationSiteTenuringChangedGroup, site);
- }
- void AssumeTransitionStable(Handle<AllocationSite> site);
-
- void Commit(Handle<Code> code);
- void Rollback();
- void Abort() { aborted_ = true; }
- bool HasAborted() const { return aborted_; }
-
- bool IsEmpty() const {
- for (int i = 0; i < DependentCode::kGroupCount; i++) {
- if (groups_[i]) return false;
- }
- return true;
- }
-
- private:
- Isolate* isolate_;
- Zone* zone_;
- Handle<Foreign> object_wrapper_;
- bool aborted_;
- ZoneList<Handle<HeapObject> >* groups_[DependentCode::kGroupCount];
-
- DependentCode* Get(Handle<Object> object);
- void Set(Handle<Object> object, Handle<DependentCode> dep);
-};
-}
-} // namespace v8::internal
-
-#endif // V8_DEPENDENCIES_H_
// called when cast as a CompilationInfo.
virtual ~CompilationInfoWithZone() {
DisableFutureOptimization();
- dependencies()->Rollback();
+ RollbackDependencies();
delete parse_info_;
parse_info_ = nullptr;
}
osr_ast_id_(BailoutId::None()),
zone_(zone),
deferred_handles_(nullptr),
- dependencies_(isolate, zone),
bailout_reason_(kNoReason),
prologue_offset_(Code::kPrologueOffsetNotSet),
no_frame_ranges_(isolate->cpu_profiler()->is_profiling()
opt_count_(has_shared_info() ? shared_info()->opt_count() : 0),
parameter_count_(0),
optimization_id_(-1),
- osr_expr_stack_height_(0) {}
+ aborted_due_to_dependency_change_(false),
+ osr_expr_stack_height_(0) {
+ std::fill_n(dependencies_, DependentCode::kGroupCount, nullptr);
+}
CompilationInfo::~CompilationInfo() {
#ifdef DEBUG
// Check that no dependent maps have been added or added dependent maps have
// been rolled back or committed.
- DCHECK(dependencies()->IsEmpty());
+ for (int i = 0; i < DependentCode::kGroupCount; i++) {
+ DCHECK(!dependencies_[i]);
+ }
#endif // DEBUG
}
+void CompilationInfo::CommitDependencies(Handle<Code> code) {
+ bool has_dependencies = false;
+ for (int i = 0; i < DependentCode::kGroupCount; i++) {
+ has_dependencies |=
+ dependencies_[i] != NULL && dependencies_[i]->length() > 0;
+ }
+ // Avoid creating a weak cell for code with no dependencies.
+ if (!has_dependencies) return;
+
+ AllowDeferredHandleDereference get_object_wrapper;
+ WeakCell* cell = *Code::WeakCellFor(code);
+ for (int i = 0; i < DependentCode::kGroupCount; i++) {
+ ZoneList<Handle<HeapObject> >* group_objects = dependencies_[i];
+ if (group_objects == NULL) continue;
+ DCHECK(!object_wrapper_.is_null());
+ for (int j = 0; j < group_objects->length(); j++) {
+ DependentCode::DependencyGroup group =
+ static_cast<DependentCode::DependencyGroup>(i);
+ Foreign* info = *object_wrapper();
+ DependentCode* dependent_code =
+ DependentCode::ForObject(group_objects->at(j), group);
+ dependent_code->UpdateToFinishedCode(group, info, cell);
+ }
+ dependencies_[i] = NULL; // Zone-allocated, no need to delete.
+ }
+}
+
+
+void CompilationInfo::RollbackDependencies() {
+ AllowDeferredHandleDereference get_object_wrapper;
+ // Unregister from all dependent maps if not yet committed.
+ for (int i = 0; i < DependentCode::kGroupCount; i++) {
+ ZoneList<Handle<HeapObject> >* group_objects = dependencies_[i];
+ if (group_objects == NULL) continue;
+ for (int j = 0; j < group_objects->length(); j++) {
+ DependentCode::DependencyGroup group =
+ static_cast<DependentCode::DependencyGroup>(i);
+ Foreign* info = *object_wrapper();
+ DependentCode* dependent_code =
+ DependentCode::ForObject(group_objects->at(j), group);
+ dependent_code->RemoveCompilationInfo(group, info);
+ }
+ dependencies_[i] = NULL; // Zone-allocated, no need to delete.
+ }
+}
+
+
int CompilationInfo::num_parameters() const {
return has_scope() ? scope()->num_parameters() : parameter_count_;
}
if (graph_ == NULL) return SetLastStatus(BAILED_OUT);
- if (info()->dependencies()->HasAborted()) {
+ if (info()->HasAbortedDueToDependencyChange()) {
// Dependency has changed during graph creation. Let's try again later.
return RetryOptimization(kBailedOutDueToDependencyChange);
}
return last_status();
}
- DCHECK(!info()->dependencies()->HasAborted());
+ DCHECK(!info()->HasAbortedDueToDependencyChange());
DisallowCodeDependencyChange no_dependency_change;
DisallowJavascriptExecution no_js(isolate());
{ // Scope for timer.
if (job->last_status() == OptimizedCompileJob::SUCCEEDED) {
if (shared->optimization_disabled()) {
job->RetryOptimization(kOptimizationDisabled);
- } else if (info->dependencies()->HasAborted()) {
+ } else if (info->HasAbortedDueToDependencyChange()) {
job->RetryOptimization(kBailedOutDueToDependencyChange);
} else if (isolate->debug()->has_break_points()) {
job->RetryOptimization(kDebuggerHasBreakPoints);
#include "src/allocation.h"
#include "src/ast.h"
#include "src/bailout-reason.h"
-#include "src/compilation-dependencies.h"
#include "src/zone.h"
namespace v8 {
deferred_handles_ = deferred_handles;
}
+ ZoneList<Handle<HeapObject> >* dependencies(
+ DependentCode::DependencyGroup group) {
+ if (dependencies_[group] == NULL) {
+ dependencies_[group] = new(zone_) ZoneList<Handle<HeapObject> >(2, zone_);
+ }
+ return dependencies_[group];
+ }
+
+ void CommitDependencies(Handle<Code> code);
+
+ void RollbackDependencies();
+
void ReopenHandlesInNewHandleScope() {
unoptimized_code_ = Handle<Code>(*unoptimized_code_);
}
int TraceInlinedFunction(Handle<SharedFunctionInfo> shared,
SourcePosition position, int pareint_id);
- CompilationDependencies* dependencies() { return &dependencies_; }
+ Handle<Foreign> object_wrapper() {
+ if (object_wrapper_.is_null()) {
+ object_wrapper_ =
+ isolate()->factory()->NewForeign(reinterpret_cast<Address>(this));
+ }
+ return object_wrapper_;
+ }
+
+ void AbortDueToDependencyChange() {
+ aborted_due_to_dependency_change_ = true;
+ }
+
+ bool HasAbortedDueToDependencyChange() const {
+ return aborted_due_to_dependency_change_;
+ }
bool HasSameOsrEntry(Handle<JSFunction> function, BailoutId osr_ast_id) {
return osr_ast_id_ == osr_ast_id && function.is_identical_to(closure());
DeferredHandles* deferred_handles_;
- // Dependencies for this compilation, e.g. stable maps.
- CompilationDependencies dependencies_;
+ ZoneList<Handle<HeapObject> >* dependencies_[DependentCode::kGroupCount];
BailoutReason bailout_reason_;
// Number of parameters used for compilation of stubs that require arguments.
int parameter_count_;
+ Handle<Foreign> object_wrapper_;
+
int optimization_id_;
+ // This flag is used by the main thread to track whether this compilation
+ // should be abandoned due to dependency change.
+ bool aborted_due_to_dependency_change_;
+
int osr_expr_stack_height_;
DISALLOW_COPY_AND_ASSIGN(CompilationInfo);
if (type == kUseCell) {
Handle<PropertyCell> cell = it.GetPropertyCell();
- top_info()->dependencies()->AssumePropertyCell(cell);
+ PropertyCell::AddDependentCompilationInfo(cell, top_info());
if (it.property_details().cell_type() == PropertyCellType::kConstant) {
Handle<Object> constant_object(cell->value(), isolate());
if (constant_object->IsConsString()) {
4);
// Register to deopt if the boilerplate ElementsKind changes.
- top_info()->dependencies()->AssumeTransitionStable(site);
+ AllocationSite::RegisterForDeoptOnTransitionChange(site, top_info());
}
// The array is expected in the bailout environment during computation
DCHECK(field_type_.IsHeapObject());
// Add dependency on the map that introduced the field.
- top_info()->dependencies()->AssumeFieldType(GetFieldOwnerFromMap(map));
+ Map::AddDependentCompilationInfo(GetFieldOwnerFromMap(map),
+ DependentCode::kFieldTypeGroup, top_info());
return true;
}
GlobalPropertyAccess type = LookupGlobalProperty(var, &it, STORE);
if (type == kUseCell) {
Handle<PropertyCell> cell = it.GetPropertyCell();
- top_info()->dependencies()->AssumePropertyCell(cell);
+ PropertyCell::AddDependentCompilationInfo(cell, top_info());
if (it.property_details().cell_type() == PropertyCellType::kConstant) {
Handle<Object> constant(cell->value(), isolate());
if (value->IsConstant()) {
HValue* constructor = environment()->ExpressionStackAt(argument_count);
// Register on the site for deoptimization if the transition feedback changes.
- top_info()->dependencies()->AssumeTransitionStable(site);
+ AllocationSite::RegisterForDeoptOnTransitionChange(site, top_info());
ElementsKind kind = site->GetElementsKind();
HInstruction* site_instruction = Add<HConstant>(site);
Handle<AllocationSite> allocation_site = expr->allocation_site();
allocation_mode = HAllocationMode(allocation_site);
// Take a dependency on allocation site.
- top_info()->dependencies()->AssumeTenuringDecision(allocation_site);
+ AllocationSite::RegisterForDeoptOnTenureChange(allocation_site,
+ top_info());
}
}
// Inlining worked, add a dependency on the initial map to make sure that
// this code is deoptimized whenever the initial map of the constructor
// changes.
- top_info()->dependencies()->AssumeInitialMapCantChange(initial_map);
+ Map::AddDependentCompilationInfo(
+ initial_map, DependentCode::kInitialMapChangedGroup, top_info());
return;
}
if (!allocation_mode.feedback_site().is_null()) {
DCHECK(!graph()->info()->IsStub());
Handle<AllocationSite> site(allocation_mode.feedback_site());
- top_info()->dependencies()->AssumeTenuringDecision(site);
+ AllocationSite::RegisterForDeoptOnTenureChange(site, top_info());
}
// Inline the string addition into the stub when creating allocation
Handle<AllocationSite> site(site_context->current());
if (FLAG_allocation_site_pretenuring) {
pretenure_flag = site_context->current()->GetPretenureMode();
- top_info()->dependencies()->AssumeTenuringDecision(site);
+ AllocationSite::RegisterForDeoptOnTenureChange(site, top_info());
}
- top_info()->dependencies()->AssumeTransitionStable(site);
+ AllocationSite::RegisterForDeoptOnTransitionChange(site, top_info());
HInstruction* object = Add<HAllocate>(object_size_constant, type,
pretenure_flag, instance_type, site_context->current());
void MarkDependsOnEmptyArrayProtoElements() {
// Add map dependency if not already added.
if (depends_on_empty_array_proto_elements_) return;
- info()->dependencies()->AssumeElementsCantBeAdded(
- handle(isolate()->initial_object_prototype()->map()));
- info()->dependencies()->AssumeElementsCantBeAdded(
- handle(isolate()->initial_array_prototype()->map()));
+ Map::AddDependentCompilationInfo(
+ handle(isolate()->initial_object_prototype()->map()),
+ DependentCode::kElementsCantBeAddedGroup, info());
+ Map::AddDependentCompilationInfo(
+ handle(isolate()->initial_array_prototype()->map()),
+ DependentCode::kElementsCantBeAddedGroup, info());
depends_on_empty_array_proto_elements_ = true;
}
Map::AddDependentCode(map, DependentCode::kPrototypeCheckGroup, code);
}
- info_->dependencies()->Commit(code);
+ info_->CommitDependencies(code);
RegisterWeakObjectsInOptimizedCode(code);
}
#include "src/bootstrapper.h"
#include "src/code-stubs.h"
#include "src/codegen.h"
-#include "src/compilation-dependencies.h"
#include "src/compiler.h"
#include "src/cpu-profiler.h"
#include "src/date.h"
}
+// static
+void Map::AddDependentCompilationInfo(Handle<Map> map,
+ DependentCode::DependencyGroup group,
+ CompilationInfo* info) {
+ Handle<DependentCode> codes = DependentCode::InsertCompilationInfo(
+ handle(map->dependent_code(), info->isolate()), group,
+ info->object_wrapper());
+ if (*codes != map->dependent_code()) map->set_dependent_code(*codes);
+ info->dependencies(group)->Add(map, info->zone());
+}
+
+
// static
void Map::AddDependentCode(Handle<Map> map,
DependentCode::DependencyGroup group,
}
-Handle<DependentCode> DependentCode::InsertCompilationDependencies(
+DependentCode* DependentCode::ForObject(Handle<HeapObject> object,
+ DependencyGroup group) {
+ AllowDeferredHandleDereference dependencies_are_safe;
+ if (group == DependentCode::kPropertyCellChangedGroup) {
+ return Handle<PropertyCell>::cast(object)->dependent_code();
+ } else if (group == DependentCode::kAllocationSiteTenuringChangedGroup ||
+ group == DependentCode::kAllocationSiteTransitionChangedGroup) {
+ return Handle<AllocationSite>::cast(object)->dependent_code();
+ }
+ return Handle<Map>::cast(object)->dependent_code();
+}
+
+
+Handle<DependentCode> DependentCode::InsertCompilationInfo(
Handle<DependentCode> entries, DependencyGroup group,
Handle<Foreign> info) {
return Insert(entries, group, info);
}
-void DependentCode::RemoveCompilationDependencies(
- DependentCode::DependencyGroup group, Foreign* info) {
+void DependentCode::RemoveCompilationInfo(DependentCode::DependencyGroup group,
+ Foreign* info) {
DisallowHeapAllocation no_allocation;
GroupStartIndexes starts(this);
int start = starts.at(group);
}
} else {
DCHECK(obj->IsForeign());
- CompilationDependencies* info =
- reinterpret_cast<CompilationDependencies*>(
- Foreign::cast(obj)->foreign_address());
- info->Abort();
+ CompilationInfo* info = reinterpret_cast<CompilationInfo*>(
+ Foreign::cast(obj)->foreign_address());
+ info->AbortDueToDependencyChange();
}
}
// Compact the array by moving all subsequent groups to fill in the new holes.
}
+// static
+void AllocationSite::RegisterForDeoptOnTenureChange(Handle<AllocationSite> site,
+ CompilationInfo* info) {
+ AddDependentCompilationInfo(
+ site, DependentCode::kAllocationSiteTenuringChangedGroup, info);
+}
+
+
+// static
+void AllocationSite::RegisterForDeoptOnTransitionChange(
+ Handle<AllocationSite> site, CompilationInfo* info) {
+ // Do nothing if the object doesn't have any useful element transitions left.
+ ElementsKind kind =
+ site->SitePointsToLiteral()
+ ? JSObject::cast(site->transition_info())->GetElementsKind()
+ : site->GetElementsKind();
+ if (AllocationSite::GetMode(kind) == TRACK_ALLOCATION_SITE) {
+ AddDependentCompilationInfo(
+ site, DependentCode::kAllocationSiteTransitionChangedGroup, info);
+ }
+}
+
+
+// static
+void AllocationSite::AddDependentCompilationInfo(
+ Handle<AllocationSite> site, DependentCode::DependencyGroup group,
+ CompilationInfo* info) {
+ Handle<DependentCode> dep(site->dependent_code());
+ Handle<DependentCode> codes =
+ DependentCode::InsertCompilationInfo(dep, group, info->object_wrapper());
+ if (*codes != site->dependent_code()) site->set_dependent_code(*codes);
+ info->dependencies(group)->Add(Handle<HeapObject>(*site), info->zone());
+}
+
+
const char* AllocationSite::PretenureDecisionName(PretenureDecision decision) {
switch (decision) {
case kUndecided: return "undecided";
return value;
}
+
+// static
+void PropertyCell::AddDependentCompilationInfo(Handle<PropertyCell> cell,
+ CompilationInfo* info) {
+ Handle<DependentCode> codes = DependentCode::InsertCompilationInfo(
+ handle(cell->dependent_code(), info->isolate()),
+ DependentCode::kPropertyCellChangedGroup, info->object_wrapper());
+ if (*codes != cell->dependent_code()) cell->set_dependent_code(*codes);
+ info->dependencies(DependentCode::kPropertyCellChangedGroup)->Add(
+ cell, info->zone());
+}
+
} } // namespace v8::internal
};
+class CompilationInfo;
+
// This class describes the layout of dependent codes array of a map. The
// array is partitioned into several groups of dependent codes. Each group
// contains codes with the same dependency on the map. The array has the
bool Contains(DependencyGroup group, WeakCell* code_cell);
- static Handle<DependentCode> InsertCompilationDependencies(
+ static Handle<DependentCode> InsertCompilationInfo(
Handle<DependentCode> entries, DependencyGroup group,
Handle<Foreign> info);
void UpdateToFinishedCode(DependencyGroup group, Foreign* info,
WeakCell* code_cell);
- void RemoveCompilationDependencies(DependentCode::DependencyGroup group,
- Foreign* info);
+ void RemoveCompilationInfo(DependentCode::DependencyGroup group,
+ Foreign* info);
void DeoptimizeDependentCodeGroup(Isolate* isolate,
DependentCode::DependencyGroup group);
inline void copy(int from, int to);
DECLARE_CAST(DependentCode)
+ static DependentCode* ForObject(Handle<HeapObject> object,
+ DependencyGroup group);
+
static const char* DependencyGroupName(DependencyGroup group);
static void SetMarkedForDeoptimization(Code* code, DependencyGroup group);
inline bool CanOmitMapChecks();
+ static void AddDependentCompilationInfo(Handle<Map> map,
+ DependentCode::DependencyGroup group,
+ CompilationInfo* info);
+
static void AddDependentCode(Handle<Map> map,
DependentCode::DependencyGroup group,
Handle<Code> code);
static void DigestTransitionFeedback(Handle<AllocationSite> site,
ElementsKind to_kind);
+ static void RegisterForDeoptOnTenureChange(Handle<AllocationSite> site,
+ CompilationInfo* info);
+
+ static void RegisterForDeoptOnTransitionChange(Handle<AllocationSite> site,
+ CompilationInfo* info);
+
DECLARE_PRINTER(AllocationSite)
DECLARE_VERIFIER(AllocationSite)
kSize> BodyDescriptor;
private:
+ static void AddDependentCompilationInfo(Handle<AllocationSite> site,
+ DependentCode::DependencyGroup group,
+ CompilationInfo* info);
+
bool PretenuringDecisionMade() {
return pretenure_decision() != kUndecided;
}
static Handle<PropertyCell> InvalidateEntry(Handle<NameDictionary> dictionary,
int entry);
+ static void AddDependentCompilationInfo(Handle<PropertyCell> cell,
+ CompilationInfo* info);
+
DECLARE_CAST(PropertyCell)
// Dispatched behavior.
// Create new maps by generalizing representation of propX field.
Handle<Map> field_owner(map->FindFieldOwner(property_index), isolate);
CompilationInfo info(&stub, isolate, &zone);
- CHECK(!info.dependencies()->HasAborted());
+ CHECK(!info.HasAbortedDueToDependencyChange());
- info.dependencies()->AssumeFieldType(field_owner);
+ Map::AddDependentCompilationInfo(field_owner, DependentCode::kFieldTypeGroup,
+ &info);
Handle<Map> new_map =
Map::ReconfigureProperty(map, property_index, kData, NONE,
CHECK(map->is_deprecated());
CHECK_NE(*map, *new_map);
CHECK_EQ(expected_field_type_dependency && !field_owner->is_deprecated(),
- info.dependencies()->HasAborted());
+ info.HasAbortedDueToDependencyChange());
} else if (expected_deprecation) {
CHECK(map->is_deprecated());
CHECK(field_owner->is_deprecated());
CHECK_NE(*map, *new_map);
- CHECK(!info.dependencies()->HasAborted());
+ CHECK(!info.HasAbortedDueToDependencyChange());
} else {
CHECK(!field_owner->is_deprecated());
CHECK_EQ(*map, *new_map);
- CHECK_EQ(expected_field_type_dependency, info.dependencies()->HasAborted());
+ CHECK_EQ(expected_field_type_dependency,
+ info.HasAbortedDueToDependencyChange());
}
- info.dependencies()->Rollback(); // Properly cleanup compilation info.
+ info.RollbackDependencies(); // Properly cleanup compilation info.
// Update all deprecated maps and check that they are now the same.
Handle<Map> updated_map = Map::Update(map);
FakeStubForTesting stub(isolate);
Handle<Map> field_owner(map->FindFieldOwner(kSplitProp), isolate);
CompilationInfo info(&stub, isolate, &zone);
- CHECK(!info.dependencies()->HasAborted());
- info.dependencies()->AssumeFieldType(field_owner);
+ CHECK(!info.HasAbortedDueToDependencyChange());
+ Map::AddDependentCompilationInfo(field_owner, DependentCode::kFieldTypeGroup,
+ &info);
// Reconfigure attributes of property |kSplitProp| of |map2| to NONE, which
// should generalize representations in |map1|.
expectations.SetDataField(i, expected_representation, expected_type);
}
CHECK(map->is_deprecated());
- CHECK(!info.dependencies()->HasAborted());
- info.dependencies()->Rollback(); // Properly cleanup compilation info.
+ CHECK(!info.HasAbortedDueToDependencyChange());
+ info.RollbackDependencies(); // Properly cleanup compilation info.
CHECK_NE(*map, *new_map);
CHECK(!new_map->is_deprecated());
FakeStubForTesting stub(isolate);
Handle<Map> field_owner(map->FindFieldOwner(kSplitProp), isolate);
CompilationInfo info(&stub, isolate, &zone);
- CHECK(!info.dependencies()->HasAborted());
- info.dependencies()->AssumeFieldType(field_owner);
+ CHECK(!info.HasAbortedDueToDependencyChange());
+ Map::AddDependentCompilationInfo(field_owner, DependentCode::kFieldTypeGroup,
+ &info);
// Reconfigure attributes of property |kSplitProp| of |map2| to NONE, which
// should generalize representations in |map1|.
}
CHECK(!map->is_deprecated());
CHECK_EQ(*map, *new_map);
- CHECK_EQ(expected_field_type_dependency, info.dependencies()->HasAborted());
- info.dependencies()->Rollback(); // Properly cleanup compilation info.
+ CHECK_EQ(expected_field_type_dependency,
+ info.HasAbortedDueToDependencyChange());
+ info.RollbackDependencies(); // Properly cleanup compilation info.
CHECK(!new_map->is_deprecated());
CHECK(expectations.Check(*new_map));
'../../src/codegen.h',
'../../src/compilation-cache.cc',
'../../src/compilation-cache.h',
- '../../src/compilation-dependencies.cc',
- '../../src/compilation-dependencies.h',
'../../src/compilation-statistics.cc',
'../../src/compilation-statistics.h',
'../../src/compiler/access-builder.cc',
projects / platform / upstream / v8.git / commitdiff