This repository has been archived by the owner on Jan 23, 2023. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 2.7k
/
Copy pathmorph.cpp
19686 lines (17087 loc) · 744 KB
/
morph.cpp
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
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
/*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XX XX
XX Morph XX
XX XX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
*/
#include "jitpch.h"
#ifdef _MSC_VER
#pragma hdrstop
#endif
#include "allocacheck.h" // for alloca
// Convert the given node into a call to the specified helper passing
// the given argument list.
//
// Tries to fold constants and also adds an edge for overflow exception
// returns the morphed tree
GenTreePtr Compiler::fgMorphCastIntoHelper(GenTreePtr tree, int helper, GenTreePtr oper)
{
GenTree* result;
/* If the operand is a constant, we'll try to fold it */
if (oper->OperIsConst())
{
GenTreePtr oldTree = tree;
tree = gtFoldExprConst(tree); // This may not fold the constant (NaN ...)
if (tree != oldTree)
{
return fgMorphTree(tree);
}
else if (tree->OperKind() & GTK_CONST)
{
return fgMorphConst(tree);
}
// assert that oper is unchanged and that it is still a GT_CAST node
noway_assert(tree->gtCast.CastOp() == oper);
noway_assert(tree->gtOper == GT_CAST);
}
result = fgMorphIntoHelperCall(tree, helper, gtNewArgList(oper));
assert(result == tree);
return result;
}
/*****************************************************************************
*
* Convert the given node into a call to the specified helper passing
* the given argument list.
*/
GenTreePtr Compiler::fgMorphIntoHelperCall(GenTreePtr tree, int helper, GenTreeArgList* args)
{
// The helper call ought to be semantically equivalent to the original node, so preserve its VN.
tree->ChangeOper(GT_CALL, GenTree::PRESERVE_VN);
tree->gtCall.gtCallType = CT_HELPER;
tree->gtCall.gtCallMethHnd = eeFindHelper(helper);
tree->gtCall.gtCallArgs = args;
tree->gtCall.gtCallObjp = nullptr;
tree->gtCall.gtCallLateArgs = nullptr;
tree->gtCall.fgArgInfo = nullptr;
tree->gtCall.gtRetClsHnd = nullptr;
tree->gtCall.gtCallMoreFlags = 0;
tree->gtCall.gtInlineCandidateInfo = nullptr;
tree->gtCall.gtControlExpr = nullptr;
#ifdef LEGACY_BACKEND
tree->gtCall.gtCallRegUsedMask = RBM_NONE;
#endif // LEGACY_BACKEND
#if DEBUG
// Helper calls are never candidates.
tree->gtCall.gtInlineObservation = InlineObservation::CALLSITE_IS_CALL_TO_HELPER;
#endif // DEBUG
#ifdef FEATURE_READYTORUN_COMPILER
tree->gtCall.gtEntryPoint.addr = nullptr;
#endif
#if (defined(_TARGET_X86_) || defined(_TARGET_ARM_)) && !defined(LEGACY_BACKEND)
if (varTypeIsLong(tree))
{
GenTreeCall* callNode = tree->AsCall();
ReturnTypeDesc* retTypeDesc = callNode->GetReturnTypeDesc();
retTypeDesc->Reset();
retTypeDesc->InitializeLongReturnType(this);
callNode->ClearOtherRegs();
}
#endif // _TARGET_XXX_
if (tree->OperMayThrow(this))
{
tree->gtFlags |= GTF_EXCEPT;
}
else
{
tree->gtFlags &= ~GTF_EXCEPT;
}
tree->gtFlags |= GTF_CALL;
if (args)
{
tree->gtFlags |= (args->gtFlags & GTF_ALL_EFFECT);
}
/* Perform the morphing */
tree = fgMorphArgs(tree->AsCall());
return tree;
}
/*****************************************************************************
*
* Determine if a relop must be morphed to a qmark to manifest a boolean value.
* This is done when code generation can't create straight-line code to do it.
*/
bool Compiler::fgMorphRelopToQmark(GenTreePtr tree)
{
#ifndef LEGACY_BACKEND
return false;
#else // LEGACY_BACKEND
return (genActualType(tree->TypeGet()) == TYP_LONG) || varTypeIsFloating(tree->TypeGet());
#endif // LEGACY_BACKEND
}
/*****************************************************************************
*
* Morph a cast node (we perform some very simple transformations here).
*/
#ifdef _PREFAST_
#pragma warning(push)
#pragma warning(disable : 21000) // Suppress PREFast warning about overly large function
#endif
GenTreePtr Compiler::fgMorphCast(GenTreePtr tree)
{
noway_assert(tree->gtOper == GT_CAST);
noway_assert(genTypeSize(TYP_I_IMPL) == sizeof(void*));
/* The first sub-operand is the thing being cast */
GenTreePtr oper = tree->gtCast.CastOp();
if (fgGlobalMorph && (oper->gtOper == GT_ADDR))
{
// Make sure we've checked if 'oper' is an address of an implicit-byref parameter.
// If it is, fgMorphImplicitByRefArgs will change its type, and we want the cast
// morphing code to see that type.
fgMorphImplicitByRefArgs(oper);
}
var_types srcType = genActualType(oper->TypeGet());
var_types dstType = tree->CastToType();
unsigned dstSize = genTypeSize(dstType);
// See if the cast has to be done in two steps. R -> I
if (varTypeIsFloating(srcType) && varTypeIsIntegral(dstType))
{
// Only x86 must go through TYP_DOUBLE to get to all
// integral types everybody else can get straight there
// except for when using helpers
if (srcType == TYP_FLOAT
#if !FEATURE_STACK_FP_X87
#if defined(_TARGET_ARM64_)
// Amd64: src = float, dst is overflow conversion.
// This goes through helper and hence src needs to be converted to double.
&& tree->gtOverflow()
#elif defined(_TARGET_AMD64_)
// Amd64: src = float, dst = uint64 or overflow conversion.
// This goes through helper and hence src needs to be converted to double.
&& (tree->gtOverflow() || (dstType == TYP_ULONG))
#elif defined(_TARGET_ARM_)
// Arm: src = float, dst = int64/uint64 or overflow conversion.
&& (tree->gtOverflow() || varTypeIsLong(dstType))
#endif
#endif // FEATURE_STACK_FP_X87
)
{
oper = gtNewCastNode(TYP_DOUBLE, oper, TYP_DOUBLE);
}
// do we need to do it in two steps R -> I, '-> smallType
CLANG_FORMAT_COMMENT_ANCHOR;
#if defined(_TARGET_ARM64_) || defined(_TARGET_AMD64_)
if (dstSize < genTypeSize(TYP_INT))
{
oper = gtNewCastNodeL(TYP_INT, oper, TYP_INT);
oper->gtFlags |= (tree->gtFlags & (GTF_UNSIGNED | GTF_OVERFLOW | GTF_EXCEPT));
tree->gtFlags &= ~GTF_UNSIGNED;
}
#else
if (dstSize < sizeof(void*))
{
oper = gtNewCastNodeL(TYP_I_IMPL, oper, TYP_I_IMPL);
oper->gtFlags |= (tree->gtFlags & (GTF_OVERFLOW | GTF_EXCEPT));
}
#endif
else
{
/* Note that if we need to use a helper call then we can not morph oper */
if (!tree->gtOverflow())
{
#ifdef _TARGET_ARM64_ // On ARM64 All non-overflow checking conversions can be optimized
goto OPTIMIZECAST;
#else
switch (dstType)
{
case TYP_INT:
#ifdef _TARGET_X86_ // there is no rounding convert to integer instruction on ARM or x64 so skip this
#ifdef LEGACY_BACKEND
// the RyuJIT backend does not use the x87 FPU and therefore
// does not support folding the cast conv.i4(round.d(d))
if ((oper->gtOper == GT_INTRINSIC) &&
(oper->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Round))
{
/* optimization: conv.i4(round.d(d)) -> round.i(d) */
oper->gtType = dstType;
return fgMorphTree(oper);
}
// if SSE2 is not enabled, we need the helper
else
#endif // LEGACY_BACKEND
if (!opts.compCanUseSSE2)
{
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2INT, oper);
}
else
#endif // _TARGET_X86_
{
goto OPTIMIZECAST;
}
#if defined(_TARGET_ARM_) || defined(_TARGET_AMD64_)
case TYP_UINT:
goto OPTIMIZECAST;
#else // _TARGET_ARM_
case TYP_UINT:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2UINT, oper);
#endif // _TARGET_ARM_
#ifdef _TARGET_AMD64_
// SSE2 has instructions to convert a float/double directly to a long
case TYP_LONG:
goto OPTIMIZECAST;
#else
case TYP_LONG:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2LNG, oper);
#endif //_TARGET_AMD64_
case TYP_ULONG:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2ULNG, oper);
default:
break;
}
#endif // _TARGET_ARM64_
}
else
{
switch (dstType)
{
case TYP_INT:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2INT_OVF, oper);
case TYP_UINT:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2UINT_OVF, oper);
case TYP_LONG:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2LNG_OVF, oper);
case TYP_ULONG:
return fgMorphCastIntoHelper(tree, CORINFO_HELP_DBL2ULNG_OVF, oper);
default:
break;
}
}
noway_assert(!"Unexpected dstType");
}
}
#ifndef _TARGET_64BIT_
// The code generation phase (for x86 & ARM32) does not handle casts
// directly from [u]long to anything other than [u]int. Insert an
// intermediate cast to native int.
else if (varTypeIsLong(srcType) && varTypeIsSmall(dstType))
{
oper = gtNewCastNode(TYP_I_IMPL, oper, TYP_I_IMPL);
oper->gtFlags |= (tree->gtFlags & (GTF_OVERFLOW | GTF_EXCEPT | GTF_UNSIGNED));
tree->gtFlags &= ~GTF_UNSIGNED;
}
#endif //!_TARGET_64BIT_
#ifdef _TARGET_ARM_
else if ((dstType == TYP_FLOAT) && (srcType == TYP_DOUBLE) && (oper->gtOper == GT_CAST) &&
!varTypeIsLong(oper->gtCast.CastOp()))
{
// optimization: conv.r4(conv.r8(?)) -> conv.r4(d)
// except when the ultimate source is a long because there is no long-to-float helper, so it must be 2 step.
// This happens semi-frequently because there is no IL 'conv.r4.un'
oper->gtType = TYP_FLOAT;
oper->CastToType() = TYP_FLOAT;
return fgMorphTree(oper);
}
// converts long/ulong --> float/double casts into helper calls.
else if (varTypeIsFloating(dstType) && varTypeIsLong(srcType))
{
if (dstType == TYP_FLOAT)
{
// there is only a double helper, so we
// - change the dsttype to double
// - insert a cast from double to float
// - recurse into the resulting tree
tree->CastToType() = TYP_DOUBLE;
tree->gtType = TYP_DOUBLE;
tree = gtNewCastNode(TYP_FLOAT, tree, TYP_FLOAT);
return fgMorphTree(tree);
}
if (tree->gtFlags & GTF_UNSIGNED)
return fgMorphCastIntoHelper(tree, CORINFO_HELP_ULNG2DBL, oper);
return fgMorphCastIntoHelper(tree, CORINFO_HELP_LNG2DBL, oper);
}
#endif //_TARGET_ARM_
#ifdef _TARGET_AMD64_
// Do we have to do two step U4/8 -> R4/8 ?
// Codegen supports the following conversion as one-step operation
// a) Long -> R4/R8
// b) U8 -> R8
//
// The following conversions are performed as two-step operations using above.
// U4 -> R4/8 = U4-> Long -> R4/8
// U8 -> R4 = U8 -> R8 -> R4
else if ((tree->gtFlags & GTF_UNSIGNED) && varTypeIsFloating(dstType))
{
srcType = genUnsignedType(srcType);
if (srcType == TYP_ULONG)
{
if (dstType == TYP_FLOAT)
{
// Codegen can handle U8 -> R8 conversion.
// U8 -> R4 = U8 -> R8 -> R4
// - change the dsttype to double
// - insert a cast from double to float
// - recurse into the resulting tree
tree->CastToType() = TYP_DOUBLE;
tree->gtType = TYP_DOUBLE;
tree = gtNewCastNode(TYP_FLOAT, tree, TYP_FLOAT);
return fgMorphTree(tree);
}
}
else if (srcType == TYP_UINT)
{
oper = gtNewCastNode(TYP_LONG, oper, TYP_LONG);
oper->gtFlags |= (tree->gtFlags & (GTF_OVERFLOW | GTF_EXCEPT | GTF_UNSIGNED));
tree->gtFlags &= ~GTF_UNSIGNED;
}
}
#endif // _TARGET_AMD64_
#ifdef _TARGET_X86_
// Do we have to do two step U4/8 -> R4/8 ?
else if ((tree->gtFlags & GTF_UNSIGNED) && varTypeIsFloating(dstType))
{
srcType = genUnsignedType(srcType);
if (srcType == TYP_ULONG)
{
return fgMorphCastIntoHelper(tree, CORINFO_HELP_ULNG2DBL, oper);
}
else if (srcType == TYP_UINT)
{
oper = gtNewCastNode(TYP_LONG, oper, TYP_LONG);
oper->gtFlags |= (tree->gtFlags & (GTF_OVERFLOW | GTF_EXCEPT | GTF_UNSIGNED));
tree->gtFlags &= ~GTF_UNSIGNED;
#ifndef LEGACY_BACKEND
return fgMorphCastIntoHelper(tree, CORINFO_HELP_LNG2DBL, oper);
#endif
}
}
#ifndef LEGACY_BACKEND
else if (((tree->gtFlags & GTF_UNSIGNED) == 0) && (srcType == TYP_LONG) && varTypeIsFloating(dstType))
{
return fgMorphCastIntoHelper(tree, CORINFO_HELP_LNG2DBL, oper);
}
#endif
#endif //_TARGET_XARCH_
else if (varTypeIsGC(srcType) != varTypeIsGC(dstType))
{
// We are casting away GC information. we would like to just
// change the type to int, however this gives the emitter fits because
// it believes the variable is a GC variable at the begining of the
// instruction group, but is not turned non-gc by the code generator
// we fix this by copying the GC pointer to a non-gc pointer temp.
noway_assert(!varTypeIsGC(dstType) && "How can we have a cast to a GCRef here?");
// We generate an assignment to an int and then do the cast from an int. With this we avoid
// the gc problem and we allow casts to bytes, longs, etc...
unsigned lclNum = lvaGrabTemp(true DEBUGARG("Cast away GC"));
oper->gtType = TYP_I_IMPL;
GenTreePtr asg = gtNewTempAssign(lclNum, oper);
oper->gtType = srcType;
// do the real cast
GenTreePtr cast = gtNewCastNode(tree->TypeGet(), gtNewLclvNode(lclNum, TYP_I_IMPL), dstType);
// Generate the comma tree
oper = gtNewOperNode(GT_COMMA, tree->TypeGet(), asg, cast);
return fgMorphTree(oper);
}
// Look for narrowing casts ([u]long -> [u]int) and try to push them
// down into the operand before morphing it.
//
// It doesn't matter if this is cast is from ulong or long (i.e. if
// GTF_UNSIGNED is set) because the transformation is only applied to
// overflow-insensitive narrowing casts, which always silently truncate.
//
// Note that casts from [u]long to small integer types are handled above.
if ((srcType == TYP_LONG) && ((dstType == TYP_INT) || (dstType == TYP_UINT)))
{
// As a special case, look for overflow-sensitive casts of an AND
// expression, and see if the second operand is a small constant. Since
// the result of an AND is bound by its smaller operand, it may be
// possible to prove that the cast won't overflow, which will in turn
// allow the cast's operand to be transformed.
if (tree->gtOverflow() && (oper->OperGet() == GT_AND))
{
GenTreePtr andOp2 = oper->gtOp.gtOp2;
// Special case to the special case: AND with a casted int.
if ((andOp2->OperGet() == GT_CAST) && (andOp2->gtCast.CastOp()->OperGet() == GT_CNS_INT))
{
// gtFoldExprConst will deal with whether the cast is signed or
// unsigned, or overflow-sensitive.
andOp2 = oper->gtOp.gtOp2 = gtFoldExprConst(andOp2);
}
// Look for a constant less than 2^{32} for a cast to uint, or less
// than 2^{31} for a cast to int.
int maxWidth = (dstType == TYP_UINT) ? 32 : 31;
if ((andOp2->OperGet() == GT_CNS_NATIVELONG) && ((andOp2->gtIntConCommon.LngValue() >> maxWidth) == 0))
{
// This cast can't overflow.
tree->gtFlags &= ~(GTF_OVERFLOW | GTF_EXCEPT);
}
}
// Only apply this transformation during global morph,
// when neither the cast node nor the oper node may throw an exception
// based on the upper 32 bits.
//
if (fgGlobalMorph && !tree->gtOverflow() && !oper->gtOverflowEx())
{
// For these operations the lower 32 bits of the result only depends
// upon the lower 32 bits of the operands
//
if (oper->OperIs(GT_ADD, GT_SUB, GT_MUL, GT_AND, GT_OR, GT_XOR, GT_NOT, GT_NEG, GT_LSH))
{
DEBUG_DESTROY_NODE(tree);
// Insert narrowing casts for op1 and op2
oper->gtOp.gtOp1 = gtNewCastNode(TYP_INT, oper->gtOp.gtOp1, dstType);
if (oper->gtOp.gtOp2 != nullptr)
{
oper->gtOp.gtOp2 = gtNewCastNode(TYP_INT, oper->gtOp.gtOp2, dstType);
}
// Clear the GT_MUL_64RSLT if it is set
if (oper->gtOper == GT_MUL && (oper->gtFlags & GTF_MUL_64RSLT))
{
oper->gtFlags &= ~GTF_MUL_64RSLT;
}
// The operation now produces a 32-bit result.
oper->gtType = TYP_INT;
// Remorph the new tree as the casts that we added may be folded away.
return fgMorphTree(oper);
}
}
}
OPTIMIZECAST:
noway_assert(tree->gtOper == GT_CAST);
/* Morph the operand */
tree->gtCast.CastOp() = oper = fgMorphTree(oper);
/* Reset the call flag */
tree->gtFlags &= ~GTF_CALL;
/* unless we have an overflow cast, reset the except flag */
if (!tree->gtOverflow())
{
tree->gtFlags &= ~GTF_EXCEPT;
}
/* Just in case new side effects were introduced */
tree->gtFlags |= (oper->gtFlags & GTF_ALL_EFFECT);
if (!gtIsActiveCSE_Candidate(tree)) // tree cannot be a CSE candidate
{
srcType = oper->TypeGet();
/* See if we can discard the cast */
if (varTypeIsIntegral(srcType) && varTypeIsIntegral(dstType))
{
if (tree->IsUnsigned() && !varTypeIsUnsigned(srcType))
{
if (varTypeIsSmall(srcType))
{
// Small signed values are automatically sign extended to TYP_INT. If the cast is interpreting the
// resulting TYP_INT value as unsigned then the "sign" bits end up being "value" bits and srcType
// must be TYP_UINT, not the original small signed type. Otherwise "conv.ovf.i2.un(i1(-1))" is
// wrongly treated as a widening conversion from i1 to i2 when in fact it is a narrowing conversion
// from u4 to i2.
srcType = genActualType(srcType);
}
srcType = genUnsignedType(srcType);
}
if (srcType == dstType)
{ // Certainly if they are identical it is pointless
goto REMOVE_CAST;
}
if (oper->OperGet() == GT_LCL_VAR && varTypeIsSmall(dstType))
{
unsigned varNum = oper->gtLclVarCommon.gtLclNum;
LclVarDsc* varDsc = &lvaTable[varNum];
if (varDsc->TypeGet() == dstType && varDsc->lvNormalizeOnStore())
{
goto REMOVE_CAST;
}
}
bool unsignedSrc = varTypeIsUnsigned(srcType);
bool unsignedDst = varTypeIsUnsigned(dstType);
bool signsDiffer = (unsignedSrc != unsignedDst);
unsigned srcSize = genTypeSize(srcType);
// For same sized casts with
// the same signs or non-overflow cast we discard them as well
if (srcSize == dstSize)
{
/* This should have been handled above */
noway_assert(varTypeIsGC(srcType) == varTypeIsGC(dstType));
if (!signsDiffer)
{
goto REMOVE_CAST;
}
if (!tree->gtOverflow())
{
/* For small type casts, when necessary we force
the src operand to the dstType and allow the
implied load from memory to perform the casting */
if (varTypeIsSmall(srcType))
{
switch (oper->gtOper)
{
case GT_IND:
case GT_CLS_VAR:
case GT_LCL_FLD:
case GT_ARR_ELEM:
oper->gtType = dstType;
goto REMOVE_CAST;
default:
break;
}
}
else
{
goto REMOVE_CAST;
}
}
}
else if (srcSize < dstSize) // widening cast
{
// Keep any long casts
if (dstSize == sizeof(int))
{
// Only keep signed to unsigned widening cast with overflow check
if (!tree->gtOverflow() || !unsignedDst || unsignedSrc)
{
goto REMOVE_CAST;
}
}
// Widening casts from unsigned or to signed can never overflow
if (unsignedSrc || !unsignedDst)
{
tree->gtFlags &= ~GTF_OVERFLOW;
if (!(oper->gtFlags & GTF_EXCEPT))
{
tree->gtFlags &= ~GTF_EXCEPT;
}
}
}
else // if (srcSize > dstSize)
{
// Try to narrow the operand of the cast and discard the cast
// Note: Do not narrow a cast that is marked as a CSE
// And do not narrow if the oper is marked as a CSE either
//
if (!tree->gtOverflow() && !gtIsActiveCSE_Candidate(oper) && (opts.compFlags & CLFLG_TREETRANS) &&
optNarrowTree(oper, srcType, dstType, tree->gtVNPair, false))
{
optNarrowTree(oper, srcType, dstType, tree->gtVNPair, true);
/* If oper is changed into a cast to TYP_INT, or to a GT_NOP, we may need to discard it */
if (oper->gtOper == GT_CAST && oper->CastToType() == genActualType(oper->CastFromType()))
{
oper = oper->gtCast.CastOp();
}
goto REMOVE_CAST;
}
}
}
switch (oper->gtOper)
{
/* If the operand is a constant, we'll fold it */
case GT_CNS_INT:
case GT_CNS_LNG:
case GT_CNS_DBL:
case GT_CNS_STR:
{
GenTreePtr oldTree = tree;
tree = gtFoldExprConst(tree); // This may not fold the constant (NaN ...)
// Did we get a comma throw as a result of gtFoldExprConst?
if ((oldTree != tree) && (oldTree->gtOper != GT_COMMA))
{
noway_assert(fgIsCommaThrow(tree));
tree->gtOp.gtOp1 = fgMorphTree(tree->gtOp.gtOp1);
fgMorphTreeDone(tree);
return tree;
}
else if (tree->gtOper != GT_CAST)
{
return tree;
}
noway_assert(tree->gtCast.CastOp() == oper); // unchanged
}
break;
case GT_CAST:
/* Check for two consecutive casts into the same dstType */
if (!tree->gtOverflow())
{
var_types dstType2 = oper->CastToType();
if (dstType == dstType2)
{
goto REMOVE_CAST;
}
}
break;
#ifdef LEGACY_BACKEND
/* If op1 is a mod node, mark it with the GTF_MOD_INT_RESULT flag
so that the code generator will know not to convert the result
of the idiv to a regpair */
case GT_MOD:
if (dstType == TYP_INT)
{
tree->gtOp.gtOp1->gtFlags |= GTF_MOD_INT_RESULT;
}
break;
case GT_UMOD:
if (dstType == TYP_UINT)
{
tree->gtOp.gtOp1->gtFlags |= GTF_MOD_INT_RESULT;
}
break;
#endif // LEGACY_BACKEND
case GT_COMMA:
// Check for cast of a GT_COMMA with a throw overflow
// Bug 110829: Since this optimization will bash the types
// neither oper or commaOp2 can be CSE candidates
if (fgIsCommaThrow(oper) && !gtIsActiveCSE_Candidate(oper)) // oper can not be a CSE candidate
{
GenTreePtr commaOp2 = oper->gtOp.gtOp2;
if (!gtIsActiveCSE_Candidate(commaOp2)) // commaOp2 can not be a CSE candidate
{
// need type of oper to be same as tree
if (tree->gtType == TYP_LONG)
{
commaOp2->ChangeOperConst(GT_CNS_NATIVELONG);
commaOp2->gtIntConCommon.SetLngValue(0);
/* Change the types of oper and commaOp2 to TYP_LONG */
oper->gtType = commaOp2->gtType = TYP_LONG;
}
else if (varTypeIsFloating(tree->gtType))
{
commaOp2->ChangeOperConst(GT_CNS_DBL);
commaOp2->gtDblCon.gtDconVal = 0.0;
// Change the types of oper and commaOp2
// X87 promotes everything to TYP_DOUBLE
// But other's are a little more precise
const var_types newTyp
#if FEATURE_X87_DOUBLES
= TYP_DOUBLE;
#else // FEATURE_X87_DOUBLES
= tree->gtType;
#endif // FEATURE_X87_DOUBLES
oper->gtType = commaOp2->gtType = newTyp;
}
else
{
commaOp2->ChangeOperConst(GT_CNS_INT);
commaOp2->gtIntCon.gtIconVal = 0;
/* Change the types of oper and commaOp2 to TYP_INT */
oper->gtType = commaOp2->gtType = TYP_INT;
}
}
if (vnStore != nullptr)
{
fgValueNumberTreeConst(commaOp2);
}
/* Return the GT_COMMA node as the new tree */
return oper;
}
break;
default:
break;
} /* end switch (oper->gtOper) */
}
if (tree->gtOverflow())
{
fgAddCodeRef(compCurBB, bbThrowIndex(compCurBB), SCK_OVERFLOW, fgPtrArgCntCur);
}
return tree;
REMOVE_CAST:
/* Here we've eliminated the cast, so just return it's operand */
assert(!gtIsActiveCSE_Candidate(tree)); // tree cannot be a CSE candidate
DEBUG_DESTROY_NODE(tree);
return oper;
}
#ifdef _PREFAST_
#pragma warning(pop)
#endif
/*****************************************************************************
*
* Perform an unwrap operation on a Proxy object
*/
GenTreePtr Compiler::fgUnwrapProxy(GenTreePtr objRef)
{
assert(info.compIsContextful && info.compUnwrapContextful && impIsThis(objRef));
CORINFO_EE_INFO* pInfo = eeGetEEInfo();
GenTreePtr addTree;
// Perform the unwrap:
//
// This requires two extra indirections.
// We mark these indirections as 'invariant' and
// the CSE logic will hoist them when appropriate.
//
// Note that each dereference is a GC pointer
addTree = gtNewOperNode(GT_ADD, TYP_I_IMPL, objRef, gtNewIconNode(pInfo->offsetOfTransparentProxyRP, TYP_I_IMPL));
objRef = gtNewOperNode(GT_IND, TYP_REF, addTree);
objRef->gtFlags |= GTF_IND_INVARIANT;
addTree = gtNewOperNode(GT_ADD, TYP_I_IMPL, objRef, gtNewIconNode(pInfo->offsetOfRealProxyServer, TYP_I_IMPL));
objRef = gtNewOperNode(GT_IND, TYP_REF, addTree);
objRef->gtFlags |= GTF_IND_INVARIANT;
// objRef now hold the 'real this' reference (i.e. the unwrapped proxy)
return objRef;
}
/*****************************************************************************
*
* Morph an argument list; compute the pointer argument count in the process.
*
* NOTE: This function can be called from any place in the JIT to perform re-morphing
* due to graph altering modifications such as copy / constant propagation
*/
unsigned UpdateGT_LISTFlags(GenTreePtr tree)
{
assert(tree->gtOper == GT_LIST);
unsigned flags = 0;
if (tree->gtOp.gtOp2)
{
flags |= UpdateGT_LISTFlags(tree->gtOp.gtOp2);
}
flags |= (tree->gtOp.gtOp1->gtFlags & GTF_ALL_EFFECT);
tree->gtFlags &= ~GTF_ALL_EFFECT;
tree->gtFlags |= flags;
return tree->gtFlags;
}
#ifdef DEBUG
void fgArgTabEntry::Dump()
{
printf("fgArgTabEntry[arg %u", argNum);
if (regNum != REG_STK)
{
printf(", %s, regs=%u", getRegName(regNum), numRegs);
}
if (numSlots > 0)
{
printf(", numSlots=%u, slotNum=%u", numSlots, slotNum);
}
printf(", align=%u", alignment);
if (lateArgInx != (unsigned)-1)
{
printf(", lateArgInx=%u", lateArgInx);
}
if (isSplit)
{
printf(", isSplit");
}
if (needTmp)
{
printf(", tmpNum=V%02u", tmpNum);
}
if (needPlace)
{
printf(", needPlace");
}
if (isTmp)
{
printf(", isTmp");
}
if (processed)
{
printf(", processed");
}
if (isHfaRegArg)
{
printf(", isHfa");
}
if (isBackFilled)
{
printf(", isBackFilled");
}
if (isNonStandard)
{
printf(", isNonStandard");
}
printf("]\n");
}
#endif
fgArgInfo::fgArgInfo(Compiler* comp, GenTreeCall* call, unsigned numArgs)
{
compiler = comp;
callTree = call;
argCount = 0; // filled in arg count, starts at zero
nextSlotNum = INIT_ARG_STACK_SLOT;
stkLevel = 0;
#if defined(UNIX_X86_ABI)
alignmentDone = false;
stkSizeBytes = 0;
padStkAlign = 0;
#endif
#if FEATURE_FIXED_OUT_ARGS
outArgSize = 0;
#endif
argTableSize = numArgs; // the allocated table size
hasRegArgs = false;
hasStackArgs = false;
argsComplete = false;
argsSorted = false;
if (argTableSize == 0)
{
argTable = nullptr;
}
else
{
argTable = new (compiler, CMK_fgArgInfoPtrArr) fgArgTabEntryPtr[argTableSize];
}
}
/*****************************************************************************
*
* fgArgInfo Copy Constructor
*
* This method needs to act like a copy constructor for fgArgInfo.
* The newCall needs to have its fgArgInfo initialized such that
* we have newCall that is an exact copy of the oldCall.
* We have to take care since the argument information
* in the argTable contains pointers that must point to the
* new arguments and not the old arguments.
*/
fgArgInfo::fgArgInfo(GenTreeCall* newCall, GenTreeCall* oldCall)
{
fgArgInfoPtr oldArgInfo = oldCall->gtCall.fgArgInfo;
compiler = oldArgInfo->compiler;
callTree = newCall;
argCount = 0; // filled in arg count, starts at zero
nextSlotNum = INIT_ARG_STACK_SLOT;
stkLevel = oldArgInfo->stkLevel;
#if defined(UNIX_X86_ABI)
alignmentDone = oldArgInfo->alignmentDone;
stkSizeBytes = oldArgInfo->stkSizeBytes;
padStkAlign = oldArgInfo->padStkAlign;
#endif
#if FEATURE_FIXED_OUT_ARGS
outArgSize = oldArgInfo->outArgSize;
#endif
argTableSize = oldArgInfo->argTableSize;
argsComplete = false;
argTable = nullptr;
if (argTableSize > 0)
{
argTable = new (compiler, CMK_fgArgInfoPtrArr) fgArgTabEntryPtr[argTableSize];
for (unsigned inx = 0; inx < argTableSize; inx++)
{
argTable[inx] = nullptr;
}
}
assert(oldArgInfo->argsComplete);
// We create local, artificial GenTreeArgLists that includes the gtCallObjp, if that exists, as first argument,
// so we can iterate over these argument lists more uniformly.
// Need to provide a temporary non-null first arguments to these constructors: if we use them, we'll replace them
GenTreeArgList* newArgs;
GenTreeArgList newArgObjp(newCall, newCall->gtCallArgs);
GenTreeArgList* oldArgs;
GenTreeArgList oldArgObjp(oldCall, oldCall->gtCallArgs);
if (newCall->gtCallObjp == nullptr)
{
assert(oldCall->gtCallObjp == nullptr);
newArgs = newCall->gtCallArgs;
oldArgs = oldCall->gtCallArgs;
}
else
{
assert(oldCall->gtCallObjp != nullptr);
newArgObjp.Current() = newCall->gtCallArgs;
newArgs = &newArgObjp;
oldArgObjp.Current() = oldCall->gtCallObjp;
oldArgs = &oldArgObjp;
}
GenTreePtr newCurr;
GenTreePtr oldCurr;
GenTreeArgList* newParent = nullptr;
GenTreeArgList* oldParent = nullptr;
fgArgTabEntryPtr* oldArgTable = oldArgInfo->argTable;
bool scanRegArgs = false;
while (newArgs)
{
/* Get hold of the next argument values for the oldCall and newCall */
newCurr = newArgs->Current();
oldCurr = oldArgs->Current();
if (newArgs != &newArgObjp)
{