case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
}
+// Helper to find an existing shared function info in the baseline code for the
+// given function literal. Used to canonicalize SharedFunctionInfo objects.
+void FunctionLiteral::InitializeSharedInfo(
+ Handle<Code> unoptimized_code) {
+ for (RelocIterator it(*unoptimized_code); !it.done(); it.next()) {
+ RelocInfo* rinfo = it.rinfo();
+ if (rinfo->rmode() != RelocInfo::EMBEDDED_OBJECT) continue;
+ Object* obj = rinfo->target_object();
+ if (obj->IsSharedFunctionInfo()) {
+ SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
+ if (shared->start_position() == start_position()) {
+ shared_info_ = Handle<SharedFunctionInfo>(shared);
+ break;
+ }
+ }
+ }
+}
+
+
ObjectLiteralProperty::ObjectLiteralProperty(Expression* key, Expression* value,
Kind kind, bool is_static,
bool is_computed_name)
bool AllowsLazyCompilation();
bool AllowsLazyCompilationWithoutContext();
+ void InitializeSharedInfo(Handle<Code> code);
+
Handle<String> debug_name() const {
if (raw_name_ != NULL && !raw_name_->IsEmpty()) {
return raw_name_->string();
inferred_name_ = Handle<String>();
}
+ // shared_info may be null if it's not cached in full code.
+ Handle<SharedFunctionInfo> shared_info() { return shared_info_; }
+
bool pretenure() { return Pretenure::decode(bitfield_); }
void set_pretenure() { bitfield_ |= Pretenure::encode(true); }
private:
const AstRawString* raw_name_;
Handle<String> name_;
+ Handle<SharedFunctionInfo> shared_info_;
Scope* scope_;
ZoneList<Statement*>* body_;
const AstString* raw_inferred_name_;
Handle<String> source = factory->NewStringFromStaticChars("() {}");
Handle<Script> script = factory->NewScript(source);
script->set_type(Smi::FromInt(Script::TYPE_NATIVE));
+ empty_function->shared()->set_script(*script);
empty_function->shared()->set_start_position(0);
empty_function->shared()->set_end_position(source->length());
empty_function->shared()->DontAdaptArguments();
- SharedFunctionInfo::SetScript(handle(empty_function->shared()), script);
// Set prototypes for the function maps.
Handle<Map> sloppy_function_map(native_context()->sloppy_function_map(),
// ~CodeGenerator
// Generate
// ComputeLazyCompile
+// BuildFunctionInfo
// ProcessDeclarations
// DeclareGlobals
// CheckForInlineRuntimeCall
if (FLAG_turbo_splitting) MarkAsSplittingEnabled();
if (FLAG_turbo_types) MarkAsTypingEnabled();
- if (has_shared_info()) {
- if (shared_info()->is_compiled()) {
- // We should initialize the CompilationInfo feedback vector from the
- // passed in shared info, rather than creating a new one.
- feedback_vector_ = Handle<TypeFeedbackVector>(
- shared_info()->feedback_vector(), parse_info->isolate());
- }
- if (shared_info()->never_compiled()) MarkAsFirstCompile();
+ if (has_shared_info() && shared_info()->is_compiled()) {
+ // We should initialize the CompilationInfo feedback vector from the
+ // passed in shared info, rather than creating a new one.
+ feedback_vector_ = Handle<TypeFeedbackVector>(
+ shared_info()->feedback_vector(), parse_info->isolate());
}
}
PostponeInterruptsScope postpone(info.isolate());
VMState<COMPILER> state(info.isolate());
- // Get rid of old list of shared function infos.
- script->set_shared_function_infos(Smi::FromInt(0));
-
info.parse_info()->set_global();
if (!Parser::ParseStatic(info.parse_info())) return;
}
}
- info->MarkAsFirstCompile();
-
FunctionLiteral* lit = info->function();
LiveEditFunctionTracker live_edit_tracker(isolate, lit);
DCHECK_EQ(RelocInfo::kNoPosition, lit->function_token_position());
SharedFunctionInfo::InitFromFunctionLiteral(result, lit);
- SharedFunctionInfo::SetScript(result, script);
+ result->set_script(*script);
result->set_is_toplevel(true);
Handle<String> script_name = script->name()->IsString()
}
-Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfo(
+Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(
FunctionLiteral* literal, Handle<Script> script,
CompilationInfo* outer_info) {
// Precondition: code has been parsed and scopes have been analyzed.
- MaybeHandle<SharedFunctionInfo> maybe_existing;
- if (outer_info->is_first_compile()) {
- // On the first compile, there are no existing shared function info for
- // inner functions yet, so do not try to find them.
- DCHECK(script->FindSharedFunctionInfo(literal).is_null());
- } else {
- maybe_existing = script->FindSharedFunctionInfo(literal);
- }
- // We found an existing shared function info. If it's already compiled,
- // don't worry about compiling it, and simply return it. If it's not yet
- // compiled, continue to decide whether to eagerly compile.
- Handle<SharedFunctionInfo> existing;
- if (maybe_existing.ToHandle(&existing) && existing->is_compiled()) {
- return existing;
- }
-
Zone zone;
ParseInfo parse_info(&zone, script);
CompilationInfo info(&parse_info);
parse_info.set_scope(literal->scope());
parse_info.set_language_mode(literal->scope()->language_mode());
if (outer_info->will_serialize()) info.PrepareForSerializing();
- if (outer_info->is_first_compile()) info.MarkAsFirstCompile();
Isolate* isolate = info.isolate();
Factory* factory = isolate->factory();
return Handle<SharedFunctionInfo>::null();
}
- if (maybe_existing.is_null()) {
- // Create a shared function info object.
- Handle<SharedFunctionInfo> result = factory->NewSharedFunctionInfo(
- literal->name(), literal->materialized_literal_count(), literal->kind(),
- info.code(), scope_info, info.feedback_vector());
+ // Create a shared function info object.
+ Handle<SharedFunctionInfo> result = factory->NewSharedFunctionInfo(
+ literal->name(), literal->materialized_literal_count(), literal->kind(),
+ info.code(), scope_info, info.feedback_vector());
- SharedFunctionInfo::InitFromFunctionLiteral(result, literal);
- SharedFunctionInfo::SetScript(result, script);
- result->set_is_toplevel(false);
+ SharedFunctionInfo::InitFromFunctionLiteral(result, literal);
+ result->set_script(*script);
+ result->set_is_toplevel(false);
- RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, result);
- result->set_allows_lazy_compilation(literal->AllowsLazyCompilation());
- result->set_allows_lazy_compilation_without_context(allow_lazy_without_ctx);
+ RecordFunctionCompilation(Logger::FUNCTION_TAG, &info, result);
+ result->set_allows_lazy_compilation(literal->AllowsLazyCompilation());
+ result->set_allows_lazy_compilation_without_context(allow_lazy_without_ctx);
- // Set the expected number of properties for instances and return
- // the resulting function.
- SetExpectedNofPropertiesFromEstimate(result,
- literal->expected_property_count());
- live_edit_tracker.RecordFunctionInfo(result, literal, info.zone());
- return result;
- } else {
- // We may have additional data from compilation now.
- DCHECK(!existing->is_compiled());
- existing->ReplaceCode(*info.code());
- existing->set_scope_info(*scope_info);
- existing->set_feedback_vector(*info.feedback_vector());
- return existing;
- }
+ // Set the expected number of properties for instances and return
+ // the resulting function.
+ SetExpectedNofPropertiesFromEstimate(result,
+ literal->expected_property_count());
+ live_edit_tracker.RecordFunctionInfo(result, literal, info.zone());
+ return result;
}
return cached_code;
}
- Isolate* isolate = function->GetIsolate();
+ SmartPointer<CompilationInfo> info(new CompilationInfoWithZone(function));
+ Isolate* isolate = info->isolate();
DCHECK(AllowCompilation::IsAllowed(isolate));
+ VMState<COMPILER> state(isolate);
+ DCHECK(!isolate->has_pending_exception());
+ PostponeInterruptsScope postpone(isolate);
- Handle<SharedFunctionInfo> shared(function->shared(), isolate);
- if (!shared->is_compiled() ||
- shared->scope_info() == ScopeInfo::Empty(isolate)) {
+ Handle<SharedFunctionInfo> shared = info->shared_info();
+ if (shared->code()->kind() != Code::FUNCTION ||
+ ScopeInfo::Empty(isolate) == shared->scope_info()) {
// The function was never compiled. Compile it unoptimized first.
// TODO(titzer): reuse the AST and scope info from this compile.
- CompilationInfoWithZone unoptimized(function);
- unoptimized.EnableDeoptimizationSupport();
- if (!GetUnoptimizedCodeCommon(&unoptimized).ToHandle(¤t_code)) {
+ CompilationInfoWithZone nested(function);
+ nested.EnableDeoptimizationSupport();
+ if (!GetUnoptimizedCodeCommon(&nested).ToHandle(¤t_code)) {
return MaybeHandle<Code>();
}
shared->ReplaceCode(*current_code);
}
-
current_code->set_profiler_ticks(0);
// TODO(mstarzinger): We cannot properly deserialize a scope chain containing
return MaybeHandle<Code>();
}
- SmartPointer<CompilationInfo> info(new CompilationInfoWithZone(function));
- VMState<COMPILER> state(isolate);
- DCHECK(!isolate->has_pending_exception());
- PostponeInterruptsScope postpone(isolate);
-
info->SetOptimizing(osr_ast_id, current_code);
if (mode == CONCURRENT) {
kSplittingEnabled = 1 << 13,
kTypeFeedbackEnabled = 1 << 14,
kDeoptimizationEnabled = 1 << 15,
- kSourcePositionsEnabled = 1 << 16,
- kFirstCompile = 1 << 17,
+ kSourcePositionsEnabled = 1 << 16
};
explicit CompilationInfo(ParseInfo* parse_info);
bool is_splitting_enabled() const { return GetFlag(kSplittingEnabled); }
- void MarkAsFirstCompile() { SetFlag(kFirstCompile); }
-
- bool is_first_compile() const { return GetFlag(kFirstCompile); }
-
bool IsCodePreAgingActive() const {
return FLAG_optimize_for_size && FLAG_age_code && !will_serialize() &&
!is_debug();
int source_length);
// Create a shared function info object (the code may be lazily compiled).
- static Handle<SharedFunctionInfo> GetSharedFunctionInfo(
- FunctionLiteral* node, Handle<Script> script, CompilationInfo* outer);
+ static Handle<SharedFunctionInfo> BuildFunctionInfo(FunctionLiteral* node,
+ Handle<Script> script,
+ CompilationInfo* outer);
enum ConcurrencyMode { NOT_CONCURRENT, CONCURRENT };
Variable* variable = decl->proxy()->var();
switch (variable->location()) {
case Variable::UNALLOCATED: {
- Handle<SharedFunctionInfo> function = Compiler::GetSharedFunctionInfo(
- decl->fun(), info()->script(), info());
+ Handle<SharedFunctionInfo> function =
+ Compiler::BuildFunctionInfo(decl->fun(), info()->script(), info());
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals()->push_back(variable->name());
void AstGraphBuilder::VisitFunctionLiteral(FunctionLiteral* expr) {
Node* context = current_context();
- // Find or build a shared function info.
- Handle<SharedFunctionInfo> shared_info =
- Compiler::GetSharedFunctionInfo(expr, info()->script(), info());
- CHECK(!shared_info.is_null()); // TODO(mstarzinger): Set stack overflow?
+ // Build a new shared function info if we cannot find one in the baseline
+ // code. We also have a stack overflow if the recursive compilation did.
+ expr->InitializeSharedInfo(handle(info()->shared_info()->code()));
+ Handle<SharedFunctionInfo> shared_info = expr->shared_info();
+ if (shared_info.is_null()) {
+ shared_info = Compiler::BuildFunctionInfo(expr, info()->script(), info());
+ CHECK(!shared_info.is_null()); // TODO(mstarzinger): Set stack overflow?
+ }
// Create node to instantiate a new closure.
PretenureFlag pretenure = expr->pretenure() ? TENURED : NOT_TENURED;
// If the candidate is not compiled, compile it to reveal any inner
// functions which might contain the requested source position. This
// will compile all inner functions that cannot be compiled without a
- // context, because Compiler::GetSharedFunctionInfo checks whether the
+ // context, because Compiler::BuildFunctionInfo checks whether the
// debugger is active.
MaybeHandle<Code> maybe_result = target_function.is_null()
? Compiler::GetUnoptimizedCode(target)
script->set_line_ends(heap->undefined_value());
script->set_eval_from_shared(heap->undefined_value());
script->set_eval_from_instructions_offset(Smi::FromInt(0));
- script->set_shared_function_infos(Smi::FromInt(0));
script->set_flags(Smi::FromInt(0));
return script;
share->set_compiler_hints(0);
share->set_opt_count_and_bailout_reason(0);
- share->set_never_compiled(!share->is_compiled());
return share;
}
// Build the function boilerplate and instantiate it.
Handle<SharedFunctionInfo> function_info =
- Compiler::GetSharedFunctionInfo(expr, script(), info_);
+ Compiler::BuildFunctionInfo(expr, script(), info_);
if (function_info.is_null()) {
SetStackOverflow();
return;
DCHECK(!HasStackOverflow());
DCHECK(current_block() != NULL);
DCHECK(current_block()->HasPredecessor());
- Handle<SharedFunctionInfo> shared_info = Compiler::GetSharedFunctionInfo(
- expr, current_info()->script(), top_info());
+ Handle<SharedFunctionInfo> shared_info = expr->shared_info();
+ if (shared_info.is_null()) {
+ shared_info =
+ Compiler::BuildFunctionInfo(expr, current_info()->script(), top_info());
+ }
// We also have a stack overflow if the recursive compilation did.
if (HasStackOverflow()) return;
HFunctionLiteral* instr =
switch (variable->location()) {
case Variable::UNALLOCATED: {
globals_.Add(variable->name(), zone());
- Handle<SharedFunctionInfo> function = Compiler::GetSharedFunctionInfo(
+ Handle<SharedFunctionInfo> function = Compiler::BuildFunctionInfo(
declaration->fun(), current_info()->script(), top_info());
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
Handle<SharedFunctionInfo> shared_info =
UnwrapSharedFunctionInfoFromJSValue(function_wrapper);
CHECK(script_handle->IsScript() || script_handle->IsUndefined());
- SharedFunctionInfo::SetScript(shared_info, script_handle);
+ shared_info->set_script(*script_handle);
shared_info->DisableOptimization(kLiveEdit);
function_wrapper->GetIsolate()->compilation_cache()->Remove(shared_info);
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
ACCESSORS(Script, eval_from_shared, Object, kEvalFromSharedOffset)
ACCESSORS_TO_SMI(Script, eval_from_instructions_offset,
kEvalFrominstructionsOffsetOffset)
-ACCESSORS(Script, shared_function_infos, Object, kSharedFunctionInfosOffset)
ACCESSORS_TO_SMI(Script, flags, kFlagsOffset)
ACCESSORS(Script, source_url, Object, kSourceUrlOffset)
ACCESSORS(Script, source_mapping_url, Object, kSourceMappingUrlOffset)
kHasDuplicateParameters)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, asm_function, kIsAsmFunction)
BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, deserialized, kDeserialized)
-BOOL_ACCESSORS(SharedFunctionInfo, compiler_hints, never_compiled,
- kNeverCompiled)
#if V8_HOST_ARCH_32_BIT
DCHECK(code()->gc_metadata() == NULL && value->gc_metadata() == NULL);
set_code(value);
-
- if (is_compiled()) set_never_compiled(false);
}
os << "\n - eval from shared: " << Brief(eval_from_shared());
os << "\n - eval from instructions offset: "
<< Brief(eval_from_instructions_offset());
- os << "\n - shared function infos: " << Brief(shared_function_infos());
os << "\n";
}
}
-MaybeHandle<SharedFunctionInfo> Script::FindSharedFunctionInfo(
- FunctionLiteral* fun) {
- if (shared_function_infos()->IsWeakFixedArray()) {
- WeakFixedArray* array = WeakFixedArray::cast(shared_function_infos());
- for (int i = 0; i < array->Length(); i++) {
- Object* obj = array->Get(i);
- if (!obj->IsSharedFunctionInfo()) continue;
- SharedFunctionInfo* shared = SharedFunctionInfo::cast(obj);
- if (fun->function_token_position() == shared->function_token_position() &&
- fun->start_position() == shared->start_position()) {
- return Handle<SharedFunctionInfo>(shared);
- }
- }
- }
- return MaybeHandle<SharedFunctionInfo>();
-}
-
-
-void SharedFunctionInfo::SetScript(Handle<SharedFunctionInfo> shared,
- Handle<Object> script_object) {
- if (shared->script() == *script_object) return;
- // Remove shared function info from old script's list.
- if (shared->script()->IsScript()) {
- Script* old_script = Script::cast(shared->script());
- if (old_script->shared_function_infos()->IsWeakFixedArray()) {
- WeakFixedArray* list =
- WeakFixedArray::cast(old_script->shared_function_infos());
- list->Remove(shared);
- }
- }
- // Add shared function info to new script's list.
- if (script_object->IsScript()) {
- Handle<Script> script = Handle<Script>::cast(script_object);
- Handle<Object> list(script->shared_function_infos(), shared->GetIsolate());
-#ifdef DEBUG
- bool found = false;
- list = WeakFixedArray::Add(list, shared, WeakFixedArray::kAddIfNotFound,
- &found);
- CHECK(!found);
-#else
- list = WeakFixedArray::Add(list, shared, WeakFixedArray::kAlwaysAdd);
-#endif // DEBUG
- script->set_shared_function_infos(*list);
- }
- // Finally set new script.
- shared->set_script(*script_object);
-}
-
-
String* SharedFunctionInfo::DebugName() {
Object* n = name();
if (!n->IsString() || String::cast(n)->length() == 0) return inferred_name();
class AllocationSite;
class AllocationSiteCreationContext;
class AllocationSiteUsageContext;
-class Cell;
class ConsString;
class DictionaryElementsAccessor;
class ElementsAccessor;
class FixedArrayBase;
class FunctionLiteral;
class GlobalObject;
-class JSBuiltinsObject;
class LayoutDescriptor;
class LookupIterator;
-class ObjectHashTable;
class ObjectVisitor;
-class PropertyCell;
-class SafepointEntry;
-class SharedFunctionInfo;
class StringStream;
-class TypeFeedbackInfo;
class TypeFeedbackVector;
class WeakCell;
DISALLOW_IMPLICIT_CONSTRUCTORS(JSReceiver);
};
+// Forward declaration for JSObject::GetOrCreateHiddenPropertiesHashTable.
+class ObjectHashTable;
+
// The JSObject describes real heap allocated JavaScript objects with
// properties.
};
+// Forward declaration.
+class Cell;
+class PropertyCell;
+class SafepointEntry;
+class TypeFeedbackInfo;
+
// Code describes objects with on-the-fly generated machine code.
class Code: public HeapObject {
public:
// function from which eval was called where eval was called.
DECL_ACCESSORS(eval_from_instructions_offset, Smi)
- // [shared_function_infos]: weak fixed array containing all shared
- // function infos created from this script.
- DECL_ACCESSORS(shared_function_infos, Object)
-
// [flags]: Holds an exciting bitfield.
DECL_ACCESSORS(flags, Smi)
// Get the JS object wrapping the given script; create it if none exists.
static Handle<JSObject> GetWrapper(Handle<Script> script);
- // Look through the list of existing shared function infos to find one
- // that matches the function literal. Return empty handle if not found.
- MaybeHandle<SharedFunctionInfo> FindSharedFunctionInfo(FunctionLiteral* fun);
-
// Dispatched behavior.
DECLARE_PRINTER(Script)
DECLARE_VERIFIER(Script)
static const int kEvalFromSharedOffset = kIdOffset + kPointerSize;
static const int kEvalFrominstructionsOffsetOffset =
kEvalFromSharedOffset + kPointerSize;
- static const int kSharedFunctionInfosOffset =
+ static const int kFlagsOffset =
kEvalFrominstructionsOffsetOffset + kPointerSize;
- static const int kFlagsOffset = kSharedFunctionInfosOffset + kPointerSize;
static const int kSourceUrlOffset = kFlagsOffset + kPointerSize;
static const int kSourceMappingUrlOffset = kSourceUrlOffset + kPointerSize;
static const int kSize = kSourceMappingUrlOffset + kPointerSize;
Handle<FixedArray> literals,
BailoutId osr_ast_id);
- // Set up the link between shared function info and the script. The shared
- // function info is added to the list on the script.
- static void SetScript(Handle<SharedFunctionInfo> shared,
- Handle<Object> script_object);
-
// Layout description of the optimized code map.
static const int kNextMapIndex = 0;
static const int kEntriesStart = 1;
// Indicates that the the shared function info is deserialized from cache.
DECL_BOOLEAN_ACCESSORS(deserialized)
- // Indicates that the the shared function info has never been compiled before.
- DECL_BOOLEAN_ACCESSORS(never_compiled)
-
inline FunctionKind kind();
inline void set_kind(FunctionKind kind);
kInClassLiteral,
kIsAsmFunction,
kDeserialized,
- kNeverCompiled,
kCompilerHintsCount // Pseudo entry
};
// Add hints for other modes when they're added.
};
+// Forward declaration.
+class JSBuiltinsObject;
+
// Common super class for JavaScript global objects and the special
// builtins global objects.
class GlobalObject: public JSObject {
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
target_shared->set_feedback_vector(source_shared->feedback_vector());
target_shared->set_internal_formal_parameter_count(
source_shared->internal_formal_parameter_count());
+ target_shared->set_script(source_shared->script());
target_shared->set_start_position_and_type(
source_shared->start_position_and_type());
target_shared->set_end_position(source_shared->end_position());
source_shared->opt_count_and_bailout_reason());
target_shared->set_native(was_native);
target_shared->set_profiler_ticks(source_shared->profiler_ticks());
- SharedFunctionInfo::SetScript(
- target_shared, Handle<Object>(source_shared->script(), isolate));
// Set the code of the target function.
target->ReplaceCode(source_shared->code());
// Clear cached line ends.
Object* undefined = serializer_->isolate()->heap()->undefined_value();
Script::cast(object_)->set_line_ends(undefined);
- Object* shared_list = Script::cast(object_)->shared_function_infos();
- if (shared_list->IsWeakFixedArray()) {
- WeakFixedArray::cast(shared_list)->Compact();
- }
}
if (object_->IsExternalString()) {
DCHECK(code_object->has_reloc_info_for_serialization());
// Only serialize the code for the toplevel function unless specified
// by flag. Replace code of inner functions by the lazy compile builtin.
- // This is safe, as checked in Compiler::GetSharedFunctionInfo.
+ // This is safe, as checked in Compiler::BuildFunctionInfo.
if (code_object != main_code_ && !FLAG_serialize_inner) {
SerializeBuiltin(Builtins::kCompileLazy, how_to_code, where_to_point);
} else {
}
-void AstTyper::VisitFunctionLiteral(FunctionLiteral* expr) {}
+void AstTyper::VisitFunctionLiteral(FunctionLiteral* expr) {
+ expr->InitializeSharedInfo(Handle<Code>(info_->closure()->shared()->code()));
+}
void AstTyper::VisitClassLiteral(ClassLiteral* expr) {}
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
case Variable::UNALLOCATED: {
globals_->Add(variable->name(), zone());
Handle<SharedFunctionInfo> function =
- Compiler::GetSharedFunctionInfo(declaration->fun(), script(), info_);
+ Compiler::BuildFunctionInfo(declaration->fun(), script(), info_);
// Check for stack-overflow exception.
if (function.is_null()) return SetStackOverflow();
globals_->Add(function, zone());
}
-static void CheckEqualSharedFunctionInfos(
- const v8::FunctionCallbackInfo<v8::Value>& args) {
- Handle<Object> obj1 = v8::Utils::OpenHandle(*args[0]);
- Handle<Object> obj2 = v8::Utils::OpenHandle(*args[1]);
- Handle<JSFunction> fun1 = Handle<JSFunction>::cast(obj1);
- Handle<JSFunction> fun2 = Handle<JSFunction>::cast(obj2);
- CHECK(fun1->shared() == fun2->shared());
-}
-
-
-static void RemoveCodeAndGC(const v8::FunctionCallbackInfo<v8::Value>& args) {
- Isolate* isolate = CcTest::i_isolate();
- Handle<Object> obj = v8::Utils::OpenHandle(*args[0]);
- Handle<JSFunction> fun = Handle<JSFunction>::cast(obj);
- fun->ReplaceCode(*isolate->builtins()->CompileLazy());
- fun->shared()->ReplaceCode(*isolate->builtins()->CompileLazy());
- isolate->heap()->CollectAllAvailableGarbage("remove code and gc");
-}
-
-
-TEST(CanonicalSharedFunctionInfo) {
- CcTest::InitializeVM();
- v8::Isolate* isolate = CcTest::isolate();
- v8::HandleScope scope(isolate);
- v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
- global->Set(isolate, "check", v8::FunctionTemplate::New(
- isolate, CheckEqualSharedFunctionInfos));
- global->Set(isolate, "remove",
- v8::FunctionTemplate::New(isolate, RemoveCodeAndGC));
- v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
- v8::Context::Scope cscope(context);
- CompileRun(
- "function f() { return function g() {}; }"
- "var g1 = f();"
- "remove(f);"
- "var g2 = f();"
- "check(g1, g2);");
-
- CompileRun(
- "function f() { return (function() { return function g() {}; })(); }"
- "var g1 = f();"
- "remove(f);"
- "var g2 = f();"
- "check(g1, g2);");
-}
-
-
TEST(OldGenerationAllocationThroughput) {
CcTest::InitializeVM();
v8::HandleScope scope(CcTest::isolate());
assertFalse(%HasFastSmiElements(second_object_array));
assertTrue(%HaveSameMap(first_object_array, second_object_array));
assertFalse(%HaveSameMap(first_smi_array, second_object_array));
-
-%ClearFunctionTypeFeedback(Loader);
-%ClearFunctionTypeFeedback(Migrator);
projects / platform / upstream / v8.git / commitdiff