LCOV - code coverage report
Current view: top level - src/objects - shared-function-info.h (source / functions) Hit Total Coverage
Test: app.info Lines: 10 10 100.0 %
Date: 2019-02-19 Functions: 6 6 100.0 %

          Line data    Source code
       1             : // Copyright 2017 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_OBJECTS_SHARED_FUNCTION_INFO_H_
       6             : #define V8_OBJECTS_SHARED_FUNCTION_INFO_H_
       7             : 
       8             : #include "src/bailout-reason.h"
       9             : #include "src/function-kind.h"
      10             : #include "src/objects.h"
      11             : #include "src/objects/builtin-function-id.h"
      12             : #include "src/objects/script.h"
      13             : #include "src/objects/smi.h"
      14             : #include "src/objects/struct.h"
      15             : #include "torque-generated/class-definitions-from-dsl.h"
      16             : 
      17             : // Has to be the last include (doesn't have include guards):
      18             : #include "src/objects/object-macros.h"
      19             : 
      20             : namespace v8 {
      21             : namespace internal {
      22             : 
      23             : class AsmWasmData;
      24             : class BytecodeArray;
      25             : class CoverageInfo;
      26             : class DebugInfo;
      27             : class IsCompiledScope;
      28             : class WasmExportedFunctionData;
      29             : 
      30             : // Data collected by the pre-parser storing information about scopes and inner
      31             : // functions.
      32             : //
      33             : // PreparseData Layout:
      34             : // +-------------------------------+
      35             : // | data_length | children_length |
      36             : // +-------------------------------+
      37             : // | Scope Byte Data ...           |
      38             : // | ...                           |
      39             : // +-------------------------------+
      40             : // | [Padding]                     |
      41             : // +-------------------------------+
      42             : // | Inner PreparseData 1          |
      43             : // +-------------------------------+
      44             : // | ...                           |
      45             : // +-------------------------------+
      46             : // | Inner PreparseData N          |
      47             : // +-------------------------------+
      48             : class PreparseData : public HeapObject {
      49             :  public:
      50             :   DECL_INT_ACCESSORS(data_length)
      51             :   DECL_INT_ACCESSORS(children_length)
      52             : 
      53             :   inline int inner_start_offset() const;
      54             :   inline ObjectSlot inner_data_start() const;
      55             : 
      56             :   inline byte get(int index) const;
      57             :   inline void set(int index, byte value);
      58             :   inline void copy_in(int index, const byte* buffer, int length);
      59             : 
      60             :   inline PreparseData get_child(int index) const;
      61             :   inline void set_child(int index, PreparseData value,
      62             :                         WriteBarrierMode mode = UPDATE_WRITE_BARRIER);
      63             : 
      64             :   // Clear uninitialized padding space.
      65             :   inline void clear_padding();
      66             : 
      67             :   DECL_CAST(PreparseData)
      68             :   DECL_PRINTER(PreparseData)
      69             :   DECL_VERIFIER(PreparseData)
      70             : 
      71             : // Layout description.
      72             : #define PREPARSE_DATA_FIELDS(V)     \
      73             :   V(kDataLengthOffset, kInt32Size)  \
      74             :   V(kInnerLengthOffset, kInt32Size) \
      75             :   /* Header size. */                \
      76             :   V(kDataStartOffset, 0)            \
      77             :   V(kHeaderSize, 0)
      78             : 
      79             :   DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, PREPARSE_DATA_FIELDS)
      80             : #undef PREPARSE_DATA_FIELDS
      81             : 
      82             :   class BodyDescriptor;
      83             : 
      84             :   static int InnerOffset(int data_length) {
      85      454587 :     return RoundUp(kDataStartOffset + data_length * kByteSize, kTaggedSize);
      86             :   }
      87             : 
      88             :   static int SizeFor(int data_length, int children_length) {
      89      318454 :     return InnerOffset(data_length) + children_length * kTaggedSize;
      90             :   }
      91             : 
      92       49953 :   OBJECT_CONSTRUCTORS(PreparseData, HeapObject);
      93             : 
      94             :  private:
      95             :   inline Object get_child_raw(int index) const;
      96             : };
      97             : 
      98             : // Abstract class representing extra data for an uncompiled function, which is
      99             : // not stored in the SharedFunctionInfo.
     100             : class UncompiledData : public HeapObject {
     101             :  public:
     102             :   DECL_ACCESSORS(inferred_name, String)
     103             :   DECL_INT32_ACCESSORS(start_position)
     104             :   DECL_INT32_ACCESSORS(end_position)
     105             :   DECL_INT32_ACCESSORS(function_literal_id)
     106             : 
     107             :   // Returns true if the UncompiledData contains a valid function_literal_id.
     108             :   inline bool has_function_literal_id();
     109             : 
     110             :   DECL_CAST(UncompiledData)
     111             : 
     112             :   inline static void Initialize(
     113             :       UncompiledData data, String inferred_name, int start_position,
     114             :       int end_position, int function_literal_id,
     115             :       std::function<void(HeapObject object, ObjectSlot slot, HeapObject target)>
     116             :           gc_notify_updated_slot =
     117             :               [](HeapObject object, ObjectSlot slot, HeapObject target) {});
     118             : 
     119             :   // Layout description.
     120             : #define UNCOMPILED_DATA_FIELDS(V)                                         \
     121             :   V(kStartOfPointerFieldsOffset, 0)                                       \
     122             :   V(kInferredNameOffset, kTaggedSize)                                     \
     123             :   V(kEndOfTaggedFieldsOffset, 0)                                          \
     124             :   /* Raw data fields. */                                                  \
     125             :   V(kStartPositionOffset, kInt32Size)                                     \
     126             :   V(kEndPositionOffset, kInt32Size)                                       \
     127             :   V(kFunctionLiteralIdOffset, kInt32Size)                                 \
     128             :   V(kOptionalPaddingOffset, POINTER_SIZE_PADDING(kOptionalPaddingOffset)) \
     129             :   /* Header size. */                                                      \
     130             :   V(kSize, 0)
     131             : 
     132             :   DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, UNCOMPILED_DATA_FIELDS)
     133             : #undef UNCOMPILED_DATA_FIELDS
     134             : 
     135             :   typedef FixedBodyDescriptor<kStartOfPointerFieldsOffset,
     136             :                               kEndOfTaggedFieldsOffset, kSize>
     137             :       BodyDescriptor;
     138             : 
     139             :   // Clear uninitialized padding space.
     140             :   inline void clear_padding();
     141             : 
     142             :   OBJECT_CONSTRUCTORS(UncompiledData, HeapObject);
     143             : };
     144             : 
     145             : // Class representing data for an uncompiled function that does not have any
     146             : // data from the pre-parser, either because it's a leaf function or because the
     147             : // pre-parser bailed out.
     148             : class UncompiledDataWithoutPreparseData : public UncompiledData {
     149             :  public:
     150             :   DECL_CAST(UncompiledDataWithoutPreparseData)
     151             :   DECL_PRINTER(UncompiledDataWithoutPreparseData)
     152             :   DECL_VERIFIER(UncompiledDataWithoutPreparseData)
     153             : 
     154             :   static const int kSize = UncompiledData::kSize;
     155             : 
     156             :   // No extra fields compared to UncompiledData.
     157             :   typedef UncompiledData::BodyDescriptor BodyDescriptor;
     158             : 
     159     6868177 :   OBJECT_CONSTRUCTORS(UncompiledDataWithoutPreparseData, UncompiledData);
     160             : };
     161             : 
     162             : // Class representing data for an uncompiled function that has pre-parsed scope
     163             : // data.
     164             : class UncompiledDataWithPreparseData : public UncompiledData {
     165             :  public:
     166             :   DECL_ACCESSORS(preparse_data, PreparseData)
     167             : 
     168             :   DECL_CAST(UncompiledDataWithPreparseData)
     169             :   DECL_PRINTER(UncompiledDataWithPreparseData)
     170             :   DECL_VERIFIER(UncompiledDataWithPreparseData)
     171             : 
     172             :   inline static void Initialize(
     173             :       UncompiledDataWithPreparseData data, String inferred_name,
     174             :       int start_position, int end_position, int function_literal_id,
     175             :       PreparseData scope_data,
     176             :       std::function<void(HeapObject object, ObjectSlot slot, HeapObject target)>
     177             :           gc_notify_updated_slot =
     178             :               [](HeapObject object, ObjectSlot slot, HeapObject target) {});
     179             : 
     180             :   // Layout description.
     181             : 
     182             : #define UNCOMPILED_DATA_WITH_PREPARSE_DATA_FIELDS(V) \
     183             :   V(kStartOfPointerFieldsOffset, 0)                  \
     184             :   V(kPreparseDataOffset, kTaggedSize)                \
     185             :   V(kEndOfTaggedFieldsOffset, 0)                     \
     186             :   /* Total size. */                                  \
     187             :   V(kSize, 0)
     188             : 
     189             :   DEFINE_FIELD_OFFSET_CONSTANTS(UncompiledData::kSize,
     190             :                                 UNCOMPILED_DATA_WITH_PREPARSE_DATA_FIELDS)
     191             : #undef UNCOMPILED_DATA_WITH_PREPARSE_DATA_FIELDS
     192             : 
     193             :   // Make sure the size is aligned
     194             :   STATIC_ASSERT(kSize == POINTER_SIZE_ALIGN(kSize));
     195             : 
     196             :   typedef SubclassBodyDescriptor<
     197             :       UncompiledData::BodyDescriptor,
     198             :       FixedBodyDescriptor<kStartOfPointerFieldsOffset, kEndOfTaggedFieldsOffset,
     199             :                           kSize>>
     200             :       BodyDescriptor;
     201             : 
     202       43488 :   OBJECT_CONSTRUCTORS(UncompiledDataWithPreparseData, UncompiledData);
     203             : };
     204             : 
     205             : class InterpreterData : public Struct {
     206             :  public:
     207             :   DECL_ACCESSORS(bytecode_array, BytecodeArray)
     208             :   DECL_ACCESSORS(interpreter_trampoline, Code)
     209             : 
     210             : // Layout description.
     211             : #define INTERPRETER_DATA_FIELDS(V)             \
     212             :   V(kBytecodeArrayOffset, kTaggedSize)         \
     213             :   V(kInterpreterTrampolineOffset, kTaggedSize) \
     214             :   /* Total size. */                            \
     215             :   V(kSize, 0)
     216             : 
     217             :   DEFINE_FIELD_OFFSET_CONSTANTS(Struct::kHeaderSize, INTERPRETER_DATA_FIELDS)
     218             : #undef INTERPRETER_DATA_FIELDS
     219             : 
     220             :   DECL_CAST(InterpreterData)
     221             :   DECL_PRINTER(InterpreterData)
     222             :   DECL_VERIFIER(InterpreterData)
     223             : 
     224             :   OBJECT_CONSTRUCTORS(InterpreterData, Struct);
     225             : };
     226             : 
     227             : // SharedFunctionInfo describes the JSFunction information that can be
     228             : // shared by multiple instances of the function.
     229             : class SharedFunctionInfo : public HeapObject {
     230             :  public:
     231             :   NEVER_READ_ONLY_SPACE
     232             :   static constexpr Object const kNoSharedNameSentinel = Smi::kZero;
     233             : 
     234             :   // [name]: Returns shared name if it exists or an empty string otherwise.
     235             :   inline String Name() const;
     236             :   inline void SetName(String name);
     237             : 
     238             :   // Get the code object which represents the execution of this function.
     239             :   Code GetCode() const;
     240             : 
     241             :   // Get the abstract code associated with the function, which will either be
     242             :   // a Code object or a BytecodeArray.
     243             :   inline AbstractCode abstract_code();
     244             : 
     245             :   // Tells whether or not this shared function info is interpreted.
     246             :   //
     247             :   // Note: function->IsInterpreted() does not necessarily return the same value
     248             :   // as function->shared()->IsInterpreted() because the closure might have been
     249             :   // optimized.
     250             :   inline bool IsInterpreted() const;
     251             : 
     252             :   // Set up the link between shared function info and the script. The shared
     253             :   // function info is added to the list on the script.
     254             :   V8_EXPORT_PRIVATE static void SetScript(
     255             :       Handle<SharedFunctionInfo> shared, Handle<Object> script_object,
     256             :       int function_literal_id, bool reset_preparsed_scope_data = true);
     257             : 
     258             :   // Layout description of the optimized code map.
     259             :   static const int kEntriesStart = 0;
     260             :   static const int kContextOffset = 0;
     261             :   static const int kCachedCodeOffset = 1;
     262             :   static const int kEntryLength = 2;
     263             :   static const int kInitialLength = kEntriesStart + kEntryLength;
     264             : 
     265             :   static const int kNotFound = -1;
     266             :   static const uint16_t kInvalidLength = static_cast<uint16_t>(-1);
     267             : 
     268             :   // [scope_info]: Scope info.
     269             :   DECL_ACCESSORS(scope_info, ScopeInfo)
     270             : 
     271             :   // End position of this function in the script source.
     272             :   V8_EXPORT_PRIVATE int EndPosition() const;
     273             : 
     274             :   // Start position of this function in the script source.
     275             :   V8_EXPORT_PRIVATE int StartPosition() const;
     276             : 
     277             :   // Set the start and end position of this function in the script source.
     278             :   // Updates the scope info if available.
     279             :   V8_EXPORT_PRIVATE void SetPosition(int start_position, int end_position);
     280             : 
     281             :   // [outer scope info | feedback metadata] Shared storage for outer scope info
     282             :   // (on uncompiled functions) and feedback metadata (on compiled functions).
     283             :   DECL_ACCESSORS(raw_outer_scope_info_or_feedback_metadata, HeapObject)
     284             : 
     285             :   // Get the outer scope info whether this function is compiled or not.
     286             :   inline bool HasOuterScopeInfo() const;
     287             :   inline ScopeInfo GetOuterScopeInfo() const;
     288             : 
     289             :   // [feedback metadata] Metadata template for feedback vectors of instances of
     290             :   // this function.
     291             :   inline bool HasFeedbackMetadata() const;
     292             :   DECL_ACCESSORS(feedback_metadata, FeedbackMetadata)
     293             : 
     294             :   // Returns if this function has been compiled yet. Note: with bytecode
     295             :   // flushing, any GC after this call is made could cause the function
     296             :   // to become uncompiled. If you need to ensure the function remains compiled
     297             :   // for some period of time, use IsCompiledScope instead.
     298             :   inline bool is_compiled() const;
     299             : 
     300             :   // Returns an IsCompiledScope which reports whether the function is compiled,
     301             :   // and if compiled, will avoid the function becoming uncompiled while it is
     302             :   // held.
     303             :   inline IsCompiledScope is_compiled_scope() const;
     304             : 
     305             :   // [length]: The function length - usually the number of declared parameters.
     306             :   // Use up to 2^16-2 parameters (16 bits of values, where one is reserved for
     307             :   // kDontAdaptArgumentsSentinel). The value is only reliable when the function
     308             :   // has been compiled.
     309             :   inline uint16_t GetLength() const;
     310             :   inline bool HasLength() const;
     311             :   inline void set_length(int value);
     312             : 
     313             :   // [internal formal parameter count]: The declared number of parameters.
     314             :   // For subclass constructors, also includes new.target.
     315             :   // The size of function's frame is internal_formal_parameter_count + 1.
     316             :   DECL_UINT16_ACCESSORS(internal_formal_parameter_count)
     317             : 
     318             :   // Set the formal parameter count so the function code will be
     319             :   // called without using argument adaptor frames.
     320             :   inline void DontAdaptArguments();
     321             : 
     322             :   // [expected_nof_properties]: Expected number of properties for the
     323             :   // function. The value is only reliable when the function has been compiled.
     324             :   DECL_UINT8_ACCESSORS(expected_nof_properties)
     325             : 
     326             :   // [function data]: This field holds some additional data for function.
     327             :   // Currently it has one of:
     328             :   //  - a FunctionTemplateInfo to make benefit the API [IsApiFunction()].
     329             :   //  - a BytecodeArray for the interpreter [HasBytecodeArray()].
     330             :   //  - a InterpreterData with the BytecodeArray and a copy of the
     331             :   //    interpreter trampoline [HasInterpreterData()]
     332             :   //  - an AsmWasmData with Asm->Wasm conversion [HasAsmWasmData()].
     333             :   //  - a Smi containing the builtin id [HasBuiltinId()]
     334             :   //  - a UncompiledDataWithoutPreparseData for lazy compilation
     335             :   //    [HasUncompiledDataWithoutPreparseData()]
     336             :   //  - a UncompiledDataWithPreparseData for lazy compilation
     337             :   //    [HasUncompiledDataWithPreparseData()]
     338             :   //  - a WasmExportedFunctionData for Wasm [HasWasmExportedFunctionData()]
     339             :   DECL_ACCESSORS(function_data, Object)
     340             : 
     341             :   inline bool IsApiFunction() const;
     342             :   inline FunctionTemplateInfo get_api_func_data();
     343             :   inline void set_api_func_data(FunctionTemplateInfo data);
     344             :   inline bool HasBytecodeArray() const;
     345             :   inline BytecodeArray GetBytecodeArray() const;
     346             :   inline void set_bytecode_array(BytecodeArray bytecode);
     347             :   inline Code InterpreterTrampoline() const;
     348             :   inline bool HasInterpreterData() const;
     349             :   inline InterpreterData interpreter_data() const;
     350             :   inline void set_interpreter_data(InterpreterData interpreter_data);
     351             :   inline BytecodeArray GetDebugBytecodeArray() const;
     352             :   inline void SetDebugBytecodeArray(BytecodeArray bytecode);
     353             :   inline bool HasAsmWasmData() const;
     354             :   inline AsmWasmData asm_wasm_data() const;
     355             :   inline void set_asm_wasm_data(AsmWasmData data);
     356             : 
     357             :   // A brief note to clear up possible confusion:
     358             :   // builtin_id corresponds to the auto-generated
     359             :   // Builtins::Name id, while builtin_function_id corresponds to
     360             :   // BuiltinFunctionId (a manually maintained list of 'interesting' functions
     361             :   // mainly used during optimization).
     362             :   inline bool HasBuiltinId() const;
     363             :   inline int builtin_id() const;
     364             :   inline void set_builtin_id(int builtin_id);
     365             :   inline bool HasUncompiledData() const;
     366             :   inline UncompiledData uncompiled_data() const;
     367             :   inline void set_uncompiled_data(UncompiledData data);
     368             :   inline bool HasUncompiledDataWithPreparseData() const;
     369             :   inline UncompiledDataWithPreparseData uncompiled_data_with_preparse_data()
     370             :       const;
     371             :   inline void set_uncompiled_data_with_preparse_data(
     372             :       UncompiledDataWithPreparseData data);
     373             :   inline bool HasUncompiledDataWithoutPreparseData() const;
     374             :   inline bool HasWasmExportedFunctionData() const;
     375             :   WasmExportedFunctionData wasm_exported_function_data() const;
     376             : 
     377             :   // Clear out pre-parsed scope data from UncompiledDataWithPreparseData,
     378             :   // turning it into UncompiledDataWithoutPreparseData.
     379             :   inline void ClearPreparseData();
     380             : 
     381             :   // [raw_builtin_function_id]: The id of the built-in function this function
     382             :   // represents, used during optimization to improve code generation.
     383             :   // TODO(leszeks): Once there are no more JS builtins, this can be replaced
     384             :   // by BuiltinId.
     385             :   DECL_UINT8_ACCESSORS(raw_builtin_function_id)
     386             :   inline bool HasBuiltinFunctionId();
     387             :   inline BuiltinFunctionId builtin_function_id();
     388             :   inline void set_builtin_function_id(BuiltinFunctionId id);
     389             :   // Make sure BuiltinFunctionIds fit in a uint8_t
     390             :   STATIC_ASSERT((std::is_same<std::underlying_type<BuiltinFunctionId>::type,
     391             :                               uint8_t>::value));
     392             : 
     393             :   // The inferred_name is inferred from variable or property assignment of this
     394             :   // function. It is used to facilitate debugging and profiling of JavaScript
     395             :   // code written in OO style, where almost all functions are anonymous but are
     396             :   // assigned to object properties.
     397             :   inline bool HasInferredName();
     398             :   inline String inferred_name();
     399             : 
     400             :   // Get the function literal id associated with this function, for parsing.
     401             :   V8_EXPORT_PRIVATE int FunctionLiteralId(Isolate* isolate) const;
     402             : 
     403             :   // Break infos are contained in DebugInfo, this is a convenience method
     404             :   // to simplify access.
     405             :   bool HasBreakInfo() const;
     406             :   bool BreakAtEntry() const;
     407             : 
     408             :   // Coverage infos are contained in DebugInfo, this is a convenience method
     409             :   // to simplify access.
     410             :   bool HasCoverageInfo() const;
     411             :   CoverageInfo GetCoverageInfo() const;
     412             : 
     413             :   // The function's name if it is non-empty, otherwise the inferred name.
     414             :   String DebugName();
     415             : 
     416             :   // Used for flags such as --turbo-filter.
     417             :   bool PassesFilter(const char* raw_filter);
     418             : 
     419             :   // [script_or_debug_info]: One of:
     420             :   //  - Script from which the function originates.
     421             :   //  - a DebugInfo which holds the actual script [HasDebugInfo()].
     422             :   DECL_ACCESSORS(script_or_debug_info, Object)
     423             : 
     424             :   inline Object script() const;
     425             :   inline void set_script(Object script);
     426             : 
     427             :   // The function is subject to debugging if a debug info is attached.
     428             :   inline bool HasDebugInfo() const;
     429             :   inline DebugInfo GetDebugInfo() const;
     430             :   inline void SetDebugInfo(DebugInfo debug_info);
     431             : 
     432             :   // The offset of the 'function' token in the script source relative to the
     433             :   // start position. Can return kFunctionTokenOutOfRange if offset doesn't
     434             :   // fit in 16 bits.
     435             :   DECL_UINT16_ACCESSORS(raw_function_token_offset)
     436             : 
     437             :   // The position of the 'function' token in the script source. Can return
     438             :   // kNoSourcePosition if raw_function_token_offset() returns
     439             :   // kFunctionTokenOutOfRange.
     440             :   inline int function_token_position() const;
     441             : 
     442             :   // Returns true if the function has shared name.
     443             :   inline bool HasSharedName() const;
     444             : 
     445             :   // [flags] Bit field containing various flags about the function.
     446             :   DECL_INT32_ACCESSORS(flags)
     447             : 
     448             :   // Is this function a named function expression in the source code.
     449             :   DECL_BOOLEAN_ACCESSORS(is_named_expression)
     450             : 
     451             :   // Is this function a top-level function (scripts, evals).
     452             :   DECL_BOOLEAN_ACCESSORS(is_toplevel)
     453             : 
     454             :   // Indicates if this function can be lazy compiled.
     455             :   DECL_BOOLEAN_ACCESSORS(allows_lazy_compilation)
     456             : 
     457             :   // Indicates the language mode.
     458             :   inline LanguageMode language_mode() const;
     459             :   inline void set_language_mode(LanguageMode language_mode);
     460             : 
     461             :   // Indicates whether the source is implicitly wrapped in a function.
     462             :   DECL_BOOLEAN_ACCESSORS(is_wrapped)
     463             : 
     464             :   // True if the function has any duplicated parameter names.
     465             :   DECL_BOOLEAN_ACCESSORS(has_duplicate_parameters)
     466             : 
     467             :   // Indicates whether the function is a native function.
     468             :   // These needs special treatment in .call and .apply since
     469             :   // null passed as the receiver should not be translated to the
     470             :   // global object.
     471             :   DECL_BOOLEAN_ACCESSORS(native)
     472             : 
     473             :   // Whether this function was created from a FunctionDeclaration.
     474             :   DECL_BOOLEAN_ACCESSORS(is_declaration)
     475             : 
     476             :   // Indicates that asm->wasm conversion failed and should not be re-attempted.
     477             :   DECL_BOOLEAN_ACCESSORS(is_asm_wasm_broken)
     478             : 
     479             :   // Indicates that the function was created by the Function function.
     480             :   // Though it's anonymous, toString should treat it as if it had the name
     481             :   // "anonymous".  We don't set the name itself so that the system does not
     482             :   // see a binding for it.
     483             :   DECL_BOOLEAN_ACCESSORS(name_should_print_as_anonymous)
     484             : 
     485             :   // Indicates that the function is either an anonymous expression
     486             :   // or an arrow function (the name field can be set through the API,
     487             :   // which does not change this flag).
     488             :   DECL_BOOLEAN_ACCESSORS(is_anonymous_expression)
     489             : 
     490             :   // Indicates that the function represented by the shared function info was
     491             :   // classed as an immediately invoked function execution (IIFE) function and
     492             :   // is only executed once.
     493             :   DECL_BOOLEAN_ACCESSORS(is_oneshot_iife)
     494             : 
     495             :   // Indicates that the function has been reported for binary code coverage.
     496             :   DECL_BOOLEAN_ACCESSORS(has_reported_binary_coverage)
     497             : 
     498             :   inline FunctionKind kind() const;
     499             : 
     500             :   // Defines the index in a native context of closure's map instantiated using
     501             :   // this shared function info.
     502             :   DECL_INT_ACCESSORS(function_map_index)
     503             : 
     504             :   // Clear uninitialized padding space. This ensures that the snapshot content
     505             :   // is deterministic.
     506             :   inline void clear_padding();
     507             : 
     508             :   // Recalculates the |map_index| value after modifications of this shared info.
     509             :   inline void UpdateFunctionMapIndex();
     510             : 
     511             :   // Indicates whether optimizations have been disabled for this shared function
     512             :   // info. If we cannot optimize the function we disable optimization to avoid
     513             :   // spending time attempting to optimize it again.
     514             :   inline bool optimization_disabled() const;
     515             : 
     516             :   // The reason why optimization was disabled.
     517             :   inline BailoutReason disable_optimization_reason() const;
     518             : 
     519             :   // Disable (further) attempted optimization of all functions sharing this
     520             :   // shared function info.
     521             :   void DisableOptimization(BailoutReason reason);
     522             : 
     523             :   // This class constructor needs to call out to an instance fields
     524             :   // initializer. This flag is set when creating the
     525             :   // SharedFunctionInfo as a reminder to emit the initializer call
     526             :   // when generating code later.
     527             :   DECL_BOOLEAN_ACCESSORS(requires_instance_members_initializer)
     528             : 
     529             :   // [source code]: Source code for the function.
     530             :   bool HasSourceCode() const;
     531             :   static Handle<Object> GetSourceCode(Handle<SharedFunctionInfo> shared);
     532             :   static Handle<Object> GetSourceCodeHarmony(Handle<SharedFunctionInfo> shared);
     533             : 
     534             :   // Tells whether this function should be subject to debugging, e.g. for
     535             :   // - scope inspection
     536             :   // - internal break points
     537             :   // - coverage and type profile
     538             :   // - error stack trace
     539             :   inline bool IsSubjectToDebugging();
     540             : 
     541             :   // Whether this function is defined in user-provided JavaScript code.
     542             :   inline bool IsUserJavaScript();
     543             : 
     544             :   // True if one can flush compiled code from this function, in such a way that
     545             :   // it can later be re-compiled.
     546             :   inline bool CanDiscardCompiled() const;
     547             : 
     548             :   // Flush compiled data from this function, setting it back to CompileLazy and
     549             :   // clearing any compiled metadata.
     550             :   static void DiscardCompiled(Isolate* isolate,
     551             :                               Handle<SharedFunctionInfo> shared_info);
     552             : 
     553             :   // Discard the compiled metadata. If called during GC then
     554             :   // |gc_notify_updated_slot| should be used to record any slot updates.
     555             :   void DiscardCompiledMetadata(
     556             :       Isolate* isolate,
     557             :       std::function<void(HeapObject object, ObjectSlot slot, HeapObject target)>
     558             :           gc_notify_updated_slot =
     559             :               [](HeapObject object, ObjectSlot slot, HeapObject target) {});
     560             : 
     561             :   // Returns true if the function has old bytecode that could be flushed.
     562             :   inline bool ShouldFlushBytecode();
     563             : 
     564             :   // Check whether or not this function is inlineable.
     565             :   bool IsInlineable();
     566             : 
     567             :   // Source size of this function.
     568             :   int SourceSize();
     569             : 
     570             :   // Returns `false` if formal parameters include rest parameters, optional
     571             :   // parameters, or destructuring parameters.
     572             :   // TODO(caitp): make this a flag set during parsing
     573             :   inline bool has_simple_parameters();
     574             : 
     575             :   // Initialize a SharedFunctionInfo from a parsed function literal.
     576             :   static void InitFromFunctionLiteral(Handle<SharedFunctionInfo> shared_info,
     577             :                                       FunctionLiteral* lit, bool is_toplevel);
     578             : 
     579             :   // Sets the expected number of properties based on estimate from parser.
     580             :   void SetExpectedNofPropertiesFromEstimate(FunctionLiteral* literal);
     581             : 
     582             :   // Sets the FunctionTokenOffset field based on the given token position and
     583             :   // start position.
     584             :   void SetFunctionTokenPosition(int function_token_position,
     585             :                                 int start_position);
     586             : 
     587             :   static void EnsureSourcePositionsAvailable(
     588             :       Isolate* isolate, Handle<SharedFunctionInfo> shared_info);
     589             : 
     590             :   inline bool construct_as_builtin() const;
     591             : 
     592             :   // Determines and sets the ConstructAsBuiltinBit in |flags|, based on the
     593             :   // |function_data|. Must be called when creating the SFI after other fields
     594             :   // are initialized. The ConstructAsBuiltinBit determines whether
     595             :   // JSBuiltinsConstructStub or JSConstructStubGeneric should be called to
     596             :   // construct this function.
     597             :   inline void CalculateConstructAsBuiltin();
     598             : 
     599             :   // Dispatched behavior.
     600             :   DECL_PRINTER(SharedFunctionInfo)
     601             :   DECL_VERIFIER(SharedFunctionInfo)
     602             : #ifdef OBJECT_PRINT
     603             :   void PrintSourceCode(std::ostream& os);
     604             : #endif
     605             : 
     606             :   // Iterate over all shared function infos in a given script.
     607             :   class ScriptIterator {
     608             :    public:
     609             :     ScriptIterator(Isolate* isolate, Script script);
     610             :     ScriptIterator(Isolate* isolate,
     611             :                    Handle<WeakFixedArray> shared_function_infos);
     612             :     SharedFunctionInfo Next();
     613      112301 :     int CurrentIndex() const { return index_ - 1; }
     614             : 
     615             :     // Reset the iterator to run on |script|.
     616             :     void Reset(Script script);
     617             : 
     618             :    private:
     619             :     Isolate* isolate_;
     620             :     Handle<WeakFixedArray> shared_function_infos_;
     621             :     int index_;
     622             :     DISALLOW_COPY_AND_ASSIGN(ScriptIterator);
     623             :   };
     624             : 
     625             :   // Iterate over all shared function infos on the heap.
     626             :   class GlobalIterator {
     627             :    public:
     628             :     explicit GlobalIterator(Isolate* isolate);
     629             :     SharedFunctionInfo Next();
     630             : 
     631             :    private:
     632             :     Script::Iterator script_iterator_;
     633             :     WeakArrayList::Iterator noscript_sfi_iterator_;
     634             :     SharedFunctionInfo::ScriptIterator sfi_iterator_;
     635             :     DISALLOW_HEAP_ALLOCATION(no_gc_)
     636             :     DISALLOW_COPY_AND_ASSIGN(GlobalIterator);
     637             :   };
     638             : 
     639             :   DECL_CAST(SharedFunctionInfo)
     640             : 
     641             :   // Constants.
     642             :   static const uint16_t kDontAdaptArgumentsSentinel = static_cast<uint16_t>(-1);
     643             : 
     644             :   static const int kMaximumFunctionTokenOffset = kMaxUInt16 - 1;
     645             :   static const uint16_t kFunctionTokenOutOfRange = static_cast<uint16_t>(-1);
     646             :   STATIC_ASSERT(kMaximumFunctionTokenOffset + 1 == kFunctionTokenOutOfRange);
     647             : 
     648             :   DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
     649             :                                 SHARED_FUNCTION_INFO_FIELDS)
     650             : 
     651             :   static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
     652             : 
     653             :   class BodyDescriptor;
     654             : 
     655             : // Bit positions in |flags|.
     656             : #define FLAGS_BIT_FIELDS(V, _)                           \
     657             :   V(IsNativeBit, bool, 1, _)                             \
     658             :   V(IsStrictBit, bool, 1, _)                             \
     659             :   V(IsWrappedBit, bool, 1, _)                            \
     660             :   V(IsClassConstructorBit, bool, 1, _)                   \
     661             :   V(IsDerivedConstructorBit, bool, 1, _)                 \
     662             :   V(FunctionKindBits, FunctionKind, 5, _)                \
     663             :   V(HasDuplicateParametersBit, bool, 1, _)               \
     664             :   V(AllowLazyCompilationBit, bool, 1, _)                 \
     665             :   V(NeedsHomeObjectBit, bool, 1, _)                      \
     666             :   V(IsDeclarationBit, bool, 1, _)                        \
     667             :   V(IsAsmWasmBrokenBit, bool, 1, _)                      \
     668             :   V(FunctionMapIndexBits, int, 5, _)                     \
     669             :   V(DisabledOptimizationReasonBits, BailoutReason, 4, _) \
     670             :   V(RequiresInstanceMembersInitializer, bool, 1, _)      \
     671             :   V(ConstructAsBuiltinBit, bool, 1, _)                   \
     672             :   V(IsAnonymousExpressionBit, bool, 1, _)                \
     673             :   V(NameShouldPrintAsAnonymousBit, bool, 1, _)           \
     674             :   V(HasReportedBinaryCoverageBit, bool, 1, _)            \
     675             :   V(IsNamedExpressionBit, bool, 1, _)                    \
     676             :   V(IsTopLevelBit, bool, 1, _)                           \
     677             :   V(IsOneshotIIFEBit, bool, 1, _)
     678             :   DEFINE_BIT_FIELDS(FLAGS_BIT_FIELDS)
     679             : #undef FLAGS_BIT_FIELDS
     680             : 
     681             :   // Bailout reasons must fit in the DisabledOptimizationReason bitfield.
     682             :   STATIC_ASSERT(BailoutReason::kLastErrorMessage <=
     683             :                 DisabledOptimizationReasonBits::kMax);
     684             : 
     685             :   STATIC_ASSERT(kLastFunctionKind <= FunctionKindBits::kMax);
     686             : 
     687             :   // Indicates that this function uses a super property (or an eval that may
     688             :   // use a super property).
     689             :   // This is needed to set up the [[HomeObject]] on the function instance.
     690             :   inline bool needs_home_object() const;
     691             : 
     692             :   V8_INLINE bool IsSharedFunctionInfoWithID() const {
     693             : #if V8_SFI_HAS_UNIQUE_ID
     694             :     return true;
     695             : #else
     696             :     return false;
     697             : #endif
     698             :   }
     699             : 
     700             :  private:
     701             :   // [name_or_scope_info]: Function name string, kNoSharedNameSentinel or
     702             :   // ScopeInfo.
     703             :   DECL_ACCESSORS(name_or_scope_info, Object)
     704             : 
     705             :   // [outer scope info] The outer scope info, needed to lazily parse this
     706             :   // function.
     707             :   DECL_ACCESSORS(outer_scope_info, HeapObject)
     708             : 
     709             :   inline void set_kind(FunctionKind kind);
     710             : 
     711             :   inline void set_needs_home_object(bool value);
     712             : 
     713             :   friend class Factory;
     714             :   friend class V8HeapExplorer;
     715             :   FRIEND_TEST(PreParserTest, LazyFunctionLength);
     716             : 
     717             :   inline uint16_t length() const;
     718             : 
     719             :   // Find the index of this function in the parent script. Slow path of
     720             :   // FunctionLiteralId.
     721             :   int FindIndexInScript(Isolate* isolate) const;
     722             : 
     723    20435736 :   OBJECT_CONSTRUCTORS(SharedFunctionInfo, HeapObject);
     724             : };
     725             : 
     726             : class SharedFunctionInfoWithID : public SharedFunctionInfo {
     727             :  public:
     728             :   // [unique_id] - For --trace-maps purposes, an identifier that's persistent
     729             :   // even if the GC moves this SharedFunctionInfo.
     730             :   DECL_INT_ACCESSORS(unique_id)
     731             : 
     732             :   DECL_CAST(SharedFunctionInfoWithID)
     733             : 
     734             :   DEFINE_FIELD_OFFSET_CONSTANTS(SharedFunctionInfo::kSize,
     735             :                                 SHARED_FUNCTION_INFO_WITH_ID_FIELDS)
     736             : 
     737             :   static const int kAlignedSize = POINTER_SIZE_ALIGN(kSize);
     738             : 
     739             :   OBJECT_CONSTRUCTORS(SharedFunctionInfoWithID, SharedFunctionInfo);
     740             : };
     741             : 
     742             : // Printing support.
     743             : struct SourceCodeOf {
     744             :   explicit SourceCodeOf(SharedFunctionInfo v, int max = -1)
     745          24 :       : value(v), max_length(max) {}
     746             :   const SharedFunctionInfo value;
     747             :   int max_length;
     748             : };
     749             : 
     750             : // IsCompiledScope enables a caller to check if a function is compiled, and
     751             : // ensure it remains compiled (i.e., doesn't have it's bytecode flushed) while
     752             : // the scope is retained.
     753             : class IsCompiledScope {
     754             :  public:
     755             :   inline IsCompiledScope(const SharedFunctionInfo shared, Isolate* isolate);
     756    11557810 :   inline IsCompiledScope() : retain_bytecode_(), is_compiled_(false) {}
     757             : 
     758      279139 :   inline bool is_compiled() const { return is_compiled_; }
     759             : 
     760             :  private:
     761             :   MaybeHandle<BytecodeArray> retain_bytecode_;
     762             :   bool is_compiled_;
     763             : };
     764             : 
     765             : std::ostream& operator<<(std::ostream& os, const SourceCodeOf& v);
     766             : 
     767             : }  // namespace internal
     768             : }  // namespace v8
     769             : 
     770             : #include "src/objects/object-macros-undef.h"
     771             : 
     772             : #endif  // V8_OBJECTS_SHARED_FUNCTION_INFO_H_

Generated by: LCOV version 1.10