Changeset 198798 in webkit for trunk/Source/JavaScriptCore/runtime/Executable.h

Timestamp:

Mar 29, 2016, 2:04:21 PM (9 years ago)

Author:

[email protected]

Message:

Allow builtin JS functions to be intrinsics
​https://bugs.webkit.org/show_bug.cgi?id=155960

Reviewed by Mark Lam.

Source/JavaScriptCore:

Builtin functions can now be recognized as intrinsics inside
the DFG. This gives us the flexibility to either lower a builtin
as an intrinsic in the DFG or as a normal function call.
Because we may decide to not lower it as an intrinsic, the DFG
inliner could still inline the function call.

You can annotate a builtin function like so to make
it be recognized as an intrinsic.
`
[intrinsic=FooIntrinsic] function foo() { ... }
`
where FooIntrinsic is an enum value of the Intrinsic enum.

So in the future if we write RegExp.prototype.test as a builtin, we would do:
` RegExpPrototype.js
[intrinsic=RegExpTestIntrinsic] function test() { ... }
`

• Scripts/builtins/builtins_generate_combined_implementation.py:

(BuiltinsCombinedImplementationGenerator.generate_secondary_header_includes):

• Scripts/builtins/builtins_generate_separate_implementation.py:

(BuiltinsSeparateImplementationGenerator.generate_secondary_header_includes):

• Scripts/builtins/builtins_generator.py:

(BuiltinsGenerator.generate_embedded_code_string_section_for_function):

• Scripts/builtins/builtins_model.py:

(BuiltinObject.init):
(BuiltinFunction):
(BuiltinFunction.init):
(BuiltinFunction.fromString):
(BuiltinFunction.str):

• Scripts/builtins/builtins_templates.py:
• bytecode/UnlinkedFunctionExecutable.cpp:

(JSC::UnlinkedFunctionExecutable::visitChildren):
(JSC::UnlinkedFunctionExecutable::link):

• bytecode/UnlinkedFunctionExecutable.h:
• dfg/DFGByteCodeParser.cpp:

(JSC::DFG::ByteCodeParser::attemptToInlineCall):

• runtime/Executable.cpp:

(JSC::ExecutableBase::clearCode):
(JSC::NativeExecutable::destroy):
(JSC::ScriptExecutable::ScriptExecutable):
(JSC::EvalExecutable::create):
(JSC::EvalExecutable::EvalExecutable):
(JSC::ProgramExecutable::ProgramExecutable):
(JSC::ModuleProgramExecutable::ModuleProgramExecutable):
(JSC::FunctionExecutable::FunctionExecutable):
(JSC::ExecutableBase::intrinsic): Deleted.
(JSC::NativeExecutable::intrinsic): Deleted.

• runtime/Executable.h:

(JSC::ExecutableBase::ExecutableBase):
(JSC::ExecutableBase::hasJITCodeFor):
(JSC::ExecutableBase::intrinsic):
(JSC::ExecutableBase::intrinsicFor):
(JSC::ScriptExecutable::finishCreation):

• runtime/Intrinsic.h:

Source/WebCore:

• ForwardingHeaders/runtime/Intrinsic.h: Added.

File:

• trunk/Source/JavaScriptCore/runtime/Executable.h (modified) (9 diffs)

trunk/Source/JavaScriptCore/runtime/Executable.h

@@ -76 +76 @@
     static const int NUM_PARAMETERS_NOT_COMPILED = -1;
 
-    ExecutableBase(VM& vm, Structure* structure, int numParameters)
+    ExecutableBase(VM& vm, Structure* structure, int numParameters, Intrinsic intrinsic)
         : JSCell(vm, structure)
         , m_numParametersForCall(numParameters)
         , m_numParametersForConstruct(numParameters)
+        , m_intrinsic(intrinsic)
     {
     }
@@ -232 +233 @@
 
     // Intrinsics are only for calls, currently.
-    Intrinsic intrinsic() const;
+    Intrinsic intrinsic() const { return m_intrinsic; }
         
     Intrinsic intrinsicFor(CodeSpecializationKind kind) const
@@ -244 +245 @@
         
 protected:
+    Intrinsic m_intrinsic;
     RefPtr<JITCode> m_jitCodeForCall;
     RefPtr<JITCode> m_jitCodeForConstruct;
@@ -260 +262 @@
     {
         NativeExecutable* executable;
-        executable = new (NotNull, allocateCell<NativeExecutable>(vm.heap)) NativeExecutable(vm, function, constructor);
-        executable->finishCreation(vm, callThunk, constructThunk, intrinsic, name);
+        executable = new (NotNull, allocateCell<NativeExecutable>(vm.heap)) NativeExecutable(vm, function, constructor, intrinsic);
+        executable->finishCreation(vm, callThunk, constructThunk, name);
         return executable;
     }
@@ -297 +299 @@
 
 protected:
-    void finishCreation(VM& vm, PassRefPtr<JITCode> callThunk, PassRefPtr<JITCode> constructThunk, Intrinsic intrinsic, const String& name)
+    void finishCreation(VM& vm, PassRefPtr<JITCode> callThunk, PassRefPtr<JITCode> constructThunk, const String& name)
     {
         Base::finishCreation(vm);
         m_jitCodeForCall = callThunk;
         m_jitCodeForConstruct = constructThunk;
-        m_intrinsic = intrinsic;
         m_name = name;
     }
@@ -309 +310 @@
     friend class ExecutableBase;
 
-    NativeExecutable(VM& vm, NativeFunction function, NativeFunction constructor)
-        : ExecutableBase(vm, vm.nativeExecutableStructure.get(), NUM_PARAMETERS_IS_HOST)
+    NativeExecutable(VM& vm, NativeFunction function, NativeFunction constructor, Intrinsic intrinsic)
+        : ExecutableBase(vm, vm.nativeExecutableStructure.get(), NUM_PARAMETERS_IS_HOST, intrinsic)
         , m_function(function)
         , m_constructor(constructor)
@@ -400 +401 @@
 
 protected:
-    ScriptExecutable(Structure*, VM&, const SourceCode&, bool isInStrictContext, DerivedContextType, bool isInArrowFunctionContext);
+    ScriptExecutable(Structure*, VM&, const SourceCode&, bool isInStrictContext, DerivedContextType, bool isInArrowFunctionContext, Intrinsic);
 
     void finishCreation(VM& vm)
@@ -581 +582 @@
     static FunctionExecutable* create(
         VM& vm, const SourceCode& source, UnlinkedFunctionExecutable* unlinkedExecutable, 
-        unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn)
-    {
-        FunctionExecutable* executable = new (NotNull, allocateCell<FunctionExecutable>(vm.heap)) FunctionExecutable(vm, source, unlinkedExecutable, firstLine, lastLine, startColumn, endColumn);
+        unsigned firstLine, unsigned lastLine, unsigned startColumn, unsigned endColumn, Intrinsic intrinsic)
+    {
+        FunctionExecutable* executable = new (NotNull, allocateCell<FunctionExecutable>(vm.heap)) FunctionExecutable(vm, source, unlinkedExecutable, firstLine, lastLine, startColumn, endColumn, intrinsic);
         executable->finishCreation(vm);
         return executable;
@@ -698 +699 @@
     FunctionExecutable(
         VM&, const SourceCode&, UnlinkedFunctionExecutable*, unsigned firstLine, 
-        unsigned lastLine, unsigned startColumn, unsigned endColumn);
+        unsigned lastLine, unsigned startColumn, unsigned endColumn, Intrinsic);
     
     void finishCreation(VM&);