Attachment #399450 for bug #211867

View Details Raw Unified Return to Bug 211867

| Differences between



2020-05-14  Ross Kirsling  <ross.kirsling@sony.com>

        [IWYU] Remove unnecessary includes from JSC implementation files
        https://bugs.webkit.org/show_bug.cgi?id=211867

        Reviewed by NOBODY (OOPS!).

        * API/:
        * assembler/:
        * b3/:
        * bindings/:
        * builtins/BuiltinExecutables.cpp:
        * bytecode/:
        * bytecompiler/:
        * debugger/:
        * dfg/:
        * disassembler/:
        * ftl/:
        * heap/:
        * inspector/:
        * interpreter/:
        * jit/:
        * jsc.cpp:
        * llint/:
        * parser/:
        * profiler/:
        * runtime/:
        * testRegExp.cpp:
        * tools/:
        * wasm/:
        * yarr/:

2020-05-14  Keith Miller  <keith_miller@apple.com>

        GetArrayLength should be "blessed" during Fixup phase in the DFG



#include "config.h"
#include "JSAPIValueWrapper.h"

#include "NumberObject.h"

namespace JSC {

STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSAPIValueWrapper);



#include "JSBasePrivate.h"

#include "APICast.h"
#include "CallFrame.h"
#include "Completion.h"
#include "Exception.h"
#include "GCActivityCallback.h"
#include "Identifier.h"
#include "InitializeThreading.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSObject.h"
#include "ObjectConstructor.h"
#include "OpaqueJSString.h"
#include "JSCInlines.h"
#include "SourceCode.h"
#include <wtf/text/StringHash.h>

#if ENABLE(REMOTE_INSPECTOR)
#include "JSGlobalObjectInspectorController.h"

Lines 27-33 a/Source/JavaScriptCore/API/JSCTestRunnerUtils.cpp_sec1
- a/Source/JavaScriptCore/API/JSCTestRunnerUtils.cpp -1 lines
27	#include "JSCTestRunnerUtils.h"	27	#include "JSCTestRunnerUtils.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "JSCInlines.h"
31	#include "TestRunnerUtils.h"	30	#include "TestRunnerUtils.h"
32		31
33	namespace JSC {	32	namespace JSC {

Lines 32-38 a/Source/JavaScriptCore/API/JSCallbackConstructor.cpp_sec1
- a/Source/JavaScriptCore/API/JSCallbackConstructor.cpp -1 lines
32	#include "JSGlobalObject.h"	32	#include "JSGlobalObject.h"
33	#include "JSLock.h"	33	#include "JSLock.h"
34	#include "ObjectPrototype.h"	34	#include "ObjectPrototype.h"
35	#include "JSCInlines.h"
36		35
37	namespace JSC {	36	namespace JSC {
38		37



#include "JSCallbackFunction.h"

#include "APICallbackFunction.h"
#include "APICast.h"
#include "CodeBlock.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "FunctionPrototype.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "JSCallbackObject.h"

#include "Heap.h"
#include "JSAPIWrapperObject.h"
#include "JSCInlines.h"
#include <wtf/text/StringHash.h>

namespace JSC {




#include "JSClassRef.h"

#include "APICast.h"
#include "Identifier.h"
#include "InitializeThreading.h"
#include "JSCallbackObject.h"
#include "JSGlobalObject.h"
#include "JSObjectRef.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"
#include <wtf/text/StringHash.h>

using namespace JSC;




#include "JSContextRefInternal.h"

#include "APICast.h"
#include "APIUtils.h"
#include "CallFrame.h"
#include "InitializeThreading.h"
#include "JSAPIGlobalObject.h"
#include "JSAPIWrapperObject.h"
#include "JSCallbackObject.h"
#include "JSClassRef.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "SourceProvider.h"
#include "StackVisitor.h"
#include "StrongInlines.h"
#include "Watchdog.h"
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringHash.h>

#if ENABLE(REMOTE_INSPECTOR)
#include "JSGlobalObjectDebuggable.h"

Lines 27-33 a/Source/JavaScriptCore/API/JSHeapFinalizerPrivate.cpp_sec1
- a/Source/JavaScriptCore/API/JSHeapFinalizerPrivate.cpp -1 lines
27	#include "JSHeapFinalizerPrivate.h"	27	#include "JSHeapFinalizerPrivate.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "JSCInlines.h"
31		30
32	void JSContextGroupAddHeapFinalizer(JSContextGroupRef group, JSHeapFinalizer finalizer, void *userData)	31	void JSContextGroupAddHeapFinalizer(JSContextGroupRef group, JSHeapFinalizer finalizer, void *userData)
33	{	32	{

Lines 27-33 a/Source/JavaScriptCore/API/JSMarkingConstraintPrivate.cpp_sec1
- a/Source/JavaScriptCore/API/JSMarkingConstraintPrivate.cpp -1 lines
27	#include "JSMarkingConstraintPrivate.h"	27	#include "JSMarkingConstraintPrivate.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "JSCInlines.h"
31	#include "SimpleMarkingConstraint.h"	30	#include "SimpleMarkingConstraint.h"
32		31
33	using namespace JSC;	32	using namespace JSC;



#include "APICast.h"
#include "APIUtils.h"
#include "DateConstructor.h"
#include "ErrorConstructor.h"
#include "Exception.h"
#include "FunctionConstructor.h"
#include "Identifier.h"
#include "InitializeThreading.h"
#include "JSAPIWrapperObject.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSCallbackConstructor.h"
#include "JSCallbackFunction.h"
#include "JSCallbackObject.h"
#include "JSClassRef.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSObject.h"
#include "JSPromise.h"
#include "JSRetainPtr.h"
#include "JSString.h"
#include "JSValueRef.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"
#include "PropertyNameArray.h"



#include "APICast.h"
#include "Completion.h"
#include "Exception.h"
#include "JSBasePrivate.h"
#include "VM.h"
#include "JSScriptRefPrivate.h"
#include "OpaqueJSString.h"
#include "JSCInlines.h"
#include "Parser.h"
#include "SourceCode.h"
#include "SourceProvider.h"



#include "ClassInfo.h"
#include "Error.h"
#include "JSArrayBufferViewInlines.h"
#include "JSCInlines.h"
#include "JSDataView.h"
#include "JSGenericTypedArrayViewInlines.h"
#include "JSTypedArrays.h"
#include "TypedArrayController.h"



#include "APICast.h"
#include "APIUtils.h"
#include "DateInstance.h"
#include "Exception.h"
#include "JSAPIWrapperObject.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSCallbackObject.h"
#include "JSGlobalObject.h"
#include "JSONObject.h"
#include "JSObjectRefPrivate.h"
#include "JSString.h"
#include "LiteralParser.h"
#include "Protect.h"
#include <algorithm>
#include <wtf/Assertions.h>
#include <wtf/text/StringHash.h>
#include <wtf/text/WTFString.h>

#if PLATFORM(MAC)



#include "JSWeakObjectMapRefPrivate.h"

#include "APICast.h"
#include "JSCJSValue.h"
#include "JSCallbackObject.h"
#include "JSWeakObjectMapRefInternal.h"
#include "JSCInlines.h"
#include "Weak.h"
#include "WeakGCMapInlines.h"

using namespace JSC;

Lines 27-33 a/Source/JavaScriptCore/API/JSWeakPrivate.cpp_sec1
- a/Source/JavaScriptCore/API/JSWeakPrivate.cpp -1 lines
27	#include "JSWeakPrivate.h"	27	#include "JSWeakPrivate.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "JSCInlines.h"
31	#include "Weak.h"	30	#include "Weak.h"
32	#include <wtf/ThreadSafeRefCounted.h>	31	#include <wtf/ThreadSafeRefCounted.h>
33		32



#include "config.h"
#include "JSWeakValue.h"

#include "JSCellInlines.h"
#include "WeakHandleOwner.h"

namespace JSC {




#include "config.h"
#include "MarkedJSValueRefArray.h"

#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSObject.h"

namespace JSC {




#include "config.h"
#include "OpaqueJSString.h"

#include "CallFrame.h"
#include "Identifier.h"
#include "IdentifierInlines.h"
#include "JSGlobalObject.h"
#include <wtf/text/StringView.h>

using namespace JSC;



#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"

#include <wtf/Atomics.h>
#include <wtf/CPUTime.h>
#include <wtf/Condition.h>
#include <wtf/Lock.h>




#include "FunctionOverrides.h"
#include "InitializeThreading.h"
#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"
#include <string>

using JSC::Options;





#pragma once

#include "JSContextRefPrivate.h"

#ifdef __cplusplus
extern "C" {
#endif



#include "JSObjectGetProxyTargetTest.h"

#include "APICast.h"
#include "InitializeThreading.h"
#include "JSCInlines.h"
#include "JSObjectRefPrivate.h"
#include "JSProxy.h"
#include "JavaScript.h"
#include "Options.h"
#include "ProxyObject.h"

using namespace JSC;



#include "MultithreadedMultiVMExecutionTest.h"

#include "InitializeThreading.h"
#include "JSContextRefPrivate.h"
#include "JavaScript.h"
#include "Options.h"
#include <mutex>
#include <string>
#include <thread>

Lines 27-33 a/Source/JavaScriptCore/API/tests/PingPongStackOverflowTest.cpp_sec1
- a/Source/JavaScriptCore/API/tests/PingPongStackOverflowTest.cpp -1 lines
27	#include "PingPongStackOverflowTest.h"	27	#include "PingPongStackOverflowTest.h"
28		28
29	#include "InitializeThreading.h"	29	#include "InitializeThreading.h"
30	#include "JSContextRefPrivate.h"
31	#include "JavaScript.h"	30	#include "JavaScript.h"
32	#include "Options.h"	31	#include "Options.h"
33	#include <wtf/text/StringBuilder.h>	32	#include <wtf/text/StringBuilder.h>

Lines 33-39 a/Source/JavaScriptCore/API/tests/testapi.c_sec1
- a/Source/JavaScriptCore/API/tests/testapi.c -1 lines
33	#endif	33	#endif
34		34
35	#include "JSBasePrivate.h"	35	#include "JSBasePrivate.h"
36	#include "JSContextRefPrivate.h"
37	#include "JSHeapFinalizerPrivate.h"	36	#include "JSHeapFinalizerPrivate.h"
38	#include "JSMarkingConstraintPrivate.h"	37	#include "JSMarkingConstraintPrivate.h"
39	#include "JSObjectRefPrivate.h"	38	#include "JSObjectRefPrivate.h"



#include "config.h"

#include "APICast.h"
#include "JSCJSValueInlines.h"
#include "JSGlobalObjectInlines.h"
#include "JSObject.h"
#include "MarkedJSValueRefArray.h"

#include <JavaScriptCore/JSContextRefPrivate.h>
#include <JavaScriptCore/JSObjectRefPrivate.h>
#include <JavaScriptCore/JavaScript.h>
#include <wtf/DataLog.h>
#include <wtf/Expected.h>



#include "config.h"
#include "AssemblerBuffer.h"

#include <wtf/NeverDestroyed.h>

namespace JSC {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(AssemblerData);



#include "CodeBlock.h"
#include "Disassembler.h"
#include "JITCode.h"
#include "JSCInlines.h"
#include "Options.h"
#include "WasmCompilationMode.h"
#include <wtf/CompilationThread.h>

#if OS(LINUX)
#include "PerfLog.h"



#include "MacroAssemblerCodeRef.h"

#include "Disassembler.h"
#include "JSCInlines.h"
#include "JSCPtrTag.h"
#include <wtf/StringPrintStream.h>

namespace JSC {


Lines 31-37 a/Source/JavaScriptCore/b3/B3BasicBlock.cpp_sec1
- a/Source/JavaScriptCore/b3/B3BasicBlock.cpp -1 lines
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BasicBlockUtils.h"	32	#include "B3BasicBlockUtils.h"
33	#include "B3Procedure.h"	33	#include "B3Procedure.h"
34	#include "B3ValueInlines.h"
35	#include <wtf/ListDump.h>	34	#include <wtf/ListDump.h>
36		35
37	namespace JSC { namespace B3 {	36	namespace JSC { namespace B3 {




#if ENABLE(B3_JIT)

#include "B3BasicBlockInlines.h"
#include "B3InsertionSet.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"
#include <wtf/BubbleSort.h>

namespace JSC { namespace B3 {


Lines 30-36 a/Source/JavaScriptCore/b3/B3BreakCriticalEdges.cpp_sec1
- a/Source/JavaScriptCore/b3/B3BreakCriticalEdges.cpp -1 lines
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BlockInsertionSet.h"	32	#include "B3BlockInsertionSet.h"
33	#include "B3ProcedureInlines.h"
34	#include "B3ValueInlines.h"	33	#include "B3ValueInlines.h"
35		34
36	namespace JSC { namespace B3 {	35	namespace JSC { namespace B3 {

Lines 28-34 a/Source/JavaScriptCore/b3/B3CaseCollection.cpp_sec1
- a/Source/JavaScriptCore/b3/B3CaseCollection.cpp -1 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"
32	#include "B3CaseCollectionInlines.h"	31	#include "B3CaseCollectionInlines.h"
33	#include <wtf/CommaPrinter.h>	32	#include <wtf/CommaPrinter.h>
34		33

Lines 28-34 a/Source/JavaScriptCore/b3/B3CheckSpecial.cpp_sec1
- a/Source/JavaScriptCore/b3/B3CheckSpecial.cpp -1 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "AirCode.h"
32	#include "AirGenerationContext.h"	31	#include "AirGenerationContext.h"
33	#include "AirInstInlines.h"	32	#include "AirInstInlines.h"
34	#include "B3StackmapGenerationParams.h"	33	#include "B3StackmapGenerationParams.h"

Lines 29-35 a/Source/JavaScriptCore/b3/B3Compilation.cpp_sec1
- a/Source/JavaScriptCore/b3/B3Compilation.cpp -1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3OpaqueByproducts.h"	31	#include "B3OpaqueByproducts.h"
32	#include "CCallHelpers.h"
33		32
34	namespace JSC { namespace B3 {	33	namespace JSC { namespace B3 {
35		34



#if ENABLE(B3_JIT)

#include "B3Generate.h"
#include "B3OpaqueByproducts.h"
#include "B3Procedure.h"
#include "B3TimingScope.h"
#include "CCallHelpers.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"

namespace JSC { namespace B3 {




#if ENABLE(B3_JIT)

#include "B3BasicBlock.h"
#include "B3BreakCriticalEdges.h"
#include "B3Dominators.h"
#include "B3FixSSA.h"
#include "B3InsertionSet.h"
#include "B3PhaseScope.h"
#include "B3Procedure.h"
#include "B3SwitchValue.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include <wtf/IndexSet.h>

namespace JSC { namespace B3 {

Lines 29-35 a/Source/JavaScriptCore/b3/B3Effects.cpp_sec1
- a/Source/JavaScriptCore/b3/B3Effects.cpp -1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include <wtf/CommaPrinter.h>	31	#include <wtf/CommaPrinter.h>
32	#include <wtf/DataLog.h>
33		32
34	namespace JSC { namespace B3 {	33	namespace JSC { namespace B3 {
35		34




#if ENABLE(B3_JIT)

#include "B3BasicBlockInlines.h"
#include "B3BlockWorklist.h"
#include "B3Dominators.h"
#include "B3HeapRange.h"

#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3PureCSE.h"
#include "B3SlotBaseValue.h"
#include "B3StackSlot.h"
#include "B3ValueKey.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"
#include "B3VariableValue.h"
#include <wtf/CommaPrinter.h>
#include <wtf/HashMap.h>




#if ENABLE(B3_JIT)

#include "B3BasicBlock.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"
#include "B3VariableValue.h"



#include "B3BasicBlockInlines.h"
#include "B3BlockInsertionSet.h"
#include "B3NaturalLoops.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 {


Lines 25-31 a/Source/JavaScriptCore/b3/B3FenceValue.cpp_sec1
- a/Source/JavaScriptCore/b3/B3FenceValue.cpp -1 lines
25		25
26	#include "config.h"	26	#include "config.h"
27	#include "B3FenceValue.h"	27	#include "B3FenceValue.h"
28	#include "B3ValueInlines.h"
29		28
30	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
31		30




#if ENABLE(B3_JIT)

#include "B3BasicBlockInlines.h"
#include "B3BreakCriticalEdges.h"
#include "B3Dominators.h"
#include "B3InsertionSetInlines.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"



#include "B3BasicBlockInlines.h"
#include "B3CaseCollectionInlines.h"
#include "B3Dominators.h"
#include "B3InsertionSet.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3SwitchValue.h"
#include "B3ValueInlines.h"





#if ENABLE(B3_JIT)

#include "AirCode.h"
#include "AirGenerate.h"
#include "AirInstInlines.h"
#include "B3Common.h"
#include "B3DuplicateTails.h"
#include "B3EliminateCommonSubexpressions.h"

#include "B3MoveConstants.h"
#include "B3OptimizeAssociativeExpressionTrees.h"
#include "B3Procedure.h"
#include "B3PureCSE.h"
#include "B3ReduceDoubleToFloat.h"
#include "B3ReduceLoopStrength.h"
#include "B3ReduceStrength.h"
#include "B3TimingScope.h"
#include "B3Validate.h"
#include "PCToCodeOriginMap.h"

namespace JSC { namespace B3 {




#if ENABLE(B3_JIT)

#include "B3BackwardsDominators.h"
#include "B3BasicBlockInlines.h"
#include "B3Dominators.h"
#include "B3EnsureLoopPreHeaders.h"
#include "B3NaturalLoops.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"
#include <wtf/RangeSet.h>

namespace JSC { namespace B3 {




#include "B3BasicBlockInlines.h"
#include "B3CaseCollectionInlines.h"
#include "B3InsertionSet.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3SwitchValue.h"
#include "B3UseCounts.h"
#include "B3ValueInlines.h"



#if ENABLE(B3_JIT)

#include "B3BasicBlock.h"
#include "B3Procedure.h"
#include "B3Value.h"
#include <wtf/BubbleSort.h>

namespace JSC { namespace B3 {




#if ENABLE(B3_JIT)

#include "B3InsertionSet.h"
#include "B3MemoryValueInlines.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"

Lines 40-46 a/Source/JavaScriptCore/b3/B3LowerMacros.cpp_sec1
- a/Source/JavaScriptCore/b3/B3LowerMacros.cpp -1 lines
40	#include "B3MemoryValueInlines.h"	40	#include "B3MemoryValueInlines.h"
41	#include "B3PatchpointValue.h"	41	#include "B3PatchpointValue.h"
42	#include "B3PhaseScope.h"	42	#include "B3PhaseScope.h"
43	#include "B3ProcedureInlines.h"
44	#include "B3StackmapGenerationParams.h"	43	#include "B3StackmapGenerationParams.h"
45	#include "B3SwitchValue.h"	44	#include "B3SwitchValue.h"
46	#include "B3UpsilonValue.h"	45	#include "B3UpsilonValue.h"



#if ENABLE(B3_JIT)

#include "AirArg.h"
#include "B3BasicBlockInlines.h"
#include "B3BlockInsertionSet.h"
#include "B3CCallValue.h"
#include "B3ConstDoubleValue.h"

#include "B3ConstPtrValue.h"
#include "B3InsertionSetInlines.h"
#include "B3PhaseScope.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 {




#if ENABLE(B3_JIT)

#include "AirBlockInsertionSet.h"
#include "AirCCallSpecial.h"
#include "AirCode.h"
#include "AirHelpers.h"
#include "AirInsertionSet.h"
#include "AirInstInlines.h"
#include "AirPrintSpecial.h"
#include "AirStackSlot.h"
#include "B3ArgumentRegValue.h"
#include "B3AtomicValue.h"
#include "B3BasicBlockInlines.h"
#include "B3BlockWorklist.h"
#include "B3CCallValue.h"
#include "B3CheckSpecial.h"

#include "B3PhiChildren.h"
#include "B3Procedure.h"
#include "B3SlotBaseValue.h"
#include "B3StackSlot.h"
#include "B3UpsilonValue.h"
#include "B3UseCounts.h"
#include "B3ValueInlines.h"

#include "B3WasmAddressValue.h"
#include <wtf/IndexMap.h>
#include <wtf/IndexSet.h>
#include <wtf/ListDump.h>

#if !ASSERT_ENABLED
IGNORE_RETURN_TYPE_WARNINGS_BEGIN

Lines 34-40 a/Source/JavaScriptCore/b3/B3MathExtras.cpp_sec1
- a/Source/JavaScriptCore/b3/B3MathExtras.cpp -1 lines
34	#include "B3ConstDoubleValue.h"	34	#include "B3ConstDoubleValue.h"
35	#include "B3ConstPtrValue.h"	35	#include "B3ConstPtrValue.h"
36	#include "B3UpsilonValue.h"	36	#include "B3UpsilonValue.h"
37	#include "B3ValueInlines.h"
38	#include "JSCPtrTag.h"	37	#include "JSCPtrTag.h"
39	#include "MathCommon.h"	38	#include "MathCommon.h"
40		39




#if ENABLE(B3_JIT)

#include "B3AtomicValue.h"
#include "B3MemoryValueInlines.h"
#include "B3ValueInlines.h"

namespace JSC { namespace B3 {





#if ENABLE(B3_JIT)

#include "AirArg.h"
#include "B3BasicBlockInlines.h"
#include "B3Dominators.h"
#include "B3InsertionSetInlines.h"
#include "B3MemoryValueInlines.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"
#include "B3ValueKeyInlines.h"
#include <wtf/HashMap.h>
#include <wtf/Vector.h>




#include "AirCode.h"
#include "B3BackwardsCFG.h"
#include "B3BackwardsDominators.h"
#include "B3BasicBlockInlines.h"
#include "B3BasicBlockUtils.h"
#include "B3BlockWorklist.h"
#include "B3CFG.h"
#include "B3DataSection.h"
#include "B3Dominators.h"
#include "B3NaturalLoops.h"
#include "B3OpaqueByproducts.h"
#include "B3PhiChildren.h"
#include "B3StackSlot.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"



#include "B3BasicBlockInlines.h"
#include "B3BlockInsertionSet.h"
#include "B3ConstPtrValue.h"
#include "B3EnsureLoopPreHeaders.h"
#include "B3InsertionSet.h"
#include "B3NaturalLoops.h"
#include "B3PhaseScope.h"
#include "B3ProcedureInlines.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"
#include "B3VariableValue.h"
#include <wtf/GraphNodeWorklist.h>
#include <wtf/IndexSet.h>
#include <wtf/SmallPtrSet.h>
#include <wtf/Vector.h>




#include "B3BasicBlockInlines.h"
#include "B3BlockInsertionSet.h"
#include "B3ComputeDivisionMagic.h"
#include "B3Dominators.h"
#include "B3EliminateDeadCode.h"
#include "B3InsertionSetInlines.h"
#include "B3MemoryValueInlines.h"
#include "B3PhaseScope.h"
#include "B3PhiChildren.h"
#include "B3ProcedureInlines.h"
#include "B3PureCSE.h"
#include "B3SlotBaseValue.h"
#include "B3StackSlot.h"
#include "B3UpsilonValue.h"
#include "B3ValueKeyInlines.h"
#include "B3ValueInlines.h"
#include "B3Variable.h"
#include "B3VariableValue.h"
#include <wtf/GraphNodeWorklist.h>
#include <wtf/HashMap.h>
#include <wtf/IndexSet.h>

namespace JSC { namespace B3 {





#if ENABLE(B3_JIT)

#include "B3BasicBlockInlines.h"
#include <wtf/CommaPrinter.h>
#include <wtf/ListDump.h>

namespace JSC { namespace B3 {


Lines 25-31 a/Source/JavaScriptCore/b3/B3StackmapValue.cpp_sec1
- a/Source/JavaScriptCore/b3/B3StackmapValue.cpp -1 lines
25		25
26	#include "config.h"	26	#include "config.h"
27	#include "B3StackmapValue.h"	27	#include "B3StackmapValue.h"
28	#include "B3ValueInlines.h"
29		28
30	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
31		30

Lines 29-35 a/Source/JavaScriptCore/b3/B3SwitchValue.cpp_sec1
- a/Source/JavaScriptCore/b3/B3SwitchValue.cpp -1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3ValueInlines.h"
33	#include <wtf/ListDump.h>	32	#include <wtf/ListDump.h>
34		33
35	namespace JSC { namespace B3 {	34	namespace JSC { namespace B3 {

Lines 29-35 a/Source/JavaScriptCore/b3/B3UseCounts.cpp_sec1
- a/Source/JavaScriptCore/b3/B3UseCounts.cpp -1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3Procedure.h"	31	#include "B3Procedure.h"
32	#include "B3ValueInlines.h"
33		32
34	namespace JSC { namespace B3 {	33	namespace JSC { namespace B3 {
35		34



#include "AirCode.h"
#include "B3ArgumentRegValue.h"
#include "B3AtomicValue.h"
#include "B3BasicBlockInlines.h"
#include "B3Dominators.h"
#include "B3MemoryValue.h"
#include "B3Procedure.h"
#include "B3SlotBaseValue.h"
#include "B3StackSlot.h"
#include "B3SwitchValue.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"



#include "B3ProcedureInlines.h"
#include "B3SlotBaseValue.h"
#include "B3StackSlot.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include "B3ValueKeyInlines.h"
#include "B3VariableValue.h"
#include "B3WasmBoundsCheckValue.h"
#include <wtf/CommaPrinter.h>
#include <wtf/ListDump.h>

Lines 29-35 a/Source/JavaScriptCore/b3/B3ValueRep.cpp_sec1
- a/Source/JavaScriptCore/b3/B3ValueRep.cpp -1 / +1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "AssemblyHelpers.h"	31	#include "AssemblyHelpers.h"
32	#include "JSCInlines.h"	32	#include "JSCJSValueInlines.h"
33		33
34	namespace JSC { namespace B3 {	34	namespace JSC { namespace B3 {
35		35

Lines 28-34 a/Source/JavaScriptCore/b3/B3VariableValue.cpp_sec1
- a/Source/JavaScriptCore/b3/B3VariableValue.cpp -1 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3ValueInlines.h"
32	#include "B3Variable.h"	31	#include "B3Variable.h"
33		32
34	namespace JSC { namespace B3 {	33	namespace JSC { namespace B3 {




#if ENABLE(B3_JIT)

#include "B3ValueInlines.h"

namespace JSC { namespace B3 {

WasmAddressValue::~WasmAddressValue()




#if ENABLE(B3_JIT)

#include "B3ValueInlines.h"

namespace JSC { namespace B3 {

WasmBoundsCheckValue::~WasmBoundsCheckValue()

Lines 39-45 a/Source/JavaScriptCore/b3/air/AirAllocateRegistersAndStackByLinearScan.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirAllocateRegistersAndStackByLinearScan.cpp -1 lines
39	#include "AirPhaseScope.h"	39	#include "AirPhaseScope.h"
40	#include "AirRegLiveness.h"	40	#include "AirRegLiveness.h"
41	#include "AirStackAllocation.h"	41	#include "AirStackAllocation.h"
42	#include "AirTmpInlines.h"
43	#include "AirTmpMap.h"	42	#include "AirTmpMap.h"
44	#include <wtf/ListDump.h>	43	#include <wtf/ListDump.h>
45	#include <wtf/Range.h>	44	#include <wtf/Range.h>

Lines 38-44 a/Source/JavaScriptCore/b3/air/AirAllocateRegistersByGraphColoring.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirAllocateRegistersByGraphColoring.cpp -1 lines
38	#include "AirTmpInlines.h"	38	#include "AirTmpInlines.h"
39	#include "AirTmpWidth.h"	39	#include "AirTmpWidth.h"
40	#include "AirUseCounts.h"	40	#include "AirUseCounts.h"
41	#include <wtf/ListDump.h>
42		41
43	namespace JSC { namespace B3 { namespace Air {	42	namespace JSC { namespace B3 { namespace Air {
44		43

Lines 35-41 a/Source/JavaScriptCore/b3/air/AirAllocateStackByGraphColoring.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirAllocateStackByGraphColoring.cpp -1 lines
35	#include "AirLiveness.h"	35	#include "AirLiveness.h"
36	#include "AirPhaseScope.h"	36	#include "AirPhaseScope.h"
37	#include "AirStackAllocation.h"	37	#include "AirStackAllocation.h"
38	#include "StackAlignment.h"
39	#include <wtf/ListDump.h>	38	#include <wtf/ListDump.h>
40		39
41	namespace JSC { namespace B3 { namespace Air {	40	namespace JSC { namespace B3 { namespace Air {

Lines 31-37 a/Source/JavaScriptCore/b3/air/AirArg.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirArg.cpp -1 lines
31	#include "AirSpecial.h"	31	#include "AirSpecial.h"
32	#include "AirStackSlot.h"	32	#include "AirStackSlot.h"
33	#include "B3Value.h"	33	#include "B3Value.h"
34	#include "FPRInfo.h"
35	#include "GPRInfo.h"	34	#include "GPRInfo.h"
36		35
37	#if !ASSERT_ENABLED	36	#if !ASSERT_ENABLED

Lines 30-36 a/Source/JavaScriptCore/b3/air/AirBlockInsertionSet.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirBlockInsertionSet.cpp -1 lines
30		30
31	#include "AirBasicBlock.h"	31	#include "AirBasicBlock.h"
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include <wtf/BubbleSort.h>
34		33
35	namespace JSC { namespace B3 { namespace Air {	34	namespace JSC { namespace B3 { namespace Air {
36		35

Lines 30-36 a/Source/JavaScriptCore/b3/air/AirBreakCriticalEdges.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirBreakCriticalEdges.cpp -1 lines
30		30
31	#include "AirBlockInsertionSet.h"	31	#include "AirBlockInsertionSet.h"
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include "AirInstInlines.h"
34		33
35	namespace JSC { namespace B3 { namespace Air {	34	namespace JSC { namespace B3 { namespace Air {
36		35

Lines 31-37 a/Source/JavaScriptCore/b3/air/AirCCallingConvention.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirCCallingConvention.cpp -1 lines
31	#include "AirCCallSpecial.h"	31	#include "AirCCallSpecial.h"
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include "B3CCallValue.h"	33	#include "B3CCallValue.h"
34	#include "B3ValueInlines.h"
35		34
36	namespace JSC { namespace B3 { namespace Air {	35	namespace JSC { namespace B3 { namespace Air {
37		36

Lines 31-37 a/Source/JavaScriptCore/b3/air/AirDisassembler.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirDisassembler.cpp -1 lines
31	#include "AirBasicBlock.h"	31	#include "AirBasicBlock.h"
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include "AirInst.h"	33	#include "AirInst.h"
34	#include "B3Value.h"
35	#include "CCallHelpers.h"	34	#include "CCallHelpers.h"
36	#include "Disassembler.h"	35	#include "Disassembler.h"
37	#include "LinkBuffer.h"	36	#include "LinkBuffer.h"



#include "AirBlockInsertionSet.h"
#include "AirCode.h"
#include "AirInsertionSet.h"
#include "AirInstInlines.h"
#include "AirTmpInlines.h"

namespace JSC { namespace B3 { namespace Air {




#include "AirFixObviousSpills.h"
#include "AirFixPartialRegisterStalls.h"
#include "AirGenerationContext.h"
#include "AirHandleCalleeSaves.h"
#include "AirLiveness.h"
#include "AirLogRegisterPressure.h"
#include "AirLowerAfterRegAlloc.h"
#include "AirLowerEntrySwitch.h"

#include "AirOptimizeBlockOrder.h"
#include "AirReportUsedRegisters.h"
#include "AirSimplifyCFG.h"
#include "AirStackAllocation.h"
#include "AirTmpMap.h"
#include "AirValidate.h"
#include "B3Common.h"
#include "B3Procedure.h"
#include "B3TimingScope.h"
#include "B3ValueInlines.h"
#include "CCallHelpers.h"
#include "DisallowMacroScratchRegisterUsage.h"
#include "LinkBuffer.h"
#include <wtf/IndexMap.h>

namespace JSC { namespace B3 { namespace Air {

Lines 29-35 a/Source/JavaScriptCore/b3/air/AirInst.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirInst.cpp -1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "AirInstInlines.h"	31	#include "AirInstInlines.h"
32	#include "B3Value.h"
33	#include <wtf/ListDump.h>	32	#include <wtf/ListDump.h>
34		33
35	namespace JSC { namespace B3 { namespace Air {	34	namespace JSC { namespace B3 { namespace Air {




#if ENABLE(B3_JIT)

#include "AirArgInlines.h"
#include "AirCCallingConvention.h"
#include "AirCode.h"
#include "AirEmitShuffle.h"
#include "AirInsertionSet.h"
#include "AirInstInlines.h"
#include "AirPadInterference.h"
#include "AirRegLiveness.h"
#include "AirPhaseScope.h"

Lines 30-36 a/Source/JavaScriptCore/b3/air/AirLowerEntrySwitch.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirLowerEntrySwitch.cpp -1 lines
30		30
31	#include "AirBlockWorklist.h"	31	#include "AirBlockWorklist.h"
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include "AirInstInlines.h"
34	#include "AirPhaseScope.h"	33	#include "AirPhaseScope.h"
35	#include "B3Procedure.h"	34	#include "B3Procedure.h"
36		35

Lines 32-38 a/Source/JavaScriptCore/b3/air/AirLowerMacros.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirLowerMacros.cpp -1 lines
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include "AirEmitShuffle.h"	33	#include "AirEmitShuffle.h"
34	#include "AirInsertionSet.h"	34	#include "AirInsertionSet.h"
35	#include "AirInstInlines.h"
36	#include "AirPhaseScope.h"	35	#include "AirPhaseScope.h"
37	#include "B3CCallValue.h"	36	#include "B3CCallValue.h"
38	#include "B3ValueInlines.h"	37	#include "B3ValueInlines.h"




#if ENABLE(B3_JIT)

#include "AirArgInlines.h"
#include "AirCode.h"
#include "AirInsertionSet.h"
#include "AirInstInlines.h"
#include "AirPhaseScope.h"
#include "StackAlignment.h"
#include <wtf/ListDump.h>

namespace JSC { namespace B3 { namespace Air {


Lines 30-36 a/Source/JavaScriptCore/b3/air/AirOptimizeBlockOrder.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirOptimizeBlockOrder.cpp -1 lines
30		30
31	#include "AirBlockWorklist.h"	31	#include "AirBlockWorklist.h"
32	#include "AirCode.h"	32	#include "AirCode.h"
33	#include "AirInstInlines.h"
34	#include "AirPhaseScope.h"	33	#include "AirPhaseScope.h"
35	#include <wtf/BubbleSort.h>	34	#include <wtf/BubbleSort.h>
36		35

Lines 30-36 a/Source/JavaScriptCore/b3/air/AirPadInterference.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirPadInterference.cpp -1 lines
30		30
31	#include "AirCode.h"	31	#include "AirCode.h"
32	#include "AirInsertionSet.h"	32	#include "AirInsertionSet.h"
33	#include "AirInstInlines.h"
34		33
35	namespace JSC { namespace B3 { namespace Air {	34	namespace JSC { namespace B3 { namespace Air {
36		35

Lines 28-34 a/Source/JavaScriptCore/b3/air/AirReportUsedRegisters.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirReportUsedRegisters.cpp -1 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "AirArgInlines.h"
32	#include "AirCode.h"	31	#include "AirCode.h"
33	#include "AirInstInlines.h"	32	#include "AirInstInlines.h"
34	#include "AirPadInterference.h"	33	#include "AirPadInterference.h"

Lines 29-35 a/Source/JavaScriptCore/b3/air/AirSimplifyCFG.cpp_sec1
- a/Source/JavaScriptCore/b3/air/AirSimplifyCFG.cpp -1 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "AirCode.h"	31	#include "AirCode.h"
32	#include "AirInstInlines.h"
33	#include "AirPhaseScope.h"	32	#include "AirPhaseScope.h"
34		33
35	namespace JSC { namespace B3 { namespace Air {	34	namespace JSC { namespace B3 { namespace Air {




#if ENABLE(B3_JIT)

#include "AirArgInlines.h"
#include "AirCode.h"
#include "AirInstInlines.h"
#include "StackAlignment.h"
#include <wtf/ListDump.h>





#include "AirCode.h"
#include "AirGenerate.h"
#include "AirInstInlines.h"
#include "AirSpecial.h"
#include "AllowMacroScratchRegisterUsage.h"
#include "B3BasicBlockInlines.h"
#include "B3Compilation.h"
#include "B3Procedure.h"
#include "B3PatchpointSpecial.h"
#include "B3PatchpointValue.h"
#include "B3StackmapGenerationParams.h"
#include "CCallHelpers.h"
#include "InitializeThreading.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "ProbeContext.h"
#include "PureNaN.h"
#include <cmath>
#include <regex>
#include <string>
#include <wtf/DataLog.h>
#include <wtf/Lock.h>
#include <wtf/NumberOfCores.h>
#include <wtf/StdMap.h>



#include "config.h"
#include "ScriptFunctionCall.h"

#include "JSCInlines.h"
#include "JSLock.h"
#include "JSObjectInlines.h"
#include <wtf/text/WTFString.h>

namespace Deprecated {



#include "config.h"
#include "ScriptObject.h"

#include "JSCInlines.h"

namespace Deprecated {

using namespace JSC;



#include "config.h"
#include "ScriptValue.h"

#include "JSGlobalObjectInlines.h"
#include "CatchScope.h"
#include "JSCInlines.h"
#include "JSLock.h"

namespace Inspector {

Lines 28-34 a/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp_sec1
- a/Source/JavaScriptCore/builtins/BuiltinExecutables.cpp -1 / +1 lines
28	#include "BuiltinExecutables.h"	28	#include "BuiltinExecutables.h"
29		29
30	#include "BuiltinNames.h"	30	#include "BuiltinNames.h"
31	#include "JSCInlines.h"	31	#include "JSCJSValueInlines.h"
32	#include "Parser.h"	32	#include "Parser.h"
33	#include <wtf/NeverDestroyed.h>	33	#include <wtf/NeverDestroyed.h>
34		34

Lines 31-37 a/Source/JavaScriptCore/bytecode/AccessCase.cpp_sec1
- a/Source/JavaScriptCore/bytecode/AccessCase.cpp -1 lines
31	#include "CCallHelpers.h"	31	#include "CCallHelpers.h"
32	#include "CacheableIdentifierInlines.h"	32	#include "CacheableIdentifierInlines.h"
33	#include "CallLinkInfo.h"	33	#include "CallLinkInfo.h"
34	#include "DOMJITGetterSetter.h"
35	#include "DirectArguments.h"	34	#include "DirectArguments.h"
36	#include "GetterSetter.h"	35	#include "GetterSetter.h"
37	#include "GetterSetterAccessCase.h"	36	#include "GetterSetterAccessCase.h"

Lines 27-33 a/Source/JavaScriptCore/bytecode/ArithProfile.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ArithProfile.cpp -1 lines
27	#include "ArithProfile.h"	27	#include "ArithProfile.h"
28		28
29	#include "CCallHelpers.h"	29	#include "CCallHelpers.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "config.h"
#include "ArrayAllocationProfile.h"

#include "JSCInlines.h"

#include <algorithm>

namespace JSC {

Lines 27-33 a/Source/JavaScriptCore/bytecode/ArrayProfile.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ArrayProfile.cpp -1 lines
27	#include "ArrayProfile.h"	27	#include "ArrayProfile.h"
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "JSCInlines.h"
31	#include <wtf/CommaPrinter.h>	30	#include <wtf/CommaPrinter.h>
32	#include <wtf/StringPrintStream.h>	31	#include <wtf/StringPrintStream.h>
33		32

Lines 27-33 a/Source/JavaScriptCore/bytecode/ByValInfo.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ByValInfo.cpp -1 lines
27	#include "ByValInfo.h"	27	#include "ByValInfo.h"
28		28
29	#include "CacheableIdentifierInlines.h"	29	#include "CacheableIdentifierInlines.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "BytecodeBasicBlock.h"

#include "CodeBlock.h"
#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "PreciseJumpTargets.h"
#include "UnlinkedCodeBlockGenerator.h"




#include "config.h"
#include "BytecodeDumper.h"

#include "ArithProfile.h"
#include "B3Type.h"
#include "BytecodeGenerator.h"
#include "BytecodeStructs.h"
#include "CallLinkStatus.h"
#include "CodeBlock.h"
#include "Error.h"
#include "HeapInlines.h"
#include "InterpreterInlines.h"
#include "PolymorphicAccess.h"
#include "StructureInlines.h"
#include "ToThisStatus.h"
#include "UnlinkedCodeBlockGenerator.h"
#include "UnlinkedMetadataTableInlines.h"
#include "WasmFunctionCodeBlock.h"



#include "BytecodeRewriter.h"
#include "BytecodeStructs.h"
#include "BytecodeUseDef.h"
#include "IdentifierInlines.h"
#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "JSGenerator.h"
#include "Label.h"
#include "StrongInlines.h"
#include "UnlinkedCodeBlockGenerator.h"
#include "UnlinkedMetadataTableInlines.h"
#include <wtf/Optional.h>

namespace JSC {



#include "config.h"
#include "BytecodeIntrinsicRegistry.h"

#include "ArrayIteratorPrototype.h"
#include "BuiltinNames.h"
#include "BytecodeGenerator.h"
#include "IdentifierInlines.h"
#include "IterationKind.h"
#include "JSArrayIterator.h"
#include "JSAsyncGenerator.h"
#include "JSCInlines.h"
#include "JSGenerator.h"
#include "JSGlobalObject.h"
#include "JSMapIterator.h"

#include "JSPromise.h"
#include "JSSetIterator.h"
#include "JSStringIterator.h"
#include "LinkTimeConstant.h"
#include "Nodes.h"
#include "StrongInlines.h"




#include "BytecodeUseDef.h"
#include "CodeBlock.h"
#include "FullBytecodeLiveness.h"
#include "HeapInlines.h"
#include "InterpreterInlines.h"
#include "PreciseJumpTargets.h"

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/bytecode/BytecodeRewriter.cpp_sec1
- a/Source/JavaScriptCore/bytecode/BytecodeRewriter.cpp -1 lines
27	#include "config.h"	27	#include "config.h"
28	#include "BytecodeRewriter.h"	28	#include "BytecodeRewriter.h"
29		29
30	#include "JSCInlines.h"
31	#include "PreciseJumpTargetsInlines.h"	30	#include "PreciseJumpTargetsInlines.h"
32	#include <wtf/BubbleSort.h>	31	#include <wtf/BubbleSort.h>
33		32



#include "CallLinkInfo.h"

#include "CallFrameShuffleData.h"
#include "DFGOperations.h"
#include "DFGThunks.h"
#include "FunctionCodeBlock.h"
#include "JSCInlines.h"
#include "Opcode.h"
#include "Repatch.h"
#include <wtf/ListDump.h>



#include "BytecodeStructs.h"
#include "CallLinkInfo.h"
#include "CodeBlock.h"
#include "DFGJITCode.h"
#include "InlineCallFrame.h"
#include "InterpreterInlines.h"
#include "LLIntCallLinkInfo.h"
#include "JSCInlines.h"
#include <wtf/CommaPrinter.h>
#include <wtf/ListDump.h>


Lines 26-32 a/Source/JavaScriptCore/bytecode/CallVariant.cpp_sec1
- a/Source/JavaScriptCore/bytecode/CallVariant.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "CallVariant.h"	27	#include "CallVariant.h"
28		28
29	#include "JSCInlines.h"
30	#include <wtf/ListDump.h>	29	#include <wtf/ListDump.h>
31		30
32	namespace JSC {	31	namespace JSC {



#include "BasicBlockLocation.h"
#include "ByValInfo.h"
#include "BytecodeDumper.h"
#include "BytecodeGenerator.h"
#include "BytecodeLivenessAnalysis.h"
#include "BytecodeOperandsForCheckpoint.h"
#include "BytecodeStructs.h"
#include "BytecodeUseDef.h"
#include "CallLinkStatus.h"
#include "CheckpointOSRExitSideState.h"
#include "CodeBlockInlines.h"
#include "CodeBlockSet.h"
#include "DFGCapabilities.h"
#include "DFGCommon.h"
#include "DFGDriver.h"
#include "DFGJITCode.h"
#include "DFGWorklist.h"
#include "Debugger.h"
#include "EvalCodeBlock.h"
#include "FullCodeOrigin.h"
#include "FunctionCodeBlock.h"

#include "InlineCallFrame.h"
#include "Instruction.h"
#include "InstructionStream.h"
#include "InterpreterInlines.h"
#include "IsoCellSetInlines.h"
#include "JIT.h"
#include "JITMathIC.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSFunction.h"
#include "JSLexicalEnvironment.h"
#include "JSModuleEnvironment.h"
#include "JSSet.h"

#include "LLIntData.h"
#include "LLIntEntrypoint.h"
#include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"
#include "LowLevelInterpreter.h"
#include "MetadataTable.h"
#include "ModuleProgramCodeBlock.h"
#include "ObjectAllocationProfileInlines.h"
#include "OpcodeInlines.h"
#include "PCToCodeOriginMap.h"
#include "PolymorphicAccess.h"
#include "ProfilerDatabase.h"
#include "ProgramCodeBlock.h"
#include "ReduceWhitespace.h"
#include "Repatch.h"
#include "SlotVisitorInlines.h"
#include "StackVisitor.h"
#include "StructureStubInfo.h"
#include "TypeLocationCache.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/BagToHashMap.h>
#include <wtf/CommaPrinter.h>
#include <wtf/Forward.h>
#include <wtf/SimpleStats.h>
#include <wtf/StringPrintStream.h>
#include <wtf/text/StringConcatenateNumbers.h>
#include <wtf/text/UniquedStringImpl.h>

#if ENABLE(ASSEMBLER)
#include "RegisterAtOffsetList.h"
#endif

#if ENABLE(DFG_JIT)
#include "DFGOperations.h"
#endif

#if ENABLE(FTL_JIT)
#include "FTLJITCode.h"
#endif

Lines 28-34 a/Source/JavaScriptCore/bytecode/CodeBlockJettisoningWatchpoint.cpp_sec1
- a/Source/JavaScriptCore/bytecode/CodeBlockJettisoningWatchpoint.cpp -1 lines
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "DFGCommon.h"	30	#include "DFGCommon.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33



#include "config.h"
#include "CodeOrigin.h"

#include "CallFrame.h"
#include "CodeBlock.h"
#include "InlineCallFrame.h"
#include "JSCInlines.h"

namespace JSC {


Lines 26-32 a/Source/JavaScriptCore/bytecode/ComplexGetStatus.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ComplexGetStatus.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ComplexGetStatus.h"	27	#include "ComplexGetStatus.h"
28		28
29	#include "JSCInlines.h"	29	#include "StructureInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32

Lines 26-32 a/Source/JavaScriptCore/bytecode/DataFormat.cpp_sec1
- a/Source/JavaScriptCore/bytecode/DataFormat.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "DataFormat.h"	27	#include "DataFormat.h"
28		28
29	#include <wtf/Assertions.h>
30	#include <wtf/PrintStream.h>	29	#include <wtf/PrintStream.h>
31		30
32	namespace WTF {	31	namespace WTF {



#include "config.h"
#include "DeferredCompilationCallback.h"

#include "CodeBlock.h"

namespace JSC {

DeferredCompilationCallback::DeferredCompilationCallback() { }



#include "DeleteByIdVariant.h"

#include "CacheableIdentifierInlines.h"
#include "JSCInlines.h"
#include <wtf/ListDump.h>

namespace JSC {




#include "config.h"
#include "DeleteByStatus.h"

#include "BytecodeStructs.h"
#include "CacheableIdentifierInlines.h"
#include "CodeBlock.h"
#include "ICStatusUtils.h"
#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "JSScope.h"
#include "LLIntData.h"
#include "LowLevelInterpreter.h"
#include "ModuleNamespaceAccessCase.h"
#include "PolymorphicAccess.h"
#include "StructureStubInfo.h"
#include <wtf/ListDump.h>

namespace JSC {
namespace DOMJIT {
class GetterSetter;
}

bool DeleteByStatus::appendVariant(const DeleteByIdVariant& variant)
{

Lines 26-32 a/Source/JavaScriptCore/bytecode/DirectEvalCodeCache.cpp_sec1
- a/Source/JavaScriptCore/bytecode/DirectEvalCodeCache.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "DirectEvalCodeCache.h"	27	#include "DirectEvalCodeCache.h"
28		28
29	#include "JSCInlines.h"	29	#include "SlotVisitorInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32

Lines 28-34 a/Source/JavaScriptCore/bytecode/ExecutionCounter.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ExecutionCounter.cpp -1 lines
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "ExecutableAllocator.h"	30	#include "ExecutableAllocator.h"
31	#include "JSCInlines.h"
32	#include "VMInlines.h"	31	#include "VMInlines.h"
33		32
34	namespace JSC {	33	namespace JSC {




#include "CacheableIdentifierInlines.h"
#include "CallLinkStatus.h"
#include "JSFunctionInlines.h"
#include <wtf/ListDump.h>

namespace JSC {




#include "ComplexGetStatus.h"
#include "GetterSetterAccessCase.h"
#include "ICStatusUtils.h"
#include "InterpreterInlines.h"
#include "IntrinsicGetterAccessCase.h"
#include "JSCInlines.h"
#include "JSScope.h"
#include "LLIntData.h"
#include "LowLevelInterpreter.h"
#include "ModuleNamespaceAccessCase.h"
#include "PolymorphicAccess.h"
#include "StructureStubInfo.h"
#include <wtf/ListDump.h>

namespace JSC {
namespace DOMJIT {
class GetterSetter;
}

bool GetByStatus::appendVariant(const GetByIdVariant& variant)
{

Lines 31-37 a/Source/JavaScriptCore/bytecode/GetterSetterAccessCase.cpp_sec1
- a/Source/JavaScriptCore/bytecode/GetterSetterAccessCase.cpp -1 lines
31	#include "AccessCaseSnippetParams.h"	31	#include "AccessCaseSnippetParams.h"
32	#include "DOMJITCallDOMGetterSnippet.h"	32	#include "DOMJITCallDOMGetterSnippet.h"
33	#include "DOMJITGetterSetter.h"	33	#include "DOMJITGetterSetter.h"
34	#include "HeapInlines.h"
35	#include "JSCJSValueInlines.h"	34	#include "JSCJSValueInlines.h"
36	#include "PolymorphicAccess.h"	35	#include "PolymorphicAccess.h"
37	#include "StructureStubInfo.h"	36	#include "StructureStubInfo.h"

Lines 26-32 a/Source/JavaScriptCore/bytecode/ICStatusMap.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ICStatusMap.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ICStatusMap.h"	27	#include "ICStatusMap.h"
28		28
29	#include "InlineCallFrame.h"
30	#include "TerminatedCodeOrigin.h"	29	#include "TerminatedCodeOrigin.h"
31		30
32	namespace JSC {	31	namespace JSC {

Lines 30-36 a/Source/JavaScriptCore/bytecode/InByIdStatus.cpp_sec1
- a/Source/JavaScriptCore/bytecode/InByIdStatus.cpp -1 lines
30	#include "CodeBlock.h"	30	#include "CodeBlock.h"
31	#include "ComplexGetStatus.h"	31	#include "ComplexGetStatus.h"
32	#include "ICStatusUtils.h"	32	#include "ICStatusUtils.h"
33	#include "JSCInlines.h"
34	#include "PolymorphicAccess.h"	33	#include "PolymorphicAccess.h"
35	#include "StructureStubInfo.h"	34	#include "StructureStubInfo.h"
36	#include <wtf/ListDump.h>	35	#include <wtf/ListDump.h>



#include "config.h"
#include "InByIdVariant.h"

#include "JSCInlines.h"
#include <wtf/ListDump.h>

namespace JSC {

InByIdVariant::InByIdVariant(const StructureSet& structureSet, PropertyOffset offset, const ObjectPropertyConditionSet& conditionSet)



#include "config.h"
#include "InlineCallFrame.h"

#include "CallFrame.h"
#include "CodeBlock.h"
#include "JSCJSValueInlines.h"

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/bytecode/InlineCallFrameSet.cpp_sec1
- a/Source/JavaScriptCore/bytecode/InlineCallFrameSet.cpp -1 lines
27	#include "InlineCallFrameSet.h"	27	#include "InlineCallFrameSet.h"
28		28
29	#include "InlineCallFrame.h"	29	#include "InlineCallFrame.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32

Lines 28-34 a/Source/JavaScriptCore/bytecode/InstanceOfAccessCase.cpp_sec1
- a/Source/JavaScriptCore/bytecode/InstanceOfAccessCase.cpp -1 / +1 lines
28		28
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "JSCInlines.h"	31	#include "JSCJSValueInlines.h"
32		32
33	namespace JSC {	33	namespace JSC {
34		34

Lines 28-34 a/Source/JavaScriptCore/bytecode/InstanceOfStatus.cpp_sec1
- a/Source/JavaScriptCore/bytecode/InstanceOfStatus.cpp -1 lines
28		28
29	#include "ICStatusUtils.h"	29	#include "ICStatusUtils.h"
30	#include "InstanceOfAccessCase.h"	30	#include "InstanceOfAccessCase.h"
31	#include "JSCInlines.h"
32	#include "PolymorphicAccess.h"	31	#include "PolymorphicAccess.h"
33	#include "StructureStubInfo.h"	32	#include "StructureStubInfo.h"
34		33



#include "config.h"
#include "InstanceOfVariant.h"

#include "JSCInlines.h"
#include <wtf/ListDump.h>

namespace JSC {

InstanceOfVariant::InstanceOfVariant(



#include "config.h"
#include "InstructionStream.h"

#include "Instruction.h"
#include "Opcode.h"

namespace JSC {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(InstructionStream);




#if ENABLE(JIT)

#include "HeapInlines.h"

namespace JSC {

IntrinsicGetterAccessCase::IntrinsicGetterAccessCase(VM& vm, JSCell* owner, CacheableIdentifier identifier, PropertyOffset offset, Structure* structure, const ObjectPropertyConditionSet& conditionSet, JSFunction* intrinsicFunction, std::unique_ptr<PolyProtoAccessChain> prototypeAccessChain)

Lines 28-34 a/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp_sec1
- a/Source/JavaScriptCore/bytecode/LLIntPrototypeLoadAdaptiveStructureWatchpoint.cpp -1 lines
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "Instruction.h"	30	#include "Instruction.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33

Lines 26-32 a/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp_sec1
- a/Source/JavaScriptCore/bytecode/LazyOperandValueProfile.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "LazyOperandValueProfile.h"	27	#include "LazyOperandValueProfile.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCJSValueInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32



#include "config.h"
#include "MetadataTable.h"

#include "JSCInlines.h"
#include "OpcodeInlines.h"
#include "UnlinkedMetadataTableInlines.h"
#include <wtf/FastMalloc.h>

namespace JSC {


Lines 31-37 a/Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp_sec1
- a/Source/JavaScriptCore/bytecode/MethodOfGettingAValueProfile.cpp -1 lines
31	#include "ArithProfile.h"	31	#include "ArithProfile.h"
32	#include "CCallHelpers.h"	32	#include "CCallHelpers.h"
33	#include "CodeBlock.h"	33	#include "CodeBlock.h"
34	#include "JSCInlines.h"
35		34
36	namespace JSC {	35	namespace JSC {
37		36

Lines 30-36 a/Source/JavaScriptCore/bytecode/ModuleNamespaceAccessCase.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ModuleNamespaceAccessCase.cpp -1 lines
30	#if ENABLE(JIT)	30	#if ENABLE(JIT)
31		31
32	#include "CCallHelpers.h"	32	#include "CCallHelpers.h"
33	#include "HeapInlines.h"
34	#include "JSModuleEnvironment.h"	33	#include "JSModuleEnvironment.h"
35	#include "JSModuleNamespaceObject.h"	34	#include "JSModuleNamespaceObject.h"
36	#include "PolymorphicAccess.h"	35	#include "PolymorphicAccess.h"

Lines 26-32 a/Source/JavaScriptCore/bytecode/ObjectPropertyCondition.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ObjectPropertyCondition.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ObjectPropertyCondition.h"	27	#include "ObjectPropertyCondition.h"
28		28
29	#include "JSCInlines.h"
30	#include "TrackedReferences.h"	29	#include "TrackedReferences.h"
31		30
32	namespace JSC {	31	namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/bytecode/ParseHash.cpp_sec1
- a/Source/JavaScriptCore/bytecode/ParseHash.cpp -1 lines
28		28
29	#include "SourceCode.h"	29	#include "SourceCode.h"
30	#include <wtf/SHA1.h>	30	#include <wtf/SHA1.h>
31	#include <wtf/SixCharacterHash.h>
32		31
33	namespace JSC {	32	namespace JSC {
34		33

Lines 26-32 a/Source/JavaScriptCore/bytecode/PolyProtoAccessChain.cpp_sec1
- a/Source/JavaScriptCore/bytecode/PolyProtoAccessChain.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "PolyProtoAccessChain.h"	27	#include "PolyProtoAccessChain.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSObject.h"	29	#include "JSObject.h"
31		30
32	namespace JSC {	31	namespace JSC {

Lines 35-41 a/Source/JavaScriptCore/bytecode/PolymorphicAccess.cpp_sec1
- a/Source/JavaScriptCore/bytecode/PolymorphicAccess.cpp -1 lines
35	#include "FullCodeOrigin.h"	35	#include "FullCodeOrigin.h"
36	#include "Heap.h"	36	#include "Heap.h"
37	#include "JITOperations.h"	37	#include "JITOperations.h"
38	#include "JSCInlines.h"
39	#include "LinkBuffer.h"	38	#include "LinkBuffer.h"
40	#include "StructureStubClearingWatchpoint.h"	39	#include "StructureStubClearingWatchpoint.h"
41	#include "StructureStubInfo.h"	40	#include "StructureStubInfo.h"



#include "config.h"
#include "PreciseJumpTargets.h"

#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "PreciseJumpTargetsInlines.h"

namespace JSC {

Lines 27-33 a/Source/JavaScriptCore/bytecode/PropertyCondition.cpp_sec1
- a/Source/JavaScriptCore/bytecode/PropertyCondition.cpp -1 lines
27	#include "PropertyCondition.h"	27	#include "PropertyCondition.h"
28		28
29	#include "GetterSetter.h"	29	#include "GetterSetter.h"
30	#include "JSCInlines.h"
31	#include "TrackedReferences.h"	30	#include "TrackedReferences.h"
32		31
33	namespace JSC {	32	namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/bytecode/PutByIdFlags.cpp_sec1
- a/Source/JavaScriptCore/bytecode/PutByIdFlags.cpp -1 lines
28		28
29	#include <wtf/CommaPrinter.h>	29	#include <wtf/CommaPrinter.h>
30	#include <wtf/PrintStream.h>	30	#include <wtf/PrintStream.h>
31	#include <wtf/StringPrintStream.h>
32		31
33	namespace WTF {	32	namespace WTF {
34		33



#include "ComplexGetStatus.h"
#include "GetterSetterAccessCase.h"
#include "ICStatusUtils.h"
#include "LLIntData.h"
#include "LowLevelInterpreter.h"
#include "JSCInlines.h"
#include "PolymorphicAccess.h"
#include "StructureInlines.h"
#include "StructureChain.h"
#include "StructureStubInfo.h"
#include <wtf/ListDump.h>




#include "PutByIdVariant.h"

#include "CallLinkStatus.h"
#include "JSCInlines.h"
#include <wtf/ListDump.h>

namespace JSC {




#include "JSArray.h"
#include "JSBigInt.h"
#include "JSBoundFunction.h"
#include "JSDataView.h"
#include "JSFunction.h"
#include "JSMap.h"
#include "JSSet.h"

#include "RegExpObject.h"
#include "ScopedArguments.h"
#include "StringObject.h"
#include "ValueProfile.h"
#include <wtf/CommaPrinter.h>
#include <wtf/StringPrintStream.h>




#include "config.h"
#include "StructureSet.h"

#include "JSCInlines.h"
#include "TrackedReferences.h"
#include <wtf/CommaPrinter.h>

namespace JSC {

Lines 29-35 a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp_sec1
- a/Source/JavaScriptCore/bytecode/StructureStubClearingWatchpoint.cpp -1 lines
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "JSCInlines.h"
33	#include "StructureStubInfo.h"	32	#include "StructureStubInfo.h"
34		33
35	namespace JSC {	34	namespace JSC {



#include "StructureStubInfo.h"

#include "CacheableIdentifierInlines.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "PolymorphicAccess.h"
#include "Repatch.h"


Lines 26-32 a/Source/JavaScriptCore/bytecode/SuperSampler.cpp_sec1
- a/Source/JavaScriptCore/bytecode/SuperSampler.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "SuperSampler.h"	27	#include "SuperSampler.h"
28		28
29	#include "MacroAssembler.h"
30	#include "Options.h"	29	#include "Options.h"
31	#include <wtf/DataLog.h>	30	#include <wtf/DataLog.h>
32	#include <wtf/Lock.h>	31	#include <wtf/Lock.h>

Lines 26-32 a/Source/JavaScriptCore/bytecode/TrackedReferences.cpp_sec1
- a/Source/JavaScriptCore/bytecode/TrackedReferences.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "TrackedReferences.h"	27	#include "TrackedReferences.h"
28		28
29	#include "JSCInlines.h"
30	#include <wtf/CommaPrinter.h>	29	#include <wtf/CommaPrinter.h>
31		30
32	namespace JSC {	31	namespace JSC {




#include "UnlinkedCodeBlock.h"

#include "BytecodeGenerator.h"
#include "BytecodeLivenessAnalysis.h"
#include "BytecodeStructs.h"
#include "ClassInfo.h"
#include "CodeCache.h"
#include "ExecutableInfo.h"
#include "FunctionOverrides.h"
#include "InstructionStream.h"
#include "SlotVisitorInlines.h"
#include "JSString.h"
#include "Opcode.h"
#include "Parser.h"
#include "PreciseJumpTargetsInlines.h"
#include "SourceProvider.h"
#include "Structure.h"
#include "SymbolTable.h"
#include "UnlinkedEvalCodeBlock.h"
#include "UnlinkedFunctionCodeBlock.h"
#include "UnlinkedMetadataTableInlines.h"
#include "UnlinkedModuleProgramCodeBlock.h"
#include "UnlinkedProgramCodeBlock.h"
#include <wtf/DataLog.h>

namespace JSC {



#include "config.h"
#include "UnlinkedCodeBlockGenerator.h"

#include "BytecodeGenerator.h"
#include "BytecodeLivenessAnalysis.h"
#include "BytecodeRewriter.h"
#include "ClassInfo.h"
#include "CodeCache.h"
#include "ExecutableInfo.h"
#include "FunctionOverrides.h"
#include "InstructionStream.h"
#include "PreciseJumpTargets.h"
#include "JSString.h"
#include "Opcode.h"
#include "Parser.h"
#include "PreciseJumpTargetsInlines.h"
#include "SourceProvider.h"
#include "Structure.h"
#include "SymbolTable.h"
#include "UnlinkedEvalCodeBlock.h"
#include "UnlinkedFunctionCodeBlock.h"
#include "UnlinkedMetadataTableInlines.h"
#include "UnlinkedModuleProgramCodeBlock.h"
#include "UnlinkedProgramCodeBlock.h"
#include <wtf/DataLog.h>

namespace JSC {


Lines 35-41 a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp_sec1
- a/Source/JavaScriptCore/bytecode/UnlinkedFunctionExecutable.cpp -1 lines
35	#include "ExecutableInfo.h"	35	#include "ExecutableInfo.h"
36	#include "FunctionOverrides.h"	36	#include "FunctionOverrides.h"
37	#include "IsoCellSetInlines.h"	37	#include "IsoCellSetInlines.h"
38	#include "JSCInlines.h"
39	#include "Parser.h"	38	#include "Parser.h"
40	#include "SourceProvider.h"	39	#include "SourceProvider.h"
41	#include "Structure.h"	40	#include "Structure.h"



#include "UnlinkedMetadataTable.h"

#include "BytecodeStructs.h"
#include "CodeBlock.h"
#include "JSCInlines.h"
#include "OpcodeInlines.h"
#include "UnlinkedMetadataTableInlines.h"
#include <wtf/FastMalloc.h>

namespace JSC {


Lines 26-32 a/Source/JavaScriptCore/bytecode/UnlinkedModuleProgramCodeBlock.cpp_sec1
- a/Source/JavaScriptCore/bytecode/UnlinkedModuleProgramCodeBlock.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "UnlinkedModuleProgramCodeBlock.h"	27	#include "UnlinkedModuleProgramCodeBlock.h"
28		28
29	#include "HeapInlines.h"
30	#include "JSCellInlines.h"	29	#include "JSCellInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/bytecode/UnlinkedProgramCodeBlock.cpp_sec1
- a/Source/JavaScriptCore/bytecode/UnlinkedProgramCodeBlock.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "UnlinkedProgramCodeBlock.h"	27	#include "UnlinkedProgramCodeBlock.h"
28		28
29	#include "HeapInlines.h"
30	#include "JSCellInlines.h"	29	#include "JSCellInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {



#include "config.h"
#include "ValueRecovery.h"

#include "CodeBlock.h"
#include "JSCInlines.h"

namespace JSC {

JSValue ValueRecovery::recover(CallFrame* callFrame) const

Lines 26-32 a/Source/JavaScriptCore/bytecode/VariableWriteFireDetail.cpp_sec1
- a/Source/JavaScriptCore/bytecode/VariableWriteFireDetail.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "VariableWriteFireDetail.h"	27	#include "VariableWriteFireDetail.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCJSValueInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32



#include "CodeBlockJettisoningWatchpoint.h"
#include "DFGAdaptiveStructureWatchpoint.h"
#include "FunctionRareData.h"
#include "HeapInlines.h"
#include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"
#include "ObjectToStringAdaptiveStructureWatchpoint.h"
#include "StructureStubClearingWatchpoint.h"
#include "VM.h"
#include <wtf/CompilationThread.h>

namespace JSC {




#include "config.h"
#include "BytecodeGenerator.h"

#include "ArithProfile.h"
#include "BuiltinExecutables.h"
#include "BuiltinNames.h"
#include "BytecodeGeneratorBaseInlines.h"
#include "BytecodeGeneratorification.h"
#include "BytecodeLivenessAnalysis.h"
#include "BytecodeUseDef.h"
#include "CatchScope.h"
#include "DefinePropertyAttributes.h"

#include "JSAsyncGenerator.h"
#include "JSBigInt.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGeneratorFunction.h"
#include "JSImmutableButterfly.h"
#include "JSLexicalEnvironment.h"
#include "JSTemplateObjectDescriptor.h"
#include "LinkTimeConstant.h"
#include "LowLevelInterpreter.h"
#include "Options.h"
#include "PreciseJumpTargetsInlines.h"
#include "StackAlignment.h"
#include "StrongInlines.h"
#include "SuperSamplerBytecodeScope.h"
#include "UnlinkedCodeBlock.h"
#include "UnlinkedEvalCodeBlock.h"
#include "UnlinkedFunctionCodeBlock.h"

#include "UnlinkedModuleProgramCodeBlock.h"
#include "UnlinkedProgramCodeBlock.h"
#include <wtf/BitVector.h>
#include <wtf/CommaPrinter.h>
#include <wtf/Optional.h>
#include <wtf/SmallPtrSet.h>
#include <wtf/StdLibExtras.h>



#include "BytecodeGenerator.h"
#include "BytecodeGeneratorBaseInlines.h"
#include "CallFrame.h"
#include "JIT.h"
#include "JSArrayIterator.h"
#include "JSAsyncGenerator.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGenerator.h"
#include "JSGlobalObject.h"
#include "JSImmutableButterfly.h"
#include "JSMapIterator.h"
#include "JSSetIterator.h"
#include "JSStringIterator.h"
#include "LabelScope.h"
#include "LinkTimeConstant.h"
#include "ModuleScopeData.h"
#include "StackAlignment.h"
#include "UnlinkedMetadataTableInlines.h"
#include "YarrFlags.h"
#include <wtf/Assertions.h>
#include <wtf/Threading.h>
#include <wtf/text/StringBuilder.h>

namespace JSC {




#include "CodeBlock.h"
#include "DebuggerCallFrame.h"
#include "Error.h"
#include "HeapIterationScope.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "MarkedSpaceInlines.h"
#include "Parser.h"
#include "Protect.h"
#include "VMEntryScope.h"

namespace JSC {



#include "DebuggerEvalEnabler.h"
#include "DebuggerScope.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSLexicalEnvironment.h"
#include "JSWithScope.h"
#include "Parser.h"
#include "ShadowChickenInlines.h"
#include "StackVisitor.h"
#include "StrongInlines.h"

Lines 26-32 a/Source/JavaScriptCore/debugger/DebuggerLocation.cpp_sec1
- a/Source/JavaScriptCore/debugger/DebuggerLocation.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "DebuggerLocation.h"	27	#include "DebuggerLocation.h"
28		28
29	#include "JSCellInlines.h"
30	#include "ScriptExecutable.h"	29	#include "ScriptExecutable.h"
31		30
32	namespace JSC {	31	namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/debugger/DebuggerScope.cpp_sec1
- a/Source/JavaScriptCore/debugger/DebuggerScope.cpp -1 lines
28		28
29	#include "JSLexicalEnvironment.h"	29	#include "JSLexicalEnvironment.h"
30	#include "JSCInlines.h"	30	#include "JSCInlines.h"
31	#include "JSWithScope.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

void AbstractHeap::Payload::dump(PrintStream& out) const

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGAbstractValue.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "JSCInlines.h"
33	#include "TrackedReferences.h"	32	#include "TrackedReferences.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGAdaptiveInferredPropertyValueWatchpoint.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGAdaptiveInferredPropertyValueWatchpoint.cpp -1 lines
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGCommon.h"	32	#include "DFGCommon.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGAdaptiveStructureWatchpoint.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34



#if ENABLE(DFG_JIT)

#include "ArrayPrototype.h"
#include "BytecodeLivenessAnalysisInlines.h"
#include "ClonedArguments.h"
#include "DFGArgumentsUtilities.h"
#include "DFGBasicBlockInlines.h"
#include "DFGBlockMapInlines.h"
#include "DFGClobberize.h"
#include "DFGCombinedLiveness.h"

Lines 28-34 a/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGArgumentsUtilities.cpp -1 / +1 lines
28		28
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "JSCInlines.h"	31	#include "JSImmutableButterfly.h"
32		32
33	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
34		34

Lines 32-38 a/Source/JavaScriptCore/dfg/DFGArrayMode.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGArrayMode.cpp -1 lines
32	#include "CacheableIdentifierInlines.h"	32	#include "CacheableIdentifierInlines.h"
33	#include "DFGAbstractValue.h"	33	#include "DFGAbstractValue.h"
34	#include "DFGGraph.h"	34	#include "DFGGraph.h"
35	#include "JSCInlines.h"
36		35
37	namespace JSC { namespace DFG {	36	namespace JSC { namespace DFG {
38		37




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

AtTailAbstractState::AtTailAbstractState(Graph& graph)

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGAvailability.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGAvailability.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGNode.h"	31	#include "DFGNode.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGAvailabilityMap.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGAvailabilityMap.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "JSCInlines.h"
33	#include "OperandsInlines.h"	32	#include "OperandsInlines.h"
34	#include <wtf/ListDump.h>	33	#include <wtf/ListDump.h>
35		34




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(BasicBlock);




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

BlockInsertionSet::BlockInsertionSet(Graph& graph)




#include "ArithProfile.h"
#include "ArrayConstructor.h"
#include "ArrayPrototype.h"
#include "BuiltinNames.h"
#include "ByValInfo.h"
#include "BytecodeGenerator.h"
#include "BytecodeOperandsForCheckpoint.h"
#include "BytecodeUseDef.h"
#include "CacheableIdentifierInlines.h"
#include "CallLinkStatus.h"
#include "CodeBlock.h"

#include "CommonSlowPaths.h"
#include "DFGAbstractHeap.h"
#include "DFGArrayMode.h"
#include "DFGBlockSet.h"
#include "DFGCapabilities.h"
#include "DFGClobberize.h"
#include "DFGClobbersExitState.h"
#include "DFGGraph.h"
#include "DOMJITGetterSetter.h"
#include "DeleteByStatus.h"
#include "FunctionCodeBlock.h"
#include "GetByStatus.h"

#include "InByIdStatus.h"
#include "InstanceOfStatus.h"
#include "JSArrayIterator.h"
#include "JSCInlines.h"
#include "JSImmutableButterfly.h"
#include "JSInternalPromise.h"
#include "JSInternalPromiseConstructor.h"

#include "StringConstructor.h"
#include "StructureStubInfo.h"
#include "SymbolConstructor.h"
#include "Watchdog.h"
#include <wtf/CommaPrinter.h>
#include <wtf/HashMap.h>
#include <wtf/MathExtras.h>
#include <wtf/Scope.h>
#include <wtf/SetForScope.h>
#include <wtf/StdLibExtras.h>





#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGValidate.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {




#include "DFGDominators.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
#include <array>

namespace JSC { namespace DFG {





#include "CodeBlock.h"
#include "DFGCommon.h"
#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "Options.h"

namespace JSC { namespace DFG {



#if ENABLE(DFG_JIT)

#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 29-35 a/Source/JavaScriptCore/dfg/DFGClobberSet.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGClobberSet.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGClobberize.h"	31	#include "DFGClobberize.h"
32	#include "JSCInlines.h"
33	#include <wtf/ListDump.h>	32	#include <wtf/ListDump.h>
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {

Lines 28-34 a/Source/JavaScriptCore/dfg/DFGClobberize.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGClobberize.cpp -1 / +1 lines
28		28
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "JSCInlines.h"	31	#include "ButterflyInlines.h"
32		32
33	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
34		34




#if ENABLE(DFG_JIT)

#include "ButterflyInlines.h"
#include "DFGClobberize.h"
#include "DFGGraph.h"
#include "DFGNode.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#include "DFGAvailabilityMap.h"
#include "DFGBlockMapInlines.h"
#include "FullBytecodeLiveness.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {




#include "config.h"
#include "DFGCommon.h"

#include <wtf/Lock.h>
#include "JSCInlines.h"
#include <wtf/PrintStream.h>

#if ENABLE(DFG_JIT)



#include "DFGNode.h"
#include "DFGPlan.h"
#include "InlineCallFrame.h"
#include "JSCInlines.h"
#include "TrackedReferences.h"
#include "VM.h"

#include <wtf/NeverDestroyed.h>

namespace JSC { namespace DFG {



#if ENABLE(DFG_JIT)

#include "CodeBlock.h"
#include "CodeBlockSet.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace WTF {

using namespace JSC::DFG;



#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 32-38 a/Source/JavaScriptCore/dfg/DFGCriticalEdgeBreakingPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGCriticalEdgeBreakingPhase.cpp -1 lines
32	#include "DFGBlockInsertionSet.h"	32	#include "DFGBlockInsertionSet.h"
33	#include "DFGGraph.h"	33	#include "DFGGraph.h"
34	#include "DFGPhase.h"	34	#include "DFGPhase.h"
35	#include "JSCInlines.h"
36		35
37	namespace JSC { namespace DFG {	36	namespace JSC { namespace DFG {
38		37




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 31-37 a/Source/JavaScriptCore/dfg/DFGDesiredGlobalProperties.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGDesiredGlobalProperties.cpp -1 lines
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGCommonData.h"	32	#include "DFGCommonData.h"
33	#include "DFGDesiredIdentifiers.h"	33	#include "DFGDesiredIdentifiers.h"
34	#include "JSCInlines.h"
35	#include "JSGlobalObject.h"	34	#include "JSGlobalObject.h"
36		35
37	namespace JSC { namespace DFG {	36	namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGDesiredIdentifiers.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGDesiredIdentifiers.cpp -1 lines
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGCommonData.h"	32	#include "DFGCommonData.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGDesiredTransitions.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGDesiredTransitions.cpp -1 lines
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGCommonData.h"	32	#include "DFGCommonData.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGDesiredWatchpoints.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGDesiredWatchpoints.cpp -1 / +1 lines
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGGraph.h"	32	#include "DFGGraph.h"
33	#include "JSCInlines.h"	33	#include "JSArrayBufferViewInlines.h"
34		34
35	namespace JSC { namespace DFG {	35	namespace JSC { namespace DFG {
36		36

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGDesiredWeakReferences.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGDesiredWeakReferences.cpp -1 lines
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGCommonData.h"	32	#include "DFGCommonData.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35




#include "CodeBlockWithJITType.h"
#include "DFGGraph.h"
#include "DFGJITCode.h"
#include "Disassembler.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "ProfilerDatabase.h"
#include <wtf/StdLibExtras.h>

namespace JSC { namespace DFG {




#include "config.h"
#include "DFGDriver.h"

#include "JSObject.h"
#include "JSString.h"

#include "CodeBlock.h"
#include "DFGJITCode.h"
#include "DFGPlan.h"

#include "DFGWorklist.h"
#include "FunctionWhitelist.h"
#include "JITCode.h"
#include "JSCInlines.h"
#include "Options.h"
#include "ThunkGenerators.h"
#include "TypeProfilerLog.h"
#include <wtf/Atomics.h>
#include <wtf/NeverDestroyed.h>

#if ENABLE(FTL_JIT)
#include "FTLThunks.h"
#endif

namespace JSC { namespace DFG {

static unsigned numCompilations;

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGEdge.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGEdge.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGNode.h"	31	#include "DFGNode.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

FailedFinalizer::FailedFinalizer(Plan& plan)




#if ENABLE(DFG_JIT)

#include "DFGPlan.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {

Finalizer::Finalizer(Plan& plan)



#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "GetterSetter.h"
#include "JSCInlines.h"
#include "TypeLocation.h"




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace WTF {

using namespace JSC::DFG;




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

void FlushedAt::dump(PrintStream& out) const

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGFrozenValue.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGFrozenValue.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGLazyJSValue.h"	31	#include "DFGLazyJSValue.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34




#if ENABLE(DFG_JIT)

#include "ArrayPrototype.h"
#include "CodeBlock.h"
#include "CodeBlockWithJITType.h"
#include "DFGBackwardsCFG.h"

#include "DFGDominators.h"
#include "DFGFlowIndexing.h"
#include "DFGFlowMap.h"
#include "DFGJITCode.h"
#include "DFGMayExit.h"
#include "DFGNaturalLoops.h"
#include "DFGVariableAccessDataDump.h"

#include "JSLexicalEnvironment.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "OperandsInlines.h"
#include "Snippet.h"
#include "StackAlignment.h"
#include <wtf/CommaPrinter.h>
#include <wtf/ListDump.h>

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGGraphSafepoint.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGGraphSafepoint.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34




#if ENABLE(DFG_JIT)

#include "CodeBlock.h"
#include "DFGBasicBlock.h"
#include "GetByStatus.h"
#include "JSCInlines.h"
#include "PutByIdStatus.h"
#include "StringObject.h"
#include "SuperSampler.h"

namespace JSC { namespace DFG {




#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "JSCInlines.h"
#include <wtf/HashMethod.h>
#include <wtf/StdUnorderedMap.h>

namespace JSC { namespace DFG {




#include "DFGInsertionSet.h"
#include "DFGNodeFlowProjection.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 33-39 a/Source/JavaScriptCore/dfg/DFGInvalidationPointInjectionPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGInvalidationPointInjectionPhase.cpp -1 lines
33	#include "DFGGraph.h"	33	#include "DFGGraph.h"
34	#include "DFGInsertionSet.h"	34	#include "DFGInsertionSet.h"
35	#include "DFGPhase.h"	35	#include "DFGPhase.h"
36	#include "JSCInlines.h"
37		36
38	namespace JSC { namespace DFG {	37	namespace JSC { namespace DFG {
39		38




#include "CodeBlock.h"
#include "FTLForOSREntryJITCode.h"
#include "JSCInlines.h"
#include "TrackedReferences.h"

namespace JSC { namespace DFG {




#include "DFGJITCode.h"
#include "DFGJITFinalizer.h"
#include "DFGOSRExit.h"
#include "DFGOperations.h"
#include "DFGRegisterBank.h"
#include "DFGSlowPathGenerator.h"
#include "DFGSpeculativeJIT.h"
#include "DFGThunks.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "LinkBuffer.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "StructureStubInfo.h"
#include "ThunkGenerators.h"
#include "VM.h"





#include "CodeBlock.h"
#include "CodeBlockWithJITType.h"
#include "DFGCommon.h"
#include "DFGPlan.h"
#include "JSCInlines.h"
#include "ProfilerDatabase.h"

namespace JSC { namespace DFG {

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGJumpReplacement.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGJumpReplacement.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "MacroAssembler.h"	31	#include "MacroAssembler.h"
32	#include "JSCInlines.h"
33	#include "Options.h"	32	#include "Options.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {




#include "DFGAbstractInterpreterInlines.h"
#include "DFGAtTailAbstractState.h"
#include "DFGBasicBlockInlines.h"
#include "DFGClobberSet.h"
#include "DFGClobberize.h"
#include "DFGControlEquivalenceAnalysis.h"
#include "DFGEdgeDominates.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGMayExit.h"
#include "DFGNaturalLoops.h"
#include "DFGPhase.h"

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGLazyJSValue.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGLazyJSValue.cpp -1 / +1 lines
30		30
31	#include "CCallHelpers.h"	31	#include "CCallHelpers.h"
32	#include "DFGGraph.h"	32	#include "DFGGraph.h"
33	#include "JSCInlines.h"	33	#include "JSCJSValueInlines.h"
34	#include "LinkBuffer.h"	34	#include "LinkBuffer.h"
35		35
36	namespace JSC { namespace DFG {	36	namespace JSC { namespace DFG {




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGBlockSet.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "FullBytecodeLiveness.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGBlockMapInlines.h"
#include "DFGFlowIndexing.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
#include <wtf/BitVector.h>
#include <wtf/IndexSparseSet.h>
#include <wtf/LoggingHashSet.h>

namespace JSC { namespace DFG {




#include "DFGGraph.h"
#include "DFGNaturalLoops.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
#include <wtf/HashMap.h>

namespace JSC { namespace DFG {


Lines 29-35 a/Source/JavaScriptCore/dfg/DFGMayExit.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGMayExit.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGAtTailAbstractState.h"	31	#include "DFGAtTailAbstractState.h"
32	#include "DFGGraph.h"
33	#include "DFGNode.h"	32	#include "DFGNode.h"
34	#include "DFGNullAbstractState.h"	33	#include "DFGNullAbstractState.h"
35		34

Lines 28-34 a/Source/JavaScriptCore/dfg/DFGMinifiedGraph.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGMinifiedGraph.cpp -1 lines
28		28
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "JSCInlines.h"
32	#include "TrackedReferences.h"	31	#include "TrackedReferences.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGMinifiedNode.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGMinifiedNode.cpp -1 lines
30		30
31	#include "DFGMinifiedIDInlines.h"	31	#include "DFGMinifiedIDInlines.h"
32	#include "DFGNode.h"	32	#include "DFGNode.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35




#if ENABLE(DFG_JIT)

#include "BytecodeLivenessAnalysisInlines.h"
#include "DFGEpoch.h"
#include "DFGForAllKills.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGMayExit.h"
#include "DFGPhase.h"
#include "JSCInlines.h"
#include "OperandsInlines.h"

namespace JSC { namespace DFG {

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGMultiGetByOffsetData.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGMultiGetByOffsetData.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGFrozenValue.h"	31	#include "DFGFrozenValue.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGNode.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGNode.cpp -1 / +1 lines
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "DFGPromotedHeapLocation.h"	32	#include "DFGPromotedHeapLocation.h"
33	#include "JSCInlines.h"	33	#include "DOMJITSignature.h"
34	#include "JSImmutableButterfly.h"	34	#include "JSImmutableButterfly.h"
35		35
36	namespace JSC { namespace DFG {	36	namespace JSC { namespace DFG {

Lines 28-34 a/Source/JavaScriptCore/dfg/DFGNodeFlags.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGNodeFlags.cpp -1 lines
28		28
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "JSCInlines.h"
32	#include <wtf/CommaPrinter.h>	31	#include <wtf/CommaPrinter.h>
33	#include <wtf/StringPrintStream.h>	32	#include <wtf/StringPrintStream.h>
34		33




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {




#include "CodeBlock.h"
#include "DFGJITCode.h"
#include "DFGNode.h"
#include "RegisterAtOffsetList.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>





#include "DFGBasicBlockInlines.h"
#include "DFGBlockInsertionSet.h"
#include "DFGCFG.h"
#include "DFGGraph.h"
#include "DFGLoopPreHeaderCreationPhase.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {




#if ENABLE(DFG_JIT)

#include "AssemblyHelpers.h"
#include "BytecodeStructs.h"
#include "CheckpointOSRExitSideState.h"
#include "ClonedArguments.h"
#include "DFGGraph.h"
#include "DFGMayExit.h"
#include "DFGOSRExitCompilerCommon.h"
#include "DFGOperations.h"
#include "DFGSpeculativeJIT.h"
#include "DirectArguments.h"
#include "FrameTracers.h"
#include "InlineCallFrame.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "OperandsInlines.h"
#include "ProbeContext.h"
#include "ProbeFrame.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "CodeBlock.h"
#include "DFGBasicBlock.h"
#include "DFGNode.h"
#include "InlineCallFrame.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "Bytecodes.h"
#include "CheckpointOSRExitSideState.h"
#include "DFGJITCode.h"
#include "DFGOperations.h"
#include "JIT.h"
#include "JSCJSValueInlines.h"
#include "JSCInlines.h"
#include "LLIntData.h"
#include "LLIntThunks.h"
#include "ProbeContext.h"
#include "StructureStubInfo.h"

namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGOSRExitJumpPlaceholder.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGOSRExitJumpPlaceholder.cpp -1 lines
30		30
31	#include "DFGJITCompiler.h"	31	#include "DFGJITCompiler.h"
32	#include "DFGSpeculativeJIT.h"	32	#include "DFGSpeculativeJIT.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 41-47 a/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGObjectAllocationSinkingPhase.cpp -1 lines
41	#include "DFGSSACalculator.h"	41	#include "DFGSSACalculator.h"
42	#include "DFGValidate.h"	42	#include "DFGValidate.h"
43	#include "JSArrayIterator.h"	43	#include "JSArrayIterator.h"
44	#include "JSCInlines.h"
45	#include "JSInternalPromise.h"	44	#include "JSInternalPromise.h"
46	#include "JSMapIterator.h"	45	#include "JSMapIterator.h"
47	#include "JSSetIterator.h"	46	#include "JSSetIterator.h"



#include "config.h"
#include "DFGOperations.h"

#include "ArrayConstructor.h"
#include "ButterflyInlines.h"
#include "CacheableIdentifierInlines.h"
#include "ClonedArguments.h"

#include "CommonSlowPaths.h"
#include "DFGDriver.h"
#include "DFGJITCode.h"
#include "DFGOSRExit.h"
#include "DFGThunks.h"
#include "DFGToFTLDeferredCompilationCallback.h"
#include "DFGToFTLForOSREntryDeferredCompilationCallback.h"
#include "DFGWorklist.h"
#include "DateInstance.h"
#include "DefinePropertyAttributes.h"
#include "DirectArguments.h"
#include "EvalCodeBlock.h"
#include "FTLForOSREntryJITCode.h"
#include "FTLOSREntry.h"
#include "FrameTracers.h"
#include "HasOwnPropertyCache.h"
#include "HostCallReturnValue.h"
#include "Interpreter.h"
#include "JIT.h"
#include "JITExceptions.h"
#include "JSArrayInlines.h"
#include "JSArrayIterator.h"
#include "JSAsyncGenerator.h"
#include "JSBigInt.h"
#include "JSCInlines.h"
#include "JSGenericTypedArrayViewConstructorInlines.h"
#include "JSGenericTypedArrayViewInlines.h"
#include "JSImmutableButterfly.h"
#include "JSInternalPromise.h"
#include "JSInternalPromiseConstructor.h"

#include "JSSetIterator.h"
#include "JSWeakMap.h"
#include "JSWeakSet.h"
#include "ModuleProgramCodeBlock.h"
#include "NumberConstructor.h"
#include "ObjectConstructor.h"
#include "Operations.h"
#include "ParseInt.h"
#include "ProgramCodeBlock.h"
#include "RegExpGlobalDataInlines.h"
#include "RegExpMatchesArray.h"
#include "RegExpObjectInlines.h"

#include "SuperSampler.h"
#include "Symbol.h"
#include "TypeProfilerLog.h"
#include "TypedArrayInlines.h"
#include "VMInlines.h"
#include <wtf/InlineASM.h>

#if ENABLE(JIT)
#if ENABLE(DFG_JIT)




#if ENABLE(DFG_JIT)

#include "BytecodeLivenessAnalysisInlines.h"
#include "DFGForAllKills.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGMayExit.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "JSCInlines.h"
#include "OperandsInlines.h"

namespace JSC { namespace DFG {

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGPhase.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGValidate.h"	31	#include "DFGValidate.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34

Lines 74-80 a/Source/JavaScriptCore/dfg/DFGPlan.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGPlan.cpp -1 lines
74	#include "DFGVarargsForwardingPhase.h"	74	#include "DFGVarargsForwardingPhase.h"
75	#include "DFGVirtualRegisterAllocationPhase.h"	75	#include "DFGVirtualRegisterAllocationPhase.h"
76	#include "DFGWatchpointCollectionPhase.h"	76	#include "DFGWatchpointCollectionPhase.h"
77	#include "JSCInlines.h"
78	#include "OperandsInlines.h"	77	#include "OperandsInlines.h"
79	#include "ProfilerDatabase.h"	78	#include "ProfilerDatabase.h"
80	#include "TrackedReferences.h"	79	#include "TrackedReferences.h"




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 30-36 a/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGPredictionPropagationPhase.cpp -1 lines
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "DFGPhase.h"	32	#include "DFGPhase.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 29-35 a/Source/JavaScriptCore/dfg/DFGPromotedHeapLocation.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGPromotedHeapLocation.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC { namespace DFG {	33	namespace JSC { namespace DFG {
35		34




#if ENABLE(DFG_JIT)

#include "ButterflyInlines.h"
#include "DFGBlockMapInlines.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGPreciseLocalClobberize.h"
#include "DFGSSACalculator.h"
#include "DFGValidate.h"
#include "JSCInlines.h"
#include "OperandsInlines.h"

namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGSSACalculator.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGSSACalculator.cpp -1 lines
30		30
31	#include "DFGBlockMapInlines.h"	31	#include "DFGBlockMapInlines.h"
32	#include <wtf/CommaPrinter.h>	32	#include <wtf/CommaPrinter.h>
33	#include <wtf/ListDump.h>
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 35-41 a/Source/JavaScriptCore/dfg/DFGSSAConversionPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGSSAConversionPhase.cpp -1 lines
35	#include "DFGPhase.h"	35	#include "DFGPhase.h"
36	#include "DFGSSACalculator.h"	36	#include "DFGSSACalculator.h"
37	#include "DFGVariableAccessDataDump.h"	37	#include "DFGVariableAccessDataDump.h"
38	#include "JSCInlines.h"
39		38
40	#undef RELEASE_ASSERT	39	#undef RELEASE_ASSERT
41	#define RELEASE_ASSERT(assertion) do { \	40	#define RELEASE_ASSERT(assertion) do { \




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 31-37 a/Source/JavaScriptCore/dfg/DFGSafepoint.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGSafepoint.cpp -1 lines
31	#include "DFGPlan.h"	31	#include "DFGPlan.h"
32	#include "DFGScannable.h"	32	#include "DFGScannable.h"
33	#include "DFGThreadData.h"	33	#include "DFGThreadData.h"
34	#include "JSCInlines.h"
35		34
36	namespace JSC { namespace DFG {	35	namespace JSC { namespace DFG {
37		36



#include "DFGSaneStringGetByValSlowPathGenerator.h"
#include "DFGSlowPathGenerator.h"
#include "DFGSnippetParams.h"
#include "DateInstance.h"
#include "DirectArguments.h"
#include "DisallowMacroScratchRegisterUsage.h"
#include "JITAddGenerator.h"
#include "JITBitAndGenerator.h"
#include "JITBitOrGenerator.h"
#include "JITBitXorGenerator.h"
#include "JITDivGenerator.h"
#include "JITLeftShiftGenerator.h"
#include "JITMulGenerator.h"
#include "JITRightShiftGenerator.h"
#include "JITSubGenerator.h"
#include "JSArrayIterator.h"
#include "JSAsyncFunction.h"
#include "JSAsyncGeneratorFunction.h"

#include "JSMapIterator.h"
#include "JSPropertyNameEnumerator.h"
#include "JSSetIterator.h"
#include "LinkBuffer.h"
#include "RegExpObject.h"
#include "ScopedArguments.h"
#include "ScratchRegisterAllocator.h"
#include "SuperSampler.h"
#include "TypeProfilerLog.h"
#include "WeakMapImpl.h"
#include <wtf/BitVector.h>




#if ENABLE(DFG_JIT)

#include "ArrayPrototype.h"
#include "AtomicsObject.h"
#include "CallFrameShuffler.h"
#include "DFGAbstractInterpreterInlines.h"
#include "DFGCallArrayAllocatorSlowPathGenerator.h"
#include "DFGClobberize.h"
#include "DFGDoesGC.h"
#include "DFGOperations.h"
#include "DFGSlowPathGenerator.h"
#include "DateInstance.h"
#include "DirectArguments.h"
#include "GetterSetter.h"
#include "HasOwnPropertyCache.h"
#include "JSCInlines.h"
#include "JSLexicalEnvironment.h"
#include "JSMap.h"
#include "JSPropertyNameEnumerator.h"
#include "JSSet.h"
#include "ObjectPrototype.h"
#include "SetupVarargsFrame.h"
#include "SpillRegistersMode.h"
#include "StructureChain.h"
#include "SuperSampler.h"
#include "Watchdog.h"

namespace JSC { namespace DFG {


Lines 31-37 a/Source/JavaScriptCore/dfg/DFGStackLayoutPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGStackLayoutPhase.cpp -1 lines
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "DFGPhase.h"	32	#include "DFGPhase.h"
33	#include "DFGValueSource.h"	33	#include "DFGValueSource.h"
34	#include "JSCInlines.h"
35		34
36	namespace JSC { namespace DFG {	35	namespace JSC { namespace DFG {
37		36




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGNaturalLoops.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {


Lines 33-39 a/Source/JavaScriptCore/dfg/DFGStoreBarrierClusteringPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGStoreBarrierClusteringPhase.cpp -1 lines
33	#include "DFGInsertionSet.h"	33	#include "DFGInsertionSet.h"
34	#include "DFGMayExit.h"	34	#include "DFGMayExit.h"
35	#include "DFGPhase.h"	35	#include "DFGPhase.h"
36	#include "JSCInlines.h"
37	#include <wtf/FastBitVector.h>	36	#include <wtf/FastBitVector.h>
38		37
39	namespace JSC { namespace DFG {	38	namespace JSC { namespace DFG {



#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "DFGPredictionPropagationPhase.h"
#include "DFGVariableAccessDataDump.h"
#include "JSCInlines.h"
#include "MathCommon.h"
#include "RegExpObject.h"
#include "StringPrototype.h"




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

ThreadData::ThreadData(Worklist* worklist)

Lines 35-41 a/Source/JavaScriptCore/dfg/DFGThunks.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGThunks.cpp -1 lines
35	#include "GPRInfo.h"	35	#include "GPRInfo.h"
36	#include "LinkBuffer.h"	36	#include "LinkBuffer.h"
37	#include "MacroAssembler.h"	37	#include "MacroAssembler.h"
38	#include "JSCInlines.h"
39	#include "DFGOSRExitCompilerCommon.h"	38	#include "DFGOSRExitCompilerCommon.h"
40		39
41	namespace JSC { namespace DFG {	40	namespace JSC { namespace DFG {

Lines 34-40 a/Source/JavaScriptCore/dfg/DFGTierUpCheckInjectionPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGTierUpCheckInjectionPhase.cpp -1 lines
34	#include "DFGPhase.h"	34	#include "DFGPhase.h"
35	#include "FTLCapabilities.h"	35	#include "FTLCapabilities.h"
36	#include "FunctionWhitelist.h"	36	#include "FunctionWhitelist.h"
37	#include "JSCInlines.h"
38	#include <wtf/NeverDestroyed.h>	37	#include <wtf/NeverDestroyed.h>
39		38
40	namespace JSC { namespace DFG {	39	namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGToFTLDeferredCompilationCallback.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGToFTLDeferredCompilationCallback.cpp -1 lines
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGJITCode.h"	32	#include "DFGJITCode.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 31-37 a/Source/JavaScriptCore/dfg/DFGToFTLForOSREntryDeferredCompilationCallback.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGToFTLForOSREntryDeferredCompilationCallback.cpp -1 lines
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "DFGJITCode.h"	32	#include "DFGJITCode.h"
33	#include "FTLForOSREntryJITCode.h"	33	#include "FTLForOSREntryJITCode.h"
34	#include "JSCInlines.h"
35		34
36	namespace JSC { namespace DFG {	35	namespace JSC { namespace DFG {
37		36




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

void Transition::dumpInContext(PrintStream& out, DumpContext* context) const



#include "DFGGraph.h"
#include "DFGInsertionSet.h"
#include "DFGPhase.h"
#include "JSCJSValueInlines.h"
#include "JSCInlines.h"
#include <wtf/HashMap.h>

namespace JSC { namespace DFG {




#if ENABLE(DFG_JIT)

#include "DFGBasicBlockInlines.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace WTF {

using namespace JSC::DFG;




#if ENABLE(DFG_JIT)

#include "ButterflyInlines.h"
#include "DFGClobberize.h"
#include "DFGClobbersExitState.h"
#include "DFGDominators.h"
#include "DFGMayExit.h"
#include "JSCInlines.h"
#include <wtf/Assertions.h>

namespace JSC { namespace DFG {




#if ENABLE(DFG_JIT)

#include "JSCInlines.h"

namespace JSC { namespace DFG {

void ValueSource::dump(PrintStream& out) const

Lines 34-40 a/Source/JavaScriptCore/dfg/DFGVarargsForwardingPhase.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGVarargsForwardingPhase.cpp -1 lines
34	#include "DFGForAllKills.h"	34	#include "DFGForAllKills.h"
35	#include "DFGGraph.h"	35	#include "DFGGraph.h"
36	#include "DFGPhase.h"	36	#include "DFGPhase.h"
37	#include "JSCInlines.h"
38	#include <wtf/ListDump.h>	37	#include <wtf/ListDump.h>
39		38
40	namespace JSC { namespace DFG {	39	namespace JSC { namespace DFG {

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGVariableAccessDataDump.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGVariableAccessDataDump.cpp -1 lines
30		30
31	#include "DFGGraph.h"	31	#include "DFGGraph.h"
32	#include "DFGVariableAccessData.h"	32	#include "DFGVariableAccessData.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC { namespace DFG {	34	namespace JSC { namespace DFG {
36		35

Lines 30-36 a/Source/JavaScriptCore/dfg/DFGVariableEvent.cpp_sec1
- a/Source/JavaScriptCore/dfg/DFGVariableEvent.cpp -1 lines
30		30
31	#include "FPRInfo.h"	31	#include "FPRInfo.h"
32	#include "GPRInfo.h"	32	#include "GPRInfo.h"
33	#include "JSCInlines.h"
34	#include "OperandsInlines.h"	33	#include "OperandsInlines.h"
35		34
36	namespace JSC { namespace DFG {	35	namespace JSC { namespace DFG {



#if ENABLE(DFG_JIT)

#include "CodeBlock.h"
#include "DFGJITCode.h"
#include "DFGValueSource.h"
#include "InlineCallFrame.h"
#include "JSCJSValueInlines.h"
#include "OperandsInlines.h"
#include <wtf/DataLog.h>
#include <wtf/HashMap.h>




#include "DFGGraph.h"
#include "DFGScoreBoard.h"
#include "JSCInlines.h"
#include "StackAlignment.h"
#include <wtf/StdLibExtras.h>

namespace JSC { namespace DFG {





#if ENABLE(DFG_JIT)

#include "ArrayPrototype.h"
#include "DFGClobberize.h"
#include "DFGGraph.h"
#include "DFGPhase.h"
#include "JSCInlines.h"

// FIXME: Remove this phase entirely by moving the addLazily() calls into either the backend or
// into the phase that performs the optimization. Moving the calls into the backend makes the most



#include "config.h"
#include "DFGWorklist.h"

#include "CodeBlock.h"
#include "DFGSafepoint.h"
#include "DeferGC.h"
#include "JSCInlines.h"
#include "ReleaseHeapAccessScope.h"
#include <mutex>
#include <wtf/CompilationThread.h>

namespace JSC { namespace DFG {


Lines 25-31 a/Source/JavaScriptCore/dfg/testdfg.cpp_sec1
- a/Source/JavaScriptCore/dfg/testdfg.cpp -1 lines
25		25
26	#include "config.h"	26	#include "config.h"
27		27
28	#include "HeapCellInlines.h"
29	#include "JSCJSValueInlines.h"	28	#include "JSCJSValueInlines.h"
30	// The above are needed before DFGAbstractValue.h	29	// The above are needed before DFGAbstractValue.h
31	#include "DFGAbstractValue.h"	30	#include "DFGAbstractValue.h"

Lines 32-38 a/Source/JavaScriptCore/disassembler/Disassembler.cpp_sec1
- a/Source/JavaScriptCore/disassembler/Disassembler.cpp -1 lines
32	#include <wtf/Deque.h>	32	#include <wtf/Deque.h>
33	#include <wtf/Lock.h>	33	#include <wtf/Lock.h>
34	#include <wtf/NeverDestroyed.h>	34	#include <wtf/NeverDestroyed.h>
35	#include <wtf/StringPrintStream.h>
36	#include <wtf/Threading.h>	35	#include <wtf/Threading.h>
37		36
38	namespace JSC {	37	namespace JSC {

Lines 29-35 a/Source/JavaScriptCore/disassembler/X86Disassembler.cpp_sec1
- a/Source/JavaScriptCore/disassembler/X86Disassembler.cpp -1 lines
29	#if ENABLE(UDIS86)	29	#if ENABLE(UDIS86)
30		30
31	#include "MacroAssemblerCodeRef.h"	31	#include "MacroAssemblerCodeRef.h"
32	#include "Options.h"
33	#include "UDis86Disassembler.h"	32	#include "UDis86Disassembler.h"
34		33
35	namespace JSC {	34	namespace JSC {




#if ENABLE(FTL_JIT)

#include "DFGCommon.h"
#include "FTLAbbreviatedTypes.h"
#include "FTLAbstractHeapRepository.h"
#include "FTLOutput.h"
#include "FTLTypedPointer.h"
#include "JSCInlines.h"
#include "Options.h"

namespace JSC { namespace FTL {



#include "FTLState.h"
#include "GetterSetter.h"
#include "JSPropertyNameEnumerator.h"
#include "JSScope.h"
#include "JSCInlines.h"
#include "RegExpObject.h"
#include "ScopedArguments.h"
#include "ScopedArgumentsTable.h"
#include "ShadowChicken.h"
#include "StructureChain.h"

namespace JSC { namespace FTL {




#include "B3Const64Value.h"
#include "B3ConstDoubleValue.h"
#include "B3ConstPtrValue.h"
#include "B3ProcedureInlines.h"
#include "B3Type.h"
#include "B3ValueInlines.h"

#if ENABLE(FTL_JIT)




#include "AirCode.h"
#include "AirDisassembler.h"
#include "B3Generate.h"
#include "B3ProcedureInlines.h"
#include "B3StackSlot.h"
#include "B3Value.h"
#include "B3ValueInlines.h"
#include "CodeBlockWithJITType.h"
#include "CCallHelpers.h"
#include "DFGCommon.h"
#include "DFGGraphSafepoint.h"
#include "DFGOperations.h"
#include "DataView.h"
#include "Disassembler.h"
#include "FTLJITCode.h"
#include "FTLThunks.h"
#include "JITSubGenerator.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "PCToCodeOriginMap.h"
#include "ScratchRegisterAllocator.h"
#include <wtf/RecursableLambda.h>

namespace JSC { namespace FTL {

Lines 28-34 a/Source/JavaScriptCore/ftl/FTLExceptionTarget.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLExceptionTarget.cpp -1 / +1 lines
28		28
29	#if ENABLE(FTL_JIT)	29	#if ENABLE(FTL_JIT)
30		30
31	#include "FTLState.h"	31	#include "LinkBuffer.h"
32		32
33	namespace JSC { namespace FTL {	33	namespace JSC { namespace FTL {
34		34




#if ENABLE(FTL_JIT)

#include "JSCJSValueInlines.h"
#include "JSCInlines.h"
#include "TrackedReferences.h"

namespace JSC { namespace FTL {

Lines 29-35 a/Source/JavaScriptCore/ftl/FTLFail.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLFail.cpp -1 lines
29	#if ENABLE(FTL_JIT)	29	#if ENABLE(FTL_JIT)
30		30
31	#include "DFGFailedFinalizer.h"	31	#include "DFGFailedFinalizer.h"
32	#include "FTLJITCode.h"
33		32
34	namespace JSC { namespace FTL {	33	namespace JSC { namespace FTL {
35		34



#include "CodeBlockWithJITType.h"
#include "DFGPlan.h"
#include "FTLState.h"
#include "FTLThunks.h"
#include "JSCInlines.h"
#include "ProfilerDatabase.h"

namespace JSC { namespace FTL {

Lines 28-34 a/Source/JavaScriptCore/ftl/FTLLazySlowPath.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLLazySlowPath.cpp -1 lines
28		28
29	#if ENABLE(FTL_JIT)	29	#if ENABLE(FTL_JIT)
30		30
31	#include "FTLSlowPathCall.h"
32	#include "LinkBuffer.h"	31	#include "LinkBuffer.h"
33		32
34	namespace JSC { namespace FTL {	33	namespace JSC { namespace FTL {




#include "CCallHelpers.h"
#include "CodeBlockWithJITType.h"
#include "DFGCommon.h"
#include "FTLJITCode.h"
#include "JITOperations.h"
#include "LinkBuffer.h"
#include "JSCInlines.h"
#include "ProfilerCompilation.h"
#include "ThunkGenerators.h"
#include "VirtualRegister.h"

namespace JSC { namespace FTL {




#include "B3ValueRep.h"
#include "FTLSaveRestore.h"
#include "RegisterSet.h"
#include <wtf/CommaPrinter.h>
#include <wtf/DataLog.h>
#include <wtf/ListDump.h>

namespace JSC { namespace FTL {




#if ENABLE(FTL_JIT)

#include "AirCode.h"
#include "AirGenerationContext.h"
#include "AllowMacroScratchRegisterUsage.h"
#include "AllowMacroScratchRegisterUsageIf.h"
#include "AtomicsObject.h"
#include "B3CheckValue.h"
#include "B3FenceValue.h"
#include "B3PatchpointValue.h"
#include "B3SlotBaseValue.h"
#include "B3StackmapGenerationParams.h"
#include "B3ValueInlines.h"
#include "ButterflyInlines.h"
#include "CallFrameShuffler.h"
#include "CodeBlockWithJITType.h"
#include "DFGAbstractInterpreterInlines.h"
#include "DFGCapabilities.h"
#include "DFGClobberize.h"

#include "DFGOSRExitFuzz.h"
#include "DirectArguments.h"
#include "FTLAbstractHeapRepository.h"
#include "FTLAvailableRecovery.h"
#include "FTLExceptionTarget.h"
#include "FTLForOSREntryJITCode.h"
#include "FTLFormattedValue.h"

#include "JSImmutableButterfly.h"
#include "JSInternalPromise.h"
#include "JSLexicalEnvironment.h"
#include "JSMap.h"
#include "JSMapIterator.h"
#include "JSSetIterator.h"
#include "OperandsInlines.h"
#include "ProbeContext.h"
#include "RegExpObject.h"
#include "ScopedArguments.h"
#include "ScopedArgumentsTable.h"
#include "ScratchRegisterAllocator.h"
#include "SetupVarargsFrame.h"
#include "ShadowChicken.h"

#include "SuperSampler.h"
#include "ThunkGenerators.h"
#include "VirtualRegister.h"
#include "Watchdog.h"
#include <atomic>
#include <wtf/Box.h>
#include <wtf/Gigacage.h>
#include <wtf/RecursableLambda.h>
#include <wtf/StdUnorderedSet.h>


Lines 31-37 a/Source/JavaScriptCore/ftl/FTLOSREntry.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLOSREntry.cpp -1 lines
31	#include "DFGJITCode.h"	31	#include "DFGJITCode.h"
32	#include "FTLForOSREntryJITCode.h"	32	#include "FTLForOSREntryJITCode.h"
33	#include "OperandsInlines.h"	33	#include "OperandsInlines.h"
34	#include "JSCInlines.h"
35	#include "VMInlines.h"	34	#include "VMInlines.h"
36		35
37	#if ENABLE(FTL_JIT)	36	#if ENABLE(FTL_JIT)




#if ENABLE(FTL_JIT)

#include "AirGenerationContext.h"
#include "B3StackmapGenerationParams.h"
#include "B3StackmapValue.h"
#include "CodeBlock.h"
#include "DFGBasicBlock.h"
#include "DFGNode.h"
#include "FTLExitArgument.h"
#include "FTLJITCode.h"
#include "FTLLocation.h"
#include "FTLState.h"
#include "JSCInlines.h"

namespace JSC { namespace FTL {




#include "BytecodeStructs.h"
#include "CheckpointOSRExitSideState.h"
#include "DFGOSRExitCompilerCommon.h"
#include "FTLExitArgumentForOperand.h"
#include "FTLJITCode.h"
#include "FTLLocation.h"
#include "FTLOSRExit.h"
#include "FTLOperations.h"
#include "FTLState.h"
#include "FTLSaveRestore.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "OperandsInlines.h"

Lines 36-42 a/Source/JavaScriptCore/ftl/FTLOperations.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLOperations.cpp -1 lines
36	#include "FTLLazySlowPath.h"	36	#include "FTLLazySlowPath.h"
37	#include "FrameTracers.h"	37	#include "FrameTracers.h"
38	#include "InlineCallFrame.h"	38	#include "InlineCallFrame.h"
39	#include "Interpreter.h"
40	#include "JSArrayIterator.h"	39	#include "JSArrayIterator.h"
41	#include "JSAsyncFunction.h"	40	#include "JSAsyncFunction.h"
42	#include "JSAsyncGeneratorFunction.h"	41	#include "JSAsyncGeneratorFunction.h"




#if ENABLE(FTL_JIT)

#include "B3ArgumentRegValue.h"
#include "B3AtomicValue.h"
#include "B3BasicBlockInlines.h"
#include "B3CCallValue.h"
#include "B3Const32Value.h"
#include "B3ConstPtrValue.h"
#include "B3FenceValue.h"
#include "B3MathExtras.h"
#include "B3MemoryValue.h"
#include "B3SlotBaseValue.h"
#include "B3StackmapGenerationParams.h"
#include "B3SwitchValue.h"
#include "B3UpsilonValue.h"
#include "B3ValueInlines.h"
#include "SuperSampler.h"

Lines 32-38 a/Source/JavaScriptCore/ftl/FTLSlowPathCall.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLSlowPathCall.cpp -1 lines
32	#include "FTLState.h"	32	#include "FTLState.h"
33	#include "FTLThunks.h"	33	#include "FTLThunks.h"
34	#include "GPRInfo.h"	34	#include "GPRInfo.h"
35	#include "JSCInlines.h"
36		35
37	namespace JSC { namespace FTL {	36	namespace JSC { namespace FTL {
38		37

Lines 30-36 a/Source/JavaScriptCore/ftl/FTLSnippetParams.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLSnippetParams.cpp -1 lines
30		30
31	#include "AllowMacroScratchRegisterUsage.h"	31	#include "AllowMacroScratchRegisterUsage.h"
32	#include "FTLSlowPathCall.h"	32	#include "FTLSlowPathCall.h"
33	#include "FTLState.h"
34		33
35	namespace JSC { namespace FTL {	34	namespace JSC { namespace FTL {
36		35




#if ENABLE(FTL_JIT)

#include "CodeBlockWithJITType.h"
#include "FTLForOSREntryJITCode.h"
#include "FTLJITCode.h"
#include "FTLJITFinalizer.h"
#include "FTLPatchpointExceptionHandle.h"
#include <stdio.h>

namespace JSC { namespace FTL {


Lines 30-36 a/Source/JavaScriptCore/ftl/FTLThunks.cpp_sec1
- a/Source/JavaScriptCore/ftl/FTLThunks.cpp -1 lines
30		30
31	#include "AssemblyHelpers.h"	31	#include "AssemblyHelpers.h"
32	#include "DFGOSRExitCompilerCommon.h"	32	#include "DFGOSRExitCompilerCommon.h"
33	#include "FPRInfo.h"
34	#include "FTLOSRExitCompiler.h"	33	#include "FTLOSRExitCompiler.h"
35	#include "FTLOperations.h"	34	#include "FTLOperations.h"
36	#include "FTLSaveRestore.h"	35	#include "FTLSaveRestore.h"

Lines 26-32 a/Source/JavaScriptCore/heap/Allocator.cpp_sec1
- a/Source/JavaScriptCore/heap/Allocator.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "Allocator.h"	27	#include "Allocator.h"
28		28
29	#include "Heap.h"
30	#include "LocalAllocator.h"	29	#include "LocalAllocator.h"
31		30
32	namespace JSC {	31	namespace JSC {



#include "BlockDirectory.h"

#include "BlockDirectoryInlines.h"
#include "GCActivityCallback.h"
#include "Heap.h"
#include "IncrementalSweeper.h"
#include "JSCInlines.h"
#include "MarkedBlockInlines.h"
#include "SubspaceInlines.h"
#include "SuperSampler.h"
#include "VM.h"

namespace JSC {




#include "CodeBlockSet.h"

#include "CodeBlock.h"
#include "JSCInlines.h"
#include "SuperSampler.h"
#include <wtf/CommaPrinter.h>

namespace JSC {




#include "AlignedMemoryAllocator.h"
#include "AllocatorInlines.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "LocalAllocatorInlines.h"
#include "MarkedBlockInlines.h"
#include "MarkedSpaceInlines.h"
#include "PreventCollectionScope.h"
#include "SubspaceInlines.h"

namespace JSC {




#include "CodeBlock.h"
#include "CodeBlockSetInlines.h"
#include "HeapInlines.h"
#include "HeapUtil.h"
#include "JITStubRoutineSet.h"
#include "JSCast.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "MarkedBlockInlines.h"
#include "Structure.h"
#include <wtf/OSAllocator.h>

namespace JSC {



#include "config.h"
#include "DeferGC.h"

#include "JSCInlines.h"

namespace JSC {

#ifndef NDEBUG

Lines 25-31 a/Source/JavaScriptCore/heap/EdenGCActivityCallback.cpp_sec1
- a/Source/JavaScriptCore/heap/EdenGCActivityCallback.cpp -1 lines
25		25
26	#include "config.h"	26	#include "config.h"
27	#include "EdenGCActivityCallback.h"	27	#include "EdenGCActivityCallback.h"
28	#include "HeapInlines.h"
29		28
30	#include "VM.h"	29	#include "VM.h"
31		30

Lines 26-32 a/Source/JavaScriptCore/heap/FastMallocAlignedMemoryAllocator.cpp_sec1
- a/Source/JavaScriptCore/heap/FastMallocAlignedMemoryAllocator.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "FastMallocAlignedMemoryAllocator.h"	27	#include "FastMallocAlignedMemoryAllocator.h"
28		28
29	#include <mutex>
30	#include <wtf/FastMalloc.h>	29	#include <wtf/FastMalloc.h>
31		30
32	namespace JSC {	31	namespace JSC {



#include "config.h"
#include "FreeList.h"

#include "FreeListInlines.h"
#include "MarkedBlock.h"
#include <wtf/CommaPrinter.h>

namespace JSC {

FreeList::FreeList(unsigned cellSize)



#include "GCActivityCallback.h"

#include "HeapInlines.h"
#include "JSLock.h"
#include "JSObject.h"
#include "VM.h"

namespace JSC {



#include "config.h"
#include "GCLogging.h"

#include "ClassInfo.h"
#include "Heap.h"
#include "HeapIterationScope.h"
#include "JSCast.h"
#include "JSCellInlines.h"
#include <wtf/PrintStream.h>

namespace JSC {



#include "config.h"
#include "GCSegmentedArray.h"

#include <wtf/NeverDestroyed.h>

namespace JSC {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(GCSegmentedArray);



#include "HandleBlock.h"
#include "HandleBlockInlines.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include <wtf/DataLog.h>

namespace JSC {




#include "config.h"
#include "Heap.h"

#include "BlockDirectoryInlines.h"
#include "BuiltinExecutables.h"
#include "CodeBlock.h"
#include "CodeBlockSetInlines.h"

#include "FullGCActivityCallback.h"
#include "FunctionExecutableInlines.h"
#include "GCActivityCallback.h"
#include "GCIncomingRefCountedInlines.h"
#include "GCIncomingRefCountedSetInlines.h"
#include "GCSegmentedArrayInlines.h"
#include "GCTypeMap.h"

#include "HeapSnapshot.h"
#include "HeapVerifier.h"
#include "IncrementalSweeper.h"
#include "InferredValueInlines.h"
#include "Interpreter.h"
#include "IsoCellSetInlines.h"
#include "JITStubRoutineSet.h"
#include "JITWorklist.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSVirtualMachineInternal.h"
#include "JSWeakMap.h"
#include "JSWeakObjectRef.h"

#include "SynchronousStopTheWorldMutatorScheduler.h"
#include "TypeProfiler.h"
#include "TypeProfilerLog.h"
#include "UnlinkedCodeBlock.h"
#include "VM.h"
#include "VisitCounter.h"
#include "WasmMemory.h"
#include "WeakMapImplInlines.h"
#include "WeakSetInlines.h"
#include <algorithm>
#include <wtf/CryptographicallyRandomNumber.h>
#include <wtf/ListDump.h>
#include <wtf/MainThread.h>
#include <wtf/ParallelVectorIterator.h>
#include <wtf/ProcessID.h>
#include <wtf/RAMSize.h>
#include <wtf/Scope.h>
#include <wtf/SimpleStats.h>

Lines 27-33 a/Source/JavaScriptCore/heap/HeapProfiler.cpp_sec1
- a/Source/JavaScriptCore/heap/HeapProfiler.cpp -1 lines
27	#include "HeapProfiler.h"	27	#include "HeapProfiler.h"
28		28
29	#include "HeapSnapshot.h"	29	#include "HeapSnapshot.h"
30	#include "VM.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32

Lines 26-32 a/Source/JavaScriptCore/heap/HeapSnapshot.cpp_sec1
- a/Source/JavaScriptCore/heap/HeapSnapshot.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "HeapSnapshot.h"	27	#include "HeapSnapshot.h"
28		28
29	#include "JSCInlines.h"	29	#include <wtf/DataLog.h>
30	#include <wtf/Optional.h>	30	#include <wtf/Optional.h>
31		31
32	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "IncrementalSweeper.h"

#include "DeferGC.h"
#include "Heap.h"
#include "JSObject.h"
#include "JSString.h"
#include "MarkedBlock.h"
#include "VM.h"

namespace JSC {


Lines 26-32 a/Source/JavaScriptCore/heap/IsoCellSet.cpp_sec1
- a/Source/JavaScriptCore/heap/IsoCellSet.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "IsoCellSet.h"	27	#include "IsoCellSet.h"
28		28
29	#include "BlockDirectoryInlines.h"
30	#include "MarkedBlockInlines.h"	29	#include "MarkedBlockInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/heap/IsoHeapCellType.cpp_sec1
- a/Source/JavaScriptCore/heap/IsoHeapCellType.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "IsoHeapCellType.h"	27	#include "IsoHeapCellType.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCJSValueInlines.h"
30	#include "MarkedBlockInlines.h"	30	#include "MarkedBlockInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {



#include "IsoSubspace.h"

#include "AllocatorInlines.h"
#include "BlockDirectoryInlines.h"
#include "IsoAlignedMemoryAllocator.h"
#include "IsoCellSetInlines.h"
#include "IsoSubspaceInlines.h"
#include "LocalAllocatorInlines.h"
#include "MarkedSpaceInlines.h"

namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/heap/IsoSubspacePerVM.cpp_sec1
- a/Source/JavaScriptCore/heap/IsoSubspacePerVM.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "IsoSubspacePerVM.h"	27	#include "IsoSubspacePerVM.h"
28		28
29	#include "JSCInlines.h"
30	#include "MarkedSpaceInlines.h"	29	#include "MarkedSpaceInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {



#if ENABLE(JIT)

#include "GCAwareJITStubRoutine.h"
#include "JSCInlines.h"
#include "SlotVisitor.h"

namespace JSC {


Lines 29-35 a/Source/JavaScriptCore/heap/LocalAllocator.cpp_sec1
- a/Source/JavaScriptCore/heap/LocalAllocator.cpp -1 lines
29	#include "AllocatingScope.h"	29	#include "AllocatingScope.h"
30	#include "FreeListInlines.h"	30	#include "FreeListInlines.h"
31	#include "GCDeferralContext.h"	31	#include "GCDeferralContext.h"
32	#include "JSCInlines.h"
33	#include "LocalAllocatorInlines.h"	32	#include "LocalAllocatorInlines.h"
34	#include "Options.h"	33	#include "Options.h"
35	#include "SuperSampler.h"	34	#include "SuperSampler.h"




#include "ConservativeRoots.h"
#include "MachineContext.h"
#include <setjmp.h>
#include <stdlib.h>
#include <wtf/BitVector.h>
#include <wtf/PageBlock.h>
#include <wtf/StdLibExtras.h>

Lines 27-33 a/Source/JavaScriptCore/heap/MarkStack.cpp_sec1
- a/Source/JavaScriptCore/heap/MarkStack.cpp -1 lines
27	#include "MarkStack.h"	27	#include "MarkStack.h"
28		28
29	#include "GCSegmentedArrayInlines.h"	29	#include "GCSegmentedArrayInlines.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "MarkedBlock.h"

#include "AlignedMemoryAllocator.h"
#include "BlockDirectoryInlines.h"
#include "FreeListInlines.h"
#include "JSCast.h"
#include "JSDestructibleObject.h"
#include "JSCInlines.h"
#include "MarkedBlockInlines.h"
#include "SuperSampler.h"
#include "SweepingScope.h"
#include <wtf/CommaPrinter.h>




#include "MarkedSpace.h"

#include "BlockDirectoryInlines.h"
#include "FunctionCodeBlock.h"
#include "IncrementalSweeper.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "MarkedBlockInlines.h"
#include "MarkedSpaceInlines.h"
#include <wtf/ListDump.h>



#include "config.h"
#include "MarkingConstraintSet.h"

#include "JSCInlines.h"
#include "MarkingConstraintSolver.h"
#include "Options.h"
#include "SimpleMarkingConstraint.h"
#include "SuperSampler.h"
#include <wtf/Function.h>
#include <wtf/TimeWithDynamicClockType.h>

namespace JSC {


Lines 29-35 a/Source/JavaScriptCore/heap/PreciseAllocation.cpp_sec1
- a/Source/JavaScriptCore/heap/PreciseAllocation.cpp -1 / +1 lines
29	#include "AlignedMemoryAllocator.h"	29	#include "AlignedMemoryAllocator.h"
30	#include "Heap.h"	30	#include "Heap.h"
31	#include "IsoCellSetInlines.h"	31	#include "IsoCellSetInlines.h"
32	#include "JSCInlines.h"	32	#include "JSCellInlines.h"
33	#include "Scribble.h"	33	#include "Scribble.h"
34	#include "SubspaceInlines.h"	34	#include "SubspaceInlines.h"
35		35



#include "config.h"
#include "SlotVisitor.h"

#include "BlockDirectoryInlines.h"
#include "CPU.h"
#include "ConservativeRoots.h"
#include "GCSegmentedArrayInlines.h"
#include "HeapAnalyzer.h"

#include "HeapProfiler.h"
#include "IntegrityInlines.h"
#include "JSArray.h"
#include "JSCellInlines.h"
#include "JSObject.h"
#include "JSString.h"
#include "JSCInlines.h"
#include "MarkedBlockInlines.h"
#include "MarkingConstraintSolver.h"
#include "SlotVisitorInlines.h"
#include "StopIfNecessaryTimer.h"
#include "SuperSampler.h"
#include "VM.h"
#include <wtf/ListDump.h>
#include <wtf/Lock.h>

Lines 26-32 a/Source/JavaScriptCore/heap/StopIfNecessaryTimer.cpp_sec1
- a/Source/JavaScriptCore/heap/StopIfNecessaryTimer.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "StopIfNecessaryTimer.h"	27	#include "StopIfNecessaryTimer.h"
28		28
29	#include "JSCInlines.h"	29	#include "VM.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32



#include "Subspace.h"

#include "AlignedMemoryAllocator.h"
#include "BlockDirectoryInlines.h"
#include "HeapCellType.h"
#include "JSCInlines.h"
#include "MarkedBlockInlines.h"
#include "MarkedSpaceInlines.h"
#include "ParallelSourceAdapter.h"
#include "PreventCollectionScope.h"
#include "SubspaceInlines.h"

namespace JSC {



#include "config.h"
#include "Weak.h"

#include "WeakSet.h"
#include "WeakSetInlines.h"

namespace JSC {


Lines 30-36 a/Source/JavaScriptCore/heap/WeakBlock.cpp_sec1
- a/Source/JavaScriptCore/heap/WeakBlock.cpp -1 lines
30	#include "Heap.h"	30	#include "Heap.h"
31	#include "HeapAnalyzer.h"	31	#include "HeapAnalyzer.h"
32	#include "JSCInlines.h"	32	#include "JSCInlines.h"
33	#include "JSObject.h"
34	#include "WeakHandleOwner.h"	33	#include "WeakHandleOwner.h"
35		34
36	namespace JSC {	35	namespace JSC {



#include "config.h"
#include "WeakHandleOwner.h"

#include "JSCInlines.h"

namespace JSC {

class SlotVisitor;

Lines 27-33 a/Source/JavaScriptCore/heap/WeakSet.cpp_sec1
- a/Source/JavaScriptCore/heap/WeakSet.cpp -1 lines
27	#include "WeakSet.h"	27	#include "WeakSet.h"
28		28
29	#include "Heap.h"	29	#include "Heap.h"
30	#include "JSCInlines.h"
31	#include "VM.h"	30	#include "VM.h"
32		31
33	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "WriteBarrierSupport.h"

#include "JSCInlines.h"

namespace JSC {

#if ENABLE(WRITE_BARRIER_PROFILING)

Lines 32-38 a/Source/JavaScriptCore/inspector/InjectedScript.cpp_sec1
- a/Source/JavaScriptCore/inspector/InjectedScript.cpp -1 / +1 lines
32	#include "config.h"	32	#include "config.h"
33	#include "InjectedScript.h"	33	#include "InjectedScript.h"
34		34
35	#include "JSCInlines.h"	35	#include "JSGlobalObjectInlines.h"
36	#include "JSLock.h"	36	#include "JSLock.h"
37	#include "ScriptFunctionCall.h"	37	#include "ScriptFunctionCall.h"
38	#include "ScriptObject.h"	38	#include "ScriptObject.h"



#include "InjectedScriptBase.h"

#include "DebuggerEvalEnabler.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "JSNativeStdFunction.h"
#include "ScriptFunctionCall.h"
#include <wtf/JSONValues.h>
#include <wtf/text/StringConcatenateNumbers.h>

namespace Inspector {


Lines 26-32 a/Source/JavaScriptCore/inspector/InjectedScriptHost.cpp_sec1
- a/Source/JavaScriptCore/inspector/InjectedScriptHost.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "InjectedScriptHost.h"	27	#include "InjectedScriptHost.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSInjectedScriptHost.h"	29	#include "JSInjectedScriptHost.h"
31		30
32	namespace Inspector {	31	namespace Inspector {



#include "InjectedScriptManager.h"

#include "CatchScope.h"
#include "Completion.h"
#include "InjectedScriptHost.h"
#include "InjectedScriptSource.h"
#include "JSCInlines.h"
#include "JSInjectedScriptHost.h"
#include "JSLock.h"
#include "JSObjectInlines.h"
#include "SourceCode.h"
#include <wtf/JSONValues.h>


Lines 35-41 a/Source/JavaScriptCore/inspector/InjectedScriptModule.cpp_sec1
- a/Source/JavaScriptCore/inspector/InjectedScriptModule.cpp -1 lines
35	#include "InjectedScript.h"	35	#include "InjectedScript.h"
36	#include "InjectedScriptManager.h"	36	#include "InjectedScriptManager.h"
37	#include "ScriptFunctionCall.h"	37	#include "ScriptFunctionCall.h"
38	#include "ScriptObject.h"
39		38
40	namespace Inspector {	39	namespace Inspector {
41		40

Lines 30-36 a/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.cpp_sec1
- a/Source/JavaScriptCore/inspector/InspectorBackendDispatcher.cpp -1 lines
30	#include "InspectorFrontendRouter.h"	30	#include "InspectorFrontendRouter.h"
31	#include <wtf/JSONValues.h>	31	#include <wtf/JSONValues.h>
32	#include <wtf/SetForScope.h>	32	#include <wtf/SetForScope.h>
33	#include <wtf/text/CString.h>
34	#include <wtf/text/WTFString.h>	33	#include <wtf/text/WTFString.h>
35		34
36	namespace Inspector {	35	namespace Inspector {



#include "InspectorDebuggerAgent.h"
#include "InspectorScriptProfilerAgent.h"
#include "ScriptArguments.h"
#include "ScriptCallStack.h"
#include "ScriptCallStackFactory.h"

namespace Inspector {




#include "InspectorAgent.h"
#include "InspectorBackendDispatcher.h"
#include "InspectorConsoleAgent.h"
#include "InspectorFrontendChannel.h"
#include "InspectorFrontendRouter.h"
#include "InspectorHeapAgent.h"
#include "InspectorScriptProfilerAgent.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSGlobalObjectAuditAgent.h"
#include "JSGlobalObjectConsoleClient.h"
#include "JSGlobalObjectDebuggerAgent.h"
#include "JSGlobalObjectRuntimeAgent.h"
#include "ScriptArguments.h"
#include "ScriptCallStack.h"
#include "ScriptCallStackFactory.h"
#include <wtf/StackTrace.h>



#include "config.h"
#include "JSGlobalObjectScriptDebugServer.h"

#include "JSGlobalObject.h"
#include "JSCInlines.h"
#include "JSLock.h"
#include <wtf/RunLoop.h>

namespace Inspector {




#include "config.h"
#include "JSInjectedScriptHost.h"

#include "ArrayIteratorPrototype.h"
#include "ArrayPrototype.h"
#include "BuiltinNames.h"
#include "Completion.h"
#include "DateInstance.h"
#include "DeferGC.h"

#include "InjectedScriptHost.h"
#include "IterationKind.h"
#include "IteratorOperations.h"
#include "IteratorPrototype.h"
#include "JSArray.h"
#include "JSArrayIterator.h"
#include "JSBoundFunction.h"
#include "JSFunctionInlines.h"
#include "JSGlobalObjectInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "JSInjectedScriptHostPrototype.h"
#include "JSLock.h"
#include "JSMap.h"
#include "JSMapIterator.h"
#include "JSPromise.h"

#include "JSTypedArrays.h"
#include "JSWeakMap.h"
#include "JSWeakSet.h"
#include "JSWithScope.h"
#include "MapIteratorPrototype.h"
#include "MapPrototype.h"
#include "MarkedSpaceInlines.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"

#include "ProxyObject.h"
#include "RegExpObject.h"
#include "ScopedArguments.h"
#include "SetIteratorPrototype.h"
#include "SetPrototype.h"
#include "SourceCode.h"
#include "TypedArrayInlines.h"
#include <wtf/Function.h>
#include <wtf/HashFunctions.h>
#include <wtf/HashMap.h>
#include <wtf/HashSet.h>
#include <wtf/HashTraits.h>
#include <wtf/Lock.h>
#include <wtf/PrintStream.h>
#include <wtf/text/StringConcatenate.h>



#include "JSInjectedScriptHostPrototype.h"

#include "Error.h"
#include "JSGlobalObject.h"
#include "Identifier.h"
#include "InjectedScriptHost.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSInjectedScriptHost.h"

namespace Inspector {

Lines 29-35 a/Source/JavaScriptCore/inspector/JSJavaScriptCallFrame.cpp_sec1
- a/Source/JavaScriptCore/inspector/JSJavaScriptCallFrame.cpp -1 lines
29	#include "DebuggerScope.h"	29	#include "DebuggerScope.h"
30	#include "Error.h"	30	#include "Error.h"
31	#include "IdentifierInlines.h"	31	#include "IdentifierInlines.h"
32	#include "JSCInlines.h"
33	#include "JSJavaScriptCallFramePrototype.h"	32	#include "JSJavaScriptCallFramePrototype.h"
34	#include "ObjectConstructor.h"	33	#include "ObjectConstructor.h"
35		34



#include "JSJavaScriptCallFramePrototype.h"

#include "Error.h"
#include "Identifier.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSJavaScriptCallFrame.h"

namespace Inspector {

Lines 33-39 a/Source/JavaScriptCore/inspector/ScriptArguments.cpp_sec1
- a/Source/JavaScriptCore/inspector/ScriptArguments.cpp -1 lines
33	#include "ScriptArguments.h"	33	#include "ScriptArguments.h"
34		34
35	#include "CatchScope.h"	35	#include "CatchScope.h"
36	#include "JSCInlines.h"
37	#include "ProxyObject.h"	36	#include "ProxyObject.h"
38	#include "StrongInlines.h"	37	#include "StrongInlines.h"
39		38



#include "config.h"
#include "ScriptCallStack.h"

#include <wtf/DataLog.h>

namespace Inspector {

Ref<ScriptCallStack> ScriptCallStack::create()




#include "CallFrame.h"
#include "CatchScope.h"
#include "CodeBlock.h"
#include "Exception.h"
#include "JSCJSValue.h"
#include "JSCInlines.h"
#include "ScriptArguments.h"
#include "ScriptCallFrame.h"
#include "StackVisitor.h"

Lines 34-40 a/Source/JavaScriptCore/inspector/ScriptDebugServer.cpp_sec1
- a/Source/JavaScriptCore/inspector/ScriptDebugServer.cpp -1 lines
34	#include "DebuggerCallFrame.h"	34	#include "DebuggerCallFrame.h"
35	#include "DebuggerScope.h"	35	#include "DebuggerScope.h"
36	#include "Exception.h"	36	#include "Exception.h"
37	#include "JSCInlines.h"
38	#include "JSJavaScriptCallFrame.h"	37	#include "JSJavaScriptCallFrame.h"
39	#include "JavaScriptCallFrame.h"	38	#include "JavaScriptCallFrame.h"
40	#include "SourceProvider.h"	39	#include "SourceProvider.h"

Lines 32-38 a/Source/JavaScriptCore/inspector/agents/InspectorAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorAgent.cpp -1 lines
32	#include "InspectorAgent.h"	32	#include "InspectorAgent.h"
33		33
34	#include "InspectorEnvironment.h"	34	#include "InspectorEnvironment.h"
35	#include "InspectorFrontendRouter.h"
36	#include <wtf/JSONValues.h>	35	#include <wtf/JSONValues.h>
37		36
38	namespace Inspector {	37	namespace Inspector {

Lines 27-33 a/Source/JavaScriptCore/inspector/agents/InspectorAuditAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorAuditAgent.cpp -1 lines
27	#include "InspectorAuditAgent.h"	27	#include "InspectorAuditAgent.h"
28		28
29	#include "InjectedScript.h"	29	#include "InjectedScript.h"
30	#include "InjectedScriptManager.h"
31	#include "JSLock.h"	30	#include "JSLock.h"
32	#include "ObjectConstructor.h"	31	#include "ObjectConstructor.h"
33	#include "ScriptDebugServer.h"	32	#include "ScriptDebugServer.h"




#include "ConsoleMessage.h"
#include "InjectedScriptManager.h"
#include "InspectorFrontendRouter.h"
#include "InspectorHeapAgent.h"
#include "ScriptArguments.h"
#include "ScriptCallFrame.h"
#include "ScriptCallStack.h"
#include "ScriptCallStackFactory.h"
#include "ScriptObject.h"
#include <wtf/text/StringConcatenateNumbers.h>

namespace Inspector {



#include "ContentSearchUtilities.h"
#include "InjectedScript.h"
#include "InjectedScriptManager.h"
#include "InspectorFrontendRouter.h"
#include "JSCInlines.h"
#include "RegularExpression.h"
#include "ScriptCallStack.h"
#include "ScriptCallStackFactory.h"
#include "ScriptDebugServer.h"
#include "ScriptObject.h"
#include <wtf/Function.h>
#include <wtf/JSONValues.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/Stopwatch.h>
#include <wtf/text/StringConcatenateNumbers.h>
#include <wtf/text/WTFString.h>

namespace Inspector {

Lines 32-38 a/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorHeapAgent.cpp -1 lines
32	#include "InjectedScriptManager.h"	32	#include "InjectedScriptManager.h"
33	#include "InspectorEnvironment.h"	33	#include "InspectorEnvironment.h"
34	#include "JSBigInt.h"	34	#include "JSBigInt.h"
35	#include "JSCInlines.h"
36	#include "VM.h"	35	#include "VM.h"
37	#include <wtf/Stopwatch.h>	36	#include <wtf/Stopwatch.h>
38		37



#include "InspectorRuntimeAgent.h"

#include "Completion.h"
#include "DFGWorklist.h"
#include "HeapIterationScope.h"
#include "InjectedScript.h"
#include "InjectedScriptHost.h"
#include "InjectedScriptManager.h"
#include "InspectorFrontendRouter.h"
#include "JSLock.h"
#include "ParserError.h"
#include "ScriptDebugServer.h"

Lines 27-33 a/Source/JavaScriptCore/inspector/agents/InspectorScriptProfilerAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/InspectorScriptProfilerAgent.cpp -1 lines
27	#include "InspectorScriptProfilerAgent.h"	27	#include "InspectorScriptProfilerAgent.h"
28		28
29	#include "DeferGC.h"	29	#include "DeferGC.h"
30	#include "HeapInlines.h"
31	#include "InspectorEnvironment.h"	30	#include "InspectorEnvironment.h"
32	#include "SamplingProfiler.h"	31	#include "SamplingProfiler.h"
33	#include "ScriptDebugServer.h"	32	#include "ScriptDebugServer.h"




#include "InjectedScript.h"
#include "InjectedScriptManager.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include <wtf/Ref.h>
#include <wtf/RefPtr.h>
#include <wtf/text/WTFString.h>

namespace Inspector {




#include "ConsoleMessage.h"
#include "InjectedScriptManager.h"
#include "InspectorConsoleAgent.h"
#include "JSGlobalObject.h"
#include "JSGlobalObjectScriptDebugServer.h"
#include "ScriptArguments.h"
#include "ScriptCallStack.h"
#include "ScriptCallStackFactory.h"

namespace Inspector {

Lines 28-34 a/Source/JavaScriptCore/inspector/agents/JSGlobalObjectRuntimeAgent.cpp_sec1
- a/Source/JavaScriptCore/inspector/agents/JSGlobalObjectRuntimeAgent.cpp -1 lines
28		28
29	#include "InjectedScript.h"	29	#include "InjectedScript.h"
30	#include "InjectedScriptManager.h"	30	#include "InjectedScriptManager.h"
31	#include "JSGlobalObject.h"
32		31
33	namespace Inspector {	32	namespace Inspector {
34		33



#include "AbstractPC.h"

#include "CallFrame.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "VM.h"

namespace JSC {



#include "CodeBlock.h"
#include "ExecutableAllocator.h"
#include "InlineCallFrame.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "JSWebAssemblyInstance.h"
#include "LLIntPCRanges.h"
#include "VMEntryScope.h"
#include "WasmContextInlines.h"
#include "WasmInstance.h"
#include <wtf/StringPrintStream.h>



#include "CatchScope.h"
#include "CheckpointOSRExitSideState.h"
#include "CodeBlock.h"
#include "CodeCache.h"
#include "DirectArguments.h"
#include "ExecutableBaseInlines.h"
#include "Heap.h"
#include "Debugger.h"
#include "DebuggerCallFrame.h"
#include "DirectEvalCodeCache.h"
#include "ErrorInstance.h"
#include "EvalCodeBlock.h"
#include "Exception.h"
#include "ExceptionHelpers.h"
#include "ExecutableBaseInlines.h"
#include "FrameTracers.h"
#include "FunctionCodeBlock.h"
#include "InterpreterInlines.h"
#include "JITCodeInlines.h"
#include "JSArrayInlines.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSImmutableButterfly.h"
#include "JSLexicalEnvironment.h"
#include "JSModuleEnvironment.h"
#include "JSObjectInlines.h"
#include "JSString.h"
#include "JSWithScope.h"
#include "LLIntCLoop.h"
#include "LLIntThunks.h"
#include "LiteralParser.h"
#include "ModuleProgramCodeBlock.h"
#include "ObjectPrototype.h"
#include "Parser.h"
#include "ProgramCodeBlock.h"
#include "ProtoCallFrameInlines.h"
#include "RegExpObject.h"
#include "Register.h"
#include "RegisterAtOffsetList.h"
#include "ScopedArguments.h"
#include "StackAlignment.h"
#include "StackFrame.h"
#include "StackVisitor.h"
#include "StrictEvalActivation.h"
#include "StrongInlines.h"
#include "Symbol.h"
#include "VMEntryScope.h"
#include "VMInlines.h"
#include "VMInspector.h"
#include "VirtualRegister.h"
#include <limits.h>
#include <stdio.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/Scope.h>
#include <wtf/StackStats.h>
#include <wtf/StdLibExtras.h>
#include <wtf/StringPrintStream.h>
#include <wtf/Threading.h>
#include <wtf/text/StringBuilder.h>

#if ENABLE(JIT)
#include "JIT.h"
#endif

#if ENABLE(WEBASSEMBLY)
#include "WasmContextInlines.h"
#include "WebAssemblyFunction.h"

Lines 27-33 a/Source/JavaScriptCore/interpreter/ShadowChicken.cpp_sec1
- a/Source/JavaScriptCore/interpreter/ShadowChicken.cpp -1 lines
27	#include "ShadowChicken.h"	27	#include "ShadowChicken.h"
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "JSCInlines.h"
31	#include "ShadowChickenInlines.h"	30	#include "ShadowChickenInlines.h"
32	#include <wtf/ListDump.h>	31	#include <wtf/ListDump.h>
33		32



#include "ClonedArguments.h"
#include "DebuggerPrimitives.h"
#include "InlineCallFrame.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "RegisterAtOffsetList.h"
#include "WasmCallee.h"
#include "WasmIndexOrName.h"



#if ENABLE(JIT)

#include "JITOperations.h"
#include "JSArrayBufferView.h"
#include "JSCJSValueInlines.h"
#include "LinkBuffer.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "SuperSampler.h"
#include "ThunkGenerators.h"

#if ENABLE(WEBASSEMBLY)
#include "WasmContextInlines.h"
#include "WasmMemoryInformation.h"
#endif


Lines 28-34 a/Source/JavaScriptCore/jit/BinarySwitch.cpp_sec1
- a/Source/JavaScriptCore/jit/BinarySwitch.cpp -1 lines
28		28
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "JSCInlines.h"
32	#include <wtf/ListDump.h>	31	#include <wtf/ListDump.h>
33		32
34	namespace JSC {	33	namespace JSC {




#if ENABLE(JIT)

#include "CCallHelpers.h"
#include "CodeBlock.h"
#include "RegisterAtOffsetList.h"

namespace JSC {


Lines 30-36 a/Source/JavaScriptCore/jit/CallFrameShuffler64.cpp_sec1
- a/Source/JavaScriptCore/jit/CallFrameShuffler64.cpp -1 / +1 lines
30		30
31	#include "CCallHelpers.h"	31	#include "CCallHelpers.h"
32	#include "DataFormat.h"	32	#include "DataFormat.h"
33	#include "JSCInlines.h"	33	#include "JSCJSValue.h"
34		34
35	namespace JSC {	35	namespace JSC {
36		36




#include "ExecutableAllocationFuzz.h"
#include "IterationStatus.h"
#include "LinkBuffer.h"
#include <wtf/FastBitVector.h>
#include <wtf/FileSystem.h>
#include <wtf/MetaAllocator.h>
#include <wtf/PageReservation.h>

#include <wtf/SystemTracing.h>
#include <wtf/WorkQueue.h>

#if OS(DARWIN)
#include <mach/mach_time.h>
#include <sys/mman.h>
#endif

#if HAVE(IOS_JIT_RESTRICTIONS)
#include <wtf/cocoa/Entitlements.h>
#endif

#include "LinkBuffer.h"
#include "MacroAssembler.h"

#if OS(DARWIN)
#include <fcntl.h>
#include <mach/mach.h>
#include <mach/mach_time.h>

extern "C" {
    /* Routine mach_vm_remap */
#ifdef mig_external

     vm_inherit_t inheritance
     );
}

#endif

namespace JSC {



#include "Heap.h"
#include "VM.h"
#include "JITStubRoutineSet.h"
#include "JSCellInlines.h"
#include "SlotVisitor.h"
#include "Structure.h"
#include <wtf/RefPtr.h>

namespace JSC {



#if !ENABLE(C_LOOP)

#include "CallFrame.h"
#include "JSCJSValueInlines.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include <wtf/InlineASM.h>




#if ENABLE(JIT)

#include "CCallHelpers.h"
#include "CallFrame.h"
#include "CodeBlock.h"
#include "IntrinsicGetterAccessCase.h"
#include "JSArrayBufferView.h"
#include "JSCJSValueInlines.h"
#include "JSCellInlines.h"
#include "PolymorphicAccess.h"
#include "StructureStubInfo.h"




#include "JIT.h"

#include "BytecodeGraph.h"
#include "BytecodeLivenessAnalysis.h"
#include "CodeBlock.h"
#include "CodeBlockWithJITType.h"
#include "DFGCapabilities.h"
#include "InterpreterInlines.h"
#include "JITInlines.h"
#include "JITOperations.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "LinkBuffer.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "ModuleProgramCodeBlock.h"

#include "ProbeContext.h"
#include "ProfilerDatabase.h"
#include "ProgramCodeBlock.h"
#include "ResultType.h"
#include "SlowPathCall.h"
#include "StackAlignment.h"
#include "ThunkGenerators.h"
#include "TypeProfilerLog.h"
#include <wtf/CryptographicallyRandomNumber.h>
#include <wtf/GraphNodeWorklist.h>
#include <wtf/SimpleStats.h>


Lines 28-34 a/Source/JavaScriptCore/jit/JITAddGenerator.cpp_sec1
- a/Source/JavaScriptCore/jit/JITAddGenerator.cpp -1 lines
28		28
29	#include "ArithProfile.h"	29	#include "ArithProfile.h"
30	#include "JITMathIC.h"	30	#include "JITMathIC.h"
31	#include "LinkBuffer.h"
32		31
33	#if ENABLE(JIT)	32	#if ENABLE(JIT)
34		33



#include "ArithProfile.h"
#include "BytecodeGenerator.h"
#include "CodeBlock.h"
#include "JITAddGenerator.h"
#include "JITBitAndGenerator.h"
#include "JITBitOrGenerator.h"
#include "JITBitXorGenerator.h"

#include "JITInlines.h"
#include "JITLeftShiftGenerator.h"
#include "JITMathIC.h"
#include "JITMulGenerator.h"
#include "JITNegGenerator.h"
#include "JITOperations.h"
#include "JITSubGenerator.h"
#include "JSArray.h"
#include "JSFunction.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "ResultType.h"
#include "SlowPathCall.h"




#include "CallFrameShuffler.h"
#include "CodeBlock.h"
#include "JITInlines.h"
#include "JSArray.h"
#include "JSFunction.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "OpcodeInlines.h"
#include "ResultType.h"
#include "SetupVarargsFrame.h"
#include "SlowPathCall.h"
#include "StackAlignment.h"
#include "ThunkGenerators.h"

#include <wtf/StringPrintStream.h>

namespace JSC {

template<typename Op>



#include "config.h"
#include "JITCode.h"

#include "JSCInlines.h"
#include "ProtoCallFrame.h"
#include <wtf/PrintStream.h>

namespace JSC {



#include "CodeBlock.h"
#include "CodeBlockWithJITType.h"
#include "Disassembler.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "ProfilerCompilation.h"
#include <wtf/StringPrintStream.h>

Lines 29-35 a/Source/JavaScriptCore/jit/JITDivGenerator.cpp_sec1
- a/Source/JavaScriptCore/jit/JITDivGenerator.cpp -1 lines
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "ArithProfile.h"	31	#include "ArithProfile.h"
32	#include "JSCJSValueInlines.h"
33	#include "MathCommon.h"	32	#include "MathCommon.h"
34		33
35	namespace JSC {	34	namespace JSC {



#include "CallFrame.h"
#include "CatchScope.h"
#include "CodeBlock.h"
#include "Disassembler.h"
#include "EntryFrame.h"
#include "Interpreter.h"
#include "JSCJSValueInlines.h"
#include "JSCJSValue.h"
#include "LLIntData.h"
#include "LLIntOpcode.h"
#include "LLIntThunks.h"
#include "Opcode.h"
#include "ShadowChicken.h"
#include "VMInlines.h"

Lines 31-37 a/Source/JavaScriptCore/jit/JITInlineCacheGenerator.cpp_sec1
- a/Source/JavaScriptCore/jit/JITInlineCacheGenerator.cpp -1 lines
31	#include "CacheableIdentifierInlines.h"	31	#include "CacheableIdentifierInlines.h"
32	#include "CodeBlock.h"	32	#include "CodeBlock.h"
33	#include "InlineAccess.h"	33	#include "InlineAccess.h"
34	#include "JSCInlines.h"
35	#include "LinkBuffer.h"	34	#include "LinkBuffer.h"
36	#include "StructureStubInfo.h"	35	#include "StructureStubInfo.h"
37		36



#include "BasicBlockLocation.h"
#include "BytecodeGenerator.h"
#include "Exception.h"
#include "Heap.h"
#include "InterpreterInlines.h"
#include "JITInlines.h"
#include "JSArray.h"
#include "JSCast.h"
#include "JSFunction.h"
#include "JSPropertyNameEnumerator.h"
#include "LinkBuffer.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "OpcodeInlines.h"
#include "SlowPathCall.h"
#include "SuperSampler.h"
#include "ThunkGenerators.h"
#include "TypeLocation.h"
#include "TypeProfilerLog.h"
#include "VirtualRegister.h"
#include "Watchdog.h"

namespace JSC {




#include "DFGThunks.h"
#include "DFGWorklist.h"
#include "Debugger.h"
#include "DirectArguments.h"
#include "Error.h"
#include "ErrorHandlingScope.h"
#include "EvalCodeBlock.h"
#include "ExceptionFuzz.h"
#include "ExecutableBaseInlines.h"
#include "FTLOSREntry.h"
#include "FrameTracers.h"
#include "FunctionCodeBlock.h"
#include "GetterSetter.h"
#include "HostCallReturnValue.h"
#include "ICStats.h"

#include "JSInternalPromise.h"
#include "JSLexicalEnvironment.h"
#include "JSWithScope.h"
#include "ModuleProgramCodeBlock.h"
#include "ObjectConstructor.h"
#include "PolymorphicAccess.h"
#include "ProgramCodeBlock.h"
#include "PropertyName.h"
#include "RegExpObject.h"
#include "Repatch.h"
#include "ScopedArguments.h"
#include "ShadowChicken.h"
#include "StructureStubInfo.h"
#include "SuperSampler.h"
#include "TestRunnerUtils.h"
#include "ThunkGenerators.h"
#include "TypeProfilerLog.h"
#include "VMInlines.h"
#include "WebAssemblyFunction.h"
#include <wtf/InlineASM.h>

IGNORE_WARNINGS_BEGIN("frame-address")




#include "CacheableIdentifierInlines.h"
#include "CodeBlock.h"
#include "DirectArguments.h"
#include "GCAwareJITStubRoutine.h"
#include "GetterSetter.h"
#include "InterpreterInlines.h"
#include "JITInlines.h"
#include "JSArray.h"
#include "JSFunction.h"
#include "JSLexicalEnvironment.h"
#include "JSPromise.h"
#include "LinkBuffer.h"
#include "OpcodeInlines.h"
#include "ResultType.h"
#include "ScopedArguments.h"
#include "ScopedArgumentsTable.h"
#include "SlowPathCall.h"
#include "StructureStubInfo.h"
#include "ThunkGenerators.h"
#include <wtf/ScopedLambda.h>
#include <wtf/StringPrintStream.h>


namespace JSC {
#if USE(JSVALUE64)





#if ENABLE(JIT)

#include "JSObject.h"
#include "JSCInlines.h"
#include "SlotVisitor.h"

namespace JSC {

JITStubRoutine::~JITStubRoutine() { }




#if ENABLE(JIT)

#include "JITCode.h"
#include "JSCJSValueInlines.h"
#include "LLIntData.h"
#include "ThunkGenerators.h"
#include "VM.h"


Lines 29-35 a/Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.cpp_sec1
- a/Source/JavaScriptCore/jit/JITToDFGDeferredCompilationCallback.cpp -1 lines
29	#if ENABLE(DFG_JIT)	29	#if ENABLE(DFG_JIT)
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC {	33	namespace JSC {
35		34

Lines 29-35 a/Source/JavaScriptCore/jit/JITWorklist.cpp_sec1
- a/Source/JavaScriptCore/jit/JITWorklist.cpp -1 lines
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "JIT.h"	31	#include "JIT.h"
32	#include "JSCInlines.h"
33	#include "VMInlines.h"	32	#include "VMInlines.h"
34		33
35	namespace JSC {	34	namespace JSC {

Lines 31-37 a/Source/JavaScriptCore/jit/PolymorphicCallStubRoutine.cpp_sec1
- a/Source/JavaScriptCore/jit/PolymorphicCallStubRoutine.cpp -1 lines
31	#include "CallLinkInfo.h"	31	#include "CallLinkInfo.h"
32	#include "CodeBlock.h"	32	#include "CodeBlock.h"
33	#include "FullCodeOrigin.h"	33	#include "FullCodeOrigin.h"
34	#include "JSCInlines.h"
35	#include "LinkBuffer.h"	34	#include "LinkBuffer.h"
36		35
37	namespace JSC {	36	namespace JSC {



#if ENABLE(ASSEMBLER)

#include "GPRInfo.h"
#include "JSCInlines.h"
#include "MacroAssembler.h"
#include "RegisterAtOffsetList.h"
#include "assembler/RegisterInfo.h"
#include <wtf/CommaPrinter.h>

namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/jit/ScratchRegisterAllocator.cpp_sec1
- a/Source/JavaScriptCore/jit/ScratchRegisterAllocator.cpp -1 lines
28		28
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "JSCInlines.h"
32	#include "MaxFrameExtentForSlowPathCall.h"	31	#include "MaxFrameExtentForSlowPathCall.h"
33	#include "VM.h"	32	#include "VM.h"
34		33

Lines 29-35 a/Source/JavaScriptCore/jit/SetupVarargsFrame.cpp_sec1
- a/Source/JavaScriptCore/jit/SetupVarargsFrame.cpp -1 lines
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "Interpreter.h"	31	#include "Interpreter.h"
32	#include "JSCInlines.h"
33	#include "StackAlignment.h"	32	#include "StackAlignment.h"
34		33
35	namespace JSC {	34	namespace JSC {



#include "config.h"
#include "ThunkGenerators.h"

#include "CodeBlock.h"
#include "DFGSpeculativeJIT.h"
#include "JITExceptions.h"
#include "JITOperations.h"
#include "JSArray.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "MathCommon.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "ProbeContext.h"
#include "SpecializedThunkJIT.h"
#include <wtf/InlineASM.h>
#include <wtf/StringPrintStream.h>



#include "config.h"

#include "ArrayBuffer.h"
#include "ArrayPrototype.h"
#include "BigIntConstructor.h"
#include "BuiltinNames.h"
#include "ButterflyInlines.h"
#include "BytecodeCacheError.h"
#include "CallFrameInlines.h"
#include "CatchScope.h"
#include "CodeBlock.h"
#include "CodeCache.h"

#include "Disassembler.h"
#include "Exception.h"
#include "ExceptionHelpers.h"
#include "HeapProfiler.h"
#include "HeapSnapshotBuilder.h"
#include "InitializeThreading.h"
#include "Interpreter.h"

#include "JSArray.h"
#include "JSArrayBuffer.h"
#include "JSBigInt.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSInternalPromise.h"
#include "JSLock.h"
#include "JSModuleLoader.h"
#include "JSNativeStdFunction.h"
#include "JSONObject.h"
#include "JSObjectInlines.h"

#include "ParserError.h"
#include "ProfilerDatabase.h"
#include "PromiseTimer.h"
#include "ProtoCallFrame.h"
#include "ReleaseHeapAccessScope.h"
#include "SamplingProfiler.h"
#include "StackVisitor.h"
#include "StructureInlines.h"
#include "StructureRareDataInlines.h"
#include "SuperSampler.h"
#include "TestRunnerUtils.h"
#include "TypedArrayInlines.h"
#include "VMInspector.h"
#include "WasmCapabilities.h"
#include "WasmContext.h"
#include "WasmMemory.h"
#include <locale.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <thread>
#include <type_traits>
#include <wtf/Box.h>
#include <wtf/CPUTime.h>
#include <wtf/CommaPrinter.h>
#include <wtf/FileSystem.h>
#include <wtf/MainThread.h>
#include <wtf/MemoryPressureHandler.h>
#include <wtf/MonotonicTime.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/Scope.h>
#include <wtf/StringPrintStream.h>
#include <wtf/URL.h>
#include <wtf/WallTime.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringConcatenateNumbers.h>

#if OS(WINDOWS)
#include <direct.h>

#undef Function
#endif

#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif

#if HAVE(SIGNAL_H)
#include <signal.h>
#endif



#include "LLIntData.h"

#include "ArithProfile.h"
#include "BytecodeConventions.h"
#include "CodeBlock.h"
#include "CodeType.h"
#include "Instruction.h"
#include "JSScope.h"
#include "LLIntCLoop.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "Opcode.h"
#include "PropertyOffset.h"
#include "ShadowChicken.h"
#include "WriteBarrier.h"

#define STATIC_ASSERT(cond) static_assert(cond, "LLInt assumes " #cond)



#include "config.h"
#include "LLIntEntrypoint.h"
#include "CodeBlock.h"
#include "HeapInlines.h"
#include "JITCode.h"
#include "JSCellInlines.h"
#include "JSObject.h"
#include "LLIntData.h"
#include "LLIntThunks.h"
#include "LowLevelInterpreter.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "StackAlignment.h"





#include "config.h"
#include "LLIntExceptions.h"
#include "CallFrame.h"
#include "CodeBlock.h"
#include "Instruction.h"
#include "LLIntCommon.h"
#include "LLIntData.h"
#include "LowLevelInterpreter.h"
#include "JSCInlines.h"

#if LLINT_TRACING
#include "Exception.h"



#include "CommonSlowPathsInlines.h"
#include "Error.h"
#include "ErrorHandlingScope.h"
#include "EvalCodeBlock.h"
#include "Exception.h"
#include "ExceptionFuzz.h"
#include "ExecutableBaseInlines.h"
#include "FrameTracers.h"
#include "FunctionCodeBlock.h"
#include "FunctionWhitelist.h"
#include "GetterSetter.h"
#include "HostCallReturnValue.h"
#include "InterpreterInlines.h"
#include "IteratorOperations.h"
#include "JIT.h"
#include "JITExceptions.h"
#include "JITWorklist.h"
#include "JSAsyncFunction.h"

#include "JSGlobalObjectFunctions.h"
#include "JSLexicalEnvironment.h"
#include "JSString.h"
#include "JSWithScope.h"
#include "LLIntCommon.h"
#include "LLIntData.h"
#include "LLIntExceptions.h"
#include "LLIntPrototypeLoadAdaptiveStructureWatchpoint.h"
#include "LowLevelInterpreter.h"
#include "ModuleProgramCodeBlock.h"
#include "ObjectConstructor.h"
#include "ObjectPropertyConditionSet.h"
#include "OpcodeInlines.h"
#include "ProgramCodeBlock.h"
#include "ProtoCallFrameInlines.h"
#include "RegExpObject.h"
#include "ShadowChicken.h"
#include "StructureRareDataInlines.h"
#include "SuperSampler.h"
#include "VMInlines.h"
#include <wtf/NeverDestroyed.h>



#include "config.h"
#include "LLIntThunks.h"

#include "CallData.h"
#include "ExceptionHelpers.h"
#include "Interpreter.h"
#include "JSCJSValueInlines.h"
#include "JSInterfaceJIT.h"
#include "JSObject.h"
#include "LLIntCLoop.h"
#include "LLIntData.h"
#include "LinkBuffer.h"
#include "LowLevelInterpreter.h"
#include "ProtoCallFrame.h"
#include "StackAlignment.h"
#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"
#include <wtf/NeverDestroyed.h>




#include "BuiltinNames.h"
#include "Identifier.h"
#include "JSCInlines.h"
#include "JSFunctionInlines.h"
#include "KeywordLookup.h"
#include "Lexer.lut.h"
#include "Nodes.h"
#include "ParseInt.h"
#include "Parser.h"
#include <ctype.h>
#include <limits.h>
#include <string.h>
#include <wtf/Assertions.h>

Lines 26-32 a/Source/JavaScriptCore/parser/ModuleAnalyzer.cpp_sec1
- a/Source/JavaScriptCore/parser/ModuleAnalyzer.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ModuleAnalyzer.h"	27	#include "ModuleAnalyzer.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSGlobalObject.h"	29	#include "JSGlobalObject.h"
31	#include "JSModuleRecord.h"	30	#include "JSModuleRecord.h"
32	#include "ModuleScopeData.h"	31	#include "ModuleScopeData.h"

Lines 27-33 a/Source/JavaScriptCore/parser/Nodes.cpp_sec1
- a/Source/JavaScriptCore/parser/Nodes.cpp -1 / +1 lines
27	#include "Nodes.h"	27	#include "Nodes.h"
28	#include "NodeConstructors.h"	28	#include "NodeConstructors.h"
29		29
30	#include "JSCInlines.h"	30	#include "ExecutableInfo.h"
31	#include "ModuleScopeData.h"	31	#include "ModuleScopeData.h"
32	#include <wtf/Assertions.h>	32	#include <wtf/Assertions.h>
33		33




#include "config.h"
#include "Nodes.h"
#include "NodeConstructors.h"

#include "JSCJSValueInlines.h"
#include "JSModuleRecord.h"
#include "ModuleAnalyzer.h"


Lines 26-32 a/Source/JavaScriptCore/parser/Parser.cpp_sec1
- a/Source/JavaScriptCore/parser/Parser.cpp -1 lines
26	#include "ASTBuilder.h"	26	#include "ASTBuilder.h"
27	#include "BuiltinNames.h"	27	#include "BuiltinNames.h"
28	#include "DebuggerParseData.h"	28	#include "DebuggerParseData.h"
29	#include "JSCInlines.h"
30	#include "VM.h"	29	#include "VM.h"
31	#include <utility>	30	#include <utility>
32	#include <wtf/Scope.h>	31	#include <wtf/Scope.h>

Lines 29-35 a/Source/JavaScriptCore/parser/ParserArena.cpp_sec1
- a/Source/JavaScriptCore/parser/ParserArena.cpp -1 lines
29	#include "CatchScope.h"	29	#include "CatchScope.h"
30	#include "JSBigInt.h"	30	#include "JSBigInt.h"
31	#include "Nodes.h"	31	#include "Nodes.h"
32	#include "JSCInlines.h"
33		32
34	namespace JSC {	33	namespace JSC {
35		34

Lines 26-32 a/Source/JavaScriptCore/parser/SourceProvider.cpp_sec1
- a/Source/JavaScriptCore/parser/SourceProvider.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "SourceProvider.h"	27	#include "SourceProvider.h"
28		28
29	#include "JSCInlines.h"
30	#include <wtf/Lock.h>	29	#include <wtf/Lock.h>
31		30
32	namespace JSC {	31	namespace JSC {



#include "config.h"
#include "SourceProviderCache.h"

#include "JSCInlines.h"

namespace JSC {

DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(SourceProviderCache);

Lines 26-32 a/Source/JavaScriptCore/parser/UnlinkedSourceCode.cpp_sec1
- a/Source/JavaScriptCore/parser/UnlinkedSourceCode.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "UnlinkedSourceCode.h"	27	#include "UnlinkedSourceCode.h"
28		28
29	#include "JSCInlines.h"
30	#include <wtf/text/CString.h>	29	#include <wtf/text/CString.h>
31		30
32	namespace JSC {	31	namespace JSC {



#include "config.h"
#include "ProfilerBytecode.h"

#include "JSCInlines.h"
#include "ObjectConstructor.h"
#include "Opcode.h"
#include "JSCInlines.h"

namespace JSC { namespace Profiler {




#include "ProfilerBytecodeSequence.h"

#include "CodeBlock.h"
#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "Operands.h"
#include <wtf/StringPrintStream.h>

namespace JSC { namespace Profiler {



#include "ProfilerBytecodes.h"

#include "CodeBlock.h"
#include "JSGlobalObject.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"
#include <wtf/StringPrintStream.h>

namespace JSC { namespace Profiler {



#include "config.h"
#include "ProfilerCompilation.h"

#include "JSGlobalObject.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"
#include "ProfilerDatabase.h"
#include "Watchpoint.h"
#include <wtf/StringPrintStream.h>

namespace JSC { namespace Profiler {



#include "config.h"
#include "ProfilerCompiledBytecode.h"

#include "JSGlobalObject.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"

namespace JSC { namespace Profiler {




#include "config.h"
#include "ProfilerDatabase.h"

#include "CatchScope.h"
#include "CodeBlock.h"
#include "JSCInlines.h"
#include "JSONObject.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include <wtf/FilePrintStream.h>

namespace JSC { namespace Profiler {



#include "ProfilerOSRExitSite.h"

#include "JSGlobalObject.h"
#include "JSScope.h"
#include "JSString.h"
#include "JSCInlines.h"
#include <wtf/StringPrintStream.h>

namespace JSC { namespace Profiler {



#include "config.h"
#include "ProfilerOrigin.h"

#include "JSCJSValueInlines.h"
#include "JSGlobalObject.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "ProfilerBytecodes.h"
#include "ProfilerDatabase.h"


Lines 29-35 a/Source/JavaScriptCore/profiler/ProfilerOriginStack.cpp_sec1
- a/Source/JavaScriptCore/profiler/ProfilerOriginStack.cpp -1 lines
29	#include "CodeOrigin.h"	29	#include "CodeOrigin.h"
30	#include "InlineCallFrame.h"	30	#include "InlineCallFrame.h"
31	#include "JSGlobalObject.h"	31	#include "JSGlobalObject.h"
32	#include "JSCInlines.h"
33	#include "ProfilerDatabase.h"	32	#include "ProfilerDatabase.h"
34		33
35	namespace JSC { namespace Profiler {	34	namespace JSC { namespace Profiler {

Lines 28-34 a/Source/JavaScriptCore/profiler/ProfilerProfiledBytecodes.cpp_sec1
- a/Source/JavaScriptCore/profiler/ProfilerProfiledBytecodes.cpp -1 lines
28		28
29	#include "JSGlobalObject.h"	29	#include "JSGlobalObject.h"
30	#include "ObjectConstructor.h"	30	#include "ObjectConstructor.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC { namespace Profiler {	32	namespace JSC { namespace Profiler {
34		33

Lines 26-32 a/Source/JavaScriptCore/profiler/ProfilerUID.cpp_sec1
- a/Source/JavaScriptCore/profiler/ProfilerUID.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ProfilerUID.h"	27	#include "ProfilerUID.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSGlobalObject.h"
30	#include <wtf/Lock.h>	30	#include <wtf/Lock.h>
31		31
32	namespace JSC { namespace Profiler {	32	namespace JSC { namespace Profiler {



#include "AbstractModuleRecord.h"

#include "Error.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "JSMap.h"
#include "JSModuleEnvironment.h"
#include "JSModuleNamespaceObject.h"
#include "JSModuleRecord.h"
#include "UnlinkedModuleProgramCodeBlock.h"
#include "WebAssemblyModuleRecord.h"
#include <wtf/Optional.h>




#include "config.h"
#include "AggregateError.h"

#include "ClassInfo.h"
#include "ExceptionScope.h"
#include "IteratorOperations.h"
#include "JSCJSValueInlines.h"
#include "JSCellInlines.h"
#include "JSGlobalObjectInlines.h"
#include <wtf/Locker.h>

namespace JSC {




#include "ExceptionScope.h"
#include "GCAssertions.h"
#include "JSCJSValueInlines.h"
#include "JSGlobalObjectInlines.h"
#include "RuntimeType.h"
#include "StructureInlines.h"
#include "VMInlines.h"

namespace JSC {





#include "AggregateError.h"
#include "CallFrame.h"
#include "IdentifierInlines.h"
#include "JSCJSValueInlines.h"
#include "JSCell.h"
#include "JSGlobalObjectInlines.h"
#include "JSObjectInlines.h"
#include "ThrowScope.h"
#include "VMInlines.h"
#include <wtf/Locker.h>

namespace JSC {




#include "config.h"
#include "ArgList.h"

#include "JSCJSValueInlines.h"
#include "JSObject.h"
#include "JSCInlines.h"

using std::min;


Lines 27-33 a/Source/JavaScriptCore/runtime/ArrayBuffer.cpp_sec1
- a/Source/JavaScriptCore/runtime/ArrayBuffer.cpp -1 lines
27	#include "ArrayBuffer.h"	27	#include "ArrayBuffer.h"
28		28
29	#include "JSArrayBufferView.h"	29	#include "JSArrayBufferView.h"
30	#include "JSCInlines.h"
31	#include <wtf/Gigacage.h>	30	#include <wtf/Gigacage.h>
32		31
33	namespace JSC {	32	namespace JSC {



#include "ArrayConstructor.h"

#include "ArrayPrototype.h"
#include "ButterflyInlines.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "GetterSetter.h"
#include "JSArray.h"
#include "JSGlobalObjectInlines.h"
#include "Lookup.h"
#include "ProxyObject.h"
#include "JSCInlines.h"

#include "ArrayConstructor.lut.h"


Lines 26-32 a/Source/JavaScriptCore/runtime/ArrayConventions.cpp_sec1
- a/Source/JavaScriptCore/runtime/ArrayConventions.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ArrayConventions.h"	27	#include "ArrayConventions.h"
28		28
29	#include "JSCInlines.h"	29	#include "GCMemoryOperations.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32



#include "config.h"
#include "ArrayIteratorPrototype.h"

#include "IteratorOperations.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "JSCellInlines.h"
#include "JSGlobalObject.h"
#include "ObjectConstructor.h"
#include "StructureInlines.h"

namespace JSC {




#include "config.h"
#include "ArrayPrototype.h"

#include "AdaptiveInferredPropertyValueWatchpointBase.h"
#include "ArrayConstructor.h"
#include "BuiltinNames.h"
#include "ButterflyInlines.h"
#include "CodeBlock.h"
#include "Error.h"
#include "GetterSetter.h"
#include "IntegrityInlines.h"
#include "Interpreter.h"
#include "JIT.h"
#include "JSArrayInlines.h"
#include "JSArrayIterator.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSImmutableButterfly.h"
#include "JSStringJoiner.h"
#include "Lookup.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"
#include "StringRecursionChecker.h"
#include <algorithm>
#include <wtf/Assertions.h>



#include "config.h"
#include "AsyncFromSyncIteratorPrototype.h"

#include "BuiltinNames.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSObject.h"

#include "AsyncFromSyncIteratorPrototype.lut.h"

namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.cpp_sec1
- a/Source/JavaScriptCore/runtime/AsyncFunctionConstructor.cpp -1 lines
28		28
29	#include "AsyncFunctionPrototype.h"	29	#include "AsyncFunctionPrototype.h"
30	#include "FunctionConstructor.h"	30	#include "FunctionConstructor.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33



#include "config.h"
#include "AsyncFunctionPrototype.h"

#include "BuiltinExecutables.h"
#include "BuiltinNames.h"
#include "Error.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSString.h"
#include "Lexer.h"

namespace JSC {

const ClassInfo AsyncFunctionPrototype::s_info = { "AsyncFunction", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(AsyncFunctionPrototype) };

Lines 28-34 a/Source/JavaScriptCore/runtime/AsyncGeneratorFunctionConstructor.cpp_sec1
- a/Source/JavaScriptCore/runtime/AsyncGeneratorFunctionConstructor.cpp -1 lines
28		28
29	#include "AsyncGeneratorFunctionPrototype.h"	29	#include "AsyncGeneratorFunctionPrototype.h"
30	#include "FunctionConstructor.h"	30	#include "FunctionConstructor.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33



#include "config.h"
#include "AsyncGeneratorFunctionPrototype.h"

#include "BuiltinExecutables.h"
#include "BuiltinNames.h"
#include "Error.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSString.h"
#include "Lexer.h"

namespace JSC {

const ClassInfo AsyncGeneratorFunctionPrototype::s_info = { "AsyncGeneratorFunction", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(AsyncGeneratorFunctionPrototype) };



#include "config.h"
#include "AsyncGeneratorPrototype.h"

#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"

#include "AsyncGeneratorPrototype.lut.h"

namespace JSC {



#include "AsyncIteratorPrototype.h"

#include "JSCBuiltins.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "ObjectConstructor.h"

namespace JSC {


Lines 29-35 a/Source/JavaScriptCore/runtime/AtomicsObject.cpp_sec1
- a/Source/JavaScriptCore/runtime/AtomicsObject.cpp -1 lines
29	#include "FrameTracers.h"	29	#include "FrameTracers.h"
30	#include "JSCInlines.h"	30	#include "JSCInlines.h"
31	#include "JSTypedArrays.h"	31	#include "JSTypedArrays.h"
32	#include "ObjectPrototype.h"
33	#include "ReleaseHeapAccessScope.h"	32	#include "ReleaseHeapAccessScope.h"
34	#include "TypedArrayController.h"	33	#include "TypedArrayController.h"
35		34




#include "BigIntPrototype.h"
#include "JSBigInt.h"
#include "JSCInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "Lookup.h"
#include "ParseInt.h"
#include "StructureInlines.h"

namespace JSC {




#include "config.h"
#include "BigIntObject.h"

#include "JSCellInlines.h"
#include "JSGlobalObject.h"

namespace JSC {




#include "IntegrityInlines.h"
#include "IntlNumberFormat.h"
#include "JSBigInt.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSCast.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSString.h"
#include "NumberPrototype.h"



#include "BooleanConstructor.h"

#include "BooleanPrototype.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "BooleanObject.h"

#include "AuxiliaryBarrierInlines.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "BooleanPrototype.h"

#include "AuxiliaryBarrierInlines.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "IntegrityInlines.h"
#include "JSFunction.h"
#include "JSString.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "CachePayload.h"

#if !OS(WINDOWS)
#include <sys/mman.h>
#endif

namespace JSC {

CachePayload CachePayload::makeMappedPayload(FileSystem::MappedFileData&& data)

Lines 28-34 a/Source/JavaScriptCore/runtime/CachedBytecode.cpp_sec1
- a/Source/JavaScriptCore/runtime/CachedBytecode.cpp -1 lines
28		28
29	#include "CachedTypes.h"	29	#include "CachedTypes.h"
30	#include "UnlinkedFunctionExecutable.h"	30	#include "UnlinkedFunctionExecutable.h"
31	#include <wtf/Function.h>
32		31
33	namespace JSC {	32	namespace JSC {
34		33

Lines 40-46 a/Source/JavaScriptCore/runtime/CachedTypes.cpp_sec1
- a/Source/JavaScriptCore/runtime/CachedTypes.cpp -1 lines
40	#include "UnlinkedMetadataTableInlines.h"	40	#include "UnlinkedMetadataTableInlines.h"
41	#include "UnlinkedModuleProgramCodeBlock.h"	41	#include "UnlinkedModuleProgramCodeBlock.h"
42	#include "UnlinkedProgramCodeBlock.h"	42	#include "UnlinkedProgramCodeBlock.h"
43	#include <wtf/FastMalloc.h>
44	#include <wtf/MallocPtr.h>	43	#include <wtf/MallocPtr.h>
45	#include <wtf/Optional.h>	44	#include <wtf/Optional.h>
46	#include <wtf/Packed.h>	45	#include <wtf/Packed.h>




#include "CatchScope.h"
#include "Interpreter.h"
#include "JSObjectInlines.h"
#include "JSFunction.h"
#include "ScriptProfilingScope.h"

namespace JSC {



#include "config.h"
#include "ClonedArguments.h"

#include "GetterSetter.h"
#include "InlineCallFrame.h"
#include "StructureInlines.h"

namespace JSC {


Lines 28-34 a/Source/JavaScriptCore/runtime/CodeCache.cpp_sec1
- a/Source/JavaScriptCore/runtime/CodeCache.cpp -1 lines
28		28
29	#include "BytecodeGenerator.h"	29	#include "BytecodeGenerator.h"
30	#include "IndirectEvalExecutable.h"	30	#include "IndirectEvalExecutable.h"
31	#include <wtf/text/StringConcatenateNumbers.h>
32		31
33	namespace JSC {	32	namespace JSC {
34		33




#include "BuiltinNames.h"
#include "IdentifierInlines.h"
#include "JSCBuiltins.h"
#include "PrivateName.h"

namespace JSC {




#include "CommonSlowPaths.h"

#include "ArithProfile.h"
#include "ArrayConstructor.h"
#include "BuiltinNames.h"
#include "BytecodeStructs.h"
#include "CallFrame.h"
#include "ClonedArguments.h"

#include "ErrorHandlingScope.h"
#include "ExceptionFuzz.h"
#include "FrameTracers.h"
#include "GetterSetter.h"
#include "HostCallReturnValue.h"
#include "ICStats.h"
#include "Interpreter.h"
#include "IteratorOperations.h"
#include "JIT.h"
#include "JSArrayInlines.h"
#include "JSArrayIterator.h"
#include "JSAsyncGenerator.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSGlobalObjectFunctions.h"
#include "JSImmutableButterfly.h"
#include "JSInternalPromise.h"
#include "JSInternalPromiseConstructor.h"
#include "JSLexicalEnvironment.h"
#include "JSObjectInlines.h"
#include "JSPromiseConstructor.h"
#include "JSPropertyNameEnumerator.h"
#include "JSString.h"
#include "JSWithScope.h"
#include "LLIntCommon.h"
#include "LLIntExceptions.h"
#include "LowLevelInterpreter.h"
#include "MathCommon.h"
#include "ObjectConstructor.h"
#include "OpcodeInlines.h"
#include "ScopedArguments.h"
#include "StructureRareDataInlines.h"
#include "ThunkGenerators.h"
#include "TypeProfilerLog.h"
#include <wtf/StringPrintStream.h>

namespace JSC {




#include "Completion.h"

#include "BytecodeCacheError.h"
#include "CallFrame.h"
#include "CatchScope.h"
#include "CodeCache.h"
#include "Exception.h"
#include "IdentifierInlines.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSInternalPromise.h"
#include "JSLock.h"
#include "JSModuleLoader.h"
#include "JSModuleRecord.h"
#include "JSWithScope.h"
#include "ModuleAnalyzer.h"
#include "Parser.h"
#include "ProgramExecutable.h"
#include "ScriptProfilingScope.h"

namespace JSC {

Lines 27-33 a/Source/JavaScriptCore/runtime/ConfigFile.cpp_sec1
- a/Source/JavaScriptCore/runtime/ConfigFile.cpp -1 lines
27	#include "ConfigFile.h"	27	#include "ConfigFile.h"
28		28
29	#include "Options.h"	29	#include "Options.h"
30	#include <limits.h>
31	#include <mutex>	30	#include <mutex>
32	#include <stdio.h>	31	#include <stdio.h>
33	#include <string.h>	32	#include <string.h>

Lines 27-33 a/Source/JavaScriptCore/runtime/ConsoleClient.cpp_sec1
- a/Source/JavaScriptCore/runtime/ConsoleClient.cpp -1 / +1 lines
27	#include "ConsoleClient.h"	27	#include "ConsoleClient.h"
28		28
29	#include "CatchScope.h"	29	#include "CatchScope.h"
30	#include "JSCInlines.h"	30	#include "JSGlobalObject.h"
31	#include "ScriptArguments.h"	31	#include "ScriptArguments.h"
32	#include "ScriptCallStack.h"	32	#include "ScriptCallStack.h"
33	#include "ScriptCallStackFactory.h"	33	#include "ScriptCallStackFactory.h"



#include "ConsoleObject.h"

#include "ConsoleClient.h"
#include "JSGlobalObject.h"
#include "JSCInlines.h"
#include "ScriptArguments.h"
#include "ScriptCallStackFactory.h"




#include "ConstructData.h"

#include "Interpreter.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSObjectInlines.h"
#include "ScriptProfilingScope.h"

namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/CustomGetterSetter.cpp_sec1
- a/Source/JavaScriptCore/runtime/CustomGetterSetter.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "CustomGetterSetter.h"	27	#include "CustomGetterSetter.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCJSValueInlines.h"
30	#include <wtf/Assertions.h>	30	#include <wtf/Assertions.h>
31		31
32	namespace JSC {	32	namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/DataView.cpp_sec1
- a/Source/JavaScriptCore/runtime/DataView.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "DataView.h"	27	#include "DataView.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSDataView.h"	29	#include "JSDataView.h"
31	#include "JSGlobalObject.h"	30	#include "JSGlobalObject.h"
32		31



#include "DateInstance.h"
#include "DatePrototype.h"
#include "JSDateMath.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSString.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"
#include <math.h>
#include <time.h>
#include <wtf/MathExtras.h>

#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif

#if HAVE(SYS_TIMEB_H)
#include <sys/timeb.h>
#endif

namespace JSC {




#include "DateInstance.h"

#include "JSDateMath.h"
#include "JSGlobalObject.h"
#include "JSCInlines.h"
#include <math.h>
#include <wtf/MathExtras.h>

namespace JSC {




#include "Error.h"
#include "IntegrityInlines.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSDateMath.h"
#include "JSGlobalObject.h"
#include "JSObject.h"
#include "JSString.h"
#include "Lookup.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <wtf/Assertions.h>
#include <wtf/MathExtras.h>

#if HAVE(LANGINFO_H)
#include <langinfo.h>
#endif

#if HAVE(SYS_PARAM_H)
#include <sys/param.h>
#endif

#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif

#if HAVE(SYS_TIMEB_H)
#include <sys/timeb.h>
#endif

#if !(OS(DARWIN) && USE(CF))
#include <unicode/udat.h>

Lines 28-34 a/Source/JavaScriptCore/runtime/DirectArguments.cpp_sec1
- a/Source/JavaScriptCore/runtime/DirectArguments.cpp -1 lines
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "GenericArgumentsInlines.h"	30	#include "GenericArgumentsInlines.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33

Lines 29-35 a/Source/JavaScriptCore/runtime/DirectEvalExecutable.cpp_sec1
- a/Source/JavaScriptCore/runtime/DirectEvalExecutable.cpp -1 lines
29	#include "CodeCache.h"	29	#include "CodeCache.h"
30	#include "Debugger.h"	30	#include "Debugger.h"
31	#include "Error.h"	31	#include "Error.h"
32	#include "HeapInlines.h"
33	#include "JSCJSValueInlines.h"	32	#include "JSCJSValueInlines.h"
34	#include "ParserError.h"	33	#include "ParserError.h"
35		34



#include "config.h"
#include "DisallowVMReentry.h"

#include "JSCInlines.h"

namespace JSC {
    
#ifndef NDEBUG



#include "config.h"
#include "Error.h"

#include "ConstructData.h"
#include "ErrorConstructor.h"
#include "ExceptionHelpers.h"
#include "FunctionPrototype.h"
#include "Interpreter.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSObject.h"
#include "JSString.h"
#include "NativeErrorConstructor.h"
#include "SourceCode.h"
#include "StackFrame.h"
#include "SuperSampler.h"

namespace JSC {




#include "config.h"
#include "ErrorConstructor.h"

#include "CallFrameInlines.h"
#include "ErrorPrototype.h"
#include "Interpreter.h"
#include "JSGlobalObject.h"
#include "JSString.h"
#include "JSCInlines.h"

namespace JSC {


Lines 25-31 a/Source/JavaScriptCore/runtime/ErrorInstance.cpp_sec1
- a/Source/JavaScriptCore/runtime/ErrorInstance.cpp -1 lines
25	#include "InlineCallFrame.h"	25	#include "InlineCallFrame.h"
26	#include "IntegrityInlines.h"	26	#include "IntegrityInlines.h"
27	#include "Interpreter.h"	27	#include "Interpreter.h"
28	#include "JSScope.h"
29	#include "JSCInlines.h"	28	#include "JSCInlines.h"
30	#include "ParseInt.h"	29	#include "ParseInt.h"
31	#include "StackFrame.h"	30	#include "StackFrame.h"



#include "ErrorPrototype.h"

#include "Error.h"
#include "ExceptionHelpers.h"
#include "IntegrityInlines.h"
#include "JSGlobalObject.h"
#include "JSStringInlines.h"
#include "ObjectPrototype.h"
#include "JSCInlines.h"
#include "StringRecursionChecker.h"

namespace JSC {



#include "config.h"
#include "EvalExecutable.h"

#include "JSCellInlines.h"
#include "JSCInlines.h"

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/runtime/Exception.cpp_sec1
- a/Source/JavaScriptCore/runtime/Exception.cpp -1 / +1 lines
27	#include "Exception.h"	27	#include "Exception.h"
28		28
29	#include "Interpreter.h"	29	#include "Interpreter.h"
30	#include "JSCInlines.h"	30	#include "JSCellInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {
33		33

Lines 27-33 a/Source/JavaScriptCore/runtime/ExceptionFuzz.cpp_sec1
- a/Source/JavaScriptCore/runtime/ExceptionFuzz.cpp -1 lines
27	#include "ExceptionFuzz.h"	27	#include "ExceptionFuzz.h"
28		28
29	#include "Error.h"	29	#include "Error.h"
30	#include "JSCInlines.h"
31	#include "TestRunnerUtils.h"	30	#include "TestRunnerUtils.h"
32		31
33	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "ExceptionHelpers.h"

#include "CallFrame.h"
#include "CatchScope.h"
#include "CodeBlock.h"
#include "ErrorHandlingScope.h"
#include "Exception.h"
#include "Interpreter.h"
#include "JSCInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "RuntimeType.h"
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringView.h>



#include "config.h"
#include "ExceptionScope.h"

#include "Exception.h"
#include "ExceptionHelpers.h"
#include <wtf/StackTrace.h>
#include <wtf/StringPrintStream.h>
#include <wtf/Threading.h>




#include "config.h"

#include "BatchedTransitionOptimizer.h"
#include "CodeBlock.h"
#include "Debugger.h"
#include "EvalCodeBlock.h"
#include "FunctionCodeBlock.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "LLIntEntrypoint.h"
#include "ModuleProgramCodeBlock.h"
#include "Parser.h"
#include "ProgramCodeBlock.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC {

Lines 21-27 a/Source/JavaScriptCore/runtime/FunctionConstructor.cpp_sec1
- a/Source/JavaScriptCore/runtime/FunctionConstructor.cpp -1 lines
21	#include "config.h"	21	#include "config.h"
22	#include "FunctionConstructor.h"	22	#include "FunctionConstructor.h"
23		23
24	#include "Completion.h"
25	#include "ExceptionHelpers.h"	24	#include "ExceptionHelpers.h"
26	#include "FunctionPrototype.h"	25	#include "FunctionPrototype.h"
27	#include "JSAsyncFunction.h"	26	#include "JSAsyncFunction.h"




#include "config.h"

#include "BatchedTransitionOptimizer.h"
#include "CodeBlock.h"
#include "Debugger.h"
#include "FunctionCodeBlock.h"
#include "FunctionOverrides.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "LLIntEntrypoint.h"
#include "Parser.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC {




#include "config.h"
#include "FunctionExecutableDump.h"

#include "CodeBlock.h"
#include "FunctionCodeBlock.h"
#include "JSCellInlines.h"

namespace JSC {




#include "config.h"
#include "FunctionPrototype.h"

#include "BuiltinExecutables.h"
#include "BuiltinNames.h"
#include "FunctionExecutable.h"
#include "GetterSetter.h"
#include "IntegrityInlines.h"
#include "JSAsyncFunction.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSStringInlines.h"
#include "Lexer.h"

namespace JSC {


Lines 26-32 a/Source/JavaScriptCore/runtime/FunctionRareData.cpp_sec1
- a/Source/JavaScriptCore/runtime/FunctionRareData.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "FunctionRareData.h"	27	#include "FunctionRareData.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30	#include "ObjectAllocationProfileInlines.h"	30	#include "ObjectAllocationProfileInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/runtime/GeneratorFunctionConstructor.cpp_sec1
- a/Source/JavaScriptCore/runtime/GeneratorFunctionConstructor.cpp -1 lines
28		28
29	#include "FunctionConstructor.h"	29	#include "FunctionConstructor.h"
30	#include "GeneratorFunctionPrototype.h"	30	#include "GeneratorFunctionPrototype.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33



#include "config.h"
#include "GeneratorFunctionPrototype.h"

#include "BuiltinExecutables.h"
#include "BuiltinNames.h"
#include "Error.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSString.h"
#include "Lexer.h"

namespace JSC {

STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(GeneratorFunctionPrototype);



#include "config.h"
#include "GeneratorPrototype.h"

#include "FunctionExecutable.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"

#include "GeneratorPrototype.lut.h"




#include "config.h"
#include "GetterSetter.h"

#include "Error.h"
#include "Exception.h"
#include "JSObjectInlines.h"
#include "JSCInlines.h"
#include <wtf/Assertions.h>

namespace JSC {



#include "config.h"
#include "HashMapImpl.h"

#include "JSCInlines.h"

namespace JSC {

template<>



#include "config.h"
#include "Identifier.h"

#include "CallFrame.h"
#include "JSObject.h"
#include "JSScope.h"
#include "NumericStrings.h"
#include "JSCInlines.h"
#include <new>
#include <string.h>
#include <wtf/Assertions.h>
#include <wtf/FastMalloc.h>
#include <wtf/text/ASCIIFastPath.h>
#include <wtf/text/StringHash.h>

namespace JSC {




#include "config.h"
#include "IndexingType.h"

#include "JSCInlines.h"

namespace JSC {

IndexingType leastUpperBoundOfIndexingTypes(IndexingType a, IndexingType b)

Lines 29-35 a/Source/JavaScriptCore/runtime/IndirectEvalExecutable.cpp_sec1
- a/Source/JavaScriptCore/runtime/IndirectEvalExecutable.cpp -1 lines
29	#include "CodeCache.h"	29	#include "CodeCache.h"
30	#include "Debugger.h"	30	#include "Debugger.h"
31	#include "Error.h"	31	#include "Error.h"
32	#include "HeapInlines.h"
33	#include "JSCJSValueInlines.h"	32	#include "JSCJSValueInlines.h"
34	#include "ParserError.h"	33	#include "ParserError.h"
35		34




#pragma once

#include "JSScope.h"
#include "VM.h"
#include "Watchpoint.h"
#include "WriteBarrier.h"
#include <wtf/Nonmovable.h>

namespace JSC {





#include "DisallowVMReentry.h"
#include "ExecutableAllocator.h"
#include "Heap.h"
#include "Identifier.h"
#include "JSCConfig.h"
#include "JSCPtrTag.h"
#include "JSDateMath.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "LLIntData.h"
#include "MacroAssemblerCodeRef.h"
#include "Options.h"
#include "SigillCrashAnalyzer.h"
#include "StructureIDTable.h"
#include "SuperSampler.h"
#include "VMTraps.h"
#include "WasmCalleeRegistry.h"
#include "WasmCapabilities.h"
#include "WasmFaultSignalHandler.h"
#include "WasmThunks.h"
#include "WriteBarrier.h"
#include <mutex>
#include <wtf/MainThread.h>
#include <wtf/Threading.h>
#include <wtf/dtoa.h>
#include <wtf/dtoa/cached-powers.h>
#include <wtf/threads/Signals.h>

namespace JSC {



#include "config.h"
#include "InspectorInstrumentationObject.h"

#include "JSCInlines.h"
#include "Lookup.h"
#include <wtf/DataLog.h>

namespace JSC {



#include "config.h"
#include "InternalFunction.h"

#include "FunctionPrototype.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSString.h"
#include "ProxyObject.h"



#include "config.h"
#include "IntlCollator.h"

#include "CatchScope.h"
#include "Error.h"
#include "IntlCollatorConstructor.h"
#include "IntlObject.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"
#include "SlotVisitorInlines.h"
#include "StructureInlines.h"
#include <unicode/ucol.h>

namespace JSC {



#include "config.h"
#include "IntlCollatorConstructor.h"

#include "Error.h"
#include "IntlCollator.h"
#include "IntlCollatorPrototype.h"
#include "IntlObject.h"
#include "JSCInlines.h"
#include "Lookup.h"

namespace JSC {


Lines 30-36 a/Source/JavaScriptCore/runtime/IntlCollatorPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/IntlCollatorPrototype.cpp -1 lines
30	#include "Error.h"	30	#include "Error.h"
31	#include "IntlCollator.h"	31	#include "IntlCollator.h"
32	#include "JSBoundFunction.h"	32	#include "JSBoundFunction.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC {	34	namespace JSC {
36		35



#include "config.h"
#include "IntlDateTimeFormat.h"

#include "DateInstance.h"
#include "Error.h"
#include "IntlDateTimeFormatConstructor.h"
#include "IntlObject.h"
#include "JSBoundFunction.h"
#include "JSGlobalObjectInlines.h"
#include "ObjectConstructor.h"
#include <unicode/ucal.h>
#include <unicode/udatpg.h>



#include "config.h"
#include "IntlDateTimeFormatConstructor.h"

#include "Error.h"
#include "IntlDateTimeFormat.h"
#include "IntlDateTimeFormatPrototype.h"
#include "IntlObject.h"
#include "IntlObjectInlines.h"
#include "JSCInlines.h"
#include "Lookup.h"

namespace JSC {





#include "BuiltinNames.h"
#include "DateConstructor.h"
#include "Error.h"
#include "IntlDateTimeFormat.h"
#include "IntlObject.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSObjectInlines.h"
#include <wtf/DateMath.h>





#include "Error.h"
#include "IntlObject.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"
#include <unicode/uloc.h>
#include <wtf/unicode/icu/ICUHelpers.h>




#include "config.h"
#include "IntlLocaleConstructor.h"

#include "AuxiliaryBarrierInlines.h"
#include "Error.h"
#include "IntlLocale.h"
#include "IntlLocalePrototype.h"
#include "IntlObject.h"
#include "JSCInlines.h"
#include "Lookup.h"

namespace JSC {




#include "config.h"
#include "IntlLocalePrototype.h"

#include "AuxiliaryBarrierInlines.h"
#include "Error.h"
#include "IntlLocale.h"
#include "JSCInlines.h"
#include "JSObjectInlines.h"

namespace JSC {




#include "config.h"
#include "IntlNumberFormat.h"

#include "CatchScope.h"
#include "Error.h"
#include "IntlNumberFormatConstructor.h"
#include "IntlObject.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"



#include "config.h"
#include "IntlNumberFormatConstructor.h"

#include "Error.h"
#include "IntlNumberFormat.h"
#include "IntlNumberFormatPrototype.h"
#include "IntlObject.h"
#include "IntlObjectInlines.h"
#include "JSCInlines.h"
#include "Lookup.h"

namespace JSC {




#include "IntlNumberFormatPrototype.h"

#include "BuiltinNames.h"
#include "Error.h"
#include "IntlNumberFormat.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSObjectInlines.h"
#include "Options.h"

namespace JSC {




#include "IntlRelativeTimeFormatConstructor.h"
#include "IntlRelativeTimeFormatPrototype.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "Lookup.h"
#include "ObjectPrototype.h"
#include "Options.h"
#include <unicode/ucol.h>
#include <unicode/ufieldpositer.h>




#include "Error.h"
#include "IntlObject.h"
#include "JSGlobalObjectInlines.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"

namespace JSC {



#include "IntlObject.h"
#include "IntlPluralRules.h"
#include "IntlPluralRulesPrototype.h"
#include "JSCInlines.h"
#include "Lookup.h"

namespace JSC {





#include "Error.h"
#include "IntlPluralRules.h"
#include "JSCInlines.h"
#include "JSObjectInlines.h"

namespace JSC {


Lines 29-35 a/Source/JavaScriptCore/runtime/IntlRelativeTimeFormat.cpp_sec1
- a/Source/JavaScriptCore/runtime/IntlRelativeTimeFormat.cpp -1 / +1 lines
29	#include "Error.h"	29	#include "Error.h"
30	#include "IntlNumberFormat.h"	30	#include "IntlNumberFormat.h"
31	#include "IntlObject.h"	31	#include "IntlObject.h"
32	#include "JSCInlines.h"	32	#include "JSGlobalObjectInlines.h"
33	#include "ObjectConstructor.h"	33	#include "ObjectConstructor.h"
34	#include <wtf/unicode/icu/ICUHelpers.h>	34	#include <wtf/unicode/icu/ICUHelpers.h>
35		35



#include "IntlObject.h"
#include "IntlRelativeTimeFormat.h"
#include "IntlRelativeTimeFormatPrototype.h"
#include "JSCInlines.h"
#include "Lookup.h"

namespace JSC {





#include "Error.h"
#include "IntlRelativeTimeFormat.h"
#include "JSCInlines.h"
#include "JSObjectInlines.h"

namespace JSC {




#include "config.h"
#include "IteratorOperations.h"

#include "CatchScope.h"
#include "Error.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"




#include "IteratorPrototype.h"

#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "ObjectConstructor.h"

namespace JSC {




#include "JSArray.h"

#include "ArrayPrototype.h"
#include "ButterflyInlines.h"
#include "CodeBlock.h"
#include "Error.h"
#include "GetterSetter.h"
#include "IndexingHeaderInlines.h"
#include "JSArrayInlines.h"
#include "JSCInlines.h"
#include "PropertyNameArray.h"



#include "config.h"
#include "JSArrayBuffer.h"

#include "JSCellInlines.h"
#include "TypeError.h"
#include "TypedArrayController.h"
#include <wtf/Gigacage.h>

namespace JSC {




#include "JSArrayBufferConstructor.h"

#include "BuiltinNames.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "GetterSetter.h"
#include "JSArrayBuffer.h"
#include "JSArrayBufferView.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "JSArrayBufferPrototype.h"

#include "Error.h"
#include "ExceptionHelpers.h"
#include "JSArrayBuffer.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "TypedArrayAdaptors.h"

namespace JSC {




#include "JSArrayBufferView.h"

#include "GenericTypedArrayViewInlines.h"
#include "JSArrayBuffer.h"
#include "JSCInlines.h"
#include "JSGenericTypedArrayViewInlines.h"
#include "JSTypedArrays.h"
#include "TypeError.h"
#include "TypedArrayController.h"
#include "TypedArrays.h"
#include <wtf/Gigacage.h>

Lines 26-32 a/Source/JavaScriptCore/runtime/JSArrayIterator.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSArrayIterator.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "JSArrayIterator.h"	27	#include "JSArrayIterator.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30	#include "JSInternalFieldObjectImplInlines.h"	30	#include "JSInternalFieldObjectImplInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "JSAsyncFunction.h"

#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSFunction.h"
#include "JSFunctionInlines.h"
#include "JSObject.h"
#include "PropertySlot.h"
#include "VM.h"

namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/JSAsyncGenerator.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSAsyncGenerator.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "JSAsyncGenerator.h"	27	#include "JSAsyncGenerator.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30	#include "JSInternalFieldObjectImplInlines.h"	30	#include "JSInternalFieldObjectImplInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "JSAsyncGeneratorFunction.h"

#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSFunction.h"
#include "JSFunctionInlines.h"
#include "JSObject.h"
#include "PropertySlot.h"
#include "VM.h"

namespace JSC {



#include "JSBigInt.h"

#include "BigIntObject.h"
#include "CatchScope.h"
#include "JSCInlines.h"
#include "MathCommon.h"
#include "ParseInt.h"
#include <algorithm>



#include "JSBoundFunction.h"

#include "ExecutableBaseInlines.h"
#include "GetterSetter.h"
#include "JSGlobalObject.h"
#include "JSCInlines.h"

namespace JSC {

Lines 27-33 a/Source/JavaScriptCore/runtime/JSCConfig.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSCConfig.cpp -1 lines
27	#include "JSCConfig.h"	27	#include "JSCConfig.h"
28		28
29	#include <wtf/Lock.h>	29	#include <wtf/Lock.h>
30	#include <wtf/ResourceUsage.h>
31	#include <wtf/StdLibExtras.h>	30	#include <wtf/StdLibExtras.h>
32	#include <wtf/WTFConfig.h>	31	#include <wtf/WTFConfig.h>
33		32




#include "BigIntObject.h"
#include "BooleanConstructor.h"
#include "BooleanPrototype.h"
#include "CustomGetterSetter.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "GetterSetter.h"
#include "JSBigInt.h"
#include "JSCJSValueInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "NumberObject.h"
#include "TypeError.h"

namespace JSC {




#include "config.h"
#include "JSCallee.h"

#include "GetterSetter.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "StackVisitor.h"

namespace JSC {




#include "config.h"
#include "JSCell.h"

#include "ArrayBufferView.h"
#include "BlockDirectoryInlines.h"
#include "IntegrityInlines.h"
#include "IsoSubspaceInlines.h"
#include "JSBigInt.h"
#include "JSGlobalObject.h"
#include "JSFunction.h"
#include "JSString.h"
#include "JSObject.h"
#include "JSString.h"
#include "MarkedBlockInlines.h"
#include "NumberObject.h"
#include "SubspaceInlines.h"
#include <wtf/LockAlgorithmInlines.h>
#include <wtf/MathExtras.h>

namespace JSC {




#include "JSCustomGetterSetterFunction.h"

#include "CustomGetterSetter.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"

namespace JSC {




#include "config.h"
#include "JSDataView.h"

#include "ArrayBufferView.h"
#include "DataView.h"
#include "Error.h"
#include "JSCInlines.h"
#include "TypeError.h"




#include "config.h"
#include "JSDataViewPrototype.h"

#include "Error.h"
#include "JSArrayBuffer.h"
#include "JSDataView.h"
#include "Lookup.h"
#include "JSCInlines.h"
#include "JSDataView.h"
#include "ToNativeFromValue.h"
#include "TypedArrayAdaptors.h"
#include <wtf/FlipBytes.h>



#include "config.h"
#include "JSDateMath.h"

#include "ExceptionHelpers.h"
#include "VM.h"
#include "JSCInlines.h"

#include <algorithm>
#include <limits.h>
#include <limits>
#include <stdint.h>
#include <time.h>
#include <wtf/ASCIICType.h>
#include <wtf/Assertions.h>
#include <wtf/MathExtras.h>
#include <wtf/StdLibExtras.h>

#if HAVE(ERRNO_H)
#include <errno.h>
#endif

#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif

#if HAVE(SYS_TIMEB_H)
#include <sys/timeb.h>
#endif

namespace JSC {




#include "config.h"
#include "JSDestructibleObjectHeapCellType.h"

#include "JSDestructibleObject.h"
#include "MarkedBlockInlines.h"
#include "JSCInlines.h"

namespace JSC {




#include "BuiltinNames.h"
#include "CatchScope.h"
#include "ClonedArguments.h"
#include "CodeBlock.h"
#include "CommonIdentifiers.h"
#include "CallFrame.h"
#include "ExceptionHelpers.h"
#include "FunctionPrototype.h"
#include "GeneratorPrototype.h"
#include "GetterSetter.h"
#include "JSArray.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSFunctionInlines.h"
#include "JSGlobalObject.h"
#include "JSToWasmICCallee.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"
#include "Parser.h"
#include "PropertyNameArray.h"
#include "StackVisitor.h"
#include "TypeError.h"

namespace JSC {


Lines 26-32 a/Source/JavaScriptCore/runtime/JSGenerator.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSGenerator.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "JSGenerator.h"	27	#include "JSGenerator.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30	#include "JSInternalFieldObjectImplInlines.h"	30	#include "JSInternalFieldObjectImplInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "JSGeneratorFunction.h"

#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSFunction.h"
#include "JSFunctionInlines.h"
#include "JSObject.h"
#include "PropertySlot.h"
#include "VM.h"

namespace JSC {



#include "config.h"
#include "JSGlobalLexicalEnvironment.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSGlobalLexicalEnvironment::s_info = { "JSGlobalLexicalEnvironment", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSGlobalLexicalEnvironment) };



#include "ArrayIteratorPrototype.h"
#include "ArrayPrototype.h"
#include "AsyncFromSyncIteratorPrototype.h"
#include "AtomicsObject.h"
#include "AsyncFunctionConstructor.h"
#include "AsyncFunctionPrototype.h"
#include "AsyncGeneratorFunctionConstructor.h"

#include "ClonedArguments.h"
#include "CodeBlock.h"
#include "CodeBlockSetInlines.h"
#include "CodeCache.h"
#include "ConsoleObject.h"
#include "DateConstructor.h"
#include "DatePrototype.h"
#include "Debugger.h"
#include "DebuggerScope.h"
#include "DirectArguments.h"
#include "DirectEvalExecutable.h"
#include "Error.h"
#include "ErrorConstructor.h"
#include "ErrorPrototype.h"
#include "Exception.h"
#include "FunctionConstructor.h"
#include "FunctionPrototype.h"
#include "GeneratorFunctionConstructor.h"

#include "GeneratorPrototype.h"
#include "GetterSetter.h"
#include "HeapIterationScope.h"
#include "IndirectEvalExecutable.h"
#include "InspectorInstrumentationObject.h"
#include "Interpreter.h"
#include "IntlCollator.h"
#include "IntlCollatorPrototype.h"
#include "IntlDateTimeFormat.h"

#include "JSAsyncFunction.h"
#include "JSAsyncGenerator.h"
#include "JSAsyncGeneratorFunction.h"
#include "JSBigInt.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSCallbackConstructor.h"
#include "JSCallbackFunction.h"
#include "JSCallbackObject.h"

#include "JSInternalPromiseConstructor.h"
#include "JSInternalPromisePrototype.h"
#include "JSLexicalEnvironment.h"
#include "JSLock.h"
#include "JSMap.h"
#include "JSMapIterator.h"
#include "JSMicrotask.h"

#include "LazyClassStructureInlines.h"
#include "LazyPropertyInlines.h"
#include "LinkTimeConstant.h"
#include "Lookup.h"
#include "MapConstructor.h"
#include "MapIteratorPrototype.h"
#include "MapPrototype.h"
#include "MarkedSpaceInlines.h"
#include "MathObject.h"
#include "Microtask.h"
#include "NativeErrorConstructor.h"
#include "NativeErrorPrototype.h"
#include "NullGetterFunction.h"

#include "ObjectPropertyChangeAdaptiveWatchpoint.h"
#include "ObjectPropertyConditionSet.h"
#include "ObjectPrototype.h"
#include "ParserError.h"
#include "ProxyConstructor.h"
#include "ProxyObject.h"
#include "ProxyRevoke.h"
#include "ReflectObject.h"
#include "RegExpCache.h"
#include "RegExpConstructor.h"
#include "RegExpMatchesArray.h"
#include "RegExpObject.h"

#include "StringConstructor.h"
#include "StringIteratorPrototype.h"
#include "StringPrototype.h"
#include "Symbol.h"
#include "SymbolConstructor.h"
#include "SymbolObject.h"
#include "SymbolPrototype.h"
#include "VariableWriteFireDetail.h"
#include "WasmCapabilities.h"
#include "WeakGCMapInlines.h"
#include "WeakMapConstructor.h"
#include "WeakMapPrototype.h"
#include "WeakObjectRefConstructor.h"




#include "CallFrame.h"
#include "CatchScope.h"
#include "EvalExecutable.h"
#include "Exception.h"
#include "IndirectEvalExecutable.h"
#include "Interpreter.h"
#include "IntlDateTimeFormat.h"
#include "IntlObject.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSInternalPromise.h"
#include "JSModuleLoader.h"

#include "JSString.h"
#include "Lexer.h"
#include "LiteralParser.h"
#include "Nodes.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "ParseInt.h"
#include "Parser.h"
#include "StackVisitor.h"
#include <stdio.h>
#include <stdlib.h>
#include <unicode/utf8.h>
#include <wtf/ASCIICType.h>
#include <wtf/Assertions.h>
#include <wtf/HexNumber.h>
#include <wtf/MathExtras.h>
#include <wtf/dtoa.h>
#include <wtf/text/StringBuilder.h>




#include "config.h"
#include "JSImmutableButterfly.h"

#include "ButterflyInlines.h"
#include "CodeBlock.h"

namespace JSC {

const ClassInfo JSImmutableButterfly::s_info = { "Immutable Butterfly", nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSImmutableButterfly) };

Lines 27-33 a/Source/JavaScriptCore/runtime/JSInternalPromise.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSInternalPromise.cpp -1 / +1 lines
27	#include "JSInternalPromise.h"	27	#include "JSInternalPromise.h"
28		28
29	#include "BuiltinNames.h"	29	#include "BuiltinNames.h"
30	#include "JSCInlines.h"	30	#include "JSObjectInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {
33		33



#include "JSInternalPromiseConstructor.h"

#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSInternalPromise.h"
#include "JSInternalPromisePrototype.h"

#include "JSInternalPromiseConstructor.lut.h"



#include "config.h"
#include "JSInternalPromisePrototype.h"

#include "JSCellInlines.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSInternalPromise.h"
#include "Microtask.h"

namespace JSC {




#include "JSLexicalEnvironment.h"

#include "HeapAnalyzer.h"
#include "Interpreter.h"
#include "JSFunction.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "JSLock.h"

#include "HeapInlines.h"
#include "CallFrame.h"
#include "JSGlobalObject.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "MachineStackMarker.h"
#include "SamplingProfiler.h"
#include "WasmCapabilities.h"
#include "WasmMachineThreads.h"
#include <thread>
#include <wtf/StackPointer.h>
#include <wtf/Threading.h>
#include <wtf/threads/Signals.h>

Lines 27-33 a/Source/JavaScriptCore/runtime/JSMap.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSMap.cpp -1 lines
27	#include "JSMap.h"	27	#include "JSMap.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCInlines.h"
30	#include "MapPrototype.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32

Lines 26-32 a/Source/JavaScriptCore/runtime/JSMapIterator.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSMapIterator.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "JSMapIterator.h"	27	#include "JSMapIterator.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSInternalFieldObjectImplInlines.h"	29	#include "JSInternalFieldObjectImplInlines.h"
31	#include "JSMap.h"	30	#include "JSMap.h"
32		31




#include "CatchScope.h"
#include "Debugger.h"
#include "Error.h"
#include "Exception.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSObjectInlines.h"
#include "Microtask.h"



#include "JSModuleEnvironment.h"

#include "AbstractModuleRecord.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "JSFunction.h"

namespace JSC {





#include "BuiltinNames.h"
#include "CatchScope.h"
#include "Error.h"
#include "Exception.h"
#include "JSCInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "JSInternalPromise.h"
#include "JSMap.h"
#include "JSModuleEnvironment.h"
#include "JSModuleNamespaceObject.h"
#include "JSModuleRecord.h"
#include "JSObjectInlines.h"
#include "JSSourceCode.h"
#include "JSWebAssembly.h"
#include "ModuleAnalyzer.h"




#include "AbstractModuleRecord.h"
#include "Error.h"
#include "JSCInlines.h"
#include "JSModuleEnvironment.h"
#include "SlotVisitorInlines.h"

namespace JSC {


Lines 29-35 a/Source/JavaScriptCore/runtime/JSModuleRecord.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSModuleRecord.cpp -1 / +1 lines
29	#include "BuiltinNames.h"	29	#include "BuiltinNames.h"
30	#include "Error.h"	30	#include "Error.h"
31	#include "Interpreter.h"	31	#include "Interpreter.h"
32	#include "JSCInlines.h"	32	#include "JSCellInlines.h"
33	#include "JSModuleEnvironment.h"	33	#include "JSModuleEnvironment.h"
34	#include "JSModuleLoader.h"	34	#include "JSModuleLoader.h"
35	#include "JSModuleNamespaceObject.h"	35	#include "JSModuleNamespaceObject.h"



#include "config.h"
#include "JSNativeStdFunction.h"

#include "JSCellInlines.h"
#include "JSFunction.h"
#include "JSFunctionInlines.h"
#include "JSObject.h"
#include "VM.h"

namespace JSC {



#include "ArrayConstructor.h"
#include "BigIntObject.h"
#include "BooleanObject.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "JSArray.h"
#include "JSArrayInlines.h"
#include "JSObjectInlines.h"
#include "LiteralParser.h"
#include "Lookup.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "PropertyNameArray.h"
#include <wtf/MathExtras.h>
#include <wtf/text/StringBuilder.h>

namespace JSC {



#include "JSObject.h"

#include "ArrayConstructor.h"
#include "ButterflyInlines.h"
#include "CatchScope.h"
#include "CustomGetterSetter.h"
#include "DatePrototype.h"
#include "ErrorConstructor.h"
#include "Exception.h"
#include "GCDeferralContextInlines.h"
#include "GetterSetter.h"

#include "JSCInlines.h"
#include "JSCustomGetterSetterFunction.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSImmutableButterfly.h"
#include "Lookup.h"
#include "NativeErrorConstructor.h"
#include "ObjectPrototype.h"
#include "PropertyDescriptor.h"
#include "PropertyNameArray.h"
#include "ProxyObject.h"
#include "SlotVisitorInlines.h"
#include "TypeError.h"
#include "VMInlines.h"
#include <math.h>
#include <wtf/Assertions.h>

namespace JSC {

Lines 27-33 a/Source/JavaScriptCore/runtime/JSPromise.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSPromise.cpp -1 lines
27	#include "JSPromise.h"	27	#include "JSPromise.h"
28		28
29	#include "BuiltinNames.h"	29	#include "BuiltinNames.h"
30	#include "Error.h"
31	#include "JSCInlines.h"	30	#include "JSCInlines.h"
32	#include "JSInternalFieldObjectImplInlines.h"	31	#include "JSInternalFieldObjectImplInlines.h"
33	#include "JSPromiseConstructor.h"	32	#include "JSPromiseConstructor.h"



#include "JSPromiseConstructor.h"

#include "BuiltinNames.h"
#include "Error.h"
#include "Exception.h"
#include "GetterSetter.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSPromise.h"
#include "JSPromisePrototype.h"
#include "Lookup.h"
#include "NumberObject.h"

namespace JSC {




#include "JSPromisePrototype.h"

#include "BuiltinNames.h"
#include "Error.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObjectInlines.h"
#include "JSPromise.h"
#include "Microtask.h"

namespace JSC {




#include "config.h"
#include "JSPropertyNameEnumerator.h"

#include "JSObjectInlines.h"
#include "LockDuringMarking.h"
#include "StrongInlines.h"

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/runtime/JSProxy.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSProxy.cpp -1 / +1 lines
27	#include "JSProxy.h"	27	#include "JSProxy.h"
28		28
29	#include "JSGlobalObject.h"	29	#include "JSGlobalObject.h"
30	#include "JSCInlines.h"	30	#include "StructureInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {
33		33



#include "JSRunLoopTimer.h"

#include "IncrementalSweeper.h"
#include "VM.h"
#include <mutex>
#include "JSString.h"

#include <wtf/MainThread.h>
#include <wtf/NoTailCalls.h>
#include <wtf/Threading.h>

#if USE(GLIB_EVENT_LOOP)
#include <glib.h>
#include <wtf/glib/RunLoopSourcePriority.h>
#endif

#include <mutex>

namespace JSC {

static inline JSRunLoopTimer::Manager::EpochTime epochTime(Seconds delay)



#include "JSScope.h"

#include "AbstractModuleRecord.h"
#include "Exception.h"
#include "JSGlobalObject.h"
#include "JSLexicalEnvironment.h"
#include "JSModuleEnvironment.h"
#include "JSWithScope.h"
#include "JSCInlines.h"
#include "VariableEnvironment.h"

namespace JSC {



#include "config.h"
#include "JSScriptFetchParameters.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSScriptFetchParameters::s_info = { "JSScriptFetchParameters", nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSScriptFetchParameters) };



#include "config.h"
#include "JSScriptFetcher.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSScriptFetcher::s_info = { "JSScriptFetcher", nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSScriptFetcher) };

Lines 30-36 a/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSSegmentedVariableObject.cpp -1 lines
30	#include "JSSegmentedVariableObject.h"	30	#include "JSSegmentedVariableObject.h"
31		31
32	#include "HeapAnalyzer.h"	32	#include "HeapAnalyzer.h"
33	#include "JSCInlines.h"
34		33
35	namespace JSC {	34	namespace JSC {
36		35

Lines 27-33 a/Source/JavaScriptCore/runtime/JSSet.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSSet.cpp -1 lines
27	#include "JSSet.h"	27	#include "JSSet.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCInlines.h"
30	#include "SetPrototype.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32

Lines 26-32 a/Source/JavaScriptCore/runtime/JSSetIterator.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSSetIterator.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "JSSetIterator.h"	27	#include "JSSetIterator.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSGlobalObjectInlines.h"
30	#include "JSInternalFieldObjectImplInlines.h"	30	#include "JSInternalFieldObjectImplInlines.h"
31	#include "JSSet.h"	31	#include "JSSet.h"
32		32



#include "config.h"
#include "JSSourceCode.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSSourceCode::s_info = { "JSSourceCode", nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSSourceCode) };




#include "JSGlobalObject.h"
#include "JSGlobalObjectFunctions.h"
#include "JSObject.h"
#include "JSCInlines.h"
#include "StringObject.h"
#include "StringPrototype.h"
#include "StrongInlines.h"

namespace JSC {

Lines 27-33 a/Source/JavaScriptCore/runtime/JSStringIterator.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSStringIterator.cpp -1 / +1 lines
27	#include "config.h"	27	#include "config.h"
28	#include "JSStringIterator.h"	28	#include "JSStringIterator.h"
29		29
30	#include "JSCInlines.h"	30	#include "JSGlobalObject.h"
31	#include "JSInternalFieldObjectImplInlines.h"	31	#include "JSInternalFieldObjectImplInlines.h"
32		32
33	namespace JSC {	33	namespace JSC {



#include "config.h"
#include "JSStringJoiner.h"

#include "JSCInlines.h"

namespace JSC {

JSStringJoiner::~JSStringJoiner()

Lines 29-35 a/Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSSymbolTableObject.cpp -1 / +1 lines
29	#include "config.h"	29	#include "config.h"
30	#include "JSSymbolTableObject.h"	30	#include "JSSymbolTableObject.h"
31		31
32	#include "JSCInlines.h"	32	#include "JSGlobalObject.h"
33	#include "PropertyNameArray.h"	33	#include "PropertyNameArray.h"
34		34
35	namespace JSC {	35	namespace JSC {




namespace WTF {

class PrintStream;

#define CASE(__type) \
    case JSC::__type: \
        out.print(#__type); \



#include "config.h"
#include "JSTypedArrayConstructors.h"

#include "JSGenericTypedArrayViewConstructorInlines.h"
#include "JSGenericTypedArrayViewInlines.h"
#include "JSCInlines.h"

namespace JSC {

#undef MAKE_S_INFO



#include "config.h"
#include "JSTypedArrayPrototypes.h"

#include "JSGenericTypedArrayViewPrototypeInlines.h"
#include "JSCInlines.h"
#include "JSTypedArrayViewPrototype.h"

namespace JSC {



#include "config.h"
#include "JSTypedArrayViewConstructor.h"

#include "CallFrame.h"
#include "Error.h"
#include "GetterSetter.h"
#include "JSCBuiltins.h"
#include "JSGlobalObject.h"
#include "JSGenericTypedArrayViewConstructorInlines.h"
#include "JSTypedArrayViewPrototype.h"
#include "JSTypedArrays.h"

namespace JSC {




#include "CallFrame.h"
#include "GetterSetter.h"
#include "JSArrayIterator.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGenericTypedArrayViewPrototypeFunctions.h"
#include "JSObjectInlines.h"
#include "TypedArrayAdaptors.h"

namespace JSC {


Lines 28-34 a/Source/JavaScriptCore/runtime/JSTypedArrays.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSTypedArrays.cpp -1 lines
28		28
29	#include "GenericTypedArrayViewInlines.h"	29	#include "GenericTypedArrayViewInlines.h"
30	#include "JSGenericTypedArrayViewInlines.h"	30	#include "JSGenericTypedArrayViewInlines.h"
31	#include "JSCInlines.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33



#include "config.h"
#include "JSWeakMap.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSWeakMap::s_info = { "WeakMap", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSWeakMap) };



#include "config.h"
#include "JSWeakObjectRef.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSWeakObjectRef::s_info = { "WeakRef", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSWeakObjectRef) };



#include "config.h"
#include "JSWeakSet.h"

#include "JSCInlines.h"

namespace JSC {

const ClassInfo JSWeakSet::s_info = { "WeakSet", &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSWeakSet) };

Lines 26-32 a/Source/JavaScriptCore/runtime/JSWithScope.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSWithScope.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "JSWithScope.h"	27	#include "JSWithScope.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32

Lines 22-28 a/Source/JavaScriptCore/runtime/JSWrapperObject.cpp_sec1
- a/Source/JavaScriptCore/runtime/JSWrapperObject.cpp -1 lines
22	#include "config.h"	22	#include "config.h"
23	#include "JSWrapperObject.h"	23	#include "JSWrapperObject.h"
24		24
25	#include "JSCInlines.h"
26	#include "JSInternalFieldObjectImplInlines.h"	25	#include "JSInternalFieldObjectImplInlines.h"
27		26
28	namespace JSC {	27	namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/LazyClassStructure.cpp_sec1
- a/Source/JavaScriptCore/runtime/LazyClassStructure.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "LazyClassStructure.h"	27	#include "LazyClassStructure.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30	#include "LazyPropertyInlines.h"	30	#include "LazyPropertyInlines.h"
31		31
32	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "LiteralParser.h"

#include "ButterflyInlines.h"
#include "CodeBlock.h"
#include "JSArray.h"
#include "JSGlobalObjectInlines.h"
#include "Lexer.h"
#include "ObjectConstructor.h"
#include "JSCInlines.h"
#include "StrongInlines.h"
#include <wtf/ASCIICType.h>
#include <wtf/dtoa.h>

Lines 22-28 a/Source/JavaScriptCore/runtime/Lookup.cpp_sec1
- a/Source/JavaScriptCore/runtime/Lookup.cpp -1 lines
22		22
23	#include "GetterSetter.h"	23	#include "GetterSetter.h"
24	#include "JSFunction.h"	24	#include "JSFunction.h"
25	#include "JSCInlines.h"
26		25
27	namespace JSC {	26	namespace JSC {
28		27



#include "config.h"
#include "MapConstructor.h"

#include "Error.h"
#include "GetterSetter.h"
#include "IteratorOperations.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSMap.h"
#include "JSObjectInlines.h"

Lines 27-33 a/Source/JavaScriptCore/runtime/MapIteratorPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/MapIteratorPrototype.cpp -1 lines
27	#include "MapIteratorPrototype.h"	27	#include "MapIteratorPrototype.h"
28		28
29	#include "JSCBuiltins.h"	29	#include "JSCBuiltins.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "BuiltinNames.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "IteratorOperations.h"
#include "JSCInlines.h"
#include "JSMap.h"
#include "JSMapIterator.h"
#include "Lookup.h"

#include "MapPrototype.lut.h"




#include "config.h"
#include "MathObject.h"

#include "JSCJSValueInlines.h"
#include "MathCommon.h"
#include "ObjectPrototype.h"
#include <time.h>
#include <wtf/Assertions.h>
#include <wtf/MathExtras.h>
#include <wtf/Vector.h>




#include "config.h"

#include "BatchedTransitionOptimizer.h"
#include "CodeBlock.h"
#include "CodeCache.h"
#include "Debugger.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "LLIntEntrypoint.h"
#include "ModuleProgramCodeBlock.h"
#include "Parser.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC {




#include "config.h"
#include "NativeErrorConstructor.h"

#include "CallFrameInlines.h"
#include "ErrorInstance.h"
#include "JSGlobalObject.h"
#include "JSFunction.h"
#include "JSString.h"
#include "NativeErrorPrototype.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "NativeErrorPrototype.h"

#include "JSGlobalObject.h"
#include "JSString.h"
#include "NativeErrorConstructor.h"
#include "JSCInlines.h"

namespace JSC {

NativeErrorPrototype::NativeErrorPrototype(VM& vm, Structure* structure)



 */

#include "config.h"
#include "NativeExecutable.h"

#include "BatchedTransitionOptimizer.h"
#include "CodeBlock.h"
#include "Debugger.h"
#include "ExecutableBaseInlines.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "LLIntEntrypoint.h"
#include "Parser.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/runtime/NullGetterFunction.cpp_sec1
- a/Source/JavaScriptCore/runtime/NullGetterFunction.cpp -1 lines
27	#include "NullGetterFunction.h"	27	#include "NullGetterFunction.h"
28		28
29	#include "JSCJSValueInlines.h"	29	#include "JSCJSValueInlines.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "NullSetterFunction.h"

#include "CodeBlock.h"
#include "Error.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "StackVisitor.h"




#include "config.h"
#include "NumberConstructor.h"

#include "JSCJSValueInlines.h"
#include "NumberObject.h"
#include "NumberPrototype.h"
#include "JSCInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "StructureInlines.h"

namespace JSC {




#include "config.h"
#include "NumberObject.h"

#include "AuxiliaryBarrierInlines.h"
#include "JSGlobalObject.h"
#include "NumberPrototype.h"
#include "JSCInlines.h"

namespace JSC {




#include "config.h"
#include "NumberPrototype.h"

#include "AuxiliaryBarrierInlines.h"
#include "BigInteger.h"
#include "Error.h"
#include "IntegrityInlines.h"
#include "IntlNumberFormat.h"
#include "IntlObject.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSString.h"
#include "Operations.h"
#include "ParseInt.h"
#include "Uint16WithFraction.h"
#include <wtf/dtoa.h>
#include <wtf/Assertions.h>
#include <wtf/MathExtras.h>
#include <wtf/dtoa/double-conversion.h>

using DoubleToStringConverter = WTF::double_conversion::DoubleToStringConverter;



#include "ObjectConstructor.h"

#include "BuiltinNames.h"
#include "ButterflyInlines.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "JSArray.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSGlobalObjectFunctions.h"
#include "JSImmutableButterfly.h"
#include "JSObjectInlines.h"
#include "ObjectPrototype.h"
#include "PropertyDescriptor.h"
#include "PropertyNameArray.h"
#include "StackVisitor.h"
#include "Symbol.h"

namespace JSC {



#include "config.h"
#include "ObjectPrototype.h"

#include "Error.h"
#include "GetterSetter.h"
#include "HasOwnPropertyCache.h"
#include "IntegrityInlines.h"
#include "JSObjectInlines.h"
#include "JSString.h"
#include "JSCInlines.h"
#include "PropertySlot.h"
#include "StructureInlines.h"
#include "StructureRareDataInlines.h"

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp_sec1
- a/Source/JavaScriptCore/runtime/ObjectToStringAdaptiveStructureWatchpoint.cpp -1 lines
27	#include "ObjectToStringAdaptiveStructureWatchpoint.h"	27	#include "ObjectToStringAdaptiveStructureWatchpoint.h"
28		28
29	#include "JSCellInlines.h"	29	#include "JSCellInlines.h"
30	#include "ObjectPropertyConditionSet.h"
31	#include "StructureRareData.h"	30	#include "StructureRareData.h"
32		31
33	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "Operations.h"

#include "Error.h"
#include "JSBigInt.h"
#include "JSCInlines.h"
#include "JSObject.h"
#include "JSString.h"
#include <wtf/MathExtras.h>

namespace JSC {




#include "CPU.h"
#include "LLIntCommon.h"
#include "MinimumReservedZoneSize.h"
#include "SigillCrashAnalyzer.h"
#include <algorithm>
#include <limits>
#include <math.h>
#include <mutex>
#include <stdlib.h>
#include <string.h>

#include <wtf/NumberOfCores.h>
#include <wtf/Optional.h>
#include <wtf/OSLogPrintStream.h>
#include <wtf/PointerPreparations.h>
#include <wtf/StdLibExtras.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/threads/Signals.h>

#include <crt_externs.h>
#endif

#if ENABLE(JIT)
#include "MacroAssembler.h"
#endif

namespace JSC {

template<typename T>



#include "config.h"

#include "BatchedTransitionOptimizer.h"
#include "CodeBlock.h"
#include "CodeCache.h"
#include "Debugger.h"
#include "Exception.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "LLIntEntrypoint.h"
#include "Parser.h"
#include "ProgramCodeBlock.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC {


Lines 29-35 a/Source/JavaScriptCore/runtime/PromiseTimer.cpp_sec1
- a/Source/JavaScriptCore/runtime/PromiseTimer.cpp -1 lines
29	#include "JSPromise.h"	29	#include "JSPromise.h"
30	#include "StrongInlines.h"	30	#include "StrongInlines.h"
31	#include "VM.h"	31	#include "VM.h"
32	#include <wtf/Locker.h>
33	#include <wtf/RunLoop.h>	32	#include <wtf/RunLoop.h>
34		33
35	namespace JSC {	34	namespace JSC {





#include "config.h"

#include "PropertyDescriptor.h"

#include "GetterSetter.h"
#include "JSObject.h"
#include "JSCInlines.h"

namespace JSC {
unsigned PropertyDescriptor::defaultAttributes = PropertyAttribute::DontDelete | PropertyAttribute::DontEnum | PropertyAttribute::ReadOnly;



#include "config.h"
#include "PropertySlot.h"

#include "DOMJITGetterSetter.h"
#include "GetterSetter.h"
#include "HeapCellInlines.h"
#include "JSCJSValueInlines.h"
#include "JSObject.h"


Lines 26-32 a/Source/JavaScriptCore/runtime/PropertyTable.cpp_sec1
- a/Source/JavaScriptCore/runtime/PropertyTable.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "PropertyMapHashTable.h"	27	#include "PropertyMapHashTable.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32



#include "config.h"
#include "ProxyConstructor.h"

#include "JSCellInlines.h"
#include "IdentifierInlines.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"
#include "ProxyObject.h"
#include "ProxyRevoke.h"
#include "StructureInlines.h"

namespace JSC {




#include "config.h"
#include "ProxyObject.h"

#include "ArrayConstructor.h"
#include "Error.h"
#include "IdentifierInlines.h"
#include "JSCInlines.h"
#include "JSObjectInlines.h"
#include "ObjectConstructor.h"
#include "SlotVisitorInlines.h"
#include "StructureInlines.h"
#include "VMInlines.h"
#include <wtf/NoTailCalls.h>


Lines 26-32 a/Source/JavaScriptCore/runtime/ProxyRevoke.cpp_sec1
- a/Source/JavaScriptCore/runtime/ProxyRevoke.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ProxyRevoke.h"	27	#include "ProxyRevoke.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30	#include "ProxyObject.h"	30	#include "ProxyObject.h"
31		31
32	namespace JSC {	32	namespace JSC {



#include "config.h"
#include "ReflectObject.h"

#include "JSObjectInlines.h"
#include "JSCInlines.h"
#include "JSGlobalObjectFunctions.h"
#include "Lookup.h"
#include "ObjectConstructor.h"

namespace JSC {



#include "config.h"
#include "RegExp.h"

#include "ExceptionHelpers.h"
#include "Lexer.h"
#include "JSCInlines.h"
#include "RegExpCache.h"
#include "RegExpInlines.h"
#include "YarrJIT.h"



#include "config.h"
#include "RegExpCache.h"

#include "JSCInlines.h"
#include "RegExpObject.h"
#include "StrongInlines.h"

namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/RegExpCachedResult.cpp_sec1
- a/Source/JavaScriptCore/runtime/RegExpCachedResult.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "RegExpCachedResult.h"	27	#include "RegExpCachedResult.h"
28		28
29	#include "JSCInlines.h"
30	#include "RegExpCache.h"	29	#include "RegExpCache.h"
31	#include "RegExpMatchesArray.h"	30	#include "RegExpMatchesArray.h"
32		31



#include "config.h"
#include "RegExpConstructor.h"

#include "JSGlobalObject.h"
#include "GetterSetter.h"
#include "JSCInlines.h"
#include "RegExpGlobalDataInlines.h"
#include "RegExpPrototype.h"
#include "YarrFlags.h"

Lines 27-33 a/Source/JavaScriptCore/runtime/RegExpGlobalData.cpp_sec1
- a/Source/JavaScriptCore/runtime/RegExpGlobalData.cpp -1 lines
27	#include "RegExpGlobalData.h"	27	#include "RegExpGlobalData.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCInlines.h"
30	#include "JSString.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "config.h"
#include "RegExpObject.h"

#include "Error.h"
#include "ExceptionHelpers.h"
#include "JSArray.h"
#include "JSGlobalObject.h"
#include "JSString.h"
#include "Lookup.h"
#include "JSCInlines.h"
#include "RegExpObjectInlines.h"

namespace JSC {



#include "config.h"
#include "RegExpPrototype.h"

#include "ArrayPrototype.h"
#include "BuiltinNames.h"
#include "Error.h"
#include "IntegrityInlines.h"
#include "JSArray.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSCJSValue.h"
#include "JSGlobalObject.h"
#include "JSStringInlines.h"
#include "Lexer.h"
#include "ObjectPrototype.h"
#include "RegExpCache.h"
#include "RegExpObject.h"
#include "RegExpObjectInlines.h"
#include "StringObject.h"
#include "StringRecursionChecker.h"
#include "YarrFlags.h"
#include <wtf/text/StringBuilder.h>



#include "config.h"
#include "RegExpStringIteratorPrototype.h"

#include "IteratorOperations.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSCJSValueInlines.h"
#include "JSCellInlines.h"
#include "JSGlobalObject.h"
#include "ObjectConstructor.h"
#include "StructureInlines.h"

namespace JSC {




#include "config.h"
#include "RuntimeType.h"

#include "JSCInlines.h"

namespace JSC {

RuntimeType runtimeTypeForValue(VM& vm, JSValue value)



#include "HeapIterationScope.h"
#include "HeapUtil.h"
#include "InlineCallFrame.h"
#include "JSObjectInlines.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "LLIntPCRanges.h"
#include "MachineContext.h"
#include "MarkedBlockInlines.h"
#include "MarkedBlockSet.h"
#include "MarkedSpaceInlines.h"
#include "NativeExecutable.h"
#include "PCToCodeOriginMap.h"
#include "SlotVisitor.h"
#include "StrongInlines.h"
#include "VM.h"
#include "WasmCallee.h"
#include "WasmCalleeRegistry.h"
#include <thread>
#include <wtf/FilePrintStream.h>
#include <wtf/HashSet.h>
#include <wtf/RefPtr.h>
#include <wtf/StackTrace.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringConcatenateNumbers.h>

namespace JSC {


Lines 27-33 a/Source/JavaScriptCore/runtime/ScopedArguments.cpp_sec1
- a/Source/JavaScriptCore/runtime/ScopedArguments.cpp -1 lines
27	#include "ScopedArguments.h"	27	#include "ScopedArguments.h"
28		28
29	#include "GenericArgumentsInlines.h"	29	#include "GenericArgumentsInlines.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32

Lines 26-32 a/Source/JavaScriptCore/runtime/ScopedArgumentsTable.cpp_sec1
- a/Source/JavaScriptCore/runtime/ScopedArgumentsTable.cpp -1 / +1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "ScopedArgumentsTable.h"	27	#include "ScopedArgumentsTable.h"
28		28
29	#include "JSCInlines.h"	29	#include "JSCellInlines.h"
30		30
31	namespace JSC {	31	namespace JSC {
32		32




#include "config.h"

#include "BatchedTransitionOptimizer.h"
#include "CodeBlock.h"
#include "Debugger.h"
#include "EvalCodeBlock.h"

#include "GlobalExecutable.h"
#include "IsoCellSetInlines.h"
#include "JIT.h"
#include "JSCInlines.h"
#include "JSTemplateObjectDescriptor.h"
#include "LLIntEntrypoint.h"
#include "ModuleProgramCodeBlock.h"
#include "ParserError.h"
#include "ProgramCodeBlock.h"
#include "TypeProfiler.h"
#include "VMInlines.h"
#include <wtf/CommaPrinter.h>

namespace JSC {




#include "config.h"
#include "SetConstructor.h"

#include "Error.h"
#include "GetterSetter.h"
#include "IteratorOperations.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSObjectInlines.h"
#include "JSSet.h"
#include "SetPrototype.h"


Lines 27-33 a/Source/JavaScriptCore/runtime/SetIteratorPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/SetIteratorPrototype.cpp -1 lines
27	#include "SetIteratorPrototype.h"	27	#include "SetIteratorPrototype.h"
28		28
29	#include "JSCBuiltins.h"	29	#include "JSCBuiltins.h"
30	#include "JSCInlines.h"
31		30
32	namespace JSC {	31	namespace JSC {
33		32



#include "BuiltinNames.h"
#include "Error.h"
#include "ExceptionHelpers.h"
#include "JSGlobalObjectInlines.h"
#include "JSCInlines.h"
#include "JSSet.h"
#include "JSSetIterator.h"
#include "Lookup.h"

#include "SetPrototype.lut.h"





#include "ArrayBuffer.h"
#include "JSArrayBuffer.h"
#include "JSGlobalObject.h"
#include "WeakInlines.h"

namespace JSC {




#include "config.h"
#include "SmallStrings.h"

#include "JSGlobalObject.h"
#include "JSString.h"
#include "JSCInlines.h"
#include <wtf/Noncopyable.h>
#include <wtf/text/StringImpl.h>

namespace JSC {



#include "config.h"
#include "SparseArrayValueMap.h"

#include "ClassInfo.h"
#include "GetterSetter.h"
#include "JSCellInlines.h"
#include "JSCInlines.h"
#include "PropertySlot.h"
#include "SlotVisitor.h"
#include "Structure.h"
#include "TypeError.h"

namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/runtime/StackFrame.cpp_sec1
- a/Source/JavaScriptCore/runtime/StackFrame.cpp -1 lines
28		28
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "DebuggerPrimitives.h"	30	#include "DebuggerPrimitives.h"
31	#include "JSCInlines.h"
32	#include <wtf/text/StringBuilder.h>	31	#include <wtf/text/StringBuilder.h>
33		32
34	namespace JSC {	33	namespace JSC {



#include "config.h"
#include "StrictEvalActivation.h"

#include "JSGlobalObject.h"
#include "JSCInlines.h"

namespace JSC {

STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(StrictEvalActivation);



#include "StringConstructor.h"

#include "Error.h"
#include "JITCode.h"
#include "JSFunction.h"
#include "JSGlobalObject.h"
#include "JSCInlines.h"
#include "StringPrototype.h"
#include <wtf/text/StringBuilder.h>




#include "StringIteratorPrototype.h"

#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSStringIterator.h"
#include "ObjectConstructor.h"

namespace JSC {




#include "config.h"
#include "StringObject.h"

#include "Error.h"
#include "JSGlobalObject.h"
#include "JSCInlines.h"
#include "PropertyNameArray.h"
#include "TypeError.h"

namespace JSC {




#include "StringPrototype.h"

#include "BuiltinNames.h"
#include "ButterflyInlines.h"
#include "CachedCall.h"
#include "Error.h"
#include "ExecutableBaseInlines.h"
#include "FrameTracers.h"
#include "IntegrityInlines.h"

#include "IntlObject.h"
#include "JITCodeInlines.h"
#include "JSArray.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSGlobalObjectFunctions.h"
#include "JSStringIterator.h"
#include "Lookup.h"
#include "ObjectConstructor.h"
#include "ObjectPrototype.h"
#include "ParseInt.h"
#include "PropertyNameArray.h"
#include "RegExpCache.h"
#include "RegExpConstructor.h"
#include "RegExpGlobalDataInlines.h"
#include "StringPrototypeInlines.h"
#include "SuperSampler.h"
#include <algorithm>
#include <unicode/uconfig.h>
#include <unicode/unorm2.h>
#include <unicode/ustring.h>
#include <wtf/ASCIICType.h>
#include <wtf/MathExtras.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/text/StringView.h>
#include <wtf/unicode/icu/ICUHelpers.h>



#include "config.h"
#include "StringRecursionChecker.h"

#include "Error.h"
#include "ExceptionHelpers.h"
#include "JSGlobalObject.h"

namespace JSC {




#include "Structure.h"

#include "BuiltinNames.h"
#include "CodeBlock.h"
#include "DumpContext.h"
#include "JSCInlines.h"
#include "JSObject.h"
#include "JSPropertyNameEnumerator.h"
#include "Lookup.h"
#include "PropertyMapHashTable.h"
#include "PropertyNameArray.h"
#include "StructureInlines.h"
#include "StructureRareDataInlines.h"
#include "WeakGCMapInlines.h"
#include <wtf/CommaPrinter.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/ProcessID.h>
#include <wtf/RefPtr.h>
#include <wtf/Threading.h>

#define DUMP_STRUCTURE_ID_STATISTICS 0


Lines 27-33 a/Source/JavaScriptCore/runtime/StructureCache.cpp_sec1
- a/Source/JavaScriptCore/runtime/StructureCache.cpp -1 / +1 lines
27	#include "StructureCache.h"	27	#include "StructureCache.h"
28		28
29	#include "JSGlobalObject.h"	29	#include "JSGlobalObject.h"
30	#include "JSCInlines.h"	30	#include "WeakInlines.h"
31	#include <wtf/Locker.h>	31	#include <wtf/Locker.h>
32		32
33	namespace JSC {	33	namespace JSC {



#include "config.h"
#include "StructureChain.h"

#include "JSObject.h"
#include "JSCInlines.h"
#include "Structure.h"

namespace JSC {
    

Lines 26-32 a/Source/JavaScriptCore/runtime/StructureIDTable.cpp_sec1
- a/Source/JavaScriptCore/runtime/StructureIDTable.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "StructureIDTable.h"	27	#include "StructureIDTable.h"
28		28
29	#include <limits.h>
30	#include <wtf/Atomics.h>	29	#include <wtf/Atomics.h>
31		30
32	namespace JSC {	31	namespace JSC {



#include "JSImmutableButterfly.h"
#include "JSPropertyNameEnumerator.h"
#include "JSString.h"
#include "JSCInlines.h"
#include "ObjectPropertyConditionSet.h"
#include "ObjectToStringAdaptiveStructureWatchpoint.h"
#include "StructureChain.h"

namespace JSC {


Lines 28-34 a/Source/JavaScriptCore/runtime/Symbol.cpp_sec1
- a/Source/JavaScriptCore/runtime/Symbol.cpp -1 / +1 lines
28	#include "Symbol.h"	28	#include "Symbol.h"
29		29
30	#include "Error.h"	30	#include "Error.h"
31	#include "JSCInlines.h"	31	#include "JSCellInlines.h"
32	#include "SymbolObject.h"	32	#include "SymbolObject.h"
33		33
34	namespace JSC {	34	namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/runtime/SymbolConstructor.cpp_sec1
- a/Source/JavaScriptCore/runtime/SymbolConstructor.cpp -1 lines
28	#include "SymbolConstructor.h"	28	#include "SymbolConstructor.h"
29		29
30	#include "Error.h"	30	#include "Error.h"
31	#include "JSCInlines.h"
32	#include "JSGlobalObject.h"	31	#include "JSGlobalObject.h"
33	#include "Symbol.h"	32	#include "Symbol.h"
34	#include "SymbolPrototype.h"	33	#include "SymbolPrototype.h"

Lines 27-33 a/Source/JavaScriptCore/runtime/SymbolObject.cpp_sec1
- a/Source/JavaScriptCore/runtime/SymbolObject.cpp -1 / +1 lines
27	#include "config.h"	27	#include "config.h"
28	#include "SymbolObject.h"	28	#include "SymbolObject.h"
29		29
30	#include "JSCInlines.h"	30	#include "JSGlobalObject.h"
31		31
32	namespace JSC {	32	namespace JSC {
33		33

Lines 29-35 a/Source/JavaScriptCore/runtime/SymbolPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/SymbolPrototype.cpp -1 lines
29		29
30	#include "Error.h"	30	#include "Error.h"
31	#include "IntegrityInlines.h"	31	#include "IntegrityInlines.h"
32	#include "JSCInlines.h"
33	#include "JSString.h"	32	#include "JSString.h"
34	#include "SymbolObject.h"	33	#include "SymbolObject.h"
35		34



#include "SymbolTable.h"

#include "CodeBlock.h"
#include "JSDestructibleObject.h"
#include "JSCInlines.h"
#include "SlotVisitorInlines.h"
#include "TypeProfiler.h"


Lines 29-35 a/Source/JavaScriptCore/runtime/TestRunnerUtils.cpp_sec1
- a/Source/JavaScriptCore/runtime/TestRunnerUtils.cpp -1 lines
29	#include "CodeBlock.h"	29	#include "CodeBlock.h"
30	#include "FunctionCodeBlock.h"	30	#include "FunctionCodeBlock.h"
31	#include "JSCInlines.h"	31	#include "JSCInlines.h"
32	#include "LLIntData.h"
33		32
34	namespace JSC {	33	namespace JSC {
35		34

Lines 27-33 a/Source/JavaScriptCore/runtime/ThrowScope.cpp_sec1
- a/Source/JavaScriptCore/runtime/ThrowScope.cpp -1 lines
27	#include "ThrowScope.h"	27	#include "ThrowScope.h"
28		28
29	#include "Exception.h"	29	#include "Exception.h"
30	#include "JSCInlines.h"
31	#include "VM.h"	30	#include "VM.h"
32		31
33	namespace JSC {	32	namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/TypeProfiler.cpp_sec1
- a/Source/JavaScriptCore/runtime/TypeProfiler.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "TypeProfiler.h"	27	#include "TypeProfiler.h"
28		28
29	#include "InspectorProtocolObjects.h"
30	#include "TypeLocation.h"	29	#include "TypeLocation.h"
31	#include <wtf/text/StringBuilder.h>	30	#include <wtf/text/StringBuilder.h>
32		31



#include "config.h"
#include "TypeProfilerLog.h"

#include "SlotVisitorInlines.h"
#include "SlotVisitor.h"
#include "TypeLocation.h"


namespace JSC {

namespace TypeProfilerLogInternal {



#include "config.h"
#include "TypeSet.h"

#include "HeapInlines.h"
#include "InspectorProtocolObjects.h"
#include "JSCInlines.h"
#include <wtf/text/CString.h>
#include <wtf/text/WTFString.h>
#include <wtf/text/StringBuilder.h>
#include <wtf/Vector.h>



#include "config.h"
#include "TypedArrayType.h"

#include "JSDataView.h"
#include "JSTypedArrayConstructors.h"
#include "JSTypedArrays.h"

namespace JSC {




#include "CodeBlock.h"
#include "CodeCache.h"
#include "CommonIdentifiers.h"
#include "CommonSlowPaths.h"
#include "CustomGetterSetter.h"
#include "DFGWorklist.h"
#include "DOMAttributeGetterSetter.h"
#include "DateInstance.h"
#include "DebuggerScope.h"
#include "DirectEvalExecutable.h"
#include "Disassembler.h"
#include "DoublePredictionFuzzerAgent.h"
#include "Error.h"
#include "ErrorConstructor.h"
#include "ErrorInstance.h"
#include "EvalCodeBlock.h"
#include "Exception.h"

#include "FastMallocAlignedMemoryAllocator.h"
#include "FileBasedFuzzerAgent.h"
#include "FunctionCodeBlock.h"
#include "FunctionConstructor.h"
#include "FunctionExecutable.h"
#include "GCActivityCallback.h"
#include "GetterSetter.h"
#include "GigacageAlignedMemoryAllocator.h"
#include "HasOwnPropertyCache.h"
#include "Heap.h"
#include "HeapIterationScope.h"
#include "HeapProfiler.h"
#include "HostCallReturnValue.h"
#include "Identifier.h"
#include "IncrementalSweeper.h"
#include "IndirectEvalExecutable.h"
#include "Interpreter.h"
#include "IntlCollator.h"
#include "IntlDateTimeFormat.h"

#include "JSAPIWrapperObject.h"
#include "JSArray.h"
#include "JSArrayBuffer.h"
#include "JSArrayBufferConstructor.h"
#include "JSArrayIterator.h"
#include "JSAsyncFunction.h"
#include "JSAsyncGenerator.h"
#include "JSBigInt.h"
#include "JSBoundFunction.h"
#include "JSCInlines.h"
#include "JSCallbackConstructor.h"
#include "JSCallbackFunction.h"
#include "JSCallbackObject.h"

#include "JSFunction.h"
#include "JSGlobalLexicalEnvironment.h"
#include "JSGlobalObject.h"
#include "JSGlobalObjectFunctions.h"
#include "JSImmutableButterfly.h"
#include "JSInjectedScriptHost.h"
#include "JSInternalPromise.h"
#include "JSJavaScriptCallFrame.h"
#include "JSLock.h"
#include "JSMap.h"

#include "JSWeakMap.h"
#include "JSWeakObjectRef.h"
#include "JSWeakSet.h"
#include "JSWebAssembly.h"
#include "JSWebAssemblyCodeBlock.h"
#include "JSWebAssemblyGlobal.h"
#include "JSWebAssemblyInstance.h"

#include "JSWebAssemblyTable.h"
#include "JSWithScope.h"
#include "LLIntData.h"
#include "Lexer.h"
#include "Lookup.h"
#include "MinimumReservedZoneSize.h"
#include "ModuleProgramCodeBlock.h"
#include "ModuleProgramExecutable.h"
#include "NarrowingNumberPredictionFuzzerAgent.h"
#include "NativeErrorConstructor.h"
#include "NativeExecutable.h"
#include "Nodes.h"
#include "NumberObject.h"
#include "Parser.h"
#include "PredictionFileCreatingFuzzerAgent.h"
#include "ProfilerDatabase.h"
#include "ProgramCodeBlock.h"

#include "RandomizingFuzzerAgent.h"
#include "RegExpCache.h"
#include "RegExpObject.h"
#include "RegisterAtOffsetList.h"
#include "RuntimeType.h"
#include "SamplingProfiler.h"
#include "ScopedArguments.h"
#include "ShadowChicken.h"
#include "SimpleTypedArrayController.h"
#include "SourceProviderCache.h"
#include "StackVisitor.h"
#include "StrictEvalActivation.h"
#include "StringObject.h"
#include "StrongInlines.h"

#include "ThunkGenerators.h"
#include "TypeProfiler.h"
#include "TypeProfilerLog.h"
#include "UnlinkedCodeBlock.h"
#include "VMEntryScope.h"
#include "VMInlines.h"
#include "VMInspector.h"

#include <wtf/StringPrintStream.h>
#include <wtf/Threading.h>
#include <wtf/text/AtomStringTable.h>
#include <wtf/text/SymbolRegistry.h>

#if ENABLE(C_LOOP)
#include "CLoopStack.h"



#include "VMEntryScope.h"

#include "DisallowVMReentry.h"
#include "JSGlobalObject.h"
#include "Options.h"
#include "SamplingProfiler.h"
#include "VM.h"
#include "Watchdog.h"
#include <wtf/StackBounds.h>
#include <wtf/SystemTracing.h>

namespace JSC {



#include "config.h"
#include "VMTraps.h"

#include "CallFrame.h"
#include "CallFrameInlines.h"
#include "CodeBlock.h"
#include "CodeBlockSet.h"
#include "DFGCommonData.h"
#include "ExceptionHelpers.h"
#include "HeapInlines.h"
#include "JSCPtrTag.h"
#include "LLIntPCRanges.h"
#include "MachineContext.h"
#include "MachineStackMarker.h"
#include "MacroAssembler.h"
#include "MacroAssemblerCodeRef.h"
#include "VM.h"
#include "VMInspector.h"
#include "Watchdog.h"
#include <wtf/ProcessID.h>
#include <wtf/ThreadMessage.h>



#include "config.h"
#include "Watchdog.h"

#include "VM.h"
#include <wtf/CPUTime.h>
#include <wtf/MathExtras.h>

namespace JSC {


Lines 28-34 a/Source/JavaScriptCore/runtime/WeakMapConstructor.cpp_sec1
- a/Source/JavaScriptCore/runtime/WeakMapConstructor.cpp -1 lines
28		28
29	#include "Error.h"	29	#include "Error.h"
30	#include "IteratorOperations.h"	30	#include "IteratorOperations.h"
31	#include "JSCInlines.h"
32	#include "JSGlobalObject.h"	31	#include "JSGlobalObject.h"
33	#include "JSObjectInlines.h"	32	#include "JSObjectInlines.h"
34	#include "JSWeakMap.h"	33	#include "JSWeakMap.h"



#include "config.h"
#include "WeakMapImpl.h"

#include "IsoCellSetInlines.h"
#include "JSCInlines.h"
#include "WeakMapImplInlines.h"

namespace JSC {

Lines 26-32 a/Source/JavaScriptCore/runtime/WeakMapPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/WeakMapPrototype.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "WeakMapPrototype.h"	27	#include "WeakMapPrototype.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSWeakMap.h"	29	#include "JSWeakMap.h"
31		30
32	namespace JSC {	31	namespace JSC {



#include "config.h"
#include "WeakObjectRefConstructor.h"

#include "Error.h"
#include "IteratorOperations.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSObjectInlines.h"
#include "JSWeakObjectRef.h"



#include "config.h"
#include "WeakObjectRefPrototype.h"

#include "JSGlobalObject.h"
#include "JSCInlines.h"
#include "JSWeakObjectRef.h"

namespace JSC {



#include "config.h"
#include "WeakSetConstructor.h"

#include "Error.h"
#include "IteratorOperations.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "JSObjectInlines.h"
#include "JSWeakSet.h"
#include "WeakSetPrototype.h"


Lines 26-32 a/Source/JavaScriptCore/runtime/WeakSetPrototype.cpp_sec1
- a/Source/JavaScriptCore/runtime/WeakSetPrototype.cpp -1 lines
26	#include "config.h"	26	#include "config.h"
27	#include "WeakSetPrototype.h"	27	#include "WeakSetPrototype.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSWeakSet.h"	29	#include "JSWeakSet.h"
31		30
32	namespace JSC {	31	namespace JSC {




#include "InitializeThreading.h"
#include "JSCInlines.h"
#include "JSGlobalObject.h"
#include "YarrFlags.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wtf/Vector.h>
#include <wtf/text/StringBuilder.h>

#if !OS(WINDOWS)
#include <unistd.h>
#endif

#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif

#if COMPILER(MSVC)
#include <crtdbg.h>
#include <mmsystem.h>

Lines 28-34 a/Source/JavaScriptCore/tools/CompilerTimingScope.cpp_sec1
- a/Source/JavaScriptCore/tools/CompilerTimingScope.cpp -1 lines
28		28
29	#include "Options.h"	29	#include "Options.h"
30	#include <wtf/DataLog.h>	30	#include <wtf/DataLog.h>
31	#include <wtf/HashMap.h>
32	#include <wtf/Lock.h>	31	#include <wtf/Lock.h>
33	#include <wtf/Vector.h>	32	#include <wtf/Vector.h>
34	#include <wtf/text/WTFString.h>	33	#include <wtf/text/WTFString.h>

Lines 29-35 a/Source/JavaScriptCore/tools/FunctionWhitelist.cpp_sec1
- a/Source/JavaScriptCore/tools/FunctionWhitelist.cpp -1 lines
29	#if ENABLE(JIT)	29	#if ENABLE(JIT)
30		30
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "Options.h"
33	#include <stdio.h>	32	#include <stdio.h>
34	#include <string.h>	33	#include <string.h>
35		34




#include "ButterflyInlines.h"
#include "CodeBlockInlines.h"
#include "HeapIterationScope.h"
#include "JSCInlines.h"
#include "JSObject.h"
#include "MarkedSpaceInlines.h"
#include "VMInspector.h"



#include "config.h"
#include "Integrity.h"

#include "HeapCellInlines.h"
#include "IntegrityInlines.h"
#include "JSCellInlines.h"
#include "Options.h"
#include "VMInspectorInlines.h"



#include "config.h"
#include "JSDollarVM.h"

#include "ArrayPrototype.h"
#include "BuiltinNames.h"
#include "CodeBlock.h"
#include "DOMAttributeGetterSetter.h"
#include "DOMJITGetterSetter.h"
#include "Debugger.h"
#include "Error.h"
#include "FrameTracers.h"
#include "FunctionCodeBlock.h"
#include "GetterSetter.h"
#include "JSArray.h"
#include "JSArrayBuffer.h"
#include "JSCInlines.h"
#include "JSFunction.h"
#include "JSONObject.h"
#include "JSProxy.h"
#include "JSString.h"
#include "Options.h"
#include "Parser.h"



#include "config.h"
#include "SigillCrashAnalyzer.h"

#include "CallFrame.h"
#include "CodeBlock.h"
#include "MachineContext.h"
#include "VMInspector.h"
#include <mutex>
#include <wtf/StdLibExtras.h>

#if ENABLE(ARM64_DISASSEMBLER)
#include "A64DOpcode.h"

Lines 31-37 a/Source/JavaScriptCore/tools/VMInspector.cpp_sec1
- a/Source/JavaScriptCore/tools/VMInspector.cpp -1 lines
31	#include "HeapInlines.h"	31	#include "HeapInlines.h"
32	#include "HeapIterationScope.h"	32	#include "HeapIterationScope.h"
33	#include "JSCInlines.h"	33	#include "JSCInlines.h"
34	#include "MachineContext.h"
35	#include "MarkedSpaceInlines.h"	34	#include "MarkedSpaceInlines.h"
36	#include "StackVisitor.h"	35	#include "StackVisitor.h"
37	#include <mutex>	36	#include <mutex>



#include "AirGenerate.h"
#include "AirHelpers.h"
#include "AirOpcodeUtils.h"
#include "AirValidate.h"
#include "AllowMacroScratchRegisterUsageIf.h"
#include "B3CCallValue.h"
#include "B3CheckSpecial.h"
#include "B3CheckValue.h"
#include "B3PatchpointSpecial.h"
#include "B3Procedure.h"
#include "B3ProcedureInlines.h"
#include "BinarySwitch.h"
#include "JSCJSValueInlines.h"
#include "JSCInlines.h"
#include "JSWebAssemblyInstance.h"
#include "ScratchRegisterAllocator.h"
#include "VirtualRegister.h"
#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"
#include "WasmExceptionType.h"
#include "WasmFunctionParser.h"
#include "WasmInstance.h"
#include "WasmMemory.h"
#include "WasmOMGPlan.h"
#include "WasmOSREntryData.h"
#include "WasmOpcodeOrigin.h"
#include "WasmOperations.h"

#include "WasmThunks.h"
#include <limits>
#include <wtf/Box.h>
#include <wtf/Optional.h>
#include <wtf/StdLibExtras.h>

namespace JSC { namespace Wasm {



#include "AllowMacroScratchRegisterUsageIf.h"
#include "B3BasicBlockInlines.h"
#include "B3CCallValue.h"
#include "B3Compile.h"
#include "B3ConstPtrValue.h"
#include "B3FixSSA.h"
#include "B3Generate.h"
#include "B3InsertionSet.h"
#include "B3SlotBaseValue.h"
#include "B3StackmapGenerationParams.h"
#include "B3SwitchValue.h"
#include "B3UpsilonValue.h"

#include "B3VariableValue.h"
#include "B3WasmAddressValue.h"
#include "B3WasmBoundsCheckValue.h"
#include "JSCJSValueInlines.h"
#include "JSCInlines.h"
#include "JSWebAssemblyInstance.h"
#include "ScratchRegisterAllocator.h"
#include "VirtualRegister.h"
#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"
#include "WasmExceptionType.h"
#include "WasmFunctionParser.h"
#include "WasmInstance.h"
#include "WasmMemory.h"
#include "WasmOMGPlan.h"
#include "WasmOSREntryData.h"
#include "WasmOpcodeOrigin.h"
#include "WasmOperations.h"




#include "B3Compilation.h"
#include "JSToWasm.h"
#include "LinkBuffer.h"
#include "WasmAirIRGenerator.h"
#include "WasmB3IRGenerator.h"
#include "WasmBinding.h"
#include "WasmCallee.h"
#include "WasmCodeBlock.h"
#include "WasmFaultSignalHandler.h"
#include "WasmMachineThreads.h"
#include "WasmMemory.h"
#include "WasmSignatureInlines.h"
#include "WasmTierUpCount.h"
#include <wtf/DataLog.h>
#include <wtf/Locker.h>
#include <wtf/MonotonicTime.h>
#include <wtf/StdLibExtras.h>
#include <wtf/SystemTracing.h>
#include <wtf/text/StringConcatenateNumbers.h>

namespace JSC { namespace Wasm {


Lines 29-35 a/Source/JavaScriptCore/wasm/WasmBinding.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmBinding.cpp -1 lines
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "CCallHelpers.h"	31	#include "CCallHelpers.h"
32	#include "JSCInlines.h"
33	#include "LinkBuffer.h"	32	#include "LinkBuffer.h"
34	#include "WasmCallingConvention.h"	33	#include "WasmCallingConvention.h"
35	#include "WasmInstance.h"	34	#include "WasmInstance.h"

Lines 28-34 a/Source/JavaScriptCore/wasm/WasmCallee.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmCallee.cpp -1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "LLIntThunks.h"
32	#include "WasmCalleeRegistry.h"	31	#include "WasmCalleeRegistry.h"
33	#include "WasmCallingConvention.h"	32	#include "WasmCallingConvention.h"
34		33

Lines 30-36 a/Source/JavaScriptCore/wasm/WasmCodeBlock.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmCodeBlock.cpp -1 lines
30		30
31	#include "WasmBBQPlan.h"	31	#include "WasmBBQPlan.h"
32	#include "WasmCallee.h"	32	#include "WasmCallee.h"
33	#include "WasmFormat.h"
34	#include "WasmLLIntPlan.h"	33	#include "WasmLLIntPlan.h"
35	#include "WasmWorklist.h"	34	#include "WasmWorklist.h"
36		35



#include "WasmEntryPlan.h"

#include "WasmBinding.h"
#include "WasmFaultSignalHandler.h"
#include "WasmMemory.h"
#include "WasmSignatureInlines.h"
#include <wtf/CrossThreadCopier.h>
#include <wtf/DataLog.h>
#include <wtf/Locker.h>
#include <wtf/MonotonicTime.h>
#include <wtf/StdLibExtras.h>
#include <wtf/SystemTracing.h>
#include <wtf/text/StringConcatenateNumbers.h>

#if ENABLE(WEBASSEMBLY)




#include "WasmExceptionType.h"
#include "WasmMemory.h"
#include "WasmThunks.h"

#include <wtf/HashSet.h>
#include <wtf/Lock.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/threads/Signals.h>

namespace JSC { namespace Wasm {

Lines 29-35 a/Source/JavaScriptCore/wasm/WasmFormat.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmFormat.cpp -1 lines
29		29
30	#if ENABLE(WEBASSEMBLY)	30	#if ENABLE(WEBASSEMBLY)
31		31
32	#include "WasmMemory.h"
33	#include <wtf/CheckedArithmetic.h>	32	#include <wtf/CheckedArithmetic.h>
34	#include <wtf/FastMalloc.h>	33	#include <wtf/FastMalloc.h>
35		34




#if ENABLE(WEBASSEMBLY)

#include "BytecodeDumper.h"
#include "BytecodeStructs.h"
#include "InstructionStream.h"
#include "LLIntThunks.h"

namespace JSC { namespace Wasm {


Lines 31-37 a/Source/JavaScriptCore/wasm/WasmGlobal.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmGlobal.cpp -1 lines
31	#include "JSCJSValueInlines.h"	31	#include "JSCJSValueInlines.h"
32	#include "JSWebAssemblyHelpers.h"	32	#include "JSWebAssemblyHelpers.h"
33	#include "JSWebAssemblyRuntimeError.h"	33	#include "JSWebAssemblyRuntimeError.h"
34	#include <wtf/CheckedArithmetic.h>
35	#include <wtf/StdLibExtras.h>	34	#include <wtf/StdLibExtras.h>
36		35
37	namespace JSC { namespace Wasm {	36	namespace JSC { namespace Wasm {




#if ENABLE(WEBASSEMBLY)

#include "JSCInlines.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyInstance.h"
#include "Register.h"
#include "WasmModuleInformation.h"



#include "WasmFunctionCodeBlock.h"
#include "WasmFunctionParser.h"
#include "WasmGeneratorTraits.h"
#include "WasmThunks.h"
#include <wtf/CompletionHandler.h>
#include <wtf/RefPtr.h>
#include <wtf/StdUnorderedMap.h>
#include <wtf/Variant.h>

namespace JSC { namespace Wasm {

Lines 31-37 a/Source/JavaScriptCore/wasm/WasmMachineThreads.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmMachineThreads.cpp -1 lines
31	#include "MachineStackMarker.h"	31	#include "MachineStackMarker.h"
32	#include <wtf/NeverDestroyed.h>	32	#include <wtf/NeverDestroyed.h>
33	#include <wtf/ThreadMessage.h>	33	#include <wtf/ThreadMessage.h>
34	#include <wtf/threads/Signals.h>
35		34
36	namespace JSC { namespace Wasm {	35	namespace JSC { namespace Wasm {
37		36



#include <wtf/DataLog.h>
#include <wtf/Gigacage.h>
#include <wtf/Lock.h>
#include <wtf/OSAllocator.h>
#include <wtf/PageBlock.h>
#include <wtf/Platform.h>
#include <wtf/PrintStream.h>
#include <wtf/RAMSize.h>




#if ENABLE(WEBASSEMBLY)

#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"
#include "WasmMemory.h"
#include <wtf/NeverDestroyed.h>

namespace JSC { namespace Wasm {

Lines 28-34 a/Source/JavaScriptCore/wasm/WasmModule.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmModule.cpp -1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "WasmBBQPlan.h"
32	#include "WasmLLIntPlan.h"	31	#include "WasmLLIntPlan.h"
33	#include "WasmModuleInformation.h"	32	#include "WasmModuleInformation.h"
34	#include "WasmWorklist.h"	33	#include "WasmWorklist.h"

Lines 29-35 a/Source/JavaScriptCore/wasm/WasmModuleInformation.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmModuleInformation.cpp -1 lines
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "WasmNameSection.h"	31	#include "WasmNameSection.h"
32	#include <wtf/SHA1.h>
33		32
34	namespace JSC { namespace Wasm {	33	namespace JSC { namespace Wasm {
35		34

Lines 28-34 a/Source/JavaScriptCore/wasm/WasmNameSectionParser.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmNameSectionParser.cpp -1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "IdentifierInlines.h"
32	#include "WasmNameSection.h"	31	#include "WasmNameSection.h"
33		32
34	namespace JSC { namespace Wasm {	33	namespace JSC { namespace Wasm {



#if ENABLE(WEBASSEMBLY)

#include "B3Compilation.h"
#include "B3OpaqueByproducts.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "WasmB3IRGenerator.h"
#include "WasmCallee.h"
#include "WasmContext.h"
#include "WasmInstance.h"
#include "WasmMachineThreads.h"
#include "WasmMemory.h"
#include "WasmNameSection.h"
#include "WasmSignatureInlines.h"
#include "WasmWorklist.h"
#include <wtf/DataLog.h>
#include <wtf/Locker.h>
#include <wtf/MonotonicTime.h>
#include <wtf/StdLibExtras.h>
#include <wtf/ThreadMessage.h>

namespace JSC { namespace Wasm {




#if ENABLE(WEBASSEMBLY)

#include "B3Compilation.h"
#include "B3OpaqueByproducts.h"
#include "JSCInlines.h"
#include "LinkBuffer.h"
#include "WasmB3IRGenerator.h"
#include "WasmCallee.h"
#include "WasmContext.h"
#include "WasmInstance.h"
#include "WasmMachineThreads.h"
#include "WasmMemory.h"
#include "WasmNameSection.h"
#include "WasmSignatureInlines.h"
#include "WasmWorklist.h"
#include <wtf/DataLog.h>
#include <wtf/Locker.h>
#include <wtf/MonotonicTime.h>
#include <wtf/StdLibExtras.h>
#include <wtf/ThreadMessage.h>

namespace JSC { namespace Wasm {




#include "WasmContextInlines.h"
#include "WasmInstance.h"
#include "WasmMemory.h"
#include "WasmNameSection.h"
#include "WasmOMGForOSREntryPlan.h"
#include "WasmOMGPlan.h"
#include "WasmOSREntryData.h"
#include "WasmSignatureInlines.h"
#include "WasmWorklist.h"
#include <wtf/DataLog.h>
#include <wtf/Locker.h>
#include <wtf/MonotonicTime.h>
#include <wtf/StdLibExtras.h>

IGNORE_WARNINGS_BEGIN("frame-address")




#if ENABLE(WEBASSEMBLY)

#include "B3Compilation.h"
#include "WasmB3IRGenerator.h"
#include "WasmBinding.h"
#include "WasmCallee.h"
#include "WasmCallingConvention.h"
#include "WasmCodeBlock.h"
#include "WasmFaultSignalHandler.h"
#include "WasmMachineThreads.h"
#include "WasmMemory.h"
#include <wtf/DataLog.h>
#include <wtf/Locker.h>
#include <wtf/MonotonicTime.h>
#include <wtf/StdLibExtras.h>
#include <wtf/SystemTracing.h>

namespace JSC { namespace Wasm {





#if ENABLE(WEBASSEMBLY)

#include "IdentifierInlines.h"
#include "JSCJSValueInlines.h"
#include "WasmMemoryInformation.h"
#include "WasmNameSectionParser.h"
#include "WasmOps.h"
#include "WasmSections.h"
#include "WasmSignatureInlines.h"
#include <wtf/Optional.h>




#if ENABLE(WEBASSEMBLY)

#include "BytecodeStructs.h"
#include "ExceptionFuzz.h"
#include "FrameTracers.h"
#include "LLIntData.h"
#include "WasmBBQPlan.h"
#include "WasmCallee.h"
#include "WasmCompilationMode.h"
#include "WasmContextInlines.h"
#include "WasmFunctionCodeBlock.h"
#include "WasmInstance.h"
#include "WasmModuleInformation.h"

#include "WasmOMGPlan.h"
#include "WasmOperations.h"
#include "WasmSignatureInlines.h"
#include "WasmThunks.h"
#include "WasmWorklist.h"

namespace JSC { namespace LLInt {

Lines 30-36 a/Source/JavaScriptCore/wasm/WasmStreamingParser.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmStreamingParser.cpp -1 lines
30		30
31	#include "WasmOps.h"	31	#include "WasmOps.h"
32	#include "WasmSectionParser.h"	32	#include "WasmSectionParser.h"
33	#include "WasmSignatureInlines.h"
34	#include <wtf/Optional.h>	33	#include <wtf/Optional.h>
35	#include <wtf/UnalignedAccess.h>	34	#include <wtf/UnalignedAccess.h>
36		35

Lines 30-36 a/Source/JavaScriptCore/wasm/WasmTable.cpp_sec1
- a/Source/JavaScriptCore/wasm/WasmTable.cpp -1 lines
30		30
31	#include "JSCJSValueInlines.h"	31	#include "JSCJSValueInlines.h"
32	#include <wtf/CheckedArithmetic.h>	32	#include <wtf/CheckedArithmetic.h>
33	#include <wtf/StdLibExtras.h>
34	#include <type_traits>	33	#include <type_traits>
35		34
36	namespace JSC { namespace Wasm {	35	namespace JSC { namespace Wasm {



#if ENABLE(WEBASSEMBLY)

#include "CCallHelpers.h"
#include "HeapCellInlines.h"
#include "JITExceptions.h"
#include "LinkBuffer.h"
#include "ScratchRegisterAllocator.h"
#include "WasmContext.h"
#include "WasmExceptionType.h"
#include "WasmInstance.h"
#include "WasmOperations.h"



#if ENABLE(WEBASSEMBLY)

#include "CCallHelpers.h"
#include "DisallowMacroScratchRegisterUsage.h"
#include "FrameTracers.h"
#include "JSCInlines.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyInstance.h"
#include "JSWebAssemblyRuntimeError.h"
#include "MaxFrameExtentForSlowPathCall.h"
#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"
#include "WasmOperations.h"
#include "WasmSignatureInlines.h"
#include "WasmToJS.h"

namespace JSC { namespace Wasm {

Lines 28-34 a/Source/JavaScriptCore/wasm/js/JSToWasmICCallee.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/JSToWasmICCallee.cpp -1 / +1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "JSCInlines.h"	31	#include "JSCellInlines.h"
32	#include "WebAssemblyFunction.h"	32	#include "WebAssemblyFunction.h"
33		33
34	namespace JSC {	34	namespace JSC {




#if ENABLE(WEBASSEMBLY)

#include "AuxiliaryBarrierInlines.h"
#include "CatchScope.h"
#include "Exception.h"
#include "FunctionPrototype.h"
#include "JSCBuiltins.h"
#include "JSCInlines.h"
#include "JSModuleNamespaceObject.h"
#include "JSPromise.h"
#include "JSToWasm.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyInstance.h"
#include "JSWebAssemblyModule.h"

#include "PromiseTimer.h"
#include "StrongInlines.h"
#include "ThrowScope.h"
#include "WasmBBQPlan.h"
#include "WasmOperations.h"
#include "WasmToJS.h"
#include "WasmWorklist.h"
#include "WebAssemblyInstanceConstructor.h"
#include "WebAssemblyModuleConstructor.h"

using JSC::Wasm::Plan;
using JSC::Wasm::BBQPlan;

namespace JSC {





#if ENABLE(WEBASSEMBLY)

#include "JSCellInlines.h"
#include "JSWebAssemblyLinkError.h"
#include "JSWebAssemblyMemory.h"
#include "WasmModuleInformation.h"
#include "WasmToJS.h"


namespace JSC {

const ClassInfo JSWebAssemblyCodeBlock::s_info = { "WebAssemblyCodeBlock", nullptr, nullptr, nullptr, CREATE_METHOD_TABLE(JSWebAssemblyCodeBlock) };

Lines 28-34 a/Source/JavaScriptCore/wasm/js/JSWebAssemblyCompileError.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/JSWebAssemblyCompileError.cpp -1 / +1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "JSCInlines.h"	31	#include "JSCellInlines.h"
32		32
33	namespace JSC {	33	namespace JSC {
34		34



#if ENABLE(WEBASSEMBLY)

#include "JSCInlines.h"
#include "JSWebAssemblyInstance.h"
#include <wtf/CheckedArithmetic.h>

namespace JSC {





#include "AbstractModuleRecord.h"
#include "JSCInlines.h"
#include "JSModuleEnvironment.h"
#include "JSModuleNamespaceObject.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyLinkError.h"
#include "JSWebAssemblyMemory.h"
#include "JSWebAssemblyModule.h"

Lines 28-34 a/Source/JavaScriptCore/wasm/js/JSWebAssemblyLinkError.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/JSWebAssemblyLinkError.cpp -1 / +1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "JSCInlines.h"	31	#include "JSCellInlines.h"
32		32
33	namespace JSC {	33	namespace JSC {
34		34



#include "JSCInlines.h"
#include "JSWebAssemblyCodeBlock.h"
#include "JSWebAssemblyCompileError.h"
#include "JSWebAssemblyMemory.h"
#include "WasmCallee.h"
#include "WasmFormat.h"
#include "WasmMemory.h"
#include "WasmModule.h"
#include "WasmModuleInformation.h"
#include <wtf/StdLibExtras.h>

namespace JSC {

Lines 28-34 a/Source/JavaScriptCore/wasm/js/JSWebAssemblyRuntimeError.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/JSWebAssemblyRuntimeError.cpp -1 / +1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "JSCInlines.h"	31	#include "JSCellInlines.h"
32		32
33	namespace JSC {	33	namespace JSC {
34		34

Lines 30-36 a/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/JSWebAssemblyTable.cpp -1 lines
30		30
31	#include "JSCInlines.h"	31	#include "JSCInlines.h"
32	#include "JSWebAssemblyInstance.h"	32	#include "JSWebAssemblyInstance.h"
33	#include <wtf/CheckedArithmetic.h>
34		33
35	namespace JSC {	34	namespace JSC {
36		35



#if ENABLE(WEBASSEMBLY)

#include "CCallHelpers.h"
#include "FrameTracers.h"
#include "IteratorOperations.h"
#include "JITExceptions.h"
#include "JSCInlines.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyInstance.h"
#include "JSWebAssemblyRuntimeError.h"
#include "LinkBuffer.h"
#include "NativeErrorConstructor.h"
#include "ThunkGenerators.h"
#include "WasmCallingConvention.h"
#include "WasmContextInlines.h"

#include "WasmInstance.h"
#include "WasmOperations.h"
#include "WasmSignatureInlines.h"

#include <wtf/FunctionTraits.h>


namespace JSC { namespace Wasm {

using JIT = CCallHelpers;




#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyCompileError.h"
#include "WebAssemblyCompileErrorPrototype.h"





#if ENABLE(WEBASSEMBLY)

#include "AuxiliaryBarrierInlines.h"
#include "JSCInlines.h"

#include "WebAssemblyCompileErrorPrototype.lut.h"





#if ENABLE(WEBASSEMBLY)

#include "JSCJSValueInlines.h"
#include "FrameTracers.h"
#include "JSCInlines.h"
#include "JSFunctionInlines.h"
#include "JSObject.h"
#include "JSToWasm.h"
#include "JSWebAssemblyHelpers.h"

#include "WasmMemoryInformation.h"
#include "WasmModuleInformation.h"
#include "WasmSignatureInlines.h"
#include <wtf/FastTLS.h>
#include <wtf/StackPointer.h>
#include <wtf/SystemTracing.h>


Lines 28-34 a/Source/JavaScriptCore/wasm/js/WebAssemblyFunctionBase.cpp_sec1
- a/Source/JavaScriptCore/wasm/js/WebAssemblyFunctionBase.cpp -1 lines
28		28
29	#if ENABLE(WEBASSEMBLY)	29	#if ENABLE(WEBASSEMBLY)
30		30
31	#include "JSCInlines.h"
32	#include "JSWebAssemblyInstance.h"	31	#include "JSWebAssemblyInstance.h"
33		32
34	namespace JSC {	33	namespace JSC {




#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyGlobal.h"
#include "JSWebAssemblyHelpers.h"
#include "WebAssemblyGlobalPrototype.h"

#include "WebAssemblyGlobalConstructor.lut.h"




#if ENABLE(WEBASSEMBLY)

#include "AuxiliaryBarrierInlines.h"
#include "GetterSetter.h"
#include "IntegrityInlines.h"
#include "JSCInlines.h"
#include "JSWebAssemblyGlobal.h"
#include "JSWebAssemblyHelpers.h"

namespace JSC {
static EncodedJSValue JSC_HOST_CALL webAssemblyGlobalProtoFuncValueOf(JSGlobalObject*, CallFrame*);




#if ENABLE(WEBASSEMBLY)

#include "JSCJSValueInlines.h"
#include "JSCInlines.h"
#include "JSModuleEnvironment.h"
#include "JSModuleNamespaceObject.h"
#include "JSToWasm.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyInstance.h"
#include "JSWebAssemblyLinkError.h"
#include "JSWebAssemblyMemory.h"
#include "JSWebAssemblyModule.h"
#include "WasmOperations.h"
#include "WasmPlan.h"
#include "WasmToJS.h"
#include "WasmWorklist.h"
#include "WebAssemblyFunction.h"
#include "WebAssemblyInstancePrototype.h"
#include "WebAssemblyModuleRecord.h"

#include "WebAssemblyInstanceConstructor.lut.h"





#if ENABLE(WEBASSEMBLY)

#include "AuxiliaryBarrierInlines.h"
#include "JSCInlines.h"
#include "JSModuleNamespaceObject.h"
#include "JSWebAssemblyInstance.h"





#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyLinkError.h"
#include "WebAssemblyLinkErrorPrototype.h"





#if ENABLE(WEBASSEMBLY)

#include "AuxiliaryBarrierInlines.h"
#include "JSCInlines.h"

#include "WebAssemblyLinkErrorPrototype.lut.h"





#if ENABLE(WEBASSEMBLY)

#include "JSGlobalObjectInlines.h"
#include "JSCInlines.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyMemory.h"
#include "WasmMemory.h"
#include "WasmPageCount.h"
#include "WebAssemblyMemoryPrototype.h"
#include <wtf/Optional.h>

#include "WebAssemblyMemoryConstructor.lut.h"





#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSArrayBuffer.h"
#include "JSCInlines.h"
#include "JSWebAssemblyMemory.h"
#include "JSWebAssemblyHelpers.h"




#if ENABLE(WEBASSEMBLY)

#include "ArrayBuffer.h"
#include "ExceptionHelpers.h"
#include "FunctionPrototype.h"
#include "JSArrayBuffer.h"
#include "JSGlobalObjectInlines.h"
#include "JSTypedArrays.h"
#include "JSWebAssemblyCompileError.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyModule.h"
#include "ObjectConstructor.h"
#include "SymbolTable.h"
#include "WasmCallee.h"
#include "WasmModuleInformation.h"
#include "WasmPlan.h"
#include "WebAssemblyModulePrototype.h"
#include <wtf/StdLibExtras.h>





#if ENABLE(WEBASSEMBLY)

#include "JSCInlines.h"

#include "WebAssemblyModulePrototype.lut.h"

namespace JSC {



#if ENABLE(WEBASSEMBLY)

#include "Error.h"
#include "JSCInlines.h"
#include "JSLexicalEnvironment.h"
#include "JSModuleEnvironment.h"
#include "JSObjectInlines.h"
#include "JSWebAssemblyGlobal.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyInstance.h"
#include "JSWebAssemblyLinkError.h"
#include "JSWebAssemblyModule.h"
#include "ProtoCallFrame.h"
#include "WasmSignatureInlines.h"
#include "WebAssemblyFunction.h"
#include <limits>

namespace JSC {





#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyRuntimeError.h"
#include "WebAssemblyRuntimeErrorPrototype.h"





#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"

#include "WebAssemblyRuntimeErrorPrototype.lut.h"

namespace JSC {




#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyTable.h"
#include "WebAssemblyTablePrototype.h"




#if ENABLE(WEBASSEMBLY)

#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyHelpers.h"
#include "JSWebAssemblyTable.h"





#if ENABLE(WEBASSEMBLY)

#include "JSObjectInlines.h"
#include "FunctionPrototype.h"
#include "JSCInlines.h"
#include "JSWebAssemblyInstance.h"
#include "WasmSignatureInlines.h"


Lines 35-41 a/Source/JavaScriptCore/yarr/YarrInterpreter.cpp_sec1
- a/Source/JavaScriptCore/yarr/YarrInterpreter.cpp -1 lines
35	#include <wtf/CheckedArithmetic.h>	35	#include <wtf/CheckedArithmetic.h>
36	#include <wtf/DataLog.h>	36	#include <wtf/DataLog.h>
37	#include <wtf/StackCheck.h>	37	#include <wtf/StackCheck.h>
38	#include <wtf/text/CString.h>
39	#include <wtf/text/WTFString.h>	38	#include <wtf/text/WTFString.h>
40		39
41	namespace JSC { namespace Yarr {	40	namespace JSC { namespace Yarr {

Lines 34-40 a/Source/JavaScriptCore/yarr/YarrPattern.cpp_sec1
- a/Source/JavaScriptCore/yarr/YarrPattern.cpp -1 lines
34	#include <wtf/DataLog.h>	34	#include <wtf/DataLog.h>
35	#include <wtf/Optional.h>	35	#include <wtf/Optional.h>
36	#include <wtf/StackCheck.h>	36	#include <wtf/StackCheck.h>
37	#include <wtf/Threading.h>
38	#include <wtf/Vector.h>	37	#include <wtf/Vector.h>
39		38
40	namespace JSC { namespace Yarr {	39	namespace JSC { namespace Yarr {

Return to Bug 211867

Lines 1-3 a/Source/JavaScriptCore/ChangeLog_sec1
- a/Source/JavaScriptCore/ChangeLog +32 lines
		1	2020-05-14 Ross Kirsling <ross.kirsling@sony.com>
		2
		3	[IWYU] Remove unnecessary includes from JSC implementation files
		4	https://bugs.webkit.org/show_bug.cgi?id=211867
		5
		6	Reviewed by NOBODY (OOPS!).
		7
		8	* API/:
		9	* assembler/:
		10	* b3/:
		11	* bindings/:
		12	* builtins/BuiltinExecutables.cpp:
		13	* bytecode/:
		14	* bytecompiler/:
		15	* debugger/:
		16	* dfg/:
		17	* disassembler/:
		18	* ftl/:
		19	* heap/:
		20	* inspector/:
		21	* interpreter/:
		22	* jit/:
		23	* jsc.cpp:
		24	* llint/:
		25	* parser/:
		26	* profiler/:
		27	* runtime/:
		28	* testRegExp.cpp:
		29	* tools/:
		30	* wasm/:
		31	* yarr/:
		32
1	2020-05-14 Keith Miller <keith_miller@apple.com>	33	2020-05-14 Keith Miller <keith_miller@apple.com>
2		34
3	GetArrayLength should be "blessed" during Fixup phase in the DFG	35	GetArrayLength should be "blessed" during Fixup phase in the DFG

Lines 23-30 a/Source/JavaScriptCore/API/JSAPIValueWrapper.cpp_sec1
- a/Source/JavaScriptCore/API/JSAPIValueWrapper.cpp -2 lines
23	#include "config.h"	23	#include "config.h"
24	#include "JSAPIValueWrapper.h"	24	#include "JSAPIValueWrapper.h"
25		25
26	#include "NumberObject.h"
27
28	namespace JSC {	26	namespace JSC {
29		27
30	STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSAPIValueWrapper);	28	STATIC_ASSERT_IS_TRIVIALLY_DESTRUCTIBLE(JSAPIValueWrapper);

Lines 29-48 a/Source/JavaScriptCore/API/JSBase.cpp_sec1
- a/Source/JavaScriptCore/API/JSBase.cpp -4 lines
29	#include "JSBasePrivate.h"	29	#include "JSBasePrivate.h"
30		30
31	#include "APICast.h"	31	#include "APICast.h"
32	#include "CallFrame.h"
33	#include "Completion.h"	32	#include "Completion.h"
34	#include "Exception.h"	33	#include "Exception.h"
35	#include "GCActivityCallback.h"	34	#include "GCActivityCallback.h"
36	#include "Identifier.h"	35	#include "Identifier.h"
37	#include "InitializeThreading.h"
38	#include "JSGlobalObject.h"	36	#include "JSGlobalObject.h"
39	#include "JSLock.h"	37	#include "JSLock.h"
40	#include "JSObject.h"	38	#include "JSObject.h"
41	#include "ObjectConstructor.h"	39	#include "ObjectConstructor.h"
42	#include "OpaqueJSString.h"	40	#include "OpaqueJSString.h"
43	#include "JSCInlines.h"
44	#include "SourceCode.h"	41	#include "SourceCode.h"
45	#include <wtf/text/StringHash.h>
46		42
47	#if ENABLE(REMOTE_INSPECTOR)	43	#if ENABLE(REMOTE_INSPECTOR)
48	#include "JSGlobalObjectInspectorController.h"	44	#include "JSGlobalObjectInspectorController.h"

Lines 27-41 a/Source/JavaScriptCore/API/JSCallbackFunction.cpp_sec1
- a/Source/JavaScriptCore/API/JSCallbackFunction.cpp -8 lines
27	#include "JSCallbackFunction.h"	27	#include "JSCallbackFunction.h"
28		28
29	#include "APICallbackFunction.h"	29	#include "APICallbackFunction.h"
30	#include "APICast.h"
31	#include "CodeBlock.h"
32	#include "Error.h"
33	#include "ExceptionHelpers.h"
34	#include "FunctionPrototype.h"
35	#include "JSFunction.h"
36	#include "JSGlobalObject.h"	30	#include "JSGlobalObject.h"
37	#include "JSLock.h"
38	#include "JSCInlines.h"
39		31
40	namespace JSC {	32	namespace JSC {
41		33

Lines 27-40 a/Source/JavaScriptCore/API/JSClassRef.cpp_sec1
- a/Source/JavaScriptCore/API/JSClassRef.cpp -5 lines
27	#include "JSClassRef.h"	27	#include "JSClassRef.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "Identifier.h"
31	#include "InitializeThreading.h"	30	#include "InitializeThreading.h"
32	#include "JSCallbackObject.h"	31	#include "JSCallbackObject.h"
33	#include "JSGlobalObject.h"	32	#include "JSGlobalObject.h"
34	#include "JSObjectRef.h"
35	#include "ObjectPrototype.h"
36	#include "JSCInlines.h"
37	#include <wtf/text/StringHash.h>
38		33
39	using namespace JSC;	34	using namespace JSC;
40		35

Lines 28-47 a/Source/JavaScriptCore/API/JSContextRef.cpp_sec1
- a/Source/JavaScriptCore/API/JSContextRef.cpp -4 / +1 lines
28	#include "JSContextRefInternal.h"	28	#include "JSContextRefInternal.h"
29		29
30	#include "APICast.h"	30	#include "APICast.h"
31	#include "APIUtils.h"
32	#include "CallFrame.h"	31	#include "CallFrame.h"
33	#include "InitializeThreading.h"	32	#include "InitializeThreading.h"
34	#include "JSAPIGlobalObject.h"	33	#include "JSAPIGlobalObject.h"
		34	#include "JSAPIWrapperObject.h"
35	#include "JSCallbackObject.h"	35	#include "JSCallbackObject.h"
36	#include "JSClassRef.h"	36	#include "JSClassRef.h"
37	#include "JSObject.h"	37	#include "JSObject.h"
38	#include "JSCInlines.h"
39	#include "SourceProvider.h"
40	#include "StackVisitor.h"	38	#include "StackVisitor.h"
41	#include "StrongInlines.h"	39	#include "StrongInlines.h"
42	#include "Watchdog.h"	40	#include "Watchdog.h"
43	#include <wtf/text/StringBuilder.h>	41	#include <wtf/text/StringBuilder.h>
44	#include <wtf/text/StringHash.h>
45		42
46	#if ENABLE(REMOTE_INSPECTOR)	43	#if ENABLE(REMOTE_INSPECTOR)
47	#include "JSGlobalObjectDebuggable.h"	44	#include "JSGlobalObjectDebuggable.h"

Lines 31-55 a/Source/JavaScriptCore/API/JSObjectRef.cpp_sec1
- a/Source/JavaScriptCore/API/JSObjectRef.cpp -8 lines
31	#include "APICast.h"	31	#include "APICast.h"
32	#include "APIUtils.h"	32	#include "APIUtils.h"
33	#include "DateConstructor.h"	33	#include "DateConstructor.h"
34	#include "ErrorConstructor.h"
35	#include "Exception.h"
36	#include "FunctionConstructor.h"	34	#include "FunctionConstructor.h"
37	#include "Identifier.h"	35	#include "Identifier.h"
38	#include "InitializeThreading.h"	36	#include "InitializeThreading.h"
39	#include "JSAPIWrapperObject.h"
40	#include "JSArray.h"	37	#include "JSArray.h"
41	#include "JSCInlines.h"	38	#include "JSCInlines.h"
42	#include "JSCallbackConstructor.h"	39	#include "JSCallbackConstructor.h"
43	#include "JSCallbackFunction.h"	40	#include "JSCallbackFunction.h"
44	#include "JSCallbackObject.h"	41	#include "JSCallbackObject.h"
45	#include "JSClassRef.h"	42	#include "JSClassRef.h"
46	#include "JSFunction.h"
47	#include "JSGlobalObject.h"
48	#include "JSObject.h"
49	#include "JSPromise.h"	43	#include "JSPromise.h"
50	#include "JSRetainPtr.h"
51	#include "JSString.h"	44	#include "JSString.h"
52	#include "JSValueRef.h"
53	#include "ObjectConstructor.h"	45	#include "ObjectConstructor.h"
54	#include "ObjectPrototype.h"	46	#include "ObjectPrototype.h"
55	#include "PropertyNameArray.h"	47	#include "PropertyNameArray.h"

Lines 28-38 a/Source/JavaScriptCore/API/JSScriptRef.cpp_sec1
- a/Source/JavaScriptCore/API/JSScriptRef.cpp -3 lines
28	#include "APICast.h"	28	#include "APICast.h"
29	#include "Completion.h"	29	#include "Completion.h"
30	#include "Exception.h"	30	#include "Exception.h"
31	#include "JSBasePrivate.h"
32	#include "VM.h"
33	#include "JSScriptRefPrivate.h"	31	#include "JSScriptRefPrivate.h"
34	#include "OpaqueJSString.h"	32	#include "OpaqueJSString.h"
35	#include "JSCInlines.h"
36	#include "Parser.h"	33	#include "Parser.h"
37	#include "SourceCode.h"	34	#include "SourceCode.h"
38	#include "SourceProvider.h"	35	#include "SourceProvider.h"

Lines 32-39 a/Source/JavaScriptCore/API/JSTypedArray.cpp_sec1
- a/Source/JavaScriptCore/API/JSTypedArray.cpp -2 lines
32	#include "ClassInfo.h"	32	#include "ClassInfo.h"
33	#include "Error.h"	33	#include "Error.h"
34	#include "JSArrayBufferViewInlines.h"	34	#include "JSArrayBufferViewInlines.h"
35	#include "JSCInlines.h"
36	#include "JSDataView.h"
37	#include "JSGenericTypedArrayViewInlines.h"	35	#include "JSGenericTypedArrayViewInlines.h"
38	#include "JSTypedArrays.h"	36	#include "JSTypedArrays.h"
39	#include "TypedArrayController.h"	37	#include "TypedArrayController.h"

Lines 29-48 a/Source/JavaScriptCore/API/JSValueRef.cpp_sec1
- a/Source/JavaScriptCore/API/JSValueRef.cpp -6 lines
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "APIUtils.h"	30	#include "APIUtils.h"
31	#include "DateInstance.h"	31	#include "DateInstance.h"
32	#include "Exception.h"
33	#include "JSAPIWrapperObject.h"
34	#include "JSCInlines.h"
35	#include "JSCJSValue.h"	32	#include "JSCJSValue.h"
36	#include "JSCallbackObject.h"	33	#include "JSCallbackObject.h"
37	#include "JSGlobalObject.h"	34	#include "JSGlobalObject.h"
38	#include "JSONObject.h"	35	#include "JSONObject.h"
39	#include "JSObjectRefPrivate.h"
40	#include "JSString.h"	36	#include "JSString.h"
41	#include "LiteralParser.h"	37	#include "LiteralParser.h"
42	#include "Protect.h"	38	#include "Protect.h"
43	#include <algorithm>
44	#include <wtf/Assertions.h>	39	#include <wtf/Assertions.h>
45	#include <wtf/text/StringHash.h>
46	#include <wtf/text/WTFString.h>	40	#include <wtf/text/WTFString.h>
47		41
48	#if PLATFORM(MAC)	42	#if PLATFORM(MAC)

Lines 27-37 a/Source/JavaScriptCore/API/JSWeakObjectMapRefPrivate.cpp_sec1
- a/Source/JavaScriptCore/API/JSWeakObjectMapRefPrivate.cpp -3 lines
27	#include "JSWeakObjectMapRefPrivate.h"	27	#include "JSWeakObjectMapRefPrivate.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "JSCJSValue.h"
31	#include "JSCallbackObject.h"	30	#include "JSCallbackObject.h"
32	#include "JSWeakObjectMapRefInternal.h"	31	#include "JSWeakObjectMapRefInternal.h"
33	#include "JSCInlines.h"
34	#include "Weak.h"
35	#include "WeakGCMapInlines.h"	32	#include "WeakGCMapInlines.h"
36		33
37	using namespace JSC;	34	using namespace JSC;

Lines 27-34 a/Source/JavaScriptCore/API/JSWeakValue.cpp_sec1
- a/Source/JavaScriptCore/API/JSWeakValue.cpp -2 / +1 lines
27	#include "config.h"	27	#include "config.h"
28	#include "JSWeakValue.h"	28	#include "JSWeakValue.h"
29		29
30	#include "JSCInlines.h"	30	#include "JSCellInlines.h"
31	#include "WeakHandleOwner.h"
32		31
33	namespace JSC {	32	namespace JSC {
34		33

Lines 26-34 a/Source/JavaScriptCore/API/MarkedJSValueRefArray.cpp_sec1
- a/Source/JavaScriptCore/API/MarkedJSValueRefArray.cpp -2 lines
26	#include "config.h"	26	#include "config.h"
27	#include "MarkedJSValueRefArray.h"	27	#include "MarkedJSValueRefArray.h"
28		28
29	#include "JSCInlines.h"
30	#include "JSCJSValue.h"	29	#include "JSCJSValue.h"
31	#include "JSObject.h"
32		30
33	namespace JSC {	31	namespace JSC {
34		32

Lines 26-35 a/Source/JavaScriptCore/API/OpaqueJSString.cpp_sec1
- a/Source/JavaScriptCore/API/OpaqueJSString.cpp -2 lines
26	#include "config.h"	26	#include "config.h"
27	#include "OpaqueJSString.h"	27	#include "OpaqueJSString.h"
28		28
29	#include "CallFrame.h"
30	#include "Identifier.h"	29	#include "Identifier.h"
31	#include "IdentifierInlines.h"	30	#include "IdentifierInlines.h"
32	#include "JSGlobalObject.h"
33	#include <wtf/text/StringView.h>	31	#include <wtf/text/StringView.h>
34		32
35	using namespace JSC;	33	using namespace JSC;

Lines 30-37 a/Source/JavaScriptCore/API/tests/ExecutionTimeLimitTest.cpp_sec1
- a/Source/JavaScriptCore/API/tests/ExecutionTimeLimitTest.cpp -2 lines
30	#include "JSContextRefPrivate.h"	30	#include "JSContextRefPrivate.h"
31	#include "JavaScript.h"	31	#include "JavaScript.h"
32	#include "Options.h"	32	#include "Options.h"
33
34	#include <wtf/Atomics.h>
35	#include <wtf/CPUTime.h>	33	#include <wtf/CPUTime.h>
36	#include <wtf/Condition.h>	34	#include <wtf/Condition.h>
37	#include <wtf/Lock.h>	35	#include <wtf/Lock.h>

Lines 28-37 a/Source/JavaScriptCore/API/tests/FunctionOverridesTest.cpp_sec1
- a/Source/JavaScriptCore/API/tests/FunctionOverridesTest.cpp -2 lines
28		28
29	#include "FunctionOverrides.h"	29	#include "FunctionOverrides.h"
30	#include "InitializeThreading.h"	30	#include "InitializeThreading.h"
31	#include "JSContextRefPrivate.h"
32	#include "JavaScript.h"	31	#include "JavaScript.h"
33	#include "Options.h"	32	#include "Options.h"
34	#include <string>
35		33
36	using JSC::Options;	34	using JSC::Options;
37		35

Lines 25-32 a/Source/JavaScriptCore/API/tests/GlobalContextWithFinalizerTest.h_sec1
- a/Source/JavaScriptCore/API/tests/GlobalContextWithFinalizerTest.h -2 lines
25		25
26	#pragma once	26	#pragma once
27		27
28	#include "JSContextRefPrivate.h"
29
30	#ifdef __cplusplus	28	#ifdef __cplusplus
31	extern "C" {	29	extern "C" {
32	#endif	30	#endif

Lines 27-38 a/Source/JavaScriptCore/API/tests/JSObjectGetProxyTargetTest.cpp_sec1
- a/Source/JavaScriptCore/API/tests/JSObjectGetProxyTargetTest.cpp -2 lines
27	#include "JSObjectGetProxyTargetTest.h"	27	#include "JSObjectGetProxyTargetTest.h"
28		28
29	#include "APICast.h"	29	#include "APICast.h"
30	#include "InitializeThreading.h"
31	#include "JSCInlines.h"	30	#include "JSCInlines.h"
32	#include "JSObjectRefPrivate.h"	31	#include "JSObjectRefPrivate.h"
33	#include "JSProxy.h"	32	#include "JSProxy.h"
34	#include "JavaScript.h"	33	#include "JavaScript.h"
35	#include "Options.h"
36	#include "ProxyObject.h"	34	#include "ProxyObject.h"
37		35
38	using namespace JSC;	36	using namespace JSC;

Lines 27-35 a/Source/JavaScriptCore/API/tests/MultithreadedMultiVMExecutionTest.cpp_sec1
- a/Source/JavaScriptCore/API/tests/MultithreadedMultiVMExecutionTest.cpp -2 lines
27	#include "MultithreadedMultiVMExecutionTest.h"	27	#include "MultithreadedMultiVMExecutionTest.h"
28		28
29	#include "InitializeThreading.h"	29	#include "InitializeThreading.h"
30	#include "JSContextRefPrivate.h"
31	#include "JavaScript.h"	30	#include "JavaScript.h"
32	#include "Options.h"
33	#include <mutex>	31	#include <mutex>
34	#include <string>	32	#include <string>
35	#include <thread>	33	#include <thread>

Lines 26-33 a/Source/JavaScriptCore/assembler/AssemblerBuffer.cpp_sec1
- a/Source/JavaScriptCore/assembler/AssemblerBuffer.cpp -2 lines
26	#include "config.h"	26	#include "config.h"
27	#include "AssemblerBuffer.h"	27	#include "AssemblerBuffer.h"
28		28
29	#include <wtf/NeverDestroyed.h>
30
31	namespace JSC {	29	namespace JSC {
32		30
33	DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(AssemblerData);	31	DEFINE_ALLOCATOR_WITH_HEAP_IDENTIFIER(AssemblerData);

Lines 31-40 a/Source/JavaScriptCore/assembler/LinkBuffer.cpp_sec1
- a/Source/JavaScriptCore/assembler/LinkBuffer.cpp -2 lines
31	#include "CodeBlock.h"	31	#include "CodeBlock.h"
32	#include "Disassembler.h"	32	#include "Disassembler.h"
33	#include "JITCode.h"	33	#include "JITCode.h"
34	#include "JSCInlines.h"
35	#include "Options.h"	34	#include "Options.h"
36	#include "WasmCompilationMode.h"	35	#include "WasmCompilationMode.h"
37	#include <wtf/CompilationThread.h>
38		36
39	#if OS(LINUX)	37	#if OS(LINUX)
40	#include "PerfLog.h"	38	#include "PerfLog.h"

Lines 27-35 a/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.cpp_sec1
- a/Source/JavaScriptCore/assembler/MacroAssemblerCodeRef.cpp -2 / +1 lines
27	#include "MacroAssemblerCodeRef.h"	27	#include "MacroAssemblerCodeRef.h"
28		28
29	#include "Disassembler.h"	29	#include "Disassembler.h"
30	#include "JSCInlines.h"
31	#include "JSCPtrTag.h"	30	#include "JSCPtrTag.h"
32	#include <mutex>	31	#include <wtf/StringPrintStream.h>
33		32
34	namespace JSC {	33	namespace JSC {
35		34

Lines 28-38 a/Source/JavaScriptCore/b3/B3BlockInsertionSet.cpp_sec1
- a/Source/JavaScriptCore/b3/B3BlockInsertionSet.cpp -2 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"
32	#include "B3InsertionSet.h"	31	#include "B3InsertionSet.h"
33	#include "B3ProcedureInlines.h"	32	#include "B3ProcedureInlines.h"
34	#include "B3ValueInlines.h"	33	#include "B3ValueInlines.h"
35	#include <wtf/BubbleSort.h>
36		34
37	namespace JSC { namespace B3 {	35	namespace JSC { namespace B3 {
38		36

Lines 29-39 a/Source/JavaScriptCore/b3/B3Compile.cpp_sec1
- a/Source/JavaScriptCore/b3/B3Compile.cpp -2 lines
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3Generate.h"	31	#include "B3Generate.h"
32	#include "B3OpaqueByproducts.h"
33	#include "B3Procedure.h"	32	#include "B3Procedure.h"
34	#include "B3TimingScope.h"	33	#include "B3TimingScope.h"
35	#include "CCallHelpers.h"	34	#include "CCallHelpers.h"
36	#include "JSCInlines.h"
37	#include "LinkBuffer.h"	35	#include "LinkBuffer.h"
38		36
39	namespace JSC { namespace B3 {	37	namespace JSC { namespace B3 {

Lines 28-43 a/Source/JavaScriptCore/b3/B3DuplicateTails.cpp_sec1
- a/Source/JavaScriptCore/b3/B3DuplicateTails.cpp -7 / +3 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlock.h"
32	#include "B3BreakCriticalEdges.h"	32	#include "B3BreakCriticalEdges.h"
33	#include "B3Dominators.h"
34	#include "B3FixSSA.h"	33	#include "B3FixSSA.h"
35	#include "B3InsertionSetInlines.h"	34	#include "B3InsertionSet.h"
36	#include "B3PhaseScope.h"	35	#include "B3PhaseScope.h"
37	#include "B3ProcedureInlines.h"	36	#include "B3Procedure.h"
38	#include "B3SwitchValue.h"
39	#include "B3UpsilonValue.h"
40	#include "B3ValueInlines.h"
41	#include <wtf/IndexSet.h>	37	#include <wtf/IndexSet.h>
42		38
43	namespace JSC { namespace B3 {	39	namespace JSC { namespace B3 {

Lines 28-34 a/Source/JavaScriptCore/b3/B3EliminateCommonSubexpressions.cpp_sec1
- a/Source/JavaScriptCore/b3/B3EliminateCommonSubexpressions.cpp -5 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"
32	#include "B3BlockWorklist.h"	31	#include "B3BlockWorklist.h"
33	#include "B3Dominators.h"	32	#include "B3Dominators.h"
34	#include "B3HeapRange.h"	33	#include "B3HeapRange.h"
Lines 37-47 a/Source/JavaScriptCore/b3/B3EliminateCommonSubexpressions.cpp_sec2
37	#include "B3PhaseScope.h"	36	#include "B3PhaseScope.h"
38	#include "B3ProcedureInlines.h"	37	#include "B3ProcedureInlines.h"
39	#include "B3PureCSE.h"	38	#include "B3PureCSE.h"
40	#include "B3SlotBaseValue.h"
41	#include "B3StackSlot.h"
42	#include "B3ValueKey.h"
43	#include "B3ValueInlines.h"	39	#include "B3ValueInlines.h"
44	#include "B3Variable.h"
45	#include "B3VariableValue.h"	40	#include "B3VariableValue.h"
46	#include <wtf/CommaPrinter.h>	41	#include <wtf/CommaPrinter.h>
47	#include <wtf/HashMap.h>	42	#include <wtf/HashMap.h>

Lines 31-38 a/Source/JavaScriptCore/b3/B3EnsureLoopPreHeaders.cpp_sec1
- a/Source/JavaScriptCore/b3/B3EnsureLoopPreHeaders.cpp -2 lines
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3BlockInsertionSet.h"	32	#include "B3BlockInsertionSet.h"
33	#include "B3NaturalLoops.h"	33	#include "B3NaturalLoops.h"
34	#include "B3ProcedureInlines.h"
35	#include "B3ValueInlines.h"
36		34
37	namespace JSC { namespace B3 {	35	namespace JSC { namespace B3 {
38		36

Lines 28-36 a/Source/JavaScriptCore/b3/B3FixSSA.cpp_sec1
- a/Source/JavaScriptCore/b3/B3FixSSA.cpp -2 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "B3BasicBlockInlines.h"
32	#include "B3BreakCriticalEdges.h"	31	#include "B3BreakCriticalEdges.h"
33	#include "B3Dominators.h"
34	#include "B3InsertionSetInlines.h"	32	#include "B3InsertionSetInlines.h"
35	#include "B3PhaseScope.h"	33	#include "B3PhaseScope.h"
36	#include "B3ProcedureInlines.h"	34	#include "B3ProcedureInlines.h"

Lines 31-39 a/Source/JavaScriptCore/b3/B3FoldPathConstants.cpp_sec1
- a/Source/JavaScriptCore/b3/B3FoldPathConstants.cpp -2 / +1 lines
31	#include "B3BasicBlockInlines.h"	31	#include "B3BasicBlockInlines.h"
32	#include "B3CaseCollectionInlines.h"	32	#include "B3CaseCollectionInlines.h"
33	#include "B3Dominators.h"	33	#include "B3Dominators.h"
34	#include "B3InsertionSetInlines.h"	34	#include "B3InsertionSet.h"
35	#include "B3PhaseScope.h"	35	#include "B3PhaseScope.h"
36	#include "B3ProcedureInlines.h"
37	#include "B3SwitchValue.h"	36	#include "B3SwitchValue.h"
38	#include "B3ValueInlines.h"	37	#include "B3ValueInlines.h"
39		38

Lines 28-36 a/Source/JavaScriptCore/b3/B3Generate.cpp_sec1
- a/Source/JavaScriptCore/b3/B3Generate.cpp -4 lines
28		28
29	#if ENABLE(B3_JIT)	29	#if ENABLE(B3_JIT)
30		30
31	#include "AirCode.h"
32	#include "AirGenerate.h"	31	#include "AirGenerate.h"
33	#include "AirInstInlines.h"
34	#include "B3Common.h"	32	#include "B3Common.h"
35	#include "B3DuplicateTails.h"	33	#include "B3DuplicateTails.h"
36	#include "B3EliminateCommonSubexpressions.h"	34	#include "B3EliminateCommonSubexpressions.h"
Lines 46-58 a/Source/JavaScriptCore/b3/B3Generate.cpp_sec2
46	#include "B3MoveConstants.h"	44	#include "B3MoveConstants.h"
47	#include "B3OptimizeAssociativeExpressionTrees.h"	45	#include "B3OptimizeAssociativeExpressionTrees.h"
48	#include "B3Procedure.h"	46	#include "B3Procedure.h"
49	#include "B3PureCSE.h"
50	#include "B3ReduceDoubleToFloat.h"	47	#include "B3ReduceDoubleToFloat.h"
51	#include "B3ReduceLoopStrength.h"	48	#include "B3ReduceLoopStrength.h"
52	#include "B3ReduceStrength.h"	49	#include "B3ReduceStrength.h"
53	#include "B3TimingScope.h"	50	#include "B3TimingScope.h"
54	#include "B3Validate.h"	51	#include "B3Validate.h"
55	#include "PCToCodeOriginMap.h"
56		52
57	namespace JSC { namespace B3 {	53	namespace JSC { namespace B3 {
58		54