Repository navigation
Expand file tree
/
Copy pathDFGClobberize.h
More file actions
2858 lines (2551 loc) · 93.1 KB
/
Copy pathDFGClobberize.h
File metadata and controls
2858 lines (2551 loc) · 93.1 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright (C) 2013-2021 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#if ENABLE(DFG_JIT)
#include "DFGAbstractHeap.h"
#include "DFGGraph.h"
#include "DFGHeapLocation.h"
#include "DFGLazyNode.h"
#include "DFGPureValue.h"
#include "DOMJITCallDOMGetterSnippet.h"
#include "DOMJITSignature.h"
#include "InlineCallFrame.h"
#include "JSCellButterfly.h"
namespace JSC { namespace DFG {
// The independently cached pieces of a Date, used to keep their heap locations apart.
enum class DateField : int64_t {
LocalBreakdown,
UTCBreakdown,
TimeValue,
Milliseconds,
};
template<typename ReadFunctor, typename WriteFunctor, typename DefFunctor>
void clobberize(Graph& graph, Node* node, NOESCAPE const ReadFunctor& read, NOESCAPE const WriteFunctor& write, NOESCAPE const DefFunctor& def)
{
clobberize(graph, node, read, write, def, [] { });
}
template<typename ReadFunctor, typename WriteFunctor, typename DefFunctor, typename ClobberTopFunctor>
void clobberize(Graph& graph, Node* node, NOESCAPE const ReadFunctor& read, NOESCAPE const WriteFunctor& write, NOESCAPE const DefFunctor& def, NOESCAPE const ClobberTopFunctor& clobberTopFunctor)
{
// Some notes:
//
// - The canonical way of clobbering the world is to read world and write
// heap. This is because World subsumes Heap and Stack, and Stack can be
// read by anyone but only written to by explicit stack writing operations.
// Of course, claiming to also write World is not wrong; it'll just
// pessimise some important optimizations.
//
// - We cannot hoist, or sink, anything that has effects. This means that the
// easiest way of indicating that something cannot be hoisted is to claim
// that it side-effects some miscellaneous thing.
//
// - Some nodes lie, and claim that they do not read the JSCell_structureID,
// JSCell_typeInfoFlags, etc. These are nodes that use the structure in a way
// that does not depend on things that change under structure transitions.
//
// - It's implicitly understood that OSR exits read the world. This is why we
// generally don't move or eliminate stores. Every node can exit, so the
// read set does not reflect things that would be read if we exited.
// Instead, the read set reflects what the node will have to read if it
// *doesn't* exit.
//
// - Broadly, we don't say that we're reading something if that something is
// immutable.
//
// - This must be sound even prior to type inference. We use this as early as
// bytecode parsing to determine at which points in the program it's legal to
// OSR exit.
//
// - If you do read(Stack) or read(World), then make sure that readTop() in
// PreciseLocalClobberize is correct.
// While read() and write() are fairly self-explanatory - they track what sorts of things the
// node may read or write - the def() functor is more tricky. It tells you the heap locations
// (not just abstract heaps) that are defined by a node. A heap location comprises an abstract
// heap, some nodes, and a LocationKind. Briefly, a location defined by a node is a location
// whose value can be deduced from looking at the node itself. The locations returned must obey
// the following properties:
//
// - If someone wants to CSE a load from the heap, then a HeapLocation object should be
// sufficient to find a single matching node.
//
// - The abstract heap is the only abstract heap that could be clobbered to invalidate any such
// CSE attempt. I.e. if clobberize() reports that on every path between some node and a node
// that defines a HeapLocation that it wanted, there were no writes to any abstract heap that
// overlap the location's heap, then we have a sound match. Effectively, the semantics of
// write() and def() are intertwined such that for them to be sound they must agree on what
// is CSEable.
//
// read(), write(), and def() for heap locations is enough to do GCSE on effectful things. To
// keep things simple, this code will also def() pure things. def() must be overloaded to also
// accept PureValue. This way, a client of clobberize() can implement GCSE entirely using the
// information that clobberize() passes to write() and def(). Other clients of clobberize() can
// just ignore def() by using a NoOpClobberize functor.
// We allow the runtime to perform a stack scan at any time. We don't model which nodes get implemented
// by calls into the runtime. For debugging we might replace the implementation of any node with a call
// to the runtime, and that call may walk stack. Therefore, each node must read() anything that a stack
// scan would read. That's what this does.
for (InlineCallFrame* inlineCallFrame = node->origin.semantic.inlineCallFrame(); inlineCallFrame; inlineCallFrame = inlineCallFrame->directCaller.inlineCallFrame()) {
if (inlineCallFrame->isClosureCall)
read(AbstractHeap(Stack, VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::callee)));
if (inlineCallFrame->isVarargs())
read(AbstractHeap(Stack, VirtualRegister(inlineCallFrame->stackOffset + CallFrameSlot::argumentCountIncludingThis)));
}
// We don't want to specifically account which nodes can read from the scope
// when the debugger is enabled. It's helpful to just claim all nodes do.
// Specifically, if a node allocates, this may call into the debugger's machinery.
// The debugger's machinery is free to take a stack trace and try to read from
// a scope which is expected to be flushed to the stack.
if (graph.hasDebuggerEnabled()) {
ASSERT(!node->origin.semantic.inlineCallFrame());
read(AbstractHeap(Stack, graph.m_codeBlock->scopeRegister()));
}
auto clobberTop = [&] {
if (Options::validateDFGClobberize())
clobberTopFunctor();
read(World);
write(Heap);
};
// Since Fixup can widen our ArrayModes based on profiling from other nodes we pessimistically assume
// all nodes with an ArrayMode can clobber top. We allow some nodes like CheckArray because they can
// only exit.
if (graph.m_planStage < PlanStage::AfterFixup && node->hasArrayMode()) {
switch (node->op()) {
case CheckArray:
case CheckArrayOrEmpty:
break;
case EnumeratorNextUpdateIndexAndMode:
case EnumeratorGetByVal:
case EnumeratorPutByVal:
case EnumeratorInByVal:
case EnumeratorHasOwnProperty:
case GetIndexedPropertyStorage:
case DataViewGetByteLength:
case DataViewGetByteLengthAsInt52:
case GetArrayLength:
case GetUndetachedTypeArrayLength:
case GetTypedArrayLengthAsInt52:
case GetTypedArrayByteOffset:
case GetTypedArrayByteOffsetAsInt52:
case GetVectorLength:
case InByVal:
case InByValMegamorphic:
case PutByValDirect:
case PutByVal:
case PutByValDirectResolved:
case PutByValMegamorphic:
case GetByVal:
case GetByValMegamorphic:
case MultiGetByVal:
case MultiPutByVal:
case StringAt:
case StringCharAt:
case StringCharCodeAt:
case StringCodePointAt:
case Arrayify:
case ArrayifyToStructure:
case ArrayPush:
case ArrayPop:
case ArrayShift:
case ArrayUnshift:
case ArrayIncludes:
case ArrayIndexOf:
case ArrayJoin:
case HasIndexedProperty:
case AtomicsAdd:
case AtomicsAnd:
case AtomicsCompareExchange:
case AtomicsExchange:
case AtomicsLoad:
case AtomicsOr:
case AtomicsStore:
case AtomicsSub:
case AtomicsXor:
case NewArrayWithSpecies:
case ArraySortCompact:
case ArraySortCommit:
case GetCellButterflySlot:
return clobberTop();
default:
DFG_CRASH(graph, node, "Unhandled ArrayMode opcode."_s);
}
}
switch (node->op()) {
case JSConstant:
case DoubleConstant:
case Int52Constant:
def(PureValue(node, node->constant()));
return;
case Identity:
case IdentityWithProfile:
case Phantom:
case Check:
case CheckVarargs:
case ExtractOSREntryLocal:
case CheckStructureImmediate:
return;
case ExtractCatchLocal:
read(AbstractHeap(CatchLocals, node->catchOSREntryIndex()));
return;
case ClearCatchLocals:
write(CatchLocals);
return;
case LazyJSConstant:
// We should enable CSE of LazyJSConstant. It's a little annoying since LazyJSValue has
// more bits than we currently have in PureValue.
return;
case CompareEqPtr:
def(PureValue(node, node->cellOperand()->cell()));
return;
case UnwrapGlobalProxy:
read(JSGlobalProxy_target);
def(HeapLocation(GlobalProxyTargetLoc, JSGlobalProxy_target, node->child1()), LazyNode(node));
return;
case ArithIMul:
case ArithPow:
case GetScope:
case SkipScope:
case GetGlobalObject:
case StringCharCodeAt:
case StringCodePointAt:
case StringIndexOf:
case StringLastIndexOf:
case StringStartsWith:
case StringEndsWith:
case CompareStrictEq:
case SameValue:
case IsEmpty:
case IsEmptyStorage:
case IsUndefinedOrNull:
case IsBoolean:
case IsNumber:
case IsBigInt:
case NumberIsInteger:
case IsObject:
case CheckInBounds:
case CheckInBoundsInt52:
case DoubleRep:
case PurifyNaN:
case ValueRep:
case Int52Rep:
case BooleanToNumber:
case FiatInt52:
case MakeRope:
case MakeAtomString:
case StrCat:
case ValueToInt32:
case GetExecutable:
case BottomValue:
case SymbolToString:
def(PureValue(node));
return;
// These nodes are realm-dependent when MasqueradesAsUndefined is involved.
// Including the globalObject in the PureValue ensures nodes from different realms are not folded by CSE.
case TypeOfIsUndefined:
case ToBoolean:
case LogicalNot:
case TypeOf:
def(PureValue(node, graph.globalObjectFor(node->origin.semantic)));
return;
// JSCallee for Eval can change the scope field.
case GetEvalScope:
read(World);
return;
case NumberIsFinite:
case NumberIsNaN:
case NumberIsSafeInteger:
def(PureValue(node));
return;
case GlobalIsFinite:
case GlobalIsNaN:
ASSERT(node->child1().useKind() == UntypedUse);
clobberTop();
return;
case StringLocaleCompare:
read(World);
write(SideState);
def(PureValue(node));
return;
case ArithMin:
case ArithMax:
def(PureValue(graph, node));
return;
case GetGlobalThis:
read(World);
return;
case AtomicsIsLockFree:
if (graph.child(node, 0).useKind() == Int32Use)
def(PureValue(graph, node));
else
clobberTop();
return;
case ArithUnary:
if (node->child1().useKind() == DoubleRepUse)
def(PureValue(node, static_cast<std::underlying_type<Arith::UnaryType>::type>(node->arithUnaryType())));
else
clobberTop();
return;
case ArithFRound:
case ArithF16Round:
case ArithSqrt:
if (node->child1().useKind() == DoubleRepUse)
def(PureValue(node));
else
clobberTop();
return;
case ArithAbs:
if (node->child1().useKind() == Int32Use || node->child1().useKind() == DoubleRepUse)
def(PureValue(node, node->arithMode()));
else
clobberTop();
return;
case ArithClz32:
if (node->child1().useKind() == Int32Use || node->child1().useKind() == KnownInt32Use)
def(PureValue(node));
else
clobberTop();
return;
case ArithNegate:
if (node->child1().useKind() == Int32Use
|| node->child1().useKind() == DoubleRepUse
|| node->child1().useKind() == Int52RepUse)
def(PureValue(node, node->arithMode()));
else
clobberTop();
return;
case IsCellWithType:
def(PureValue(node, node->queriedType().rawValue()));
return;
case ValueBitNot:
if (node->child1().useKind() == AnyBigIntUse || node->child1().useKind() == BigInt32Use || node->child1().useKind() == HeapBigIntUse) {
def(PureValue(node));
return;
}
clobberTop();
return;
case ArithBitNot:
if (node->child1().useKind() == UntypedUse) {
clobberTop();
return;
}
def(PureValue(node));
return;
case ArithBitAnd:
case ArithBitOr:
case ArithBitXor:
case ArithBitLShift:
case ArithBitRShift:
case ArithBitURShift:
if (node->child1().useKind() == UntypedUse || node->child2().useKind() == UntypedUse) {
clobberTop();
return;
}
def(PureValue(node));
return;
case ArithRandom:
read(MathDotRandomState);
write(MathDotRandomState);
return;
case DateNow:
read(WallClock);
write(WallClock);
return;
case EnumeratorNextUpdatePropertyName: {
def(PureValue(node, node->enumeratorMetadata().toRaw()));
return;
}
case ExtractFromTuple: {
def(PureValue(node, node->extractOffset()));
return;
}
case EnumeratorNextUpdateIndexAndMode:
case HasIndexedProperty: {
if (node->op() == EnumeratorNextUpdateIndexAndMode) {
if (node->enumeratorMetadata() == JSPropertyNameEnumerator::OwnStructureMode && graph.varArgChild(node, 0).useKind() == CellUse) {
read(JSObject_butterfly);
read(NamedProperties);
read(JSCell_structureID);
return;
}
if (node->enumeratorMetadata() != JSPropertyNameEnumerator::IndexedMode) {
clobberTop();
return;
}
}
read(JSObject_butterfly);
ArrayMode mode = node->arrayMode();
LocationKind locationKind = node->op() == EnumeratorNextUpdateIndexAndMode ? EnumeratorNextUpdateIndexAndModeLoc : HasIndexedPropertyLoc;
switch (mode.type()) {
case Array::ForceExit: {
write(SideState);
return;
}
case Array::Int32: {
if (mode.isInBounds()) {
read(Butterfly_publicLength);
read(IndexedInt32Properties);
def(HeapLocation(locationKind, IndexedInt32Properties, graph.varArgChild(node, 0), graph.varArgChild(node, 1)), LazyNode(node));
return;
}
break;
}
case Array::Double: {
if (mode.isInBounds()) {
read(Butterfly_publicLength);
read(IndexedDoubleProperties);
def(HeapLocation(locationKind, IndexedDoubleProperties, graph.varArgChild(node, 0), graph.varArgChild(node, 1)), LazyNode(node));
return;
}
break;
}
case Array::Contiguous: {
if (mode.isInBounds()) {
read(Butterfly_publicLength);
read(IndexedContiguousProperties);
def(HeapLocation(locationKind, IndexedContiguousProperties, graph.varArgChild(node, 0), graph.varArgChild(node, 1)), LazyNode(node));
return;
}
break;
}
case Array::ArrayStorage: {
if (mode.isInBounds()) {
read(Butterfly_vectorLength);
read(IndexedArrayStorageProperties);
return;
}
break;
}
default:
break;
}
clobberTop();
return;
}
case StringFromCharCode:
switch (node->child1().useKind()) {
case Int32Use:
case KnownInt32Use:
def(PureValue(node));
return;
case UntypedUse:
clobberTop();
return;
default:
DFG_CRASH(graph, node, "Bad use kind"_s);
}
return;
case StringFromCodePoint:
switch (node->child1().useKind()) {
case Int32Use:
case KnownInt32Use:
// Can throw a RangeError for an out-of-range code point, so this is not pure.
read(World);
write(SideState);
def(PureValue(node));
return;
case UntypedUse:
clobberTop();
return;
default:
DFG_CRASH(graph, node, "Bad use kind"_s);
}
return;
case ArithAdd:
case DoubleAsInt32:
case UInt32ToNumber:
def(PureValue(node, node->arithMode()));
return;
case ArithDiv:
case ArithMod:
case ArithMul:
case ArithSub:
switch (node->binaryUseKind()) {
case Int32Use:
case Int52RepUse:
case DoubleRepUse:
def(PureValue(node, node->arithMode()));
return;
case UntypedUse:
clobberTop();
return;
default:
DFG_CRASH(graph, node, "Bad use kind"_s);
}
case ArithRound:
case ArithFloor:
case ArithCeil:
case ArithTrunc:
if (node->child1().useKind() == DoubleRepUse)
def(PureValue(node, static_cast<uintptr_t>(node->arithRoundingMode())));
else
clobberTop();
return;
case CheckIsConstant:
def(PureValue(CheckIsConstant, AdjacencyList(AdjacencyList::Fixed, node->child1()), node->constant()));
return;
case CheckNotEmpty:
def(PureValue(CheckNotEmpty, AdjacencyList(AdjacencyList::Fixed, node->child1())));
return;
case AssertInBounds:
case AssertNotEmpty:
write(SideState);
return;
case CheckIdent:
def(PureValue(CheckIdent, AdjacencyList(AdjacencyList::Fixed, node->child1()), node->uidOperand()));
return;
case ConstantStoragePointer:
def(PureValue(node, node->storagePointer()));
return;
case KillStack:
write(AbstractHeap(Stack, node->unlinkedOperand()));
return;
case MovHint:
case ZombieHint:
case ExitOK:
case Upsilon:
case Phi:
case PhantomLocal:
case SetArgumentDefinitely:
case SetArgumentMaybe:
case Jump:
case Branch:
case Switch:
case EntrySwitch:
case ForceOSRExit:
case CPUIntrinsic:
case CheckBadValue:
case Return:
case Unreachable:
case CheckTierUpInLoop:
case CheckTierUpAtReturn:
case CheckTierUpAndOSREnter:
case LoopHint:
case ProfileType:
case ProfileControlFlow:
case PutHint:
case InitializeEntrypointArguments:
case FilterCallLinkStatus:
case FilterGetByStatus:
case FilterPutByStatus:
case FilterInByStatus:
case FilterDeleteByStatus:
case FilterCheckPrivateBrandStatus:
case FilterSetPrivateBrandStatus:
write(SideState);
return;
case StoreBarrier:
read(JSCell_cellState);
write(JSCell_cellState);
return;
case FencedStoreBarrier:
read(Heap);
write(JSCell_cellState);
return;
case CheckTraps:
read(InternalState);
write(InternalState);
return;
case InvalidationPoint:
write(SideState);
def(HeapLocation(InvalidationPointLoc, Watchpoint_fire), LazyNode(node));
return;
case Flush:
read(AbstractHeap(Stack, node->operand()));
write(SideState);
return;
case NotifyWrite:
write(Watchpoint_fire);
write(SideState);
return;
case PushWithScope: {
read(World);
write(HeapObjectCount);
return;
}
case CreateActivation: {
SymbolTable* table = node->castOperand<SymbolTable*>();
if (table->singleton().isStillValid())
write(Watchpoint_fire);
read(HeapObjectCount);
write(HeapObjectCount);
return;
}
case CreateDirectArguments:
case CreateScopedArguments:
case CreateClonedArguments:
read(Stack);
read(HeapObjectCount);
write(HeapObjectCount);
return;
case PhantomDirectArguments:
case PhantomClonedArguments:
// DFG backend requires that the locals that this reads are flushed. FTL backend can handle those
// locals being promoted.
if (!graph.m_plan.isFTL())
read(Stack);
// Even though it's phantom, it still has the property that one can't be replaced with another.
read(HeapObjectCount);
write(HeapObjectCount);
return;
case PhantomSpread:
case PhantomNewArrayWithSpread:
case PhantomNewArrayBuffer:
case PhantomCreateRest:
// Even though it's phantom, it still has the property that one can't be replaced with another.
read(HeapObjectCount);
write(HeapObjectCount);
return;
case CallObjectConstructor:
read(HeapObjectCount);
write(HeapObjectCount);
return;
case ToThis:
read(MiscFields);
read(HeapObjectCount);
write(HeapObjectCount);
return;
case TypeOfIsObject:
read(MiscFields);
def(HeapLocation(TypeOfIsObjectLoc, MiscFields, node->child1(), graph.globalObjectFor(node->origin.semantic)), LazyNode(node));
return;
case TypeOfIsFunction:
read(MiscFields);
def(HeapLocation(TypeOfIsFunctionLoc, MiscFields, node->child1(), graph.globalObjectFor(node->origin.semantic)), LazyNode(node));
return;
case IsCallable:
read(MiscFields);
def(HeapLocation(IsCallableLoc, MiscFields, node->child1()), LazyNode(node));
return;
case IsConstructor:
read(MiscFields);
def(HeapLocation(IsConstructorLoc, MiscFields, node->child1()), LazyNode(node));
return;
case ArrayIsArray:
read(MiscFields);
write(SideState);
def(HeapLocation(ArrayIsArrayLoc, MiscFields, node->child1()), LazyNode(node));
return;
case MatchStructure:
read(JSCell_structureID);
return;
case ArraySlice:
read(MiscFields);
read(JSCell_indexingType);
read(JSCell_structureID);
read(JSObject_butterfly);
read(Butterfly_publicLength);
read(IndexedDoubleProperties);
read(IndexedInt32Properties);
read(IndexedContiguousProperties);
read(HeapObjectCount);
write(HeapObjectCount);
return;
case ArrayConcatArray:
case ArrayConcatAppendOne: {
read(MiscFields);
read(JSCell_indexingType);
read(JSCell_structureID);
read(JSObject_butterfly);
read(Butterfly_publicLength);
read(IndexedDoubleProperties);
read(IndexedInt32Properties);
read(IndexedContiguousProperties);
read(IndexedArrayStorageProperties);
read(HeapObjectCount);
write(HeapObjectCount);
return;
}
case ArrayIncludes:
case ArrayIndexOf: {
// FIXME: Should support a CSE rule.
// https://bugs.webkit.org/show_bug.cgi?id=173173
read(MiscFields);
read(JSCell_indexingType);
read(JSCell_structureID);
read(JSObject_butterfly);
read(Butterfly_publicLength);
switch (node->arrayMode().type()) {
case Array::Double:
read(IndexedDoubleProperties);
return;
case Array::Int32:
read(IndexedInt32Properties);
return;
case Array::Contiguous:
read(IndexedContiguousProperties);
return;
default:
RELEASE_ASSERT_NOT_REACHED();
return;
}
return;
}
case ArrayJoin: {
clobberTop();
return;
}
case GetById:
case GetByIdFlush:
case GetByIdMegamorphic:
case GetByIdWithThis:
case GetByIdWithThisMegamorphic:
case GetByIdDirect:
case GetByIdDirectFlush:
case GetByValWithThis:
case GetByValWithThisMegamorphic:
case PutById:
case PutByIdMegamorphic:
case PutByIdWithThis:
case PutByValWithThis:
case PutByIdFlush:
case PutByIdDirect:
case PutGetterById:
case PutSetterById:
case PutGetterSetterById:
case PutGetterByVal:
case PutSetterByVal:
case PutPrivateName:
case PutPrivateNameById:
case GetPrivateName:
case GetPrivateNameById:
case DefineDataProperty:
case DefineAccessorProperty:
case ObjectDefineProperty:
case ObjectDefinePropertyFromFields:
case DeleteById:
case DeleteByVal:
case ArrayPush:
case ArrayPop:
case ArrayShift:
case ArrayUnshift:
case ArraySplice:
case Call:
case DirectCall:
case TailCallInlinedCaller:
case DirectTailCallInlinedCaller:
case Construct:
case DirectConstruct:
case CallVarargs:
case CallForwardVarargs:
case TailCallVarargsInlinedCaller:
case TailCallForwardVarargsInlinedCaller:
case ConstructVarargs:
case ConstructForwardVarargs:
case CallDirectEval:
case CallWasm:
case TailCallInlinedCallerWasm:
case CallCustomAccessorGetter:
case CallCustomAccessorSetter:
case ToPrimitive:
case ToPropertyKey:
case ToPropertyKeyOrNumber:
case InByVal:
case InByValMegamorphic:
case EnumeratorInByVal:
case EnumeratorHasOwnProperty:
case InById:
case InByIdMegamorphic:
case HasPrivateName:
case HasPrivateBrand:
case HasOwnProperty:
case ValueNegate:
case SetFunctionName:
case EnqueueAsyncGeneratorDriver:
case GetDynamicVar:
case PutDynamicVar:
case ResolveScopeForHoistingFuncDeclInEval:
case ResolveScope:
case ToObject:
case OpenAsyncFromSyncIterator:
case GetPropertyEnumerator:
case InstanceOfCustom:
case ToNumeric:
case NumberToStringWithRadix:
case CreateThis:
case CreatePromise:
case CreateGenerator:
case CreateAsyncGenerator:
case InstanceOf:
case InstanceOfMegamorphic:
case ObjectKeys:
case ObjectGetOwnPropertyNames:
case ObjectGetOwnPropertySymbols:
case ObjectToString:
case ReflectOwnKeys:
clobberTop();
return;
case StringValueOf:
switch (node->child1().useKind()) {
case StringOrOtherUse:
read(World);
write(SideState);
def(PureValue(node));
return;
default:
clobberTop();
return;
}
case ToNumber:
switch (node->child1().useKind()) {
case StringUse:
def(PureValue(node));
return;
default:
clobberTop();
return;
}
case CallNumberConstructor:
switch (node->child1().useKind()) {
case BigInt32Use:
def(PureValue(node));
return;
case UntypedUse:
clobberTop();
return;
default:
DFG_CRASH(graph, node, "Bad use kind"_s);
}
case Inc:
case Dec:
switch (node->child1().useKind()) {
case Int32Use:
case Int52RepUse:
case DoubleRepUse:
case BigInt32Use:
case HeapBigIntUse:
case AnyBigIntUse:
def(PureValue(node));
return;
case UntypedUse:
clobberTop();
return;
default:
DFG_CRASH(graph, node, "Bad use kind"_s);
}
case ValueBitAnd:
case ValueBitXor:
case ValueBitOr:
case ValueAdd:
case ValueSub:
case ValueMul:
case ValueDiv:
case ValueMod:
case ValuePow:
case ValueBitLShift:
case ValueBitRShift:
// FIXME: this use of single-argument isBinaryUseKind would prevent us from specializing (for example) for a HeapBigInt left-operand and a BigInt32 right-operand.
if (node->isBinaryUseKind(AnyBigIntUse) || node->isBinaryUseKind(BigInt32Use) || node->isBinaryUseKind(HeapBigIntUse)) {
read(World);
write(SideState);
def(PureValue(node));
return;
}
clobberTop();
return;
case ValueBitURShift:
// URShift >>> does not accept BigInt.
clobberTop();
return;
case AtomicsAdd:
case AtomicsAnd:
case AtomicsCompareExchange:
case AtomicsExchange:
case AtomicsLoad:
case AtomicsOr:
case AtomicsStore:
case AtomicsSub:
case AtomicsXor: {
unsigned numExtraArgs = numExtraAtomicsArgs(node->op());
Edge storageEdge = graph.child(node, 2 + numExtraArgs);
if (!storageEdge) {
clobberTop();
return;
}
read(TypedArrayProperties);
read(MiscFields);
write(TypedArrayProperties);
return;
}
case Throw:
case ThrowStaticError:
case TailCall:
case DirectTailCall:
case TailCallVarargs:
case TailCallForwardVarargs:
read(World);
write(SideState);
return;
case GetGetter:
read(GetterSetter_getter);
def(HeapLocation(GetterLoc, GetterSetter_getter, node->child1()), LazyNode(node));
return;
case GetSetter:
read(GetterSetter_setter);