// Copyright 2017 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_OBJECTS_SHARED_FUNCTION_INFO_H_
|
#define V8_OBJECTS_SHARED_FUNCTION_INFO_H_
|
|
#include "src/bailout-reason.h"
|
#include "src/objects.h"
|
#include "src/objects/script.h"
|
|
// Has to be the last include (doesn't have include guards):
|
#include "src/objects/object-macros.h"
|
|
namespace v8 {
|
namespace internal {
|
|
class BytecodeArray;
|
class CoverageInfo;
|
class DebugInfo;
|
class WasmExportedFunctionData;
|
|
// Data collected by the pre-parser storing information about scopes and inner
|
// functions.
|
class PreParsedScopeData : public HeapObject {
|
public:
|
DECL_ACCESSORS(scope_data, PodArray<uint8_t>)
|
DECL_INT_ACCESSORS(length)
|
|
inline Object* child_data(int index) const;
|
inline void set_child_data(int index, Object* value,
|
WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
|
|
inline Object** child_data_start() const;
|
|
// Clear uninitialized padding space.
|
inline void clear_padding();
|
|
DECL_CAST(PreParsedScopeData)
|
DECL_PRINTER(PreParsedScopeData)
|
DECL_VERIFIER(PreParsedScopeData)
|
|
#define PRE_PARSED_SCOPE_DATA_FIELDS(V) \
|
V(kScopeDataOffset, kPointerSize) \
|
V(kLengthOffset, kIntSize) \
|
V(kUnalignedChildDataStartOffset, 0)
|
|
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
|
PRE_PARSED_SCOPE_DATA_FIELDS)
|
#undef PRE_PARSED_SCOPE_DATA_FIELDS
|
|
static const int kChildDataStartOffset =
|
POINTER_SIZE_ALIGN(kUnalignedChildDataStartOffset);
|
|
class BodyDescriptor;
|
// No weak fields.
|
typedef BodyDescriptor BodyDescriptorWeak;
|
|
static constexpr int SizeFor(int length) {
|
return kChildDataStartOffset + length * kPointerSize;
|
}
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(PreParsedScopeData);
|
};
|
|
// Abstract class representing extra data for an uncompiled function, which is
|
// not stored in the SharedFunctionInfo.
|
class UncompiledData : public HeapObject {
|
public:
|
DECL_ACCESSORS(inferred_name, String)
|
DECL_INT32_ACCESSORS(start_position)
|
DECL_INT32_ACCESSORS(end_position)
|
DECL_INT32_ACCESSORS(function_literal_id)
|
|
DECL_CAST(UncompiledData)
|
|
#define UNCOMPILED_DATA_FIELDS(V) \
|
V(kStartOfPointerFieldsOffset, 0) \
|
V(kInferredNameOffset, kPointerSize) \
|
V(kEndOfPointerFieldsOffset, 0) \
|
V(kStartPositionOffset, kInt32Size) \
|
V(kEndPositionOffset, kInt32Size) \
|
V(kFunctionLiteralIdOffset, kInt32Size) \
|
/* Total size. */ \
|
V(kUnalignedSize, 0)
|
|
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, UNCOMPILED_DATA_FIELDS)
|
#undef UNCOMPILED_DATA_FIELDS
|
|
static const int kSize = POINTER_SIZE_ALIGN(kUnalignedSize);
|
|
typedef FixedBodyDescriptor<kStartOfPointerFieldsOffset,
|
kEndOfPointerFieldsOffset, kSize>
|
BodyDescriptor;
|
|
// Clear uninitialized padding space.
|
inline void clear_padding();
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(UncompiledData);
|
};
|
|
// Class representing data for an uncompiled function that does not have any
|
// data from the pre-parser, either because it's a leaf function or because the
|
// pre-parser bailed out.
|
class UncompiledDataWithoutPreParsedScope : public UncompiledData {
|
public:
|
DECL_CAST(UncompiledDataWithoutPreParsedScope)
|
DECL_PRINTER(UncompiledDataWithoutPreParsedScope)
|
DECL_VERIFIER(UncompiledDataWithoutPreParsedScope)
|
|
static const int kSize = UncompiledData::kSize;
|
|
// No extra fields compared to UncompiledData.
|
typedef UncompiledData::BodyDescriptor BodyDescriptor;
|
// No weak fields.
|
typedef BodyDescriptor BodyDescriptorWeak;
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(UncompiledDataWithoutPreParsedScope);
|
};
|
|
// Class representing data for an uncompiled function that has pre-parsed scope
|
// data.
|
class UncompiledDataWithPreParsedScope : public UncompiledData {
|
public:
|
DECL_ACCESSORS(pre_parsed_scope_data, PreParsedScopeData)
|
|
DECL_CAST(UncompiledDataWithPreParsedScope)
|
DECL_PRINTER(UncompiledDataWithPreParsedScope)
|
DECL_VERIFIER(UncompiledDataWithPreParsedScope)
|
|
#define UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_FIELDS(V) \
|
V(kStartOfPointerFieldsOffset, 0) \
|
V(kPreParsedScopeDataOffset, kPointerSize) \
|
V(kEndOfPointerFieldsOffset, 0) \
|
/* Total size. */ \
|
V(kSize, 0)
|
|
DEFINE_FIELD_OFFSET_CONSTANTS(UncompiledData::kSize,
|
UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_FIELDS)
|
#undef UNCOMPILED_DATA_WITH_PRE_PARSED_SCOPE_FIELDS
|
|
// Make sure the size is aligned
|
STATIC_ASSERT(kSize == POINTER_SIZE_ALIGN(kSize));
|
|
typedef SubclassBodyDescriptor<
|
UncompiledData::BodyDescriptor,
|
FixedBodyDescriptor<kStartOfPointerFieldsOffset,
|
kEndOfPointerFieldsOffset, kSize>>
|
BodyDescriptor;
|
// No weak fields.
|
typedef BodyDescriptor BodyDescriptorWeak;
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(UncompiledDataWithPreParsedScope);
|
};
|
|
class InterpreterData : public Struct {
|
public:
|
DECL_ACCESSORS(bytecode_array, BytecodeArray)
|
DECL_ACCESSORS(interpreter_trampoline, Code)
|
|
static const int kBytecodeArrayOffset = Struct::kHeaderSize;
|
static const int kInterpreterTrampolineOffset =
|
kBytecodeArrayOffset + kPointerSize;
|
static const int kSize = kInterpreterTrampolineOffset + kPointerSize;
|
|
DECL_CAST(InterpreterData)
|
DECL_PRINTER(InterpreterData)
|
DECL_VERIFIER(InterpreterData)
|
|
private:
|
DISALLOW_IMPLICIT_CONSTRUCTORS(InterpreterData);
|
};
|
|
// SharedFunctionInfo describes the JSFunction information that can be
|
// shared by multiple instances of the function.
|
class SharedFunctionInfo : public HeapObject, public NeverReadOnlySpaceObject {
|
public:
|
using NeverReadOnlySpaceObject::GetHeap;
|
using NeverReadOnlySpaceObject::GetIsolate;
|
|
static constexpr Object* const kNoSharedNameSentinel = Smi::kZero;
|
|
// [name]: Returns shared name if it exists or an empty string otherwise.
|
inline String* Name() const;
|
inline void SetName(String* name);
|
|
// Get the code object which represents the execution of this function.
|
Code* GetCode() const;
|
|
// Get the abstract code associated with the function, which will either be
|
// a Code object or a BytecodeArray.
|
inline AbstractCode* abstract_code();
|
|
// Tells whether or not this shared function info is interpreted.
|
//
|
// Note: function->IsInterpreted() does not necessarily return the same value
|
// as function->shared()->IsInterpreted() because the closure might have been
|
// optimized.
|
inline bool IsInterpreted() const;
|
|
// Set up the link between shared function info and the script. The shared
|
// function info is added to the list on the script.
|
V8_EXPORT_PRIVATE static void SetScript(
|
Handle<SharedFunctionInfo> shared, Handle<Object> script_object,
|
int function_literal_id, bool reset_preparsed_scope_data = true);
|
|
// Layout description of the optimized code map.
|
static const int kEntriesStart = 0;
|
static const int kContextOffset = 0;
|
static const int kCachedCodeOffset = 1;
|
static const int kEntryLength = 2;
|
static const int kInitialLength = kEntriesStart + kEntryLength;
|
|
static const int kNotFound = -1;
|
static const uint16_t kInvalidLength = static_cast<uint16_t>(-1);
|
|
// Helpers for assembly code that does a backwards walk of the optimized code
|
// map.
|
static const int kOffsetToPreviousContext =
|
FixedArray::kHeaderSize + kPointerSize * (kContextOffset - kEntryLength);
|
static const int kOffsetToPreviousCachedCode =
|
FixedArray::kHeaderSize +
|
kPointerSize * (kCachedCodeOffset - kEntryLength);
|
|
// [scope_info]: Scope info.
|
DECL_ACCESSORS(scope_info, ScopeInfo)
|
|
// End position of this function in the script source.
|
inline int EndPosition() const;
|
|
// Start position of this function in the script source.
|
inline int StartPosition() const;
|
|
// Set the start and end position of this function in the script source.
|
// Updates the scope info if available.
|
inline void SetPosition(int start_position, int end_position);
|
|
// [outer scope info | feedback metadata] Shared storage for outer scope info
|
// (on uncompiled functions) and feedback metadata (on compiled functions).
|
DECL_ACCESSORS(raw_outer_scope_info_or_feedback_metadata, HeapObject)
|
|
// Get the outer scope info whether this function is compiled or not.
|
inline bool HasOuterScopeInfo() const;
|
inline ScopeInfo* GetOuterScopeInfo() const;
|
|
// [feedback metadata] Metadata template for feedback vectors of instances of
|
// this function.
|
inline bool HasFeedbackMetadata() const;
|
DECL_ACCESSORS(feedback_metadata, FeedbackMetadata)
|
|
// Returns if this function has been compiled to native code yet.
|
inline bool is_compiled() const;
|
|
// [length]: The function length - usually the number of declared parameters.
|
// Use up to 2^16-2 parameters (16 bits of values, where one is reserved for
|
// kDontAdaptArgumentsSentinel). The value is only reliable when the function
|
// has been compiled.
|
inline uint16_t GetLength() const;
|
inline bool HasLength() const;
|
inline void set_length(int value);
|
|
// [internal formal parameter count]: The declared number of parameters.
|
// For subclass constructors, also includes new.target.
|
// The size of function's frame is internal_formal_parameter_count + 1.
|
DECL_UINT16_ACCESSORS(internal_formal_parameter_count)
|
|
// Set the formal parameter count so the function code will be
|
// called without using argument adaptor frames.
|
inline void DontAdaptArguments();
|
|
// [expected_nof_properties]: Expected number of properties for the
|
// function. The value is only reliable when the function has been compiled.
|
DECL_UINT8_ACCESSORS(expected_nof_properties)
|
|
#if V8_SFI_HAS_UNIQUE_ID
|
// [unique_id] - For --trace-maps purposes, an identifier that's persistent
|
// even if the GC moves this SharedFunctionInfo.
|
DECL_INT_ACCESSORS(unique_id)
|
#endif
|
|
// [function data]: This field holds some additional data for function.
|
// Currently it has one of:
|
// - a FunctionTemplateInfo to make benefit the API [IsApiFunction()].
|
// - a BytecodeArray for the interpreter [HasBytecodeArray()].
|
// - a InterpreterData with the BytecodeArray and a copy of the
|
// interpreter trampoline [HasInterpreterData()]
|
// - a FixedArray with Asm->Wasm conversion [HasAsmWasmData()].
|
// - a Smi containing the builtin id [HasBuiltinId()]
|
// - a UncompiledDataWithoutPreParsedScope for lazy compilation
|
// [HasUncompiledDataWithoutPreParsedScope()]
|
// - a UncompiledDataWithPreParsedScope for lazy compilation
|
// [HasUncompiledDataWithPreParsedScope()]
|
// - a WasmExportedFunctionData for Wasm [HasWasmExportedFunctionData()]
|
DECL_ACCESSORS(function_data, Object)
|
|
inline bool IsApiFunction() const;
|
inline FunctionTemplateInfo* get_api_func_data();
|
inline void set_api_func_data(FunctionTemplateInfo* data);
|
inline bool HasBytecodeArray() const;
|
inline BytecodeArray* GetBytecodeArray() const;
|
inline void set_bytecode_array(BytecodeArray* bytecode);
|
inline Code* InterpreterTrampoline() const;
|
inline bool HasInterpreterData() const;
|
inline InterpreterData* interpreter_data() const;
|
inline void set_interpreter_data(InterpreterData* interpreter_data);
|
inline BytecodeArray* GetDebugBytecodeArray() const;
|
inline void SetDebugBytecodeArray(BytecodeArray* bytecode);
|
inline bool HasAsmWasmData() const;
|
inline FixedArray* asm_wasm_data() const;
|
inline void set_asm_wasm_data(FixedArray* data);
|
|
// A brief note to clear up possible confusion:
|
// builtin_id corresponds to the auto-generated
|
// Builtins::Name id, while builtin_function_id corresponds to
|
// BuiltinFunctionId (a manually maintained list of 'interesting' functions
|
// mainly used during optimization).
|
inline bool HasBuiltinId() const;
|
inline int builtin_id() const;
|
inline void set_builtin_id(int builtin_id);
|
inline bool HasUncompiledData() const;
|
inline UncompiledData* uncompiled_data() const;
|
inline void set_uncompiled_data(UncompiledData* data);
|
inline bool HasUncompiledDataWithPreParsedScope() const;
|
inline UncompiledDataWithPreParsedScope*
|
uncompiled_data_with_pre_parsed_scope() const;
|
inline void set_uncompiled_data_with_pre_parsed_scope(
|
UncompiledDataWithPreParsedScope* data);
|
inline bool HasUncompiledDataWithoutPreParsedScope() const;
|
inline bool HasWasmExportedFunctionData() const;
|
WasmExportedFunctionData* wasm_exported_function_data() const;
|
inline void set_wasm_exported_function_data(WasmExportedFunctionData* data);
|
|
// Clear out pre-parsed scope data from UncompiledDataWithPreParsedScope,
|
// turning it into UncompiledDataWithoutPreParsedScope.
|
inline void ClearPreParsedScopeData();
|
|
// [raw_builtin_function_id]: The id of the built-in function this function
|
// represents, used during optimization to improve code generation.
|
// TODO(leszeks): Once there are no more JS builtins, this can be replaced
|
// by BuiltinId.
|
DECL_UINT8_ACCESSORS(raw_builtin_function_id)
|
inline bool HasBuiltinFunctionId();
|
inline BuiltinFunctionId builtin_function_id();
|
inline void set_builtin_function_id(BuiltinFunctionId id);
|
// Make sure BuiltinFunctionIds fit in a uint8_t
|
STATIC_ASSERT((std::is_same<std::underlying_type<BuiltinFunctionId>::type,
|
uint8_t>::value));
|
|
// The inferred_name is inferred from variable or property assignment of this
|
// function. It is used to facilitate debugging and profiling of JavaScript
|
// code written in OO style, where almost all functions are anonymous but are
|
// assigned to object properties.
|
inline bool HasInferredName();
|
inline String* inferred_name();
|
|
// Get the function literal id associated with this function, for parsing.
|
inline int FunctionLiteralId(Isolate* isolate) const;
|
|
// Break infos are contained in DebugInfo, this is a convenience method
|
// to simplify access.
|
bool HasBreakInfo() const;
|
bool BreakAtEntry() const;
|
|
// Coverage infos are contained in DebugInfo, this is a convenience method
|
// to simplify access.
|
bool HasCoverageInfo() const;
|
CoverageInfo* GetCoverageInfo() const;
|
|
// The function's name if it is non-empty, otherwise the inferred name.
|
String* DebugName();
|
|
// Used for flags such as --turbo-filter.
|
bool PassesFilter(const char* raw_filter);
|
|
// [script_or_debug_info]: One of:
|
// - Script from which the function originates.
|
// - a DebugInfo which holds the actual script [HasDebugInfo()].
|
DECL_ACCESSORS(script_or_debug_info, Object)
|
|
inline Object* script() const;
|
inline void set_script(Object* script);
|
|
// The function is subject to debugging if a debug info is attached.
|
inline bool HasDebugInfo() const;
|
inline DebugInfo* GetDebugInfo() const;
|
inline void SetDebugInfo(DebugInfo* debug_info);
|
|
// The offset of the 'function' token in the script source relative to the
|
// start position. Can return kFunctionTokenOutOfRange if offset doesn't
|
// fit in 16 bits.
|
DECL_UINT16_ACCESSORS(raw_function_token_offset)
|
|
// The position of the 'function' token in the script source. Can return
|
// kNoSourcePosition if raw_function_token_offset() returns
|
// kFunctionTokenOutOfRange.
|
inline int function_token_position() const;
|
|
// Returns true if the function has shared name.
|
inline bool HasSharedName() const;
|
|
// [flags] Bit field containing various flags about the function.
|
DECL_INT_ACCESSORS(flags)
|
|
// Is this function a named function expression in the source code.
|
DECL_BOOLEAN_ACCESSORS(is_named_expression)
|
|
// Is this function a top-level function (scripts, evals).
|
DECL_BOOLEAN_ACCESSORS(is_toplevel)
|
|
// Indicates if this function can be lazy compiled.
|
DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation)
|
|
// Indicates the language mode.
|
inline LanguageMode language_mode() const;
|
inline void set_language_mode(LanguageMode language_mode);
|
|
// Indicates whether the source is implicitly wrapped in a function.
|
DECL_BOOLEAN_ACCESSORS(is_wrapped)
|
|
// True if the function has any duplicated parameter names.
|
DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters)
|
|
// Indicates whether the function is a native function.
|
// These needs special treatment in .call and .apply since
|
// null passed as the receiver should not be translated to the
|
// global object.
|
DECL_BOOLEAN_ACCESSORS(native)
|
|
// Whether this function was created from a FunctionDeclaration.
|
DECL_BOOLEAN_ACCESSORS(is_declaration)
|
|
// Indicates that asm->wasm conversion failed and should not be re-attempted.
|
DECL_BOOLEAN_ACCESSORS(is_asm_wasm_broken)
|
|
// Indicates that the function was created by the Function function.
|
// Though it's anonymous, toString should treat it as if it had the name
|
// "anonymous". We don't set the name itself so that the system does not
|
// see a binding for it.
|
DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous)
|
|
// Indicates that the function is either an anonymous expression
|
// or an arrow function (the name field can be set through the API,
|
// which does not change this flag).
|
DECL_BOOLEAN_ACCESSORS(is_anonymous_expression)
|
|
// Indicates that the the shared function info is deserialized from cache.
|
DECL_BOOLEAN_ACCESSORS(deserialized)
|
|
// Indicates that the function has been reported for binary code coverage.
|
DECL_BOOLEAN_ACCESSORS(has_reported_binary_coverage)
|
|
inline FunctionKind kind() const;
|
|
// Defines the index in a native context of closure's map instantiated using
|
// this shared function info.
|
DECL_INT_ACCESSORS(function_map_index)
|
|
// Clear uninitialized padding space. This ensures that the snapshot content
|
// is deterministic.
|
inline void clear_padding();
|
|
// Recalculates the |map_index| value after modifications of this shared info.
|
inline void UpdateFunctionMapIndex();
|
|
// Indicates whether optimizations have been disabled for this shared function
|
// info. If we cannot optimize the function we disable optimization to avoid
|
// spending time attempting to optimize it again.
|
inline bool optimization_disabled() const;
|
|
// The reason why optimization was disabled.
|
inline BailoutReason disable_optimization_reason() const;
|
|
// Disable (further) attempted optimization of all functions sharing this
|
// shared function info.
|
void DisableOptimization(BailoutReason reason);
|
|
// This class constructor needs to call out to an instance fields
|
// initializer. This flag is set when creating the
|
// SharedFunctionInfo as a reminder to emit the initializer call
|
// when generating code later.
|
DECL_BOOLEAN_ACCESSORS(requires_instance_fields_initializer)
|
|
// [source code]: Source code for the function.
|
bool HasSourceCode() const;
|
static Handle<Object> GetSourceCode(Handle<SharedFunctionInfo> shared);
|
static Handle<Object> GetSourceCodeHarmony(Handle<SharedFunctionInfo> shared);
|
|
// Tells whether this function should be subject to debugging, e.g. for
|
// - scope inspection
|
// - internal break points
|
// - coverage and type profile
|
// - error stack trace
|
inline bool IsSubjectToDebugging();
|
|
// Whether this function is defined in user-provided JavaScript code.
|
inline bool IsUserJavaScript();
|
|
// True if one can flush compiled code from this function, in such a way that
|
// it can later be re-compiled.
|
inline bool CanDiscardCompiled() const;
|
|
// Flush compiled data from this function, setting it back to CompileLazy and
|
// clearing any feedback metadata.
|
static inline void DiscardCompiled(Isolate* isolate,
|
Handle<SharedFunctionInfo> shared_info);
|
|
// Check whether or not this function is inlineable.
|
bool IsInlineable();
|
|
// Source size of this function.
|
int SourceSize();
|
|
// Returns `false` if formal parameters include rest parameters, optional
|
// parameters, or destructuring parameters.
|
// TODO(caitp): make this a flag set during parsing
|
inline bool has_simple_parameters();
|
|
// Initialize a SharedFunctionInfo from a parsed function literal.
|
static void InitFromFunctionLiteral(Handle<SharedFunctionInfo> shared_info,
|
FunctionLiteral* lit, bool is_toplevel);
|
|
// Sets the expected number of properties based on estimate from parser.
|
void SetExpectedNofPropertiesFromEstimate(FunctionLiteral* literal);
|
|
// Sets the FunctionTokenOffset field based on the given token position and
|
// start position.
|
void SetFunctionTokenPosition(int function_token_position,
|
int start_position);
|
|
inline bool construct_as_builtin() const;
|
|
// Determines and sets the ConstructAsBuiltinBit in |flags|, based on the
|
// |function_data|. Must be called when creating the SFI after other fields
|
// are initialized. The ConstructAsBuiltinBit determines whether
|
// JSBuiltinsConstructStub or JSConstructStubGeneric should be called to
|
// construct this function.
|
inline void CalculateConstructAsBuiltin();
|
|
// Dispatched behavior.
|
DECL_PRINTER(SharedFunctionInfo)
|
DECL_VERIFIER(SharedFunctionInfo)
|
#ifdef OBJECT_PRINT
|
void PrintSourceCode(std::ostream& os);
|
#endif
|
|
// Iterate over all shared function infos in a given script.
|
class ScriptIterator {
|
public:
|
ScriptIterator(Isolate* isolate, Script* script);
|
ScriptIterator(Isolate* isolate,
|
Handle<WeakFixedArray> shared_function_infos);
|
SharedFunctionInfo* Next();
|
int CurrentIndex() const { return index_ - 1; }
|
|
// Reset the iterator to run on |script|.
|
void Reset(Script* script);
|
|
private:
|
Isolate* isolate_;
|
Handle<WeakFixedArray> shared_function_infos_;
|
int index_;
|
DISALLOW_COPY_AND_ASSIGN(ScriptIterator);
|
};
|
|
// Iterate over all shared function infos on the heap.
|
class GlobalIterator {
|
public:
|
explicit GlobalIterator(Isolate* isolate);
|
SharedFunctionInfo* Next();
|
|
private:
|
Script::Iterator script_iterator_;
|
WeakArrayList::Iterator noscript_sfi_iterator_;
|
SharedFunctionInfo::ScriptIterator sfi_iterator_;
|
DisallowHeapAllocation no_gc_;
|
DISALLOW_COPY_AND_ASSIGN(GlobalIterator);
|
};
|
|
DECL_CAST(SharedFunctionInfo)
|
|
// Constants.
|
static const uint16_t kDontAdaptArgumentsSentinel = static_cast<uint16_t>(-1);
|
|
static const int kMaximumFunctionTokenOffset = kMaxUInt16 - 1;
|
static const uint16_t kFunctionTokenOutOfRange = static_cast<uint16_t>(-1);
|
STATIC_ASSERT(kMaximumFunctionTokenOffset + 1 == kFunctionTokenOutOfRange);
|
|
#if V8_SFI_HAS_UNIQUE_ID
|
static const int kUniqueIdFieldSize = kInt32Size;
|
#else
|
// Just to not break the postmortrem support with conditional offsets
|
static const int kUniqueIdFieldSize = 0;
|
#endif
|
|
// Layout description.
|
#define SHARED_FUNCTION_INFO_FIELDS(V) \
|
/* Pointer fields. */ \
|
V(kStartOfPointerFieldsOffset, 0) \
|
V(kFunctionDataOffset, kPointerSize) \
|
V(kNameOrScopeInfoOffset, kPointerSize) \
|
V(kOuterScopeInfoOrFeedbackMetadataOffset, kPointerSize) \
|
V(kScriptOrDebugInfoOffset, kPointerSize) \
|
V(kEndOfPointerFieldsOffset, 0) \
|
/* Raw data fields. */ \
|
V(kUniqueIdOffset, kUniqueIdFieldSize) \
|
V(kLengthOffset, kUInt16Size) \
|
V(kFormalParameterCountOffset, kUInt16Size) \
|
V(kExpectedNofPropertiesOffset, kUInt8Size) \
|
V(kBuiltinFunctionId, kUInt8Size) \
|
V(kFunctionTokenOffsetOffset, kUInt16Size) \
|
V(kFlagsOffset, kInt32Size) \
|
/* Total size. */ \
|
V(kSize, 0)
|
|
DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
|
SHARED_FUNCTION_INFO_FIELDS)
|
#undef SHARED_FUNCTION_INFO_FIELDS
|
|
static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
|
|
typedef FixedBodyDescriptor<kStartOfPointerFieldsOffset,
|
kEndOfPointerFieldsOffset, kAlignedSize>
|
BodyDescriptor;
|
// No weak fields.
|
typedef BodyDescriptor BodyDescriptorWeak;
|
|
// Bit positions in |flags|.
|
#define FLAGS_BIT_FIELDS(V, _) \
|
V(IsNativeBit, bool, 1, _) \
|
V(IsStrictBit, bool, 1, _) \
|
V(IsWrappedBit, bool, 1, _) \
|
V(IsClassConstructorBit, bool, 1, _) \
|
V(IsDerivedConstructorBit, bool, 1, _) \
|
V(FunctionKindBits, FunctionKind, 5, _) \
|
V(HasDuplicateParametersBit, bool, 1, _) \
|
V(AllowLazyCompilationBit, bool, 1, _) \
|
V(NeedsHomeObjectBit, bool, 1, _) \
|
V(IsDeclarationBit, bool, 1, _) \
|
V(IsAsmWasmBrokenBit, bool, 1, _) \
|
V(FunctionMapIndexBits, int, 5, _) \
|
V(DisabledOptimizationReasonBits, BailoutReason, 4, _) \
|
V(RequiresInstanceFieldsInitializer, bool, 1, _) \
|
V(ConstructAsBuiltinBit, bool, 1, _) \
|
V(IsAnonymousExpressionBit, bool, 1, _) \
|
V(NameShouldPrintAsAnonymousBit, bool, 1, _) \
|
V(IsDeserializedBit, bool, 1, _) \
|
V(HasReportedBinaryCoverageBit, bool, 1, _) \
|
V(IsNamedExpressionBit, bool, 1, _) \
|
V(IsTopLevelBit, bool, 1, _)
|
DEFINE_BIT_FIELDS(FLAGS_BIT_FIELDS)
|
#undef FLAGS_BIT_FIELDS
|
|
// Bailout reasons must fit in the DisabledOptimizationReason bitfield.
|
STATIC_ASSERT(BailoutReason::kLastErrorMessage <=
|
DisabledOptimizationReasonBits::kMax);
|
|
STATIC_ASSERT(kLastFunctionKind <= FunctionKindBits::kMax);
|
|
// Indicates that this function uses a super property (or an eval that may
|
// use a super property).
|
// This is needed to set up the [[HomeObject]] on the function instance.
|
inline bool needs_home_object() const;
|
|
private:
|
// [name_or_scope_info]: Function name string, kNoSharedNameSentinel or
|
// ScopeInfo.
|
DECL_ACCESSORS(name_or_scope_info, Object)
|
|
// [outer scope info] The outer scope info, needed to lazily parse this
|
// function.
|
DECL_ACCESSORS(outer_scope_info, HeapObject)
|
|
inline void set_kind(FunctionKind kind);
|
|
inline void set_needs_home_object(bool value);
|
|
friend class Factory;
|
friend class V8HeapExplorer;
|
FRIEND_TEST(PreParserTest, LazyFunctionLength);
|
|
inline uint16_t length() const;
|
|
// Find the index of this function in the parent script. Slow path of
|
// FunctionLiteralId.
|
int FindIndexInScript(Isolate* isolate) const;
|
|
DISALLOW_IMPLICIT_CONSTRUCTORS(SharedFunctionInfo);
|
};
|
|
// Printing support.
|
struct SourceCodeOf {
|
explicit SourceCodeOf(SharedFunctionInfo* v, int max = -1)
|
: value(v), max_length(max) {}
|
const SharedFunctionInfo* value;
|
int max_length;
|
};
|
|
std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
|
|
} // namespace internal
|
} // namespace v8
|
|
#include "src/objects/object-macros-undef.h"
|
|
#endif // V8_OBJECTS_SHARED_FUNCTION_INFO_H_
|
