gentree.cpp source code [CoreCLR/jit/gentree.cpp]

1	// Licensed to the .NET Foundation under one or more agreements.
2	// The .NET Foundation licenses this file to you under the MIT license.
3	// See the LICENSE file in the project root for more information.
4
5	/XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX*
6	XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
7	XX XX
8	XX GenTree XX
9	XX XX
10	XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
11	XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
12	*/
13
14	#include "jitpch.h"
15	#include "hwintrinsic.h"
16	#include "simd.h"
17
18	#ifdef _MSC_VER
19	#pragma hdrstop
20	#endif
21
22	/***************************************************************************/
23
24	const unsigned short GenTree::gtOperKindTable[] = {
25	#define GTNODE(en, st, cm, ok) ok + GTK_COMMUTE *cm,
26	#include "gtlist.h"
27	};
28
29	/*****************************************************************************
30	*
31	* The types of different GenTree nodes
32	*/
33
34	#ifdef DEBUG
35
36	#define INDENT_SIZE 3
37
38	//--------------------------------------------
39	//
40	// IndentStack: This struct is used, along with its related enums and strings,
41	// to control both the indendtation and the printing of arcs.
42	//
43	// Notes:
44	// The mode of printing is set in the Constructor, using its 'compiler' argument.
45	// Currently it only prints arcs when fgOrder == fgOrderLinear.
46	// The type of arc to print is specified by the IndentInfo enum, and is controlled
47	// by the caller of the Push() method.
48
49	enum IndentChars
50	{
51	ICVertical,
52	ICBottom,
53	ICTop,
54	ICMiddle,
55	ICDash,
56	ICEmbedded,
57	ICTerminal,
58	ICError,
59	IndentCharCount
60	};
61
62	// clang-format off
63	// Sets of strings for different dumping options vert bot top mid dash embedded terminal error
64	static const char* emptyIndents[IndentCharCount] = { " ", " ", " ", " ", " ", "{", "", "?" };
65	static const char* asciiIndents[IndentCharCount] = { "\|", "\\", "/", "+", "-", "{", "*", "?" };
66	static const char* unicodeIndents[IndentCharCount] = { "\xe2\x94\x82", "\xe2\x94\x94", "\xe2\x94\x8c", "\xe2\x94\x9c", "\xe2\x94\x80", "{", "\xe2\x96\x8c", "?" };
67	// clang-format on
68
69	typedef ArrayStack<Compiler::IndentInfo> IndentInfoStack;
70	struct IndentStack
71	{
72	IndentInfoStack stack;
73	const char** indents;
74
75	// Constructor for IndentStack. Uses 'compiler' to determine the mode of printing.
76	IndentStack(Compiler* compiler) : stack (compiler->getAllocator(CMK_DebugOnly))
77	{
78	if (compiler->asciiTrees)
79	{
80	indents = asciiIndents;
81	}
82	else
83	{
84	indents = unicodeIndents;
85	}
86	}
87
88	// Return the depth of the current indentation.
89	unsigned Depth()
90	{
91	return stack.Height();
92	}
93
94	// Push a new indentation onto the stack, of the given type.
95	void Push(Compiler::IndentInfo info)
96	{
97	stack.Push(info);
98	}
99
100	// Pop the most recent indentation type off the stack.
101	Compiler::IndentInfo Pop()
102	{
103	return stack.Pop();
104	}
105
106	// Print the current indentation and arcs.
107	void print()
108	{
109	unsigned indentCount = Depth();
110	for (unsigned i = `0`; i < indentCount; i++)
111	{
112	unsigned index = indentCount - `1` - i;
113	switch (stack.Index(index))
114	{
115	case Compiler::IndentInfo::IINone:
116	printf(" ");
117	break;
118	case Compiler::IndentInfo::IIEmbedded:
119	printf("%s ", indents[ICEmbedded]);
120	break;
121	case Compiler::IndentInfo::IIArc:
122	if (index == `0`)
123	{
124	printf("%s%s%s", indents[ICMiddle], indents[ICDash], indents[ICDash]);
125	}
126	else
127	{
128	printf("%s ", indents[ICVertical]);
129	}
130	break;
131	case Compiler::IndentInfo::IIArcBottom:
132	printf("%s%s%s", indents[ICBottom], indents[ICDash], indents[ICDash]);
133	break;
134	case Compiler::IndentInfo::IIArcTop:
135	printf("%s%s%s", indents[ICTop], indents[ICDash], indents[ICDash]);
136	break;
137	case Compiler::IndentInfo::IIError:
138	printf("%s%s%s", indents[ICError], indents[ICDash], indents[ICDash]);
139	break;
140	default:
141	unreached();
142	}
143	}
144	printf("%s", indents[ICTerminal]);
145	}
146	};
147
148	//------------------------------------------------------------------------
149	// printIndent: This is a static method which simply invokes the 'print'
150	// method on its 'indentStack' argument.
151	//
152	// Arguments:
153	// indentStack - specifies the information for the indentation & arcs to be printed
154	//
155	// Notes:
156	// This method exists to localize the checking for the case where indentStack is null.
157
158	static void printIndent(IndentStack* indentStack)
159	{
160	if (indentStack == nullptr)
161	{
162	return;
163	}
164	indentStack->print();
165	}
166
167	#endif
168
169	#if defined(DEBUG) \|\| NODEBASH_STATS \|\| MEASURE_NODE_SIZE \|\| COUNT_AST_OPERS
170
171	static const char* opNames[] = {
172	#define GTNODE(en, st, cm, ok) #en,
173	#include "gtlist.h"
174	};
175
176	const char* GenTree::OpName(genTreeOps op)
177	{
178	assert((unsigned)op < _countof(opNames));
179
180	return opNames[op];
181	}
182
183	#endif
184
185	#if MEASURE_NODE_SIZE && SMALL_TREE_NODES
186
187	static const char* opStructNames[] = {
188	#define GTNODE(en, st, cm, ok) #st,
189	#include "gtlist.h"
190	};
191
192	const char* GenTree::OpStructName(genTreeOps op)
193	{
194	assert((unsigned)op < _countof(opStructNames));
195
196	return opStructNames[op];
197	}
198
199	#endif
200
201	/*****************************************************************************
202	*
203	* When 'SMALL_TREE_NODES' is enabled, we allocate tree nodes in 2 different
204	* sizes: 'TREE_NODE_SZ_SMALL' for most nodes and 'TREE_NODE_SZ_LARGE' for the
205	* few nodes (such as calls) that have more fields and take up a lot more space.
206	*/
207
208	#if SMALL_TREE_NODES
209
210	/ GT_COUNT'th oper is overloaded as 'undefined oper', so allocate storage for GT_COUNT'th oper also /
211	/ static /
212	unsigned char GenTree::s_gtNodeSizes[GT_COUNT + `1`];
213
214	#if NODEBASH_STATS \|\| MEASURE_NODE_SIZE \|\| COUNT_AST_OPERS
215
216	unsigned char GenTree::s_gtTrueSizes[GT_COUNT + `1`]{
217	#define GTNODE(en, st, cm, ok) sizeof(st),
218	#include "gtlist.h"
219	};
220
221	#endif // NODEBASH_STATS \|\| MEASURE_NODE_SIZE \|\| COUNT_AST_OPERS
222
223	#if COUNT_AST_OPERS
224	LONG GenTree::s_gtNodeCounts[GT_COUNT + `1`] = {`0`};
225	#endif // COUNT_AST_OPERS
226
227	/ static /
228	void GenTree::InitNodeSize()
229	{
230	/ Set all sizes to 'small' first /
231
232	for (unsigned op = `0`; op <= GT_COUNT; op++)
233	{
234	GenTree::s_gtNodeSizes[op] = TREE_NODE_SZ_SMALL;
235	}
236
237	// Now set all of the appropriate entries to 'large'
238	CLANG_FORMAT_COMMENT_ANCHOR;
239
240	// clang-format off
241	#if defined(FEATURE_HFA) \|\| defined(UNIX_AMD64_ABI)
242	// On ARM32, ARM64 and System V for struct returning
243	// there is code that does GT_ASG-tree.CopyObj call.
244	// CopyObj is a large node and the GT_ASG is small, which triggers an exception.
245	GenTree::s_gtNodeSizes[GT_ASG] = TREE_NODE_SZ_LARGE;
246	GenTree::s_gtNodeSizes[GT_RETURN] = TREE_NODE_SZ_LARGE;
247	#endif // defined(FEATURE_HFA) \|\| defined(UNIX_AMD64_ABI)
248
249	GenTree::s_gtNodeSizes[GT_CALL] = TREE_NODE_SZ_LARGE;
250	GenTree::s_gtNodeSizes[GT_CAST] = TREE_NODE_SZ_LARGE;
251	GenTree::s_gtNodeSizes[GT_FTN_ADDR] = TREE_NODE_SZ_LARGE;
252	GenTree::s_gtNodeSizes[GT_BOX] = TREE_NODE_SZ_LARGE;
253	GenTree::s_gtNodeSizes[GT_INDEX] = TREE_NODE_SZ_LARGE;
254	GenTree::s_gtNodeSizes[GT_INDEX_ADDR] = TREE_NODE_SZ_LARGE;
255	GenTree::s_gtNodeSizes[GT_ARR_BOUNDS_CHECK] = TREE_NODE_SZ_LARGE;
256	#ifdef FEATURE_SIMD
257	GenTree::s_gtNodeSizes[GT_SIMD_CHK] = TREE_NODE_SZ_LARGE;
258	#endif // FEATURE_SIMD
259	#ifdef FEATURE_HW_INTRINSICS
260	GenTree::s_gtNodeSizes[GT_HW_INTRINSIC_CHK] = TREE_NODE_SZ_LARGE;
261	#endif // FEATURE_HW_INTRINSICS
262
263	GenTree::s_gtNodeSizes[GT_ARR_ELEM] = TREE_NODE_SZ_LARGE;
264	GenTree::s_gtNodeSizes[GT_ARR_INDEX] = TREE_NODE_SZ_LARGE;
265	GenTree::s_gtNodeSizes[GT_ARR_OFFSET] = TREE_NODE_SZ_LARGE;
266	GenTree::s_gtNodeSizes[GT_RET_EXPR] = TREE_NODE_SZ_LARGE;
267	GenTree::s_gtNodeSizes[GT_OBJ] = TREE_NODE_SZ_LARGE;
268	GenTree::s_gtNodeSizes[GT_FIELD] = TREE_NODE_SZ_LARGE;
269	GenTree::s_gtNodeSizes[GT_STMT] = TREE_NODE_SZ_LARGE;
270	GenTree::s_gtNodeSizes[GT_CMPXCHG] = TREE_NODE_SZ_LARGE;
271	GenTree::s_gtNodeSizes[GT_QMARK] = TREE_NODE_SZ_LARGE;
272	GenTree::s_gtNodeSizes[GT_LEA] = TREE_NODE_SZ_LARGE;
273	GenTree::s_gtNodeSizes[GT_STORE_OBJ] = TREE_NODE_SZ_LARGE;
274	GenTree::s_gtNodeSizes[GT_DYN_BLK] = TREE_NODE_SZ_LARGE;
275	GenTree::s_gtNodeSizes[GT_STORE_DYN_BLK] = TREE_NODE_SZ_LARGE;
276	GenTree::s_gtNodeSizes[GT_INTRINSIC] = TREE_NODE_SZ_LARGE;
277	GenTree::s_gtNodeSizes[GT_ALLOCOBJ] = TREE_NODE_SZ_LARGE;
278	#if USE_HELPERS_FOR_INT_DIV
279	GenTree::s_gtNodeSizes[GT_DIV] = TREE_NODE_SZ_LARGE;
280	GenTree::s_gtNodeSizes[GT_UDIV] = TREE_NODE_SZ_LARGE;
281	GenTree::s_gtNodeSizes[GT_MOD] = TREE_NODE_SZ_LARGE;
282	GenTree::s_gtNodeSizes[GT_UMOD] = TREE_NODE_SZ_LARGE;
283	#endif
284	#ifdef FEATURE_PUT_STRUCT_ARG_STK
285	// TODO-Throughput: This should not need to be a large node. The object info should be
286	// obtained from the child node.
287	GenTree::s_gtNodeSizes[GT_PUTARG_STK] = TREE_NODE_SZ_LARGE;
288	#if FEATURE_ARG_SPLIT
289	GenTree::s_gtNodeSizes[GT_PUTARG_SPLIT] = TREE_NODE_SZ_LARGE;
290	#endif // FEATURE_ARG_SPLIT
291	#endif // FEATURE_PUT_STRUCT_ARG_STK
292
293	assert(GenTree::s_gtNodeSizes[GT_RETURN] == GenTree::s_gtNodeSizes[GT_ASG]);
294
295	// This list of assertions should come to contain all GenTree subtypes that are declared
296	// "small".
297	assert(sizeof(GenTreeLclFld) <= GenTree::s_gtNodeSizes[GT_LCL_FLD]);
298	assert(sizeof(GenTreeLclVar) <= GenTree::s_gtNodeSizes[GT_LCL_VAR]);
299
300	static_assert_no_msg(sizeof(GenTree) <= TREE_NODE_SZ_SMALL);
301	static_assert_no_msg(sizeof(GenTreeUnOp) <= TREE_NODE_SZ_SMALL);
302	static_assert_no_msg(sizeof(GenTreeOp) <= TREE_NODE_SZ_SMALL);
303	static_assert_no_msg(sizeof(GenTreeVal) <= TREE_NODE_SZ_SMALL);
304	static_assert_no_msg(sizeof(GenTreeIntConCommon) <= TREE_NODE_SZ_SMALL);
305	static_assert_no_msg(sizeof(GenTreePhysReg) <= TREE_NODE_SZ_SMALL);
306	static_assert_no_msg(sizeof(GenTreeJumpTable) <= TREE_NODE_SZ_SMALL);
307	static_assert_no_msg(sizeof(GenTreeIntCon) <= TREE_NODE_SZ_SMALL);
308	static_assert_no_msg(sizeof(GenTreeLngCon) <= TREE_NODE_SZ_SMALL);
309	static_assert_no_msg(sizeof(GenTreeDblCon) <= TREE_NODE_SZ_SMALL);
310	static_assert_no_msg(sizeof(GenTreeStrCon) <= TREE_NODE_SZ_SMALL);
311	static_assert_no_msg(sizeof(GenTreeLclVarCommon) <= TREE_NODE_SZ_SMALL);
312	static_assert_no_msg(sizeof(GenTreeLclVar) <= TREE_NODE_SZ_SMALL);
313	static_assert_no_msg(sizeof(GenTreeLclFld) <= TREE_NODE_SZ_SMALL);
314	static_assert_no_msg(sizeof(GenTreeCC) <= TREE_NODE_SZ_SMALL);
315	static_assert_no_msg(sizeof(GenTreeCast) <= TREE_NODE_SZ_LARGE); // ** large node*
316	static_assert_no_msg(sizeof(GenTreeBox) <= TREE_NODE_SZ_LARGE); // ** large node*
317	static_assert_no_msg(sizeof(GenTreeField) <= TREE_NODE_SZ_LARGE); // ** large node*
318	static_assert_no_msg(sizeof(GenTreeArgList) <= TREE_NODE_SZ_SMALL);
319	static_assert_no_msg(sizeof(GenTreeFieldList) <= TREE_NODE_SZ_SMALL);
320	static_assert_no_msg(sizeof(GenTreeColon) <= TREE_NODE_SZ_SMALL);
321	static_assert_no_msg(sizeof(GenTreeCall) <= TREE_NODE_SZ_LARGE); // ** large node*
322	static_assert_no_msg(sizeof(GenTreeCmpXchg) <= TREE_NODE_SZ_LARGE); // ** large node*
323	static_assert_no_msg(sizeof(GenTreeFptrVal) <= TREE_NODE_SZ_LARGE); // ** large node*
324	static_assert_no_msg(sizeof(GenTreeQmark) <= TREE_NODE_SZ_LARGE); // ** large node*
325	static_assert_no_msg(sizeof(GenTreeIntrinsic) <= TREE_NODE_SZ_LARGE); // ** large node*
326	static_assert_no_msg(sizeof(GenTreeIndex) <= TREE_NODE_SZ_LARGE); // ** large node*
327	static_assert_no_msg(sizeof(GenTreeArrLen) <= TREE_NODE_SZ_LARGE); // ** large node*
328	static_assert_no_msg(sizeof(GenTreeBoundsChk) <= TREE_NODE_SZ_LARGE); // ** large node*
329	static_assert_no_msg(sizeof(GenTreeArrElem) <= TREE_NODE_SZ_LARGE); // ** large node*
330	static_assert_no_msg(sizeof(GenTreeArrIndex) <= TREE_NODE_SZ_LARGE); // ** large node*
331	static_assert_no_msg(sizeof(GenTreeArrOffs) <= TREE_NODE_SZ_LARGE); // ** large node*
332	static_assert_no_msg(sizeof(GenTreeIndir) <= TREE_NODE_SZ_SMALL);
333	static_assert_no_msg(sizeof(GenTreeStoreInd) <= TREE_NODE_SZ_SMALL);
334	static_assert_no_msg(sizeof(GenTreeAddrMode) <= TREE_NODE_SZ_SMALL);
335	static_assert_no_msg(sizeof(GenTreeObj) <= TREE_NODE_SZ_LARGE); // ** large node*
336	static_assert_no_msg(sizeof(GenTreeBlk) <= TREE_NODE_SZ_SMALL);
337	static_assert_no_msg(sizeof(GenTreeRetExpr) <= TREE_NODE_SZ_LARGE); // ** large node*
338	static_assert_no_msg(sizeof(GenTreeStmt) <= TREE_NODE_SZ_LARGE); // ** large node*
339	static_assert_no_msg(sizeof(GenTreeClsVar) <= TREE_NODE_SZ_SMALL);
340	static_assert_no_msg(sizeof(GenTreeArgPlace) <= TREE_NODE_SZ_SMALL);
341	static_assert_no_msg(sizeof(GenTreeLabel) <= TREE_NODE_SZ_SMALL);
342	static_assert_no_msg(sizeof(GenTreePhiArg) <= TREE_NODE_SZ_SMALL);
343	static_assert_no_msg(sizeof(GenTreeAllocObj) <= TREE_NODE_SZ_LARGE); // ** large node*
344	#ifndef FEATURE_PUT_STRUCT_ARG_STK
345	static_assert_no_msg(sizeof(GenTreePutArgStk) <= TREE_NODE_SZ_SMALL);
346	#else // FEATURE_PUT_STRUCT_ARG_STK
347	// TODO-Throughput: This should not need to be a large node. The object info should be
348	// obtained from the child node.
349	static_assert_no_msg(sizeof(GenTreePutArgStk) <= TREE_NODE_SZ_LARGE);
350	#if FEATURE_ARG_SPLIT
351	static_assert_no_msg(sizeof(GenTreePutArgSplit) <= TREE_NODE_SZ_LARGE);
352	#endif // FEATURE_ARG_SPLIT
353	#endif // FEATURE_PUT_STRUCT_ARG_STK
354
355	#ifdef FEATURE_SIMD
356	static_assert_no_msg(sizeof(GenTreeSIMD) <= TREE_NODE_SZ_SMALL);
357	#endif // FEATURE_SIMD
358
359	#ifdef FEATURE_HW_INTRINSICS
360	static_assert_no_msg(sizeof(GenTreeHWIntrinsic) <= TREE_NODE_SZ_SMALL);
361	#endif // FEATURE_HW_INTRINSICS
362	// clang-format on
363	}
364
365	size_t GenTree::GetNodeSize() const
366	{
367	return GenTree::s_gtNodeSizes[gtOper];
368	}
369
370	#ifdef DEBUG
371	bool GenTree::IsNodeProperlySized() const
372	{
373	size_t size;
374
375	if (gtDebugFlags & GTF_DEBUG_NODE_SMALL)
376	{
377	size = TREE_NODE_SZ_SMALL;
378	}
379	else
380	{
381	assert(gtDebugFlags & GTF_DEBUG_NODE_LARGE);
382	size = TREE_NODE_SZ_LARGE;
383	}
384
385	return GenTree::s_gtNodeSizes[gtOper] <= size;
386	}
387	#endif
388
389	#if SMALL_TREE_NODES
390	//------------------------------------------------------------------------
391	// ReplaceWith: replace this with the src node. The source must be an isolated node
392	// and cannot be used after the replacement.
393	//
394	// Arguments:
395	// src - source tree, that replaces this.
396	// comp - the compiler instance to transfer annotations for arrays.
397	//
398	void GenTree::ReplaceWith(GenTree* src, Compiler* comp)
399	{
400	// The source may be big only if the target is also a big node
401	assert((gtDebugFlags & GTF_DEBUG_NODE_LARGE) \|\| GenTree::s_gtNodeSizes[src->gtOper] == TREE_NODE_SZ_SMALL);
402
403	// The check is effective only if nodes have been already threaded.
404	assert((src->gtPrev == nullptr) && (src->gtNext == nullptr));
405
406	RecordOperBashing(OperGet(), src->OperGet()); // nop unless NODEBASH_STATS is enabled
407
408	GenTree* prev = gtPrev;
409	GenTree* next = gtNext;
410	// The VTable pointer is copied intentionally here
411	memcpy((void)this, (void**)src, src->GetNodeSize());
412	this->gtPrev = prev;
413	this->gtNext = next;
414
415	#ifdef DEBUG
416	gtSeqNum = `0`;
417	#endif
418	// Transfer any annotations.
419	if (src->OperGet() == GT_IND && src->gtFlags & GTF_IND_ARR_INDEX)
420	{
421	ArrayInfo arrInfo;
422	bool b = comp->GetArrayInfoMap()->Lookup(src, &arrInfo);
423	assert(b);
424	comp->GetArrayInfoMap()->Set(this, arrInfo);
425	}
426	DEBUG_DESTROY_NODE(src);
427	}
428
429	#endif
430
431	/*****************************************************************************
432	*
433	* When 'NODEBASH_STATS' is enabled in "jit.h" we record all instances of
434	* an existing GenTree node having its operator changed. This can be useful
435	* for two (related) things - to see what is being bashed (and what isn't),
436	* and to verify that the existing choices for what nodes are marked 'large'
437	* are reasonable (to minimize "wasted" space).
438	*
439	* And yes, the hash function / logic is simplistic, but it is conflict-free
440	* and transparent for what we need.
441	*/
442
443	#if NODEBASH_STATS
444
445	#define BASH_HASH_SIZE 211
446
447	inline unsigned hashme(genTreeOps op1, genTreeOps op2)
448	{
449	return ((op1 * `104729`) ^ (op2 * `56569`)) % BASH_HASH_SIZE;
450	}
451
452	struct BashHashDsc
453	{
454	unsigned __int32 bhFullHash; // the hash value (unique for all old->new pairs)
455	unsigned __int32 bhCount; // the same old->new bashings seen so far
456	unsigned __int8 bhOperOld; // original gtOper
457	unsigned __int8 bhOperNew; // new gtOper
458	};
459
460	static BashHashDsc BashHash[BASH_HASH_SIZE];
461
462	void GenTree::RecordOperBashing(genTreeOps operOld, genTreeOps operNew)
463	{
464	unsigned hash = hashme(operOld, operNew);
465	BashHashDsc* desc = BashHash + hash;
466
467	if (desc->bhFullHash != hash)
468	{
469	noway_assert(desc->bhCount == `0`); // if this ever fires, need fix the hash fn
470	desc->bhFullHash = hash;
471	}
472
473	desc->bhCount += `1`;
474	desc->bhOperOld = operOld;
475	desc->bhOperNew = operNew;
476	}
477
478	void GenTree::ReportOperBashing(FILE* f)
479	{
480	unsigned total = `0`;
481
482	fflush(f);
483
484	fprintf(f, "\n");
485	fprintf(f, "Bashed gtOper stats:\n");
486	fprintf(f, "\n");
487	fprintf(f, " Old operator New operator #bytes old->new Count\n");
488	fprintf(f, " ---------------------------------------------------------------\n");
489
490	for (unsigned h = `0`; h < BASH_HASH_SIZE; h++)
491	{
492	unsigned count = BashHash[h].bhCount;
493	if (count == `0`)
494	continue;
495
496	unsigned opOld = BashHash[h].bhOperOld;
497	unsigned opNew = BashHash[h].bhOperNew;
498
499	fprintf(f, " GT_%-13s -> GT_%-13s [size: %3u->%3u] %c %7u\n", OpName((genTreeOps)opOld),
500	OpName((genTreeOps)opNew), s_gtTrueSizes[opOld], s_gtTrueSizes[opNew],
501	(s_gtTrueSizes[opOld] < s_gtTrueSizes[opNew]) ? `'X'` : `' '`, count);
502	total += count;
503	}
504	fprintf(f, "\n");
505	fprintf(f, "Total bashings: %u\n", total);
506	fprintf(f, "\n");
507
508	fflush(f);
509	}
510
511	#endif // NODEBASH_STATS
512
513	#else // SMALL_TREE_NODES
514
515	#ifdef DEBUG
516	bool GenTree::IsNodeProperlySized() const
517	{
518	return true;
519	}
520	#endif
521
522	#endif // SMALL_TREE_NODES
523
524	/***************************************************************************/
525
526	#if MEASURE_NODE_SIZE
527
528	void GenTree::DumpNodeSizes(FILE* fp)
529	{
530	// Dump the sizes of the various GenTree flavors
531
532	#if SMALL_TREE_NODES
533	fprintf(fp, "Small tree node size = %3u bytes\n", TREE_NODE_SZ_SMALL);
534	#endif
535	fprintf(fp, "Large tree node size = %3u bytes\n", TREE_NODE_SZ_LARGE);
536	fprintf(fp, "\n");
537
538	#if SMALL_TREE_NODES
539
540	// Verify that node sizes are set kosherly and dump sizes
541	for (unsigned op = GT_NONE + `1`; op < GT_COUNT; op++)
542	{
543	unsigned needSize = s_gtTrueSizes[op];
544	unsigned nodeSize = s_gtNodeSizes[op];
545
546	const char* structNm = OpStructName((genTreeOps)op);
547	const char* operName = OpName((genTreeOps)op);
548
549	bool repeated = false;
550
551	// Have we seen this struct flavor before?
552	for (unsigned mop = GT_NONE + `1`; mop < op; mop++)
553	{
554	if (strcmp(structNm, OpStructName((genTreeOps)mop)) == `0`)
555	{
556	repeated = true;
557	break;
558	}
559	}
560
561	// Don't repeat the same GenTree flavor unless we have an error
562	if (!repeated \|\| needSize > nodeSize)
563	{
564	unsigned sizeChar = `'?'`;
565
566	if (nodeSize == TREE_NODE_SZ_SMALL)
567	sizeChar = `'S'`;
568	else if (nodeSize == TREE_NODE_SZ_LARGE)
569	sizeChar = `'L'`;
570
571	fprintf(fp, "GT_%-16s ... %-19s = %3u bytes (%c)", operName, structNm, needSize, sizeChar);
572	if (needSize > nodeSize)
573	{
574	fprintf(fp, " -- ERROR -- allocation is only %u bytes!", nodeSize);
575	}
576	else if (needSize <= TREE_NODE_SZ_SMALL && nodeSize == TREE_NODE_SZ_LARGE)
577	{
578	fprintf(fp, " ... could be small");
579	}
580
581	fprintf(fp, "\n");
582	}
583	}
584
585	#endif
586	}
587
588	#endif // MEASURE_NODE_SIZE
589
590	/*****************************************************************************
591	*
592	* Walk all basic blocks and call the given function pointer for all tree
593	* nodes contained therein.
594	*/
595
596	void Compiler::fgWalkAllTreesPre(fgWalkPreFn* visitor, void* pCallBackData)
597	{
598	BasicBlock* block;
599
600	for (block = fgFirstBB; block; block = block->bbNext)
601	{
602	GenTree* tree;
603
604	for (tree = block->bbTreeList; tree; tree = tree->gtNext)
605	{
606	assert(tree->gtOper == GT_STMT);
607
608	fgWalkTreePre(&tree->gtStmt.gtStmtExpr, visitor, pCallBackData);
609	}
610	}
611	}
612
613	//-----------------------------------------------------------
614	// CopyReg: Copy the _gtRegNum/gtRegTag fields.
615	//
616	// Arguments:
617	// from - GenTree node from which to copy
618	//
619	// Return Value:
620	// None
621	void GenTree::CopyReg(GenTree* from)
622	{
623	_gtRegNum = from->_gtRegNum;
624	INDEBUG(gtRegTag = from->gtRegTag;)
625
626	// Also copy multi-reg state if this is a call node
627	if (IsCall())
628	{
629	assert(from->IsCall());
630	this->AsCall()->CopyOtherRegs(from->AsCall());
631	}
632	else if (IsCopyOrReload())
633	{
634	this->AsCopyOrReload()->CopyOtherRegs(from->AsCopyOrReload());
635	}
636	}
637
638	//------------------------------------------------------------------
639	// gtHasReg: Whether node beeen assigned a register by LSRA
640	//
641	// Arguments:
642	// None
643	//
644	// Return Value:
645	// Returns true if the node was assigned a register.
646	//
647	// In case of multi-reg call nodes, it is considered
648	// having a reg if regs are allocated for all its
649	// return values.
650	//
651	// In case of GT_COPY or GT_RELOAD of a multi-reg call,
652	// GT_COPY/GT_RELOAD is considered having a reg if it
653	// has a reg assigned to any of its positions.
654	//
655	// Assumption:
656	// In order for this to work properly, gtClearReg must be called
657	// prior to setting the register value.
658	//
659	bool GenTree::gtHasReg() const
660	{
661	bool hasReg;
662
663	if (IsMultiRegCall())
664	{
665	// Have to cast away const-ness because GetReturnTypeDesc() is a non-const method
666	GenTree* tree = const_cast<GenTree>(this*);
667	GenTreeCall* call = tree->AsCall();
668	unsigned regCount = call->GetReturnTypeDesc()->GetReturnRegCount();
669	hasReg = false;
670
671	// A Multi-reg call node is said to have regs, if it has
672	// reg assigned to each of its result registers.
673	for (unsigned i = `0`; i < regCount; ++i)
674	{
675	hasReg = (call->GetRegNumByIdx(i) != REG_NA);
676	if (!hasReg)
677	{
678	break;
679	}
680	}
681	}
682	else if (IsCopyOrReloadOfMultiRegCall())
683	{
684	GenTree* tree = const_cast<GenTree>(this*);
685	GenTreeCopyOrReload* copyOrReload = tree->AsCopyOrReload();
686	GenTreeCall* call = copyOrReload->gtGetOp1()->AsCall();
687	unsigned regCount = call->GetReturnTypeDesc()->GetReturnRegCount();
688	hasReg = false;
689
690	// A Multi-reg copy or reload node is said to have regs,
691	// if it has valid regs in any of the positions.
692	for (unsigned i = `0`; i < regCount; ++i)
693	{
694	hasReg = (copyOrReload->GetRegNumByIdx(i) != REG_NA);
695	if (hasReg)
696	{
697	break;
698	}
699	}
700	}
701	else
702	{
703	hasReg = (gtRegNum != REG_NA);
704	}
705
706	return hasReg;
707	}
708
709	//-----------------------------------------------------------------------------
710	// GetRegisterDstCount: Get the number of registers defined by the node.
711	//
712	// Arguments:
713	// None
714	//
715	// Return Value:
716	// The number of registers that this node defines.
717	//
718	// Notes:
719	// This should not be called on a contained node.
720	// This does not look at the actual register assignments, if any, and so
721	// is valid after Lowering.
722	//
723	int GenTree::GetRegisterDstCount() const
724	{
725	assert(!isContained());
726	if (!IsMultiRegNode())
727	{
728	return (IsValue()) ? `1` : `0`;
729	}
730	else if (IsMultiRegCall())
731	{
732	// temporarily cast away const-ness as AsCall() method is not declared const
733	GenTree* temp = const_cast<GenTree>(this*);
734	return temp->AsCall()->GetReturnTypeDesc()->GetReturnRegCount();
735	}
736	else if (IsCopyOrReload())
737	{
738	return gtGetOp1()->GetRegisterDstCount();
739	}
740	#if FEATURE_ARG_SPLIT
741	else if (OperIsPutArgSplit())
742	{
743	return (const_cast<GenTree>(this*))->AsPutArgSplit()->gtNumRegs;
744	}
745	#endif
746	#if !defined(_TARGET_64BIT_)
747	else if (OperIsMultiRegOp())
748	{
749	// A MultiRegOp is a GT_MUL_LONG, GT_PUTARG_REG, or GT_BITCAST.
750	// For the latter two (ARM-only), they only have multiple registers if they produce a long value
751	// (GT_MUL_LONG always produces a long value).
752	CLANG_FORMAT_COMMENT_ANCHOR;
753	#ifdef _TARGET_ARM_
754	return (TypeGet() == TYP_LONG) ? `2` : `1`;
755	#else
756	assert(OperIs(GT_MUL_LONG));
757	return `2`;
758	#endif
759	}
760	#endif
761	assert(!"Unexpected multi-reg node");
762	return `0`;
763	}
764
765	//---------------------------------------------------------------
766	// gtGetRegMask: Get the reg mask of the node.
767	//
768	// Arguments:
769	// None
770	//
771	// Return Value:
772	// Reg Mask of GenTree node.
773	//
774	regMaskTP GenTree::gtGetRegMask() const
775	{
776	regMaskTP resultMask;
777
778	if (IsMultiRegCall())
779	{
780	// temporarily cast away const-ness as AsCall() method is not declared const
781	resultMask = genRegMask(gtRegNum);
782	GenTree* temp = const_cast<GenTree>(this*);
783	resultMask \|= temp->AsCall()->GetOtherRegMask();
784	}
785	else if (IsCopyOrReloadOfMultiRegCall())
786	{
787	// A multi-reg copy or reload, will have valid regs for only those
788	// positions that need to be copied or reloaded. Hence we need
789	// to consider only those registers for computing reg mask.
790
791	GenTree* tree = const_cast<GenTree>(this*);
792	GenTreeCopyOrReload* copyOrReload = tree->AsCopyOrReload();
793	GenTreeCall* call = copyOrReload->gtGetOp1()->AsCall();
794	unsigned regCount = call->GetReturnTypeDesc()->GetReturnRegCount();
795
796	resultMask = RBM_NONE;
797	for (unsigned i = `0`; i < regCount; ++i)
798	{
799	regNumber reg = copyOrReload->GetRegNumByIdx(i);
800	if (reg != REG_NA)
801	{
802	resultMask \|= genRegMask(reg);
803	}
804	}
805	}
806	#if FEATURE_ARG_SPLIT
807	else if (OperIsPutArgSplit())
808	{
809	GenTree* tree = const_cast<GenTree>(this*);
810	GenTreePutArgSplit* splitArg = tree->AsPutArgSplit();
811	unsigned regCount = splitArg->gtNumRegs;
812
813	resultMask = RBM_NONE;
814	for (unsigned i = `0`; i < regCount; ++i)
815	{
816	regNumber reg = splitArg->GetRegNumByIdx(i);
817	assert(reg != REG_NA);
818	resultMask \|= genRegMask(reg);
819	}
820	}
821	#endif // FEATURE_ARG_SPLIT
822	else
823	{
824	resultMask = genRegMask(gtRegNum);
825	}
826
827	return resultMask;
828	}
829
830	//---------------------------------------------------------------
831	// GetOtherRegMask: Get the reg mask of gtOtherRegs of call node
832	//
833	// Arguments:
834	// None
835	//
836	// Return Value:
837	// Reg mask of gtOtherRegs of call node.
838	//
839	regMaskTP GenTreeCall::GetOtherRegMask() const
840	{
841	regMaskTP resultMask = RBM_NONE;
842
843	#if FEATURE_MULTIREG_RET
844	for (unsigned i = `0`; i < MAX_RET_REG_COUNT - `1`; ++i)
845	{
846	if (gtOtherRegs[i] != REG_NA)
847	{
848	resultMask \|= genRegMask((regNumber)gtOtherRegs[i]);
849	continue;
850	}
851	break;
852	}
853	#endif
854
855	return resultMask;
856	}
857
858	//-------------------------------------------------------------------------
859	// IsPure:
860	// Returns true if this call is pure. For now, this uses the same
861	// definition of "pure" that is that used by HelperCallProperties: a
862	// pure call does not read or write any aliased (e.g. heap) memory or
863	// have other global side effects (e.g. class constructors, finalizers),
864	// but is allowed to throw an exception.
865	//
866	// NOTE: this call currently only returns true if the call target is a
867	// helper method that is known to be pure. No other analysis is
868	// performed.
869	//
870	// Arguments:
871	// Copiler - the compiler context.
872	//
873	// Returns:
874	// True if the call is pure; false otherwise.
875	//
876	bool GenTreeCall::IsPure(Compiler* compiler) const
877	{
878	return (gtCallType == CT_HELPER) &&
879	compiler->s_helperCallProperties.IsPure(compiler->eeGetHelperNum(gtCallMethHnd));
880	}
881
882	//-------------------------------------------------------------------------
883	// HasSideEffects:
884	// Returns true if this call has any side effects. All non-helpers are considered to have side-effects. Only helpers
885	// that do not mutate the heap, do not run constructors, may not throw, and are either a) pure or b) non-finalizing
886	// allocation functions are considered side-effect-free.
887	//
888	// Arguments:
889	// compiler - the compiler instance
890	// ignoreExceptions - when `true`, ignores exception side effects
891	// ignoreCctors - when `true`, ignores class constructor side effects
892	//
893	// Return Value:
894	// true if this call has any side-effects; false otherwise.
895	bool GenTreeCall::HasSideEffects(Compiler* compiler, bool ignoreExceptions, bool ignoreCctors) const
896	{
897	// Generally all GT_CALL nodes are considered to have side-effects, but we may have extra information about helper
898	// calls that can prove them side-effect-free.
899	if (gtCallType != CT_HELPER)
900	{
901	return true;
902	}
903
904	CorInfoHelpFunc helper = compiler->eeGetHelperNum(gtCallMethHnd);
905	HelperCallProperties& helperProperties = compiler->s_helperCallProperties;
906
907	// We definitely care about the side effects if MutatesHeap is true
908	if (helperProperties.MutatesHeap(helper))
909	{
910	return true;
911	}
912
913	// Unless we have been instructed to ignore cctors (CSE, for example, ignores cctors), consider them side effects.
914	if (!ignoreCctors && helperProperties.MayRunCctor(helper))
915	{
916	return true;
917	}
918
919	// If we also care about exceptions then check if the helper can throw
920	if (!ignoreExceptions && !helperProperties.NoThrow(helper))
921	{
922	return true;
923	}
924
925	// If this is not a Pure helper call or an allocator (that will not need to run a finalizer)
926	// then this call has side effects.
927	return !helperProperties.IsPure(helper) &&
928	(!helperProperties.IsAllocator(helper) \|\| ((gtCallMoreFlags & GTF_CALL_M_ALLOC_SIDE_EFFECTS) != `0`));
929	}
930
931	//-------------------------------------------------------------------------
932	// HasNonStandardAddedArgs: Return true if the method has non-standard args added to the call
933	// argument list during argument morphing (fgMorphArgs), e.g., passed in R10 or R11 on AMD64.
934	// See also GetNonStandardAddedArgCount().
935	//
936	// Arguments:
937	// compiler - the compiler instance
938	//
939	// Return Value:
940	// true if there are any such args, false otherwise.
941	//
942	bool GenTreeCall::HasNonStandardAddedArgs(Compiler* compiler) const
943	{
944	return GetNonStandardAddedArgCount(compiler) != `0`;
945	}
946
947	//-------------------------------------------------------------------------
948	// GetNonStandardAddedArgCount: Get the count of non-standard arguments that have been added
949	// during call argument morphing (fgMorphArgs). Do not count non-standard args that are already
950	// counted in the argument list prior to morphing.
951	//
952	// This function is used to help map the caller and callee arguments during tail call setup.
953	//
954	// Arguments:
955	// compiler - the compiler instance
956	//
957	// Return Value:
958	// The count of args, as described.
959	//
960	// Notes:
961	// It would be more general to have fgMorphArgs set a bit on the call node when such
962	// args are added to a call, and a bit on each such arg, and then have this code loop
963	// over the call args when the special call bit is set, counting the args with the special
964	// arg bit. This seems pretty heavyweight, though. Instead, this logic needs to be kept
965	// in sync with fgMorphArgs.
966	//
967	int GenTreeCall::GetNonStandardAddedArgCount(Compiler* compiler) const
968	{
969	if (IsUnmanaged() && !compiler->opts.ShouldUsePInvokeHelpers())
970	{
971	// R11 = PInvoke cookie param
972	return `1`;
973	}
974	else if (IsVirtualStub())
975	{
976	// R11 = Virtual stub param
977	return `1`;
978	}
979	else if ((gtCallType == CT_INDIRECT) && (gtCallCookie != nullptr))
980	{
981	// R10 = PInvoke target param
982	// R11 = PInvoke cookie param
983	return `2`;
984	}
985	return `0`;
986	}
987
988	//-------------------------------------------------------------------------
989	// TreatAsHasRetBufArg:
990	//
991	// Arguments:
992	// compiler, the compiler instance so that we can call eeGetHelperNum
993	//
994	// Return Value:
995	// Returns true if we treat the call as if it has a retBuf argument
996	// This method may actually have a retBuf argument
997	// or it could be a JIT helper that we are still transforming during
998	// the importer phase.
999	//
1000	// Notes:
1001	// On ARM64 marking the method with the GTF_CALL_M_RETBUFFARG flag
1002	// will make HasRetBufArg() return true, but will also force the
1003	// use of register x8 to pass the RetBuf argument.
1004	//
1005	// These two Jit Helpers that we handle here by returning true
1006	// aren't actually defined to return a struct, so they don't expect
1007	// their RetBuf to be passed in x8, instead they expect it in x0.
1008	//
1009	bool GenTreeCall::TreatAsHasRetBufArg(Compiler* compiler) const
1010	{
1011	if (HasRetBufArg())
1012	{
1013	return true;
1014	}
1015	else
1016	{
1017	// If we see a Jit helper call that returns a TYP_STRUCT we will
1018	// transform it as if it has a Return Buffer Argument
1019	//
1020	if (IsHelperCall() && (gtReturnType == TYP_STRUCT))
1021	{
1022	// There are two possible helper calls that use this path:
1023	// CORINFO_HELP_GETFIELDSTRUCT and CORINFO_HELP_UNBOX_NULLABLE
1024	//
1025	CorInfoHelpFunc helpFunc = compiler->eeGetHelperNum(gtCallMethHnd);
1026
1027	if (helpFunc == CORINFO_HELP_GETFIELDSTRUCT)
1028	{
1029	return true;
1030	}
1031	else if (helpFunc == CORINFO_HELP_UNBOX_NULLABLE)
1032	{
1033	return true;
1034	}
1035	else
1036	{
1037	assert(!"Unexpected JIT helper in TreatAsHasRetBufArg");
1038	}
1039	}
1040	}
1041	return false;
1042	}
1043
1044	//-------------------------------------------------------------------------
1045	// IsHelperCall: Determine if this GT_CALL node is a specific helper call.
1046	//
1047	// Arguments:
1048	// compiler - the compiler instance so that we can call eeFindHelper
1049	//
1050	// Return Value:
1051	// Returns true if this GT_CALL node is a call to the specified helper.
1052	//
1053	bool GenTreeCall::IsHelperCall(Compiler* compiler, unsigned helper) const
1054	{
1055	return IsHelperCall(compiler->eeFindHelper(helper));
1056	}
1057
1058	//------------------------------------------------------------------------
1059	// GenTreeCall::ReplaceCallOperand:
1060	// Replaces a given operand to a call node and updates the call
1061	// argument table if necessary.
1062	//
1063	// Arguments:
1064	// useEdge - the use edge that points to the operand to be replaced.
1065	// replacement - the replacement node.
1066	//
1067	void GenTreeCall::ReplaceCallOperand(GenTree** useEdge, GenTree* replacement)
1068	{
1069	assert(useEdge != nullptr);
1070	assert(replacement != nullptr);
1071	assert(TryGetUse(*useEdge, &useEdge));
1072
1073	GenTree* originalOperand = *useEdge;
1074	*useEdge = replacement;
1075
1076	const bool isArgument =
1077	(replacement != gtControlExpr) &&
1078	((gtCallType != CT_INDIRECT) \|\| ((replacement != gtCallCookie) && (replacement != gtCallAddr)));
1079
1080	if (isArgument)
1081	{
1082	if ((originalOperand->gtFlags & GTF_LATE_ARG) != `0`)
1083	{
1084	replacement->gtFlags \|= GTF_LATE_ARG;
1085	}
1086	else
1087	{
1088	assert((replacement->gtFlags & GTF_LATE_ARG) == `0`);
1089
1090	fgArgTabEntry* fp = Compiler::gtArgEntryByNode(this, originalOperand);
1091	assert(fp->node == originalOperand);
1092	fp->node = replacement;
1093	}
1094	}
1095	}
1096
1097	//-------------------------------------------------------------------------
1098	// AreArgsComplete: Determine if this GT_CALL node's arguments have been processed.
1099	//
1100	// Return Value:
1101	// Returns true if fgMorphArgs has processed the arguments.
1102	//
1103	bool GenTreeCall::AreArgsComplete() const
1104	{
1105	if (fgArgInfo == nullptr)
1106	{
1107	return false;
1108	}
1109	if (fgArgInfo->AreArgsComplete())
1110	{
1111	assert((gtCallLateArgs != nullptr) \|\| !fgArgInfo->HasRegArgs());
1112	return true;
1113	}
1114	assert(gtCallArgs == nullptr);
1115	return false;
1116	}
1117
1118	#if !defined(FEATURE_PUT_STRUCT_ARG_STK)
1119	unsigned GenTreePutArgStk::getArgSize()
1120	{
1121	return genTypeSize(genActualType(gtOp1->gtType));
1122	}
1123	#endif // !defined(FEATURE_PUT_STRUCT_ARG_STK)
1124
1125	/*****************************************************************************
1126	*
1127	* Returns non-zero if the two trees are identical.
1128	*/
1129
1130	bool GenTree::Compare(GenTree* op1, GenTree* op2, bool swapOK)
1131	{
1132	genTreeOps oper;
1133	unsigned kind;
1134
1135	// printf("tree1:\n"); gtDispTree(op1);
1136	// printf("tree2:\n"); gtDispTree(op2);
1137
1138	AGAIN:
1139
1140	if (op1 == nullptr)
1141	{
1142	return (op2 == nullptr);
1143	}
1144	if (op2 == nullptr)
1145	{
1146	return false;
1147	}
1148	if (op1 == op2)
1149	{
1150	return true;
1151	}
1152
1153	assert(op1->gtOper != GT_STMT);
1154	assert(op2->gtOper != GT_STMT);
1155
1156	oper = op1->OperGet();
1157
1158	/ The operators must be equal /
1159
1160	if (oper != op2->gtOper)
1161	{
1162	return false;
1163	}
1164
1165	/ The types must be equal /
1166
1167	if (op1->gtType != op2->gtType)
1168	{
1169	return false;
1170	}
1171
1172	/ Overflow must be equal /
1173	if (op1->gtOverflowEx() != op2->gtOverflowEx())
1174	{
1175	return false;
1176	}
1177
1178	/ Sensible flags must be equal /
1179	if ((op1->gtFlags & (GTF_UNSIGNED)) != (op2->gtFlags & (GTF_UNSIGNED)))
1180	{
1181	return false;
1182	}
1183
1184	/ Figure out what kind of nodes we're comparing /
1185
1186	kind = op1->OperKind();
1187
1188	/ Is this a constant node? /
1189
1190	if (kind & GTK_CONST)
1191	{
1192	switch (oper)
1193	{
1194	case GT_CNS_INT:
1195	if (op1->gtIntCon.gtIconVal == op2->gtIntCon.gtIconVal)
1196	{
1197	return true;
1198	}
1199	break;
1200	#if 0
1201	// TODO-CQ: Enable this in the future
1202	case GT_CNS_LNG:
1203	if (op1->gtLngCon.gtLconVal == op2->gtLngCon.gtLconVal)
1204	return true;
1205	break;
1206
1207	case GT_CNS_DBL:
1208	if (op1->gtDblCon.gtDconVal == op2->gtDblCon.gtDconVal)
1209	return true;
1210	break;
1211	#endif
1212	default:
1213	break;
1214	}
1215
1216	return false;
1217	}
1218
1219	/ Is this a leaf node? /
1220
1221	if (kind & GTK_LEAF)
1222	{
1223	switch (oper)
1224	{
1225	case GT_LCL_VAR:
1226	if (op1->gtLclVarCommon.gtLclNum != op2->gtLclVarCommon.gtLclNum)
1227	{
1228	break;
1229	}
1230
1231	return true;
1232
1233	case GT_LCL_FLD:
1234	if (op1->gtLclFld.gtLclNum != op2->gtLclFld.gtLclNum \|\|
1235	op1->gtLclFld.gtLclOffs != op2->gtLclFld.gtLclOffs)
1236	{
1237	break;
1238	}
1239
1240	return true;
1241
1242	case GT_CLS_VAR:
1243	if (op1->gtClsVar.gtClsVarHnd != op2->gtClsVar.gtClsVarHnd)
1244	{
1245	break;
1246	}
1247
1248	return true;
1249
1250	case GT_LABEL:
1251	return true;
1252
1253	case GT_ARGPLACE:
1254	if ((op1->gtType == TYP_STRUCT) &&
1255	(op1->gtArgPlace.gtArgPlaceClsHnd != op2->gtArgPlace.gtArgPlaceClsHnd))
1256	{
1257	break;
1258	}
1259	return true;
1260
1261	default:
1262	break;
1263	}
1264
1265	return false;
1266	}
1267
1268	/ Is it a 'simple' unary/binary operator? /
1269
1270	if (kind & GTK_UNOP)
1271	{
1272	if (IsExOp(kind))
1273	{
1274	// ExOp operators extend unary operator with extra, non-GenTree members. In many cases,*
1275	// these should be included in the comparison.
1276	switch (oper)
1277	{
1278	case GT_ARR_LENGTH:
1279	if (op1->gtArrLen.ArrLenOffset() != op2->gtArrLen.ArrLenOffset())
1280	{
1281	return false;
1282	}
1283	break;
1284	case GT_CAST:
1285	if (op1->gtCast.gtCastType != op2->gtCast.gtCastType)
1286	{
1287	return false;
1288	}
1289	break;
1290	case GT_OBJ:
1291	if (op1->AsObj()->gtClass != op2->AsObj()->gtClass)
1292	{
1293	return false;
1294	}
1295	break;
1296
1297	// For the ones below no extra argument matters for comparison.
1298	case GT_BOX:
1299	case GT_RUNTIMELOOKUP:
1300	break;
1301
1302	default:
1303	assert(!"unexpected unary ExOp operator");
1304	}
1305	}
1306	return Compare(op1->gtOp.gtOp1, op2->gtOp.gtOp1);
1307	}
1308
1309	if (kind & GTK_BINOP)
1310	{
1311	if (IsExOp(kind))
1312	{
1313	// ExOp operators extend unary operator with extra, non-GenTree members. In many cases,*
1314	// these should be included in the hash code.
1315	switch (oper)
1316	{
1317	case GT_INTRINSIC:
1318	if (op1->gtIntrinsic.gtIntrinsicId != op2->gtIntrinsic.gtIntrinsicId)
1319	{
1320	return false;
1321	}
1322	break;
1323	case GT_LEA:
1324	if (op1->gtAddrMode.gtScale != op2->gtAddrMode.gtScale)
1325	{
1326	return false;
1327	}
1328	if (op1->gtAddrMode.Offset() != op2->gtAddrMode.Offset())
1329	{
1330	return false;
1331	}
1332	break;
1333	case GT_INDEX:
1334	if (op1->gtIndex.gtIndElemSize != op2->gtIndex.gtIndElemSize)
1335	{
1336	return false;
1337	}
1338	break;
1339	case GT_INDEX_ADDR:
1340	if (op1->AsIndexAddr()->gtElemSize != op2->AsIndexAddr()->gtElemSize)
1341	{
1342	return false;
1343	}
1344	break;
1345	#ifdef FEATURE_SIMD
1346	case GT_SIMD:
1347	if ((op1->AsSIMD()->gtSIMDIntrinsicID != op2->AsSIMD()->gtSIMDIntrinsicID) \|\|
1348	(op1->AsSIMD()->gtSIMDBaseType != op2->AsSIMD()->gtSIMDBaseType) \|\|
1349	(op1->AsSIMD()->gtSIMDSize != op2->AsSIMD()->gtSIMDSize))
1350	{
1351	return false;
1352	}
1353	break;
1354	#endif // FEATURE_SIMD
1355
1356	#ifdef FEATURE_HW_INTRINSICS
1357	case GT_HWIntrinsic:
1358	if ((op1->AsHWIntrinsic()->gtHWIntrinsicId != op2->AsHWIntrinsic()->gtHWIntrinsicId) \|\|
1359	(op1->AsHWIntrinsic()->gtSIMDBaseType != op2->AsHWIntrinsic()->gtSIMDBaseType) \|\|
1360	(op1->AsHWIntrinsic()->gtSIMDSize != op2->AsHWIntrinsic()->gtSIMDSize) \|\|
1361	(op1->AsHWIntrinsic()->gtIndexBaseType != op2->AsHWIntrinsic()->gtIndexBaseType))
1362	{
1363	return false;
1364	}
1365	break;
1366	#endif
1367
1368	// For the ones below no extra argument matters for comparison.
1369	case GT_QMARK:
1370	break;
1371
1372	default:
1373	assert(!"unexpected binary ExOp operator");
1374	}
1375	}
1376
1377	if (op1->gtOp.gtOp2)
1378	{
1379	if (!Compare(op1->gtOp.gtOp1, op2->gtOp.gtOp1, swapOK))
1380	{
1381	if (swapOK && OperIsCommutative(oper) &&
1382	((op1->gtOp.gtOp1->gtFlags \| op1->gtOp.gtOp2->gtFlags \| op2->gtOp.gtOp1->gtFlags \|
1383	op2->gtOp.gtOp2->gtFlags) &
1384	GTF_ALL_EFFECT) == `0`)
1385	{
1386	if (Compare(op1->gtOp.gtOp1, op2->gtOp.gtOp2, swapOK))
1387	{
1388	op1 = op1->gtOp.gtOp2;
1389	op2 = op2->gtOp.gtOp1;
1390	goto AGAIN;
1391	}
1392	}
1393
1394	return false;
1395	}
1396
1397	op1 = op1->gtOp.gtOp2;
1398	op2 = op2->gtOp.gtOp2;
1399
1400	goto AGAIN;
1401	}
1402	else
1403	{
1404
1405	op1 = op1->gtOp.gtOp1;
1406	op2 = op2->gtOp.gtOp1;
1407
1408	if (!op1)
1409	{
1410	return (op2 == nullptr);
1411	}
1412	if (!op2)
1413	{
1414	return false;
1415	}
1416
1417	goto AGAIN;
1418	}
1419	}
1420
1421	/ See what kind of a special operator we have here /
1422
1423	switch (oper)
1424	{
1425	case GT_FIELD:
1426	if (op1->gtField.gtFldHnd != op2->gtField.gtFldHnd)
1427	{
1428	break;
1429	}
1430
1431	op1 = op1->gtField.gtFldObj;
1432	op2 = op2->gtField.gtFldObj;
1433
1434	if (op1 \|\| op2)
1435	{
1436	if (op1 && op2)
1437	{
1438	goto AGAIN;
1439	}
1440	}
1441
1442	return true;
1443
1444	case GT_CALL:
1445
1446	if (op1->gtCall.gtCallType != op2->gtCall.gtCallType)
1447	{
1448	return false;
1449	}
1450
1451	if (op1->gtCall.gtCallType != CT_INDIRECT)
1452	{
1453	if (op1->gtCall.gtCallMethHnd != op2->gtCall.gtCallMethHnd)
1454	{
1455	return false;
1456	}
1457
1458	#ifdef FEATURE_READYTORUN_COMPILER
1459	if (op1->gtCall.gtEntryPoint.addr != op2->gtCall.gtEntryPoint.addr)
1460	{
1461	return false;
1462	}
1463	#endif
1464	}
1465	else
1466	{
1467	if (!Compare(op1->gtCall.gtCallAddr, op2->gtCall.gtCallAddr))
1468	{
1469	return false;
1470	}
1471	}
1472
1473	if (Compare(op1->gtCall.gtCallLateArgs, op2->gtCall.gtCallLateArgs) &&
1474	Compare(op1->gtCall.gtCallArgs, op2->gtCall.gtCallArgs) &&
1475	Compare(op1->gtCall.gtControlExpr, op2->gtCall.gtControlExpr) &&
1476	Compare(op1->gtCall.gtCallObjp, op2->gtCall.gtCallObjp))
1477	{
1478	return true;
1479	}
1480	break;
1481
1482	case GT_ARR_ELEM:
1483
1484	if (op1->gtArrElem.gtArrRank != op2->gtArrElem.gtArrRank)
1485	{
1486	return false;
1487	}
1488
1489	// NOTE: gtArrElemSize may need to be handled
1490
1491	unsigned dim;
1492	for (dim = `0`; dim < op1->gtArrElem.gtArrRank; dim++)
1493	{
1494	if (!Compare(op1->gtArrElem.gtArrInds[dim], op2->gtArrElem.gtArrInds[dim]))
1495	{
1496	return false;
1497	}
1498	}
1499
1500	op1 = op1->gtArrElem.gtArrObj;
1501	op2 = op2->gtArrElem.gtArrObj;
1502	goto AGAIN;
1503
1504	case GT_ARR_OFFSET:
1505	if (op1->gtArrOffs.gtCurrDim != op2->gtArrOffs.gtCurrDim \|\|
1506	op1->gtArrOffs.gtArrRank != op2->gtArrOffs.gtArrRank)
1507	{
1508	return false;
1509	}
1510	return (Compare(op1->gtArrOffs.gtOffset, op2->gtArrOffs.gtOffset) &&
1511	Compare(op1->gtArrOffs.gtIndex, op2->gtArrOffs.gtIndex) &&
1512	Compare(op1->gtArrOffs.gtArrObj, op2->gtArrOffs.gtArrObj));
1513
1514	case GT_CMPXCHG:
1515	return Compare(op1->gtCmpXchg.gtOpLocation, op2->gtCmpXchg.gtOpLocation) &&
1516	Compare(op1->gtCmpXchg.gtOpValue, op2->gtCmpXchg.gtOpValue) &&
1517	Compare(op1->gtCmpXchg.gtOpComparand, op2->gtCmpXchg.gtOpComparand);
1518
1519	case GT_ARR_BOUNDS_CHECK:
1520	#ifdef FEATURE_SIMD
1521	case GT_SIMD_CHK:
1522	#endif // FEATURE_SIMD
1523	#ifdef FEATURE_HW_INTRINSICS
1524	case GT_HW_INTRINSIC_CHK:
1525	#endif // FEATURE_HW_INTRINSICS
1526	return Compare(op1->gtBoundsChk.gtIndex, op2->gtBoundsChk.gtIndex) &&
1527	Compare(op1->gtBoundsChk.gtArrLen, op2->gtBoundsChk.gtArrLen) &&
1528	(op1->gtBoundsChk.gtThrowKind == op2->gtBoundsChk.gtThrowKind);
1529
1530	case GT_STORE_DYN_BLK:
1531	case GT_DYN_BLK:
1532	return Compare(op1->gtDynBlk.Addr(), op2->gtDynBlk.Addr()) &&
1533	Compare(op1->gtDynBlk.Data(), op2->gtDynBlk.Data()) &&
1534	Compare(op1->gtDynBlk.gtDynamicSize, op2->gtDynBlk.gtDynamicSize);
1535
1536	default:
1537	assert(!"unexpected operator");
1538	}
1539
1540	return false;
1541	}
1542
1543	/*****************************************************************************
1544	*
1545	* Returns non-zero if the given tree contains a use of a local #lclNum.
1546	*/
1547
1548	bool Compiler::gtHasRef(GenTree* tree, ssize_t lclNum, bool defOnly)
1549	{
1550	genTreeOps oper;
1551	unsigned kind;
1552
1553	AGAIN:
1554
1555	assert(tree);
1556
1557	oper = tree->OperGet();
1558	kind = tree->OperKind();
1559
1560	assert(oper != GT_STMT);
1561
1562	/ Is this a constant node? /
1563
1564	if (kind & GTK_CONST)
1565	{
1566	return false;
1567	}
1568
1569	/ Is this a leaf node? /
1570
1571	if (kind & GTK_LEAF)
1572	{
1573	if (oper == GT_LCL_VAR)
1574	{
1575	if (tree->gtLclVarCommon.gtLclNum == (unsigned)lclNum)
1576	{
1577	if (!defOnly)
1578	{
1579	return true;
1580	}
1581	}
1582	}
1583	else if (oper == GT_RET_EXPR)
1584	{
1585	return gtHasRef(tree->gtRetExpr.gtInlineCandidate, lclNum, defOnly);
1586	}
1587
1588	return false;
1589	}
1590
1591	/ Is it a 'simple' unary/binary operator? /
1592
1593	if (kind & GTK_SMPOP)
1594	{
1595	if (tree->gtGetOp2IfPresent())
1596	{
1597	if (gtHasRef(tree->gtOp.gtOp1, lclNum, defOnly))
1598	{
1599	return true;
1600	}
1601
1602	tree = tree->gtOp.gtOp2;
1603	goto AGAIN;
1604	}
1605	else
1606	{
1607	tree = tree->gtOp.gtOp1;
1608
1609	if (!tree)
1610	{
1611	return false;
1612	}
1613
1614	if (oper == GT_ASG)
1615	{
1616	// 'tree' is the gtOp1 of an assignment node. So we can handle
1617	// the case where defOnly is either true or false.
1618
1619	if (tree->gtOper == GT_LCL_VAR && tree->gtLclVarCommon.gtLclNum == (unsigned)lclNum)
1620	{
1621	return true;
1622	}
1623	else if (tree->gtOper == GT_FIELD && lclNum == (ssize_t)tree->gtField.gtFldHnd)
1624	{
1625	return true;
1626	}
1627	}
1628
1629	goto AGAIN;
1630	}
1631	}
1632
1633	/ See what kind of a special operator we have here /
1634
1635	switch (oper)
1636	{
1637	case GT_FIELD:
1638	if (lclNum == (ssize_t)tree->gtField.gtFldHnd)
1639	{
1640	if (!defOnly)
1641	{
1642	return true;
1643	}
1644	}
1645
1646	tree = tree->gtField.gtFldObj;
1647	if (tree)
1648	{
1649	goto AGAIN;
1650	}
1651	break;
1652
1653	case GT_CALL:
1654
1655	if (tree->gtCall.gtCallObjp)
1656	{
1657	if (gtHasRef(tree->gtCall.gtCallObjp, lclNum, defOnly))
1658	{
1659	return true;
1660	}
1661	}
1662
1663	if (tree->gtCall.gtCallArgs)
1664	{
1665	if (gtHasRef(tree->gtCall.gtCallArgs, lclNum, defOnly))
1666	{
1667	return true;
1668	}
1669	}
1670
1671	if (tree->gtCall.gtCallLateArgs)
1672	{
1673	if (gtHasRef(tree->gtCall.gtCallLateArgs, lclNum, defOnly))
1674	{
1675	return true;
1676	}
1677	}
1678
1679	if (tree->gtCall.gtControlExpr)
1680	{
1681	if (gtHasRef(tree->gtCall.gtControlExpr, lclNum, defOnly))
1682	{
1683	return true;
1684	}
1685	}
1686
1687	if (tree->gtCall.gtCallType == CT_INDIRECT)
1688	{
1689	// pinvoke-calli cookie is a constant, or constant indirection
1690	assert(tree->gtCall.gtCallCookie == nullptr \|\| tree->gtCall.gtCallCookie->gtOper == GT_CNS_INT \|\|
1691	tree->gtCall.gtCallCookie->gtOper == GT_IND);
1692
1693	tree = tree->gtCall.gtCallAddr;
1694	}
1695	else
1696	{
1697	tree = nullptr;
1698	}
1699
1700	if (tree)
1701	{
1702	goto AGAIN;
1703	}
1704
1705	break;
1706
1707	case GT_ARR_ELEM:
1708	if (gtHasRef(tree->gtArrElem.gtArrObj, lclNum, defOnly))
1709	{
1710	return true;
1711	}
1712
1713	unsigned dim;
1714	for (dim = `0`; dim < tree->gtArrElem.gtArrRank; dim++)
1715	{
1716	if (gtHasRef(tree->gtArrElem.gtArrInds[dim], lclNum, defOnly))
1717	{
1718	return true;
1719	}
1720	}
1721
1722	break;
1723
1724	case GT_ARR_OFFSET:
1725	if (gtHasRef(tree->gtArrOffs.gtOffset, lclNum, defOnly) \|\|
1726	gtHasRef(tree->gtArrOffs.gtIndex, lclNum, defOnly) \|\|
1727	gtHasRef(tree->gtArrOffs.gtArrObj, lclNum, defOnly))
1728	{
1729	return true;
1730	}
1731	break;
1732
1733	case GT_CMPXCHG:
1734	if (gtHasRef(tree->gtCmpXchg.gtOpLocation, lclNum, defOnly))
1735	{
1736	return true;
1737	}
1738	if (gtHasRef(tree->gtCmpXchg.gtOpValue, lclNum, defOnly))
1739	{
1740	return true;
1741	}
1742	if (gtHasRef(tree->gtCmpXchg.gtOpComparand, lclNum, defOnly))
1743	{
1744	return true;
1745	}
1746	break;
1747
1748	case GT_ARR_BOUNDS_CHECK:
1749	#ifdef FEATURE_SIMD
1750	case GT_SIMD_CHK:
1751	#endif // FEATURE_SIMD
1752	#ifdef FEATURE_HW_INTRINSICS
1753	case GT_HW_INTRINSIC_CHK:
1754	#endif // FEATURE_HW_INTRINSICS
1755	if (gtHasRef(tree->gtBoundsChk.gtIndex, lclNum, defOnly))
1756	{
1757	return true;
1758	}
1759	if (gtHasRef(tree->gtBoundsChk.gtArrLen, lclNum, defOnly))
1760	{
1761	return true;
1762	}
1763	break;
1764
1765	case GT_STORE_DYN_BLK:
1766	if (gtHasRef(tree->gtDynBlk.Data(), lclNum, defOnly))
1767	{
1768	return true;
1769	}
1770	__fallthrough;
1771	case GT_DYN_BLK:
1772	if (gtHasRef(tree->gtDynBlk.Addr(), lclNum, defOnly))
1773	{
1774	return true;
1775	}
1776	if (gtHasRef(tree->gtDynBlk.gtDynamicSize, lclNum, defOnly))
1777	{
1778	return true;
1779	}
1780	break;
1781
1782	default:
1783	#ifdef DEBUG
1784	gtDispTree(tree);
1785	#endif
1786	assert(!"unexpected operator");
1787	}
1788
1789	return false;
1790	}
1791
1792	struct AddrTakenDsc
1793	{
1794	Compiler* comp;
1795	bool hasAddrTakenLcl;
1796	};
1797
1798	/ static /
1799	Compiler::fgWalkResult Compiler::gtHasLocalsWithAddrOpCB(GenTree** pTree, fgWalkData* data)
1800	{
1801	GenTree* tree = *pTree;
1802	Compiler* comp = data->compiler;
1803
1804	if (tree->gtOper == GT_LCL_VAR)
1805	{
1806	unsigned lclNum = tree->gtLclVarCommon.gtLclNum;
1807	LclVarDsc* varDsc = &comp->lvaTable[lclNum];
1808
1809	if (varDsc->lvHasLdAddrOp \|\| varDsc->lvAddrExposed)
1810	{
1811	((AddrTakenDsc)data->pCallbackData)->hasAddrTakenLcl = true*;
1812	return WALK_ABORT;
1813	}
1814	}
1815
1816	return WALK_CONTINUE;
1817	}
1818
1819	/*****************************************************************************
1820	*
1821	* Return true if this tree contains locals with lvHasLdAddrOp or lvAddrExposed
1822	* flag(s) set.
1823	*/
1824
1825	bool Compiler::gtHasLocalsWithAddrOp(GenTree* tree)
1826	{
1827	AddrTakenDsc desc;
1828
1829	desc.comp = this;
1830	desc.hasAddrTakenLcl = false;
1831
1832	fgWalkTreePre(&tree, gtHasLocalsWithAddrOpCB, &desc);
1833
1834	return desc.hasAddrTakenLcl;
1835	}
1836
1837	#ifdef DEBUG
1838
1839	/*****************************************************************************
1840	*
1841	* Helper used to compute hash values for trees.
1842	*/
1843
1844	inline unsigned genTreeHashAdd(unsigned old, unsigned add)
1845	{
1846	return (old + old / `2`) ^ add;
1847	}
1848
1849	inline unsigned genTreeHashAdd(unsigned old, void* add)
1850	{
1851	return genTreeHashAdd(old, (unsigned)(size_t)add);
1852	}
1853
1854	/*****************************************************************************
1855	*
1856	* Given an arbitrary expression tree, compute a hash value for it.
1857	*/
1858
1859	unsigned Compiler::gtHashValue(GenTree* tree)
1860	{
1861	genTreeOps oper;
1862	unsigned kind;
1863
1864	unsigned hash = `0`;
1865
1866	GenTree* temp;
1867
1868	AGAIN:
1869	assert(tree);
1870	assert(tree->gtOper != GT_STMT);
1871
1872	/ Figure out what kind of a node we have /
1873
1874	oper = tree->OperGet();
1875	kind = tree->OperKind();
1876
1877	/ Include the operator value in the hash /
1878
1879	hash = genTreeHashAdd(hash, oper);
1880
1881	/ Is this a constant or leaf node? /
1882
1883	if (kind & (GTK_CONST \| GTK_LEAF))
1884	{
1885	size_t add;
1886
1887	switch (oper)
1888	{
1889	UINT64 bits;
1890	case GT_LCL_VAR:
1891	add = tree->gtLclVar.gtLclNum;
1892	break;
1893	case GT_LCL_FLD:
1894	hash = genTreeHashAdd(hash, tree->gtLclFld.gtLclNum);
1895	add = tree->gtLclFld.gtLclOffs;
1896	break;
1897
1898	case GT_CNS_INT:
1899	add = tree->gtIntCon.gtIconVal;
1900	break;
1901	case GT_CNS_LNG:
1902	bits = (UINT64)tree->gtLngCon.gtLconVal;
1903	#ifdef _HOST_64BIT_
1904	add = bits;
1905	#else // 32-bit host
1906	add = genTreeHashAdd(uhi32(bits), ulo32(bits));
1907	#endif
1908	break;
1909	case GT_CNS_DBL:
1910	bits = (UINT64)(&tree->gtDblCon.gtDconVal);
1911	#ifdef _HOST_64BIT_
1912	add = bits;
1913	#else // 32-bit host
1914	add = genTreeHashAdd(uhi32(bits), ulo32(bits));
1915	#endif
1916	break;
1917	case GT_CNS_STR:
1918	add = tree->gtStrCon.gtSconCPX;
1919	break;
1920
1921	case GT_JMP:
1922	add = tree->gtVal.gtVal1;
1923	break;
1924
1925	default:
1926	add = `0`;
1927	break;
1928	}
1929
1930	// clang-format off
1931	// narrow 'add' into a 32-bit 'val'
1932	unsigned val;
1933	#ifdef _HOST_64BIT_
1934	val = genTreeHashAdd(uhi32(add), ulo32(add));
1935	#else // 32-bit host
1936	val = add;
1937	#endif
1938	// clang-format on
1939
1940	hash = genTreeHashAdd(hash, val);
1941	goto DONE;
1942	}
1943
1944	/ Is it a 'simple' unary/binary operator? /
1945
1946	GenTree* op1;
1947
1948	if (kind & GTK_UNOP)
1949	{
1950	op1 = tree->gtOp.gtOp1;
1951	/ Special case: no sub-operand at all /
1952
1953	if (GenTree::IsExOp(kind))
1954	{
1955	// ExOp operators extend operators with extra, non-GenTree members. In many cases,*
1956	// these should be included in the hash code.
1957	switch (oper)
1958	{
1959	case GT_ARR_LENGTH:
1960	hash += tree->gtArrLen.ArrLenOffset();
1961	break;
1962	case GT_CAST:
1963	hash ^= tree->gtCast.gtCastType;
1964	break;
1965	case GT_INDEX:
1966	hash += tree->gtIndex.gtIndElemSize;
1967	break;
1968	case GT_INDEX_ADDR:
1969	hash += tree->AsIndexAddr()->gtElemSize;
1970	break;
1971	case GT_ALLOCOBJ:
1972	hash = genTreeHashAdd(hash, static_cast<unsigned>(
1973	reinterpret_cast<uintptr_t>(tree->gtAllocObj.gtAllocObjClsHnd)));
1974	hash = genTreeHashAdd(hash, tree->gtAllocObj.gtNewHelper);
1975	break;
1976	case GT_RUNTIMELOOKUP:
1977	hash =
1978	genTreeHashAdd(hash,
1979	static_cast<unsigned>(reinterpret_cast<uintptr_t>(tree->gtRuntimeLookup.gtHnd)));
1980	break;
1981
1982	case GT_OBJ:
1983	hash =
1984	genTreeHashAdd(hash, static_cast<unsigned>(reinterpret_cast<uintptr_t>(tree->gtObj.gtClass)));
1985	break;
1986	// For the ones below no extra argument matters for comparison.
1987	case GT_BOX:
1988	break;
1989
1990	default:
1991	assert(!"unexpected unary ExOp operator");
1992	}
1993	}
1994
1995	if (!op1)
1996	{
1997	goto DONE;
1998	}
1999
2000	tree = op1;
2001	goto AGAIN;
2002	}
2003
2004	if (kind & GTK_BINOP)
2005	{
2006	if (GenTree::IsExOp(kind))
2007	{
2008	// ExOp operators extend operators with extra, non-GenTree members. In many cases,*
2009	// these should be included in the hash code.
2010	switch (oper)
2011	{
2012	case GT_INTRINSIC:
2013	hash += tree->gtIntrinsic.gtIntrinsicId;
2014	break;
2015	case GT_LEA:
2016	hash += static_cast<unsigned>(tree->gtAddrMode.Offset() << `3`) + tree->gtAddrMode.gtScale;
2017	break;
2018
2019	case GT_BLK:
2020	case GT_STORE_BLK:
2021	hash += tree->gtBlk.gtBlkSize;
2022	break;
2023
2024	case GT_OBJ:
2025	case GT_STORE_OBJ:
2026	hash ^= PtrToUlong(tree->AsObj()->gtClass);
2027	break;
2028
2029	case GT_DYN_BLK:
2030	case GT_STORE_DYN_BLK:
2031	hash += gtHashValue(tree->AsDynBlk()->gtDynamicSize);
2032	break;
2033
2034	// For the ones below no extra argument matters for comparison.
2035	case GT_ARR_INDEX:
2036	case GT_QMARK:
2037	case GT_INDEX:
2038	case GT_INDEX_ADDR:
2039	break;
2040
2041	#ifdef FEATURE_SIMD
2042	case GT_SIMD:
2043	hash += tree->gtSIMD.gtSIMDIntrinsicID;
2044	hash += tree->gtSIMD.gtSIMDBaseType;
2045	hash += tree->gtSIMD.gtSIMDSize;
2046	break;
2047	#endif // FEATURE_SIMD
2048
2049	#ifdef FEATURE_HW_INTRINSICS
2050	case GT_HWIntrinsic:
2051	hash += tree->gtHWIntrinsic.gtHWIntrinsicId;
2052	hash += tree->gtHWIntrinsic.gtSIMDBaseType;
2053	hash += tree->gtHWIntrinsic.gtSIMDSize;
2054	hash += tree->gtHWIntrinsic.gtIndexBaseType;
2055	break;
2056	#endif // FEATURE_HW_INTRINSICS
2057
2058	default:
2059	assert(!"unexpected binary ExOp operator");
2060	}
2061	}
2062
2063	op1 = tree->gtOp.gtOp1;
2064	GenTree* op2 = tree->gtOp.gtOp2;
2065
2066	/ Is there a second sub-operand? /
2067
2068	if (!op2)
2069	{
2070	/ Special case: no sub-operands at all /
2071
2072	if (!op1)
2073	{
2074	goto DONE;
2075	}
2076
2077	/ This is a unary operator /
2078
2079	tree = op1;
2080	goto AGAIN;
2081	}
2082
2083	/ This is a binary operator /
2084
2085	unsigned hsh1 = gtHashValue(op1);
2086
2087	/ Add op1's hash to the running value and continue with op2 /
2088
2089	hash = genTreeHashAdd(hash, hsh1);
2090
2091	tree = op2;
2092	goto AGAIN;
2093	}
2094
2095	/ See what kind of a special operator we have here /
2096	switch (tree->gtOper)
2097	{
2098	case GT_FIELD:
2099	if (tree->gtField.gtFldObj)
2100	{
2101	temp = tree->gtField.gtFldObj;
2102	assert(temp);
2103	hash = genTreeHashAdd(hash, gtHashValue(temp));
2104	}
2105	break;
2106
2107	case GT_STMT:
2108	temp = tree->gtStmt.gtStmtExpr;
2109	assert(temp);
2110	hash = genTreeHashAdd(hash, gtHashValue(temp));
2111	break;
2112
2113	case GT_ARR_ELEM:
2114
2115	hash = genTreeHashAdd(hash, gtHashValue(tree->gtArrElem.gtArrObj));
2116
2117	unsigned dim;
2118	for (dim = `0`; dim < tree->gtArrElem.gtArrRank; dim++)
2119	{
2120	hash = genTreeHashAdd(hash, gtHashValue(tree->gtArrElem.gtArrInds[dim]));
2121	}
2122
2123	break;
2124
2125	case GT_ARR_OFFSET:
2126	hash = genTreeHashAdd(hash, gtHashValue(tree->gtArrOffs.gtOffset));
2127	hash = genTreeHashAdd(hash, gtHashValue(tree->gtArrOffs.gtIndex));
2128	hash = genTreeHashAdd(hash, gtHashValue(tree->gtArrOffs.gtArrObj));
2129	break;
2130
2131	case GT_CALL:
2132
2133	if (tree->gtCall.gtCallObjp && tree->gtCall.gtCallObjp->gtOper != GT_NOP)
2134	{
2135	temp = tree->gtCall.gtCallObjp;
2136	assert(temp);
2137	hash = genTreeHashAdd(hash, gtHashValue(temp));
2138	}
2139
2140	if (tree->gtCall.gtCallArgs)
2141	{
2142	temp = tree->gtCall.gtCallArgs;
2143	assert(temp);
2144	hash = genTreeHashAdd(hash, gtHashValue(temp));
2145	}
2146
2147	if (tree->gtCall.gtCallType == CT_INDIRECT)
2148	{
2149	temp = tree->gtCall.gtCallAddr;
2150	assert(temp);
2151	hash = genTreeHashAdd(hash, gtHashValue(temp));
2152	}
2153	else
2154	{
2155	hash = genTreeHashAdd(hash, tree->gtCall.gtCallMethHnd);
2156	}
2157
2158	if (tree->gtCall.gtCallLateArgs)
2159	{
2160	temp = tree->gtCall.gtCallLateArgs;
2161	assert(temp);
2162	hash = genTreeHashAdd(hash, gtHashValue(temp));
2163	}
2164	break;
2165
2166	case GT_CMPXCHG:
2167	hash = genTreeHashAdd(hash, gtHashValue(tree->gtCmpXchg.gtOpLocation));
2168	hash = genTreeHashAdd(hash, gtHashValue(tree->gtCmpXchg.gtOpValue));
2169	hash = genTreeHashAdd(hash, gtHashValue(tree->gtCmpXchg.gtOpComparand));
2170	break;
2171
2172	case GT_ARR_BOUNDS_CHECK:
2173	#ifdef FEATURE_SIMD
2174	case GT_SIMD_CHK:
2175	#endif // FEATURE_SIMD
2176	#ifdef FEATURE_HW_INTRINSICS
2177	case GT_HW_INTRINSIC_CHK:
2178	#endif // FEATURE_HW_INTRINSICS
2179	hash = genTreeHashAdd(hash, gtHashValue(tree->gtBoundsChk.gtIndex));
2180	hash = genTreeHashAdd(hash, gtHashValue(tree->gtBoundsChk.gtArrLen));
2181	hash = genTreeHashAdd(hash, tree->gtBoundsChk.gtThrowKind);
2182	break;
2183
2184	case GT_STORE_DYN_BLK:
2185	hash = genTreeHashAdd(hash, gtHashValue(tree->gtDynBlk.Data()));
2186	__fallthrough;
2187	case GT_DYN_BLK:
2188	hash = genTreeHashAdd(hash, gtHashValue(tree->gtDynBlk.Addr()));
2189	hash = genTreeHashAdd(hash, gtHashValue(tree->gtDynBlk.gtDynamicSize));
2190	break;
2191
2192	default:
2193	#ifdef DEBUG
2194	gtDispTree(tree);
2195	#endif
2196	assert(!"unexpected operator");
2197	break;
2198	}
2199
2200	DONE:
2201
2202	return hash;
2203	}
2204
2205	#endif // DEBUG
2206
2207	/*****************************************************************************
2208	*
2209	* Return a relational operator that is the reverse of the given one.
2210	*/
2211
2212	/ static /
2213	genTreeOps GenTree::ReverseRelop(genTreeOps relop)
2214	{
2215	static const genTreeOps reverseOps[] = {
2216	GT_NE, // GT_EQ
2217	GT_EQ, // GT_NE
2218	GT_GE, // GT_LT
2219	GT_GT, // GT_LE
2220	GT_LT, // GT_GE
2221	GT_LE, // GT_GT
2222	GT_TEST_NE, // GT_TEST_EQ
2223	GT_TEST_EQ, // GT_TEST_NE
2224	};
2225
2226	assert(reverseOps[GT_EQ - GT_EQ] == GT_NE);
2227	assert(reverseOps[GT_NE - GT_EQ] == GT_EQ);
2228
2229	assert(reverseOps[GT_LT - GT_EQ] == GT_GE);
2230	assert(reverseOps[GT_LE - GT_EQ] == GT_GT);
2231	assert(reverseOps[GT_GE - GT_EQ] == GT_LT);
2232	assert(reverseOps[GT_GT - GT_EQ] == GT_LE);
2233
2234	assert(reverseOps[GT_TEST_EQ - GT_EQ] == GT_TEST_NE);
2235	assert(reverseOps[GT_TEST_NE - GT_EQ] == GT_TEST_EQ);
2236
2237	assert(OperIsCompare(relop));
2238	assert(relop >= GT_EQ && (unsigned)(relop - GT_EQ) < sizeof(reverseOps));
2239
2240	return reverseOps[relop - GT_EQ];
2241	}
2242
2243	/*****************************************************************************
2244	*
2245	* Return a relational operator that will work for swapped operands.
2246	*/
2247
2248	/ static /
2249	genTreeOps GenTree::SwapRelop(genTreeOps relop)
2250	{
2251	static const genTreeOps swapOps[] = {
2252	GT_EQ, // GT_EQ
2253	GT_NE, // GT_NE
2254	GT_GT, // GT_LT
2255	GT_GE, // GT_LE
2256	GT_LE, // GT_GE
2257	GT_LT, // GT_GT
2258	GT_TEST_EQ, // GT_TEST_EQ
2259	GT_TEST_NE, // GT_TEST_NE
2260	};
2261
2262	assert(swapOps[GT_EQ - GT_EQ] == GT_EQ);
2263	assert(swapOps[GT_NE - GT_EQ] == GT_NE);
2264
2265	assert(swapOps[GT_LT - GT_EQ] == GT_GT);
2266	assert(swapOps[GT_LE - GT_EQ] == GT_GE);
2267	assert(swapOps[GT_GE - GT_EQ] == GT_LE);
2268	assert(swapOps[GT_GT - GT_EQ] == GT_LT);
2269
2270	assert(swapOps[GT_TEST_EQ - GT_EQ] == GT_TEST_EQ);
2271	assert(swapOps[GT_TEST_NE - GT_EQ] == GT_TEST_NE);
2272
2273	assert(OperIsCompare(relop));
2274	assert(relop >= GT_EQ && (unsigned)(relop - GT_EQ) < sizeof(swapOps));
2275
2276	return swapOps[relop - GT_EQ];
2277	}
2278
2279	/*****************************************************************************
2280	*
2281	* Reverse the meaning of the given test condition.
2282	*/
2283
2284	GenTree* Compiler::gtReverseCond(GenTree* tree)
2285	{
2286	if (tree->OperIsCompare())
2287	{
2288	tree->SetOper(GenTree::ReverseRelop(tree->OperGet()));
2289
2290	// Flip the GTF_RELOP_NAN_UN bit
2291	// a ord b === (a != NaN && b != NaN)
2292	// a unord b === (a == NaN \|\| b == NaN)
2293	// => !(a ord b) === (a unord b)
2294	if (varTypeIsFloating(tree->gtOp.gtOp1->TypeGet()))
2295	{
2296	tree->gtFlags ^= GTF_RELOP_NAN_UN;
2297	}
2298	}
2299	else if (tree->OperIs(GT_JCC, GT_SETCC))
2300	{
2301	GenTreeCC* cc = tree->AsCC();
2302	cc->gtCondition = GenTree::ReverseRelop(cc->gtCondition);
2303	}
2304	else if (tree->OperIs(GT_JCMP))
2305	{
2306	// Flip the GTF_JCMP_EQ
2307	//
2308	// This causes switching
2309	// cbz <=> cbnz
2310	// tbz <=> tbnz
2311	tree->gtFlags ^= GTF_JCMP_EQ;
2312	}
2313	else
2314	{
2315	tree = gtNewOperNode(GT_NOT, TYP_INT, tree);
2316	}
2317
2318	return tree;
2319	}
2320
2321	/***************************************************************************/
2322
2323	#ifdef DEBUG
2324
2325	bool GenTree::gtIsValid64RsltMul()
2326	{
2327	if ((gtOper != GT_MUL) \|\| !(gtFlags & GTF_MUL_64RSLT))
2328	{
2329	return false;
2330	}
2331
2332	GenTree* op1 = gtOp.gtOp1;
2333	GenTree* op2 = gtOp.gtOp2;
2334
2335	if (TypeGet() != TYP_LONG \|\| op1->TypeGet() != TYP_LONG \|\| op2->TypeGet() != TYP_LONG)
2336	{
2337	return false;
2338	}
2339
2340	if (gtOverflow())
2341	{
2342	return false;
2343	}
2344
2345	// op1 has to be conv.i8(i4Expr)
2346	if ((op1->gtOper != GT_CAST) \|\| (genActualType(op1->CastFromType()) != TYP_INT))
2347	{
2348	return false;
2349	}
2350
2351	// op2 has to be conv.i8(i4Expr)
2352	if ((op2->gtOper != GT_CAST) \|\| (genActualType(op2->CastFromType()) != TYP_INT))
2353	{
2354	return false;
2355	}
2356
2357	// The signedness of both casts must be the same
2358	if (((op1->gtFlags & GTF_UNSIGNED) != `0`) != ((op2->gtFlags & GTF_UNSIGNED) != `0`))
2359	{
2360	return false;
2361	}
2362
2363	// Do unsigned mul iff both the casts are unsigned
2364	if (((op1->gtFlags & GTF_UNSIGNED) != `0`) != ((gtFlags & GTF_UNSIGNED) != `0`))
2365	{
2366	return false;
2367	}
2368
2369	return true;
2370	}
2371
2372	#endif // DEBUG
2373
2374	//------------------------------------------------------------------------------
2375	// gtSetListOrder : Figure out the evaluation order for a list of values.
2376	//
2377	//
2378	// Arguments:
2379	// list - List to figure out the evaluation order for
2380	// isListCallArgs - True iff the list is a list of call arguments
2381	// callArgsInRegs - True iff the list is a list of call arguments and they are passed in registers
2382	//
2383	// Return Value:
2384	// True if the operation can be a root of a bitwise rotation tree; false otherwise.
2385
2386	unsigned Compiler::gtSetListOrder(GenTree* list, bool isListCallArgs, bool callArgsInRegs)
2387	{
2388	assert((list != nullptr) && list->OperIsAnyList());
2389	assert(!callArgsInRegs \|\| isListCallArgs);
2390
2391	ArrayStack<GenTree*> listNodes(getAllocator(CMK_ArrayStack));
2392
2393	do
2394	{
2395	listNodes.Push(list);
2396	list = list->gtOp.gtOp2;
2397	} while ((list != nullptr) && (list->OperIsAnyList()));
2398
2399	unsigned nxtlvl = (list == nullptr) ? `0` : gtSetEvalOrder(list);
2400	while (!listNodes.Empty())
2401	{
2402	list = listNodes.Pop();
2403	assert(list && list->OperIsAnyList());
2404	GenTree* next = list->gtOp.gtOp2;
2405
2406	unsigned level = `0`;
2407
2408	// TODO: Do we have to compute costs differently for argument lists and
2409	// all other lists?
2410	// https://github.com/dotnet/coreclr/issues/7095
2411	unsigned costSz = (isListCallArgs \|\| (next == nullptr)) ? `0` : `1`;
2412	unsigned costEx = (isListCallArgs \|\| (next == nullptr)) ? `0` : `1`;
2413
2414	if (next != nullptr)
2415	{
2416	if (isListCallArgs)
2417	{
2418	if (level < nxtlvl)
2419	{
2420	level = nxtlvl;
2421	}
2422	}
2423	costEx += next->gtCostEx;
2424	costSz += next->gtCostSz;
2425	}
2426
2427	GenTree* op1 = list->gtOp.gtOp1;
2428	unsigned lvl = gtSetEvalOrder(op1);
2429
2430	// Swap the level counts
2431	if (list->gtFlags & GTF_REVERSE_OPS)
2432	{
2433	unsigned tmpl;
2434
2435	tmpl = lvl;
2436	lvl = nxtlvl;
2437	nxtlvl = tmpl;
2438	}
2439
2440	// TODO: Do we have to compute levels differently for argument lists and
2441	// all other lists?
2442	// https://github.com/dotnet/coreclr/issues/7095
2443	if (isListCallArgs)
2444	{
2445	if (level < lvl)
2446	{
2447	level = lvl;
2448	}
2449	}
2450	else
2451	{
2452	if (lvl < `1`)
2453	{
2454	level = nxtlvl;
2455	}
2456	else if (lvl == nxtlvl)
2457	{
2458	level = lvl + `1`;
2459	}
2460	else
2461	{
2462	level = lvl;
2463	}
2464	}
2465
2466	if (op1->gtCostEx != `0`)
2467	{
2468	costEx += op1->gtCostEx;
2469	costEx += (callArgsInRegs \|\| !isListCallArgs) ? `0` : IND_COST_EX;
2470	}
2471
2472	if (op1->gtCostSz != `0`)
2473	{
2474	costSz += op1->gtCostSz;
2475	#ifdef _TARGET_XARCH_
2476	if (callArgsInRegs) // push is smaller than mov to reg
2477	#endif
2478	{
2479	costSz += `1`;
2480	}
2481	}
2482
2483	list->SetCosts(costEx, costSz);
2484
2485	nxtlvl = level;
2486	}
2487
2488	return nxtlvl;
2489	}
2490
2491	//-----------------------------------------------------------------------------
2492	// gtWalkOp: Traverse and mark an address expression
2493	//
2494	// Arguments:
2495	// op1WB - An out parameter which is either the address expression, or one
2496	// of its operands.
2497	// op2WB - An out parameter which starts as either null or one of the operands
2498	// of the address expression.
2499	// base - The base address of the addressing mode, or null if 'constOnly' is false
2500	// constOnly - True if we will only traverse into ADDs with constant op2.
2501	//
2502	// This routine is a helper routine for gtSetEvalOrder() and is used to identify the
2503	// base and index nodes, which will be validated against those identified by
2504	// genCreateAddrMode().
2505	// It also marks the ADD nodes involved in the address expression with the
2506	// GTF_ADDRMODE_NO_CSE flag which prevents them from being considered for CSE's.
2507	//
2508	// Its two output parameters are modified under the following conditions:
2509	//
2510	// It is called once with the original address expression as 'op1WB', and
2511	// with 'constOnly' set to false. On this first invocation, op1WB is always*
2512	// an ADD node, and it will consider the operands of the ADD even if its op2 is
2513	// not a constant. However, when it encounters a non-constant or the base in the
2514	// op2 position, it stops iterating. That operand is returned in the 'op2WB' out
2515	// parameter, and will be considered on the third invocation of this method if
2516	// it is an ADD.
2517	//
2518	// It is called the second time with the two operands of the original expression, in
2519	// the original order, and the third time in reverse order. For these invocations
2520	// 'constOnly' is true, so it will only traverse cascaded ADD nodes if they have a
2521	// constant op2.
2522	//
2523	// The result, after three invocations, is that the values of the two out parameters
2524	// correspond to the base and index in some fashion. This method doesn't attempt
2525	// to determine or validate the scale or offset, if any.
2526	//
2527	// Assumptions (presumed to be ensured by genCreateAddrMode()):
2528	// If an ADD has a constant operand, it is in the op2 position.
2529	//
2530	// Notes:
2531	// This method, and its invocation sequence, are quite confusing, and since they
2532	// were not originally well-documented, this specification is a possibly-imperfect
2533	// reconstruction.
2534	// The motivation for the handling of the NOP case is unclear.
2535	// Note that 'op2WB' is only modified in the initial (!constOnly) case,
2536	// or if a NOP is encountered in the op1 position.
2537	//
2538	void Compiler::gtWalkOp(GenTree op1WB, GenTree op2WB, GenTree* base, bool constOnly)
2539	{
2540	GenTree* op1 = *op1WB;
2541	GenTree* op2 = *op2WB;
2542
2543	op1 = op1->gtEffectiveVal();
2544
2545	// Now we look for op1's with non-overflow GT_ADDs [of constants]
2546	while ((op1->gtOper == GT_ADD) && (!op1->gtOverflow()) && (!constOnly \|\| (op1->gtOp.gtOp2->IsCnsIntOrI())))
2547	{
2548	// mark it with GTF_ADDRMODE_NO_CSE
2549	op1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
2550
2551	if (!constOnly)
2552	{
2553	op2 = op1->gtOp.gtOp2;
2554	}
2555	op1 = op1->gtOp.gtOp1;
2556
2557	// If op1 is a GT_NOP then swap op1 and op2.
2558	// (Why? Also, presumably op2 is not a GT_NOP in this case?)
2559	if (op1->gtOper == GT_NOP)
2560	{
2561	GenTree* tmp;
2562
2563	tmp = op1;
2564	op1 = op2;
2565	op2 = tmp;
2566	}
2567
2568	if (!constOnly && ((op2 == base) \|\| (!op2->IsCnsIntOrI())))
2569	{
2570	break;
2571	}
2572
2573	op1 = op1->gtEffectiveVal();
2574	}
2575
2576	*op1WB = op1;
2577	*op2WB = op2;
2578	}
2579
2580	#ifdef DEBUG
2581	/*****************************************************************************
2582	* This is a workaround. It is to help implement an assert in gtSetEvalOrder() that the values
2583	* gtWalkOp() leaves in op1 and op2 correspond with the values of adr, idx, mul, and cns
2584	* that are returned by genCreateAddrMode(). It's essentially impossible to determine
2585	* what gtWalkOp() should return for all possible trees. This simply loosens one assert
2586	* to handle the following case:
2587
2588	indir int
2589	const(h) int 4 field
2590	+ byref
2591	lclVar byref V00 this <-- op2
2592	comma byref <-- adr (base)
2593	indir byte
2594	lclVar byref V00 this
2595	+ byref
2596	const int 2 <-- mul == 4
2597	<< int <-- op1
2598	lclVar int V01 arg1 <-- idx
2599
2600	* Here, we are planning to generate the address mode [edx+4*eax], where eax = idx and edx = the GT_COMMA expression.
2601	* To check adr equivalence with op2, we need to walk down the GT_ADD tree just like gtWalkOp() does.
2602	*/
2603	GenTree* Compiler::gtWalkOpEffectiveVal(GenTree* op)
2604	{
2605	for (;;)
2606	{
2607	op = op->gtEffectiveVal();
2608
2609	if ((op->gtOper != GT_ADD) \|\| op->gtOverflow() \|\| !op->gtOp.gtOp2->IsCnsIntOrI())
2610	{
2611	break;
2612	}
2613
2614	op = op->gtOp.gtOp1;
2615	}
2616
2617	return op;
2618	}
2619	#endif // DEBUG
2620
2621	/*****************************************************************************
2622	*
2623	* Given a tree, set the gtCostEx and gtCostSz fields which
2624	* are used to measure the relative costs of the codegen of the tree
2625	*
2626	*/
2627
2628	void Compiler::gtPrepareCost(GenTree* tree)
2629	{
2630	gtSetEvalOrder(tree);
2631	}
2632
2633	bool Compiler::gtIsLikelyRegVar(GenTree* tree)
2634	{
2635	if (tree->gtOper != GT_LCL_VAR)
2636	{
2637	return false;
2638	}
2639
2640	assert(tree->gtLclVar.gtLclNum < lvaTableCnt);
2641	LclVarDsc* varDsc = lvaTable + tree->gtLclVar.gtLclNum;
2642
2643	if (varDsc->lvDoNotEnregister)
2644	{
2645	return false;
2646	}
2647
2648	// Be pessimistic if ref counts are not yet set up.
2649	//
2650	// Perhaps we should be optimistic though.
2651	// See notes in GitHub issue 18969.
2652	if (!lvaLocalVarRefCounted())
2653	{
2654	return false;
2655	}
2656
2657	if (varDsc->lvRefCntWtd() < (BB_UNITY_WEIGHT * `3`))
2658	{
2659	return false;
2660	}
2661
2662	#ifdef _TARGET_X86_
2663	if (varTypeIsFloating(tree->TypeGet()))
2664	return false;
2665	if (varTypeIsLong(tree->TypeGet()))
2666	return false;
2667	#endif
2668
2669	return true;
2670	}
2671
2672	//------------------------------------------------------------------------
2673	// gtCanSwapOrder: Returns true iff the secondNode can be swapped with firstNode.
2674	//
2675	// Arguments:
2676	// firstNode - An operand of a tree that can have GTF_REVERSE_OPS set.
2677	// secondNode - The other operand of the tree.
2678	//
2679	// Return Value:
2680	// Returns a boolean indicating whether it is safe to reverse the execution
2681	// order of the two trees, considering any exception, global effects, or
2682	// ordering constraints.
2683	//
2684	bool Compiler::gtCanSwapOrder(GenTree* firstNode, GenTree* secondNode)
2685	{
2686	// Relative of order of global / side effects can't be swapped.
2687
2688	bool canSwap = true;
2689
2690	if (optValnumCSE_phase)
2691	{
2692	canSwap = optCSE_canSwap(firstNode, secondNode);
2693	}
2694
2695	// We cannot swap in the presence of special side effects such as GT_CATCH_ARG.
2696
2697	if (canSwap && (firstNode->gtFlags & GTF_ORDER_SIDEEFF))
2698	{
2699	canSwap = false;
2700	}
2701
2702	// When strict side effect order is disabled we allow GTF_REVERSE_OPS to be set
2703	// when one or both sides contains a GTF_CALL or GTF_EXCEPT.
2704	// Currently only the C and C++ languages allow non strict side effect order.
2705
2706	unsigned strictEffects = GTF_GLOB_EFFECT;
2707
2708	if (canSwap && (firstNode->gtFlags & strictEffects))
2709	{
2710	// op1 has side efects that can't be reordered.
2711	// Check for some special cases where we still may be able to swap.
2712
2713	if (secondNode->gtFlags & strictEffects)
2714	{
2715	// op2 has also has non reorderable side effects - can't swap.
2716	canSwap = false;
2717	}
2718	else
2719	{
2720	// No side effects in op2 - we can swap iff op1 has no way of modifying op2,
2721	// i.e. through byref assignments or calls or op2 is a constant.
2722
2723	if (firstNode->gtFlags & strictEffects & GTF_PERSISTENT_SIDE_EFFECTS)
2724	{
2725	// We have to be conservative - can swap iff op2 is constant.
2726	if (!secondNode->OperIsConst())
2727	{
2728	canSwap = false;
2729	}
2730	}
2731	}
2732	}
2733	return canSwap;
2734	}
2735
2736	/*****************************************************************************
2737	*
2738	* Given a tree, figure out the order in which its sub-operands should be
2739	* evaluated. If the second operand of a binary operator is more expensive
2740	* than the first operand, then try to swap the operand trees. Updates the
2741	* GTF_REVERSE_OPS bit if necessary in this case.
2742	*
2743	* Returns the Sethi 'complexity' estimate for this tree (the higher
2744	* the number, the higher is the tree's resources requirement).
2745	*
2746	* This function sets:
2747	* 1. gtCostEx to the execution complexity estimate
2748	* 2. gtCostSz to the code size estimate
2749	* 3. Sometimes sets GTF_ADDRMODE_NO_CSE on nodes in the tree.
2750	* 4. DEBUG-only: clears GTF_DEBUG_NODE_MORPHED.
2751	*/
2752
2753	#ifdef _PREFAST_
2754	#pragma warning(push)
2755	#pragma warning(disable : 21000) // Suppress PREFast warning about overly large function
2756	#endif
2757	unsigned Compiler::gtSetEvalOrder(GenTree* tree)
2758	{
2759	assert(tree);
2760	assert(tree->gtOper != GT_STMT);
2761
2762	#ifdef DEBUG
2763	/ Clear the GTF_DEBUG_NODE_MORPHED flag as well /
2764	tree->gtDebugFlags &= ~GTF_DEBUG_NODE_MORPHED;
2765	#endif
2766
2767	/ Is this a FP value? /
2768
2769	bool isflt = varTypeIsFloating(tree->TypeGet());
2770
2771	/ Figure out what kind of a node we have /
2772
2773	const genTreeOps oper = tree->OperGet();
2774	const unsigned kind = tree->OperKind();
2775
2776	/ Assume no fixed registers will be trashed /
2777
2778	unsigned level;
2779	int costEx;
2780	int costSz;
2781
2782	#ifdef DEBUG
2783	costEx = -`1`;
2784	costSz = -`1`;
2785	#endif
2786
2787	/ Is this a constant or a leaf node? /
2788
2789	if (kind & (GTK_LEAF \| GTK_CONST))
2790	{
2791	switch (oper)
2792	{
2793	#ifdef _TARGET_ARM_
2794	case GT_CNS_LNG:
2795	costSz = `9`;
2796	costEx = `4`;
2797	goto COMMON_CNS;
2798
2799	case GT_CNS_STR:
2800	// Uses movw/movt
2801	costSz = `7`;
2802	costEx = `3`;
2803	goto COMMON_CNS;
2804
2805	case GT_CNS_INT:
2806	{
2807	// If the constant is a handle then it will need to have a relocation
2808	// applied to it.
2809	// Any constant that requires a reloc must use the movw/movt sequence
2810	//
2811	GenTreeIntConCommon* con = tree->AsIntConCommon();
2812
2813	if (con->ImmedValNeedsReloc(this) \|\|
2814	!codeGen->validImmForInstr(INS_mov, (target_ssize_t)tree->gtIntCon.gtIconVal))
2815	{
2816	// Uses movw/movt
2817	costSz = `7`;
2818	costEx = `3`;
2819	}
2820	else if (((unsigned)tree->gtIntCon.gtIconVal) <= `0x00ff`)
2821	{
2822	// mov Rd, <const8>
2823	costSz = `1`;
2824	costEx = `1`;
2825	}
2826	else
2827	{
2828	// Uses movw/mvn
2829	costSz = `3`;
2830	costEx = `1`;
2831	}
2832	goto COMMON_CNS;
2833	}
2834
2835	#elif defined _TARGET_XARCH_
2836
2837	case GT_CNS_LNG:
2838	costSz = `10`;
2839	costEx = `3`;
2840	goto COMMON_CNS;
2841
2842	case GT_CNS_STR:
2843	costSz = `4`;
2844	costEx = `1`;
2845	goto COMMON_CNS;
2846
2847	case GT_CNS_INT:
2848	{
2849	// If the constant is a handle then it will need to have a relocation
2850	// applied to it.
2851	//
2852	GenTreeIntConCommon* con = tree->AsIntConCommon();
2853
2854	bool iconNeedsReloc = con->ImmedValNeedsReloc(this);
2855
2856	if (!iconNeedsReloc && con->FitsInI8())
2857	{
2858	costSz = `1`;
2859	costEx = `1`;
2860	}
2861	#if defined(_TARGET_AMD64_)
2862	else if (iconNeedsReloc \|\| !con->FitsInI32())
2863	{
2864	costSz = `10`;
2865	costEx = `3`;
2866	}
2867	#endif // _TARGET_AMD64_
2868	else
2869	{
2870	costSz = `4`;
2871	costEx = `1`;
2872	}
2873	goto COMMON_CNS;
2874	}
2875
2876	#elif defined(_TARGET_ARM64_)
2877	case GT_CNS_LNG:
2878	case GT_CNS_STR:
2879	case GT_CNS_INT:
2880	// TODO-ARM64-NYI: Need cost estimates.
2881	costSz = `1`;
2882	costEx = `1`;
2883	goto COMMON_CNS;
2884
2885	#else
2886	case GT_CNS_LNG:
2887	case GT_CNS_STR:
2888	case GT_CNS_INT:
2889	#error "Unknown _TARGET_"
2890	#endif
2891
2892	COMMON_CNS:
2893	/*
2894	Note that some code below depends on constants always getting
2895	moved to be the second operand of a binary operator. This is
2896	easily accomplished by giving constants a level of 0, which
2897	we do on the next line. If you ever decide to change this, be
2898	aware that unless you make other arrangements for integer
2899	constants to be moved, stuff will break.
2900	*/
2901
2902	level = `0`;
2903	break;
2904
2905	case GT_CNS_DBL:
2906	level = `0`;
2907	/ We use fldz and fld1 to load 0.0 and 1.0, but all other /
2908	/ floating point constants are loaded using an indirection /
2909	if ((((__int64**)&(tree->gtDblCon.gtDconVal)) == `0`) \|\|
2910	(((__int64**)&(tree->gtDblCon.gtDconVal)) == I64(`0x3ff0000000000000`)))
2911	{
2912	costEx = `1`;
2913	costSz = `1`;
2914	}
2915	else
2916	{
2917	costEx = IND_COST_EX;
2918	costSz = `4`;
2919	}
2920	break;
2921
2922	case GT_LCL_VAR:
2923	level = `1`;
2924	if (gtIsLikelyRegVar(tree))
2925	{
2926	costEx = `1`;
2927	costSz = `1`;
2928	/ Sign-extend and zero-extend are more expensive to load /
2929	if (lvaTable[tree->gtLclVar.gtLclNum].lvNormalizeOnLoad())
2930	{
2931	costEx += `1`;
2932	costSz += `1`;
2933	}
2934	}
2935	else
2936	{
2937	costEx = IND_COST_EX;
2938	costSz = `2`;
2939	/ Sign-extend and zero-extend are more expensive to load /
2940	if (varTypeIsSmall(tree->TypeGet()))
2941	{
2942	costEx += `1`;
2943	costSz += `1`;
2944	}
2945	}
2946	#if defined(_TARGET_AMD64_)
2947	// increase costSz for floating point locals
2948	if (isflt)
2949	{
2950	costSz += `1`;
2951	if (!gtIsLikelyRegVar(tree))
2952	{
2953	costSz += `1`;
2954	}
2955	}
2956	#endif
2957	break;
2958
2959	case GT_CLS_VAR:
2960	#ifdef _TARGET_ARM_
2961	// We generate movw/movt/ldr
2962	level = `1`;
2963	costEx = `3` + IND_COST_EX; // 6
2964	costSz = `4` + `4` + `2`; // 10
2965	break;
2966	#endif
2967	case GT_LCL_FLD:
2968	level = `1`;
2969	costEx = IND_COST_EX;
2970	costSz = `4`;
2971	if (varTypeIsSmall(tree->TypeGet()))
2972	{
2973	costEx += `1`;
2974	costSz += `1`;
2975	}
2976	break;
2977
2978	case GT_PHI_ARG:
2979	case GT_ARGPLACE:
2980	level = `0`;
2981	costEx = `0`;
2982	costSz = `0`;
2983	break;
2984
2985	default:
2986	level = `1`;
2987	costEx = `1`;
2988	costSz = `1`;
2989	break;
2990	}
2991	goto DONE;
2992	}
2993
2994	/ Is it a 'simple' unary/binary operator? /
2995
2996	if (kind & GTK_SMPOP)
2997	{
2998	int lvlb; // preference for op2
2999	unsigned lvl2; // scratch variable
3000
3001	GenTree* op1 = tree->gtOp.gtOp1;
3002	GenTree* op2 = tree->gtGetOp2IfPresent();
3003
3004	costEx = `0`;
3005	costSz = `0`;
3006
3007	if (tree->OperIsAddrMode())
3008	{
3009	if (op1 == nullptr)
3010	{
3011	op1 = op2;
3012	op2 = nullptr;
3013	}
3014	}
3015
3016	/ Check for a nilary operator /
3017
3018	if (op1 == nullptr)
3019	{
3020	assert(op2 == nullptr);
3021
3022	level = `0`;
3023
3024	goto DONE;
3025	}
3026
3027	/ Is this a unary operator? /
3028
3029	if (op2 == nullptr)
3030	{
3031	/ Process the operand of the operator /
3032
3033	/ Most Unary ops have costEx of 1 /
3034	costEx = `1`;
3035	costSz = `1`;
3036
3037	level = gtSetEvalOrder(op1);
3038
3039	/ Special handling for some operators /
3040
3041	switch (oper)
3042	{
3043	case GT_JTRUE:
3044	costEx = `2`;
3045	costSz = `2`;
3046	break;
3047
3048	case GT_SWITCH:
3049	costEx = `10`;
3050	costSz = `5`;
3051	break;
3052
3053	case GT_CAST:
3054	#if defined(_TARGET_ARM_)
3055	costEx = `1`;
3056	costSz = `1`;
3057	if (isflt \|\| varTypeIsFloating(op1->TypeGet()))
3058	{
3059	costEx = `3`;
3060	costSz = `4`;
3061	}
3062	#elif defined(_TARGET_ARM64_)
3063	costEx = `1`;
3064	costSz = `2`;
3065	if (isflt \|\| varTypeIsFloating(op1->TypeGet()))
3066	{
3067	costEx = `2`;
3068	costSz = `4`;
3069	}
3070	#elif defined(_TARGET_XARCH_)
3071	costEx = `1`;
3072	costSz = `2`;
3073
3074	if (isflt \|\| varTypeIsFloating(op1->TypeGet()))
3075	{
3076	/ cast involving floats always go through memory /
3077	costEx = IND_COST_EX * `2`;
3078	costSz = `6`;
3079	}
3080	#else
3081	#error "Unknown _TARGET_"
3082	#endif
3083
3084	/ Overflow casts are a lot more expensive /
3085	if (tree->gtOverflow())
3086	{
3087	costEx += `6`;
3088	costSz += `6`;
3089	}
3090
3091	break;
3092
3093	case GT_LIST:
3094	case GT_FIELD_LIST:
3095	case GT_NOP:
3096	costEx = `0`;
3097	costSz = `0`;
3098	break;
3099
3100	case GT_INTRINSIC:
3101	// GT_INTRINSIC intrinsics Sin, Cos, Sqrt, Abs ... have higher costs.
3102	// TODO: tune these costs target specific as some of these are
3103	// target intrinsics and would cost less to generate code.
3104	switch (tree->gtIntrinsic.gtIntrinsicId)
3105	{
3106	default:
3107	assert(!"missing case for gtIntrinsicId");
3108	costEx = `12`;
3109	costSz = `12`;
3110	break;
3111
3112	case CORINFO_INTRINSIC_Sin:
3113	case CORINFO_INTRINSIC_Cos:
3114	case CORINFO_INTRINSIC_Sqrt:
3115	case CORINFO_INTRINSIC_Cbrt:
3116	case CORINFO_INTRINSIC_Cosh:
3117	case CORINFO_INTRINSIC_Sinh:
3118	case CORINFO_INTRINSIC_Tan:
3119	case CORINFO_INTRINSIC_Tanh:
3120	case CORINFO_INTRINSIC_Asin:
3121	case CORINFO_INTRINSIC_Asinh:
3122	case CORINFO_INTRINSIC_Acos:
3123	case CORINFO_INTRINSIC_Acosh:
3124	case CORINFO_INTRINSIC_Atan:
3125	case CORINFO_INTRINSIC_Atanh:
3126	case CORINFO_INTRINSIC_Atan2:
3127	case CORINFO_INTRINSIC_Log10:
3128	case CORINFO_INTRINSIC_Pow:
3129	case CORINFO_INTRINSIC_Exp:
3130	case CORINFO_INTRINSIC_Ceiling:
3131	case CORINFO_INTRINSIC_Floor:
3132	case CORINFO_INTRINSIC_Object_GetType:
3133	// Giving intrinsics a large fixed execution cost is because we'd like to CSE
3134	// them, even if they are implemented by calls. This is different from modeling
3135	// user calls since we never CSE user calls.
3136	costEx = `36`;
3137	costSz = `4`;
3138	break;
3139
3140	case CORINFO_INTRINSIC_Abs:
3141	costEx = `5`;
3142	costSz = `15`;
3143	break;
3144
3145	case CORINFO_INTRINSIC_Round:
3146	costEx = `3`;
3147	costSz = `4`;
3148	break;
3149	}
3150	level++;
3151	break;
3152
3153	case GT_NOT:
3154	case GT_NEG:
3155	// We need to ensure that -x is evaluated before x or else
3156	// we get burned while adjusting genFPstkLevel in x-x where*
3157	// the rhs x is the last use of the enregistered x.
3158	//
3159	// Even in the integer case we want to prefer to
3160	// evaluate the side without the GT_NEG node, all other things
3161	// being equal. Also a GT_NOT requires a scratch register
3162
3163	level++;
3164	break;
3165
3166	case GT_ADDR:
3167
3168	costEx = `0`;
3169	costSz = `1`;
3170
3171	// If we have a GT_ADDR of an GT_IND we can just copy the costs from indOp1
3172	if (op1->OperGet() == GT_IND)
3173	{
3174	GenTree* indOp1 = op1->gtOp.gtOp1;
3175	costEx = indOp1->gtCostEx;
3176	costSz = indOp1->gtCostSz;
3177	}
3178	break;
3179
3180	case GT_ARR_LENGTH:
3181	level++;
3182
3183	/ Array Len should be the same as an indirections, which have a costEx of IND_COST_EX /
3184	costEx = IND_COST_EX - `1`;
3185	costSz = `2`;
3186	break;
3187
3188	case GT_MKREFANY:
3189	case GT_OBJ:
3190	// We estimate the cost of a GT_OBJ or GT_MKREFANY to be two loads (GT_INDs)
3191	costEx = `2` * IND_COST_EX;
3192	costSz = `2` * `2`;
3193	break;
3194
3195	case GT_BOX:
3196	// We estimate the cost of a GT_BOX to be two stores (GT_INDs)
3197	costEx = `2` * IND_COST_EX;
3198	costSz = `2` * `2`;
3199	break;
3200
3201	case GT_BLK:
3202	case GT_IND:
3203
3204	/ An indirection should always have a non-zero level.*
3205	* Only constant leaf nodes have level 0.
3206	*/
3207
3208	if (level == `0`)
3209	{
3210	level = `1`;
3211	}
3212
3213	/ Indirections have a costEx of IND_COST_EX /
3214	costEx = IND_COST_EX;
3215	costSz = `2`;
3216
3217	/ If we have to sign-extend or zero-extend, bump the cost /
3218	if (varTypeIsSmall(tree->TypeGet()))
3219	{
3220	costEx += `1`;
3221	costSz += `1`;
3222	}
3223
3224	if (isflt)
3225	{
3226	if (tree->TypeGet() == TYP_DOUBLE)
3227	{
3228	costEx += `1`;
3229	}
3230	#ifdef _TARGET_ARM_
3231	costSz += `2`;
3232	#endif // _TARGET_ARM_
3233	}
3234
3235	// Can we form an addressing mode with this indirection?
3236	// TODO-CQ: Consider changing this to op1->gtEffectiveVal() to take into account
3237	// addressing modes hidden under a comma node.
3238
3239	if (op1->gtOper == GT_ADD)
3240	{
3241	bool rev;
3242	#if SCALED_ADDR_MODES
3243	unsigned mul;
3244	#endif // SCALED_ADDR_MODES
3245	ssize_t cns;
3246	GenTree* base;
3247	GenTree* idx;
3248
3249	// See if we can form a complex addressing mode.
3250
3251	GenTree* addr = op1->gtEffectiveVal();
3252
3253	bool doAddrMode = true;
3254	// See if we can form a complex addressing mode.
3255	// Always use an addrMode for an array index indirection.
3256	// TODO-1stClassStructs: Always do this, but first make sure it's
3257	// done in Lowering as well.
3258	if ((tree->gtFlags & GTF_IND_ARR_INDEX) == `0`)
3259	{
3260	if (tree->TypeGet() == TYP_STRUCT)
3261	{
3262	doAddrMode = false;
3263	}
3264	else if (varTypeIsStruct(tree))
3265	{
3266	// This is a heuristic attempting to match prior behavior when indirections
3267	// under a struct assignment would not be considered for addressing modes.
3268	if (compCurStmt != nullptr)
3269	{
3270	GenTree* expr = compCurStmt->gtStmt.gtStmtExpr;
3271	if ((expr->OperGet() == GT_ASG) &&
3272	((expr->gtGetOp1() == tree) \|\| (expr->gtGetOp2() == tree)))
3273	{
3274	doAddrMode = false;
3275	}
3276	}
3277	}
3278	}
3279	if ((doAddrMode) &&
3280	codeGen->genCreateAddrMode(addr, // address
3281	false, // fold
3282	&rev, // reverse ops
3283	&base, // base addr
3284	&idx, // index val
3285	#if SCALED_ADDR_MODES
3286	&mul, // scaling
3287	#endif // SCALED_ADDR_MODES
3288	&cns)) // displacement
3289	{
3290	// We can form a complex addressing mode, so mark each of the interior
3291	// nodes with GTF_ADDRMODE_NO_CSE and calculate a more accurate cost.
3292
3293	addr->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3294	#ifdef _TARGET_XARCH_
3295	// addrmodeCount is the count of items that we used to form
3296	// an addressing mode. The maximum value is 4 when we have
3297	// all of these: { base, idx, cns, mul }
3298	//
3299	unsigned addrmodeCount = `0`;
3300	if (base)
3301	{
3302	costEx += base->gtCostEx;
3303	costSz += base->gtCostSz;
3304	addrmodeCount++;
3305	}
3306
3307	if (idx)
3308	{
3309	costEx += idx->gtCostEx;
3310	costSz += idx->gtCostSz;
3311	addrmodeCount++;
3312	}
3313
3314	if (cns)
3315	{
3316	if (((signed char)cns) == ((int)cns))
3317	{
3318	costSz += `1`;
3319	}
3320	else
3321	{
3322	costSz += `4`;
3323	}
3324	addrmodeCount++;
3325	}
3326	if (mul)
3327	{
3328	addrmodeCount++;
3329	}
3330	// When we form a complex addressing mode we can reduced the costs
3331	// associated with the interior GT_ADD and GT_LSH nodes:
3332	//
3333	// GT_ADD -- reduce this interior GT_ADD by (-3,-3)
3334	// / \ --
3335	// GT_ADD 'cns' -- reduce this interior GT_ADD by (-2,-2)
3336	// / \ --
3337	// 'base' GT_LSL -- reduce this interior GT_LSL by (-1,-1)
3338	// / \ --
3339	// 'idx' 'mul'
3340	//
3341	if (addrmodeCount > `1`)
3342	{
3343	// The number of interior GT_ADD and GT_LSL will always be one less than addrmodeCount
3344	//
3345	addrmodeCount--;
3346
3347	GenTree* tmp = addr;
3348	while (addrmodeCount > `0`)
3349	{
3350	// decrement the gtCosts for the interior GT_ADD or GT_LSH node by the remaining
3351	// addrmodeCount
3352	tmp->SetCosts(tmp->gtCostEx - addrmodeCount, tmp->gtCostSz - addrmodeCount);
3353
3354	addrmodeCount--;
3355	if (addrmodeCount > `0`)
3356	{
3357	GenTree* tmpOp1 = tmp->gtOp.gtOp1;
3358	GenTree* tmpOp2 = tmp->gtGetOp2();
3359	assert(tmpOp2 != nullptr);
3360
3361	if ((tmpOp1 != base) && (tmpOp1->OperGet() == GT_ADD))
3362	{
3363	tmp = tmpOp1;
3364	}
3365	else if (tmpOp2->OperGet() == GT_LSH)
3366	{
3367	tmp = tmpOp2;
3368	}
3369	else if (tmpOp1->OperGet() == GT_LSH)
3370	{
3371	tmp = tmpOp1;
3372	}
3373	else if (tmpOp2->OperGet() == GT_ADD)
3374	{
3375	tmp = tmpOp2;
3376	}
3377	else
3378	{
3379	// We can very rarely encounter a tree that has a GT_COMMA node
3380	// that is difficult to walk, so we just early out without decrementing.
3381	addrmodeCount = `0`;
3382	}
3383	}
3384	}
3385	}
3386	#elif defined _TARGET_ARM_
3387	if (base)
3388	{
3389	costEx += base->gtCostEx;
3390	costSz += base->gtCostSz;
3391	if ((base->gtOper == GT_LCL_VAR) && ((idx == NULL) \|\| (cns == `0`)))
3392	{
3393	costSz -= `1`;
3394	}
3395	}
3396
3397	if (idx)
3398	{
3399	costEx += idx->gtCostEx;
3400	costSz += idx->gtCostSz;
3401	if (mul > `0`)
3402	{
3403	costSz += `2`;
3404	}
3405	}
3406
3407	if (cns)
3408	{
3409	if (cns >= `128`) // small offsets fits into a 16-bit instruction
3410	{
3411	if (cns < `4096`) // medium offsets require a 32-bit instruction
3412	{
3413	if (!isflt)
3414	costSz += `2`;
3415	}
3416	else
3417	{
3418	costEx += `2`; // Very large offsets require movw/movt instructions
3419	costSz += `8`;
3420	}
3421	}
3422	}
3423	#elif defined _TARGET_ARM64_
3424	if (base)
3425	{
3426	costEx += base->gtCostEx;
3427	costSz += base->gtCostSz;
3428	}
3429
3430	if (idx)
3431	{
3432	costEx += idx->gtCostEx;
3433	costSz += idx->gtCostSz;
3434	}
3435
3436	if (cns != `0`)
3437	{
3438	if (cns >= (`4096` * genTypeSize(tree->TypeGet())))
3439	{
3440	costEx += `1`;
3441	costSz += `4`;
3442	}
3443	}
3444	#else
3445	#error "Unknown _TARGET_"
3446	#endif
3447
3448	assert(addr->gtOper == GT_ADD);
3449	assert(!addr->gtOverflow());
3450	assert(op2 == nullptr);
3451	assert(mul != `1`);
3452
3453	// If we have an addressing mode, we have one of:
3454	// [base + cns]
3455	// [ idx mul ] // mul >= 2, else we would use base instead of idx*
3456	// [ idx mul + cns] // mul >= 2, else we would use base instead of idx*
3457	// [base + idx mul ] // mul can be 0, 2, 4, or 8*
3458	// [base + idx mul + cns] // mul can be 0, 2, 4, or 8*
3459	// Note that mul == 0 is semantically equivalent to mul == 1.
3460	// Note that cns can be zero.
3461	CLANG_FORMAT_COMMENT_ANCHOR;
3462
3463	#if SCALED_ADDR_MODES
3464	assert((base != nullptr) \|\| (idx != nullptr && mul >= `2`));
3465	#else
3466	assert(base != NULL);
3467	#endif
3468
3469	INDEBUG(GenTree* op1Save = addr);
3470
3471	// Walk 'addr' identifying non-overflow ADDs that will be part of the address mode.
3472	// Note that we will be modifying 'op1' and 'op2' so that eventually they should
3473	// map to the base and index.
3474	op1 = addr;
3475	gtWalkOp(&op1, &op2, base, false);
3476
3477	// op1 and op2 are now descendents of the root GT_ADD of the addressing mode.
3478	assert(op1 != op1Save);
3479	assert(op2 != nullptr);
3480
3481	// Walk the operands again (the third operand is unused in this case).
3482	// This time we will only consider adds with constant op2's, since
3483	// we have already found either a non-ADD op1 or a non-constant op2.
3484	gtWalkOp(&op1, &op2, nullptr, true);
3485
3486	#if defined(_TARGET_XARCH_)
3487	// For XARCH we will fold GT_ADDs in the op2 position into the addressing mode, so we call
3488	// gtWalkOp on both operands of the original GT_ADD.
3489	// This is not done for ARMARCH. Though the stated reason is that we don't try to create a
3490	// scaled index, in fact we actually do create them (even base + indexscale + offset).*
3491
3492	// At this point, 'op2' may itself be an ADD of a constant that should be folded
3493	// into the addressing mode.
3494	// Walk op2 looking for non-overflow GT_ADDs of constants.
3495	gtWalkOp(&op2, &op1, nullptr, true);
3496	#endif // defined(_TARGET_XARCH_)
3497
3498	// OK we are done walking the tree
3499	// Now assert that op1 and op2 correspond with base and idx
3500	// in one of the several acceptable ways.
3501
3502	// Note that sometimes op1/op2 is equal to idx/base
3503	// and other times op1/op2 is a GT_COMMA node with
3504	// an effective value that is idx/base
3505
3506	if (mul > `1`)
3507	{
3508	if ((op1 != base) && (op1->gtOper == GT_LSH))
3509	{
3510	op1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3511	if (op1->gtOp.gtOp1->gtOper == GT_MUL)
3512	{
3513	op1->gtOp.gtOp1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3514	}
3515	assert((base == nullptr) \|\| (op2 == base) \|\|
3516	(op2->gtEffectiveVal() == base->gtEffectiveVal()) \|\|
3517	(gtWalkOpEffectiveVal(op2) == gtWalkOpEffectiveVal(base)));
3518	}
3519	else
3520	{
3521	assert(op2);
3522	assert(op2->gtOper == GT_LSH \|\| op2->gtOper == GT_MUL);
3523	op2->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3524	// We may have eliminated multiple shifts and multiplies in the addressing mode,
3525	// so navigate down through them to get to "idx".
3526	GenTree* op2op1 = op2->gtOp.gtOp1;
3527	while ((op2op1->gtOper == GT_LSH \|\| op2op1->gtOper == GT_MUL) && op2op1 != idx)
3528	{
3529	op2op1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3530	op2op1 = op2op1->gtOp.gtOp1;
3531	}
3532	assert(op1->gtEffectiveVal() == base);
3533	assert(op2op1 == idx);
3534	}
3535	}
3536	else
3537	{
3538	assert(mul == `0`);
3539
3540	if ((op1 == idx) \|\| (op1->gtEffectiveVal() == idx))
3541	{
3542	if (idx != nullptr)
3543	{
3544	if ((op1->gtOper == GT_MUL) \|\| (op1->gtOper == GT_LSH))
3545	{
3546	if ((op1->gtOp.gtOp1->gtOper == GT_NOP) \|\|
3547	(op1->gtOp.gtOp1->gtOper == GT_MUL &&
3548	op1->gtOp.gtOp1->gtOp.gtOp1->gtOper == GT_NOP))
3549	{
3550	op1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3551	if (op1->gtOp.gtOp1->gtOper == GT_MUL)
3552	{
3553	op1->gtOp.gtOp1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3554	}
3555	}
3556	}
3557	}
3558	assert((op2 == base) \|\| (op2->gtEffectiveVal() == base));
3559	}
3560	else if ((op1 == base) \|\| (op1->gtEffectiveVal() == base))
3561	{
3562	if (idx != nullptr)
3563	{
3564	assert(op2);
3565	if ((op2->gtOper == GT_MUL) \|\| (op2->gtOper == GT_LSH))
3566	{
3567	if ((op2->gtOp.gtOp1->gtOper == GT_NOP) \|\|
3568	(op2->gtOp.gtOp1->gtOper == GT_MUL &&
3569	op2->gtOp.gtOp1->gtOp.gtOp1->gtOper == GT_NOP))
3570	{
3571	op2->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3572	if (op2->gtOp.gtOp1->gtOper == GT_MUL)
3573	{
3574	op2->gtOp.gtOp1->gtFlags \|= GTF_ADDRMODE_NO_CSE;
3575	}
3576	}
3577	}
3578	assert((op2 == idx) \|\| (op2->gtEffectiveVal() == idx));
3579	}
3580	}
3581	else
3582	{
3583	// op1 isn't base or idx. Is this possible? Or should there be an assert?
3584	}
3585	}
3586	goto DONE;
3587
3588	} // end if (genCreateAddrMode(...))
3589
3590	} // end if (op1->gtOper == GT_ADD)
3591	else if (gtIsLikelyRegVar(op1))
3592	{
3593	/ Indirection of an enregister LCL_VAR, don't increase costEx/costSz /
3594	goto DONE;
3595	}
3596	#ifdef _TARGET_XARCH_
3597	else if (op1->IsCnsIntOrI())
3598	{
3599	// Indirection of a CNS_INT, subtract 1 from costEx
3600	// makes costEx 3 for x86 and 4 for amd64
3601	//
3602	costEx += (op1->gtCostEx - `1`);
3603	costSz += op1->gtCostSz;
3604	goto DONE;
3605	}
3606	#endif
3607	break;
3608
3609	default:
3610	break;
3611	}
3612	costEx += op1->gtCostEx;
3613	costSz += op1->gtCostSz;
3614	goto DONE;
3615	}
3616
3617	/ Binary operator - check for certain special cases /
3618
3619	lvlb = `0`;
3620
3621	/ Default Binary ops have a cost of 1,1 /
3622	costEx = `1`;
3623	costSz = `1`;
3624
3625	#ifdef _TARGET_ARM_
3626	if (isflt)
3627	{
3628	costSz += `2`;
3629	}
3630	#endif
3631	#ifndef _TARGET_64BIT_
3632	if (varTypeIsLong(op1->TypeGet()))
3633	{
3634	/ Operations on longs are more expensive /
3635	costEx += `3`;
3636	costSz += `3`;
3637	}
3638	#endif
3639	switch (oper)
3640	{
3641	case GT_MOD:
3642	case GT_UMOD:
3643
3644	/ Modulo by a power of 2 is easy /
3645
3646	if (op2->IsCnsIntOrI())
3647	{
3648	size_t ival = op2->gtIntConCommon.IconValue();
3649
3650	if (ival > `0` && ival == genFindLowestBit(ival))
3651	{
3652	break;
3653	}
3654	}
3655
3656	__fallthrough;
3657
3658	case GT_DIV:
3659	case GT_UDIV:
3660
3661	if (isflt)
3662	{
3663	/ fp division is very expensive to execute /
3664	costEx = `36`; // TYP_DOUBLE
3665	costSz += `3`;
3666	}
3667	else
3668	{
3669	/ integer division is also very expensive /
3670	costEx = `20`;
3671	costSz += `2`;
3672
3673	// Encourage the first operand to be evaluated (into EAX/EDX) first /*
3674	lvlb -= `3`;
3675	}
3676	break;
3677
3678	case GT_MUL:
3679
3680	if (isflt)
3681	{
3682	/ FP multiplication instructions are more expensive /
3683	costEx += `4`;
3684	costSz += `3`;
3685	}
3686	else
3687	{
3688	/ Integer multiplication instructions are more expensive /
3689	costEx += `3`;
3690	costSz += `2`;
3691
3692	if (tree->gtOverflow())
3693	{
3694	/ Overflow check are more expensive /
3695	costEx += `3`;
3696	costSz += `3`;
3697	}
3698
3699	#ifdef _TARGET_X86_
3700	if ((tree->gtType == TYP_LONG) \|\| tree->gtOverflow())
3701	{
3702	/ We use imulEAX for TYP_LONG and overflow multiplications /
3703	// Encourage the first operand to be evaluated (into EAX/EDX) first /*
3704	lvlb -= `4`;
3705
3706	/ The 64-bit imul instruction costs more /
3707	costEx += `4`;
3708	}
3709	#endif // _TARGET_X86_
3710	}
3711	break;
3712
3713	case GT_ADD:
3714	case GT_SUB:
3715	if (isflt)
3716	{
3717	/ FP instructions are a bit more expensive /
3718	costEx += `4`;
3719	costSz += `3`;
3720	break;
3721	}
3722
3723	/ Overflow check are more expensive /
3724	if (tree->gtOverflow())
3725	{
3726	costEx += `3`;
3727	costSz += `3`;
3728	}
3729	break;
3730
3731	case GT_COMMA:
3732
3733	/ Comma tosses the result of the left operand /
3734	gtSetEvalOrder(op1);
3735	level = gtSetEvalOrder(op2);
3736
3737	/ GT_COMMA cost is the sum of op1 and op2 costs /
3738	costEx = (op1->gtCostEx + op2->gtCostEx);
3739	costSz = (op1->gtCostSz + op2->gtCostSz);
3740
3741	goto DONE;
3742
3743	case GT_COLON:
3744
3745	level = gtSetEvalOrder(op1);
3746	lvl2 = gtSetEvalOrder(op2);
3747
3748	if (level < lvl2)
3749	{
3750	level = lvl2;
3751	}
3752	else if (level == lvl2)
3753	{
3754	level += `1`;
3755	}
3756
3757	costEx = op1->gtCostEx + op2->gtCostEx;
3758	costSz = op1->gtCostSz + op2->gtCostSz;
3759
3760	goto DONE;
3761
3762	case GT_LIST:
3763	case GT_FIELD_LIST:
3764	{
3765	const bool isListCallArgs = false;
3766	const bool callArgsInRegs = false;
3767	return gtSetListOrder(tree, isListCallArgs, callArgsInRegs);
3768	}
3769
3770	case GT_ASG:
3771	/ Assignments need a bit of special handling /
3772	/ Process the target /
3773	level = gtSetEvalOrder(op1);
3774
3775	if (gtIsLikelyRegVar(op1))
3776	{
3777	assert(lvlb == `0`);
3778	lvl2 = gtSetEvalOrder(op2);
3779
3780	/ Assignment to an enregistered LCL_VAR /
3781	costEx = op2->gtCostEx;
3782	costSz = max(`3`, op2->gtCostSz); // 3 is an estimate for a reg-reg assignment
3783	goto DONE_OP1_AFTER_COST;
3784	}
3785	goto DONE_OP1;
3786
3787	default:
3788	break;
3789	}
3790
3791	/ Process the sub-operands /
3792
3793	level = gtSetEvalOrder(op1);
3794	if (lvlb < `0`)
3795	{
3796	level -= lvlb; // lvlb is negative, so this increases level
3797	lvlb = `0`;
3798	}
3799
3800	DONE_OP1:
3801	assert(lvlb >= `0`);
3802	lvl2 = gtSetEvalOrder(op2) + lvlb;
3803
3804	costEx += (op1->gtCostEx + op2->gtCostEx);
3805	costSz += (op1->gtCostSz + op2->gtCostSz);
3806
3807	DONE_OP1_AFTER_COST:
3808
3809	bool bReverseInAssignment = false;
3810	if (oper == GT_ASG)
3811	{
3812	GenTree* op1Val = op1;
3813
3814	// Skip over the GT_IND/GT_ADDR tree (if one exists)
3815	//
3816	if ((op1->gtOper == GT_IND) && (op1->gtOp.gtOp1->gtOper == GT_ADDR))
3817	{
3818	op1Val = op1->gtOp.gtOp1->gtOp.gtOp1;
3819	}
3820
3821	switch (op1Val->gtOper)
3822	{
3823	case GT_IND:
3824	case GT_BLK:
3825	case GT_OBJ:
3826	case GT_DYN_BLK:
3827
3828	// In an indirection, the destination address is evaluated prior to the source.
3829	// If we have any side effects on the target indirection,
3830	// we have to evaluate op1 first.
3831	// However, if the LHS is a lclVar address, SSA relies on using evaluation order for its
3832	// renaming, and therefore the RHS must be evaluated first.
3833	// If we have an assignment involving a lclVar address, the LHS may be marked as having
3834	// side-effects.
3835	// However the side-effects won't require that we evaluate the LHS address first:
3836	// - The GTF_GLOB_REF might have been conservatively set on a FIELD of a local.
3837	// - The local might be address-exposed, but that side-effect happens at the actual assignment (not
3838	// when its address is "evaluated") so it doesn't change the side effect to "evaluate" the address
3839	// after the RHS (note that in this case it won't be renamed by SSA anyway, but the reordering is
3840	// safe).
3841	//
3842	if (op1Val->AsIndir()->Addr()->IsLocalAddrExpr())
3843	{
3844	bReverseInAssignment = true;
3845	tree->gtFlags \|= GTF_REVERSE_OPS;
3846	break;
3847	}
3848	if (op1Val->AsIndir()->Addr()->gtFlags & GTF_ALL_EFFECT)
3849	{
3850	break;
3851	}
3852
3853	// In case op2 assigns to a local var that is used in op1Val, we have to evaluate op1Val first.
3854	if (op2->gtFlags & GTF_ASG)
3855	{
3856	break;
3857	}
3858
3859	// If op2 is simple then evaluate op1 first
3860
3861	if (op2->OperKind() & GTK_LEAF)
3862	{
3863	break;
3864	}
3865
3866	// fall through and set GTF_REVERSE_OPS
3867
3868	case GT_LCL_VAR:
3869	case GT_LCL_FLD:
3870
3871	// We evaluate op2 before op1
3872	bReverseInAssignment = true;
3873	tree->gtFlags \|= GTF_REVERSE_OPS;
3874	break;
3875
3876	default:
3877	break;
3878	}
3879	}
3880	else if (kind & GTK_RELOP)
3881	{
3882	/ Float compares remove both operands from the FP stack /
3883	/ Also FP comparison uses EAX for flags /
3884
3885	if (varTypeIsFloating(op1->TypeGet()))
3886	{
3887	level++;
3888	lvl2++;
3889	}
3890	if ((tree->gtFlags & GTF_RELOP_JMP_USED) == `0`)
3891	{
3892	/ Using a setcc instruction is more expensive /
3893	costEx += `3`;
3894	}
3895	}
3896
3897	/ Check for other interesting cases /
3898
3899	switch (oper)
3900	{
3901	case GT_LSH:
3902	case GT_RSH:
3903	case GT_RSZ:
3904	case GT_ROL:
3905	case GT_ROR:
3906	/ Variable sized shifts are more expensive and use REG_SHIFT /
3907
3908	if (!op2->IsCnsIntOrI())
3909	{
3910	costEx += `3`;
3911	#ifndef _TARGET_64BIT_
3912	// Variable sized LONG shifts require the use of a helper call
3913	//
3914	if (tree->gtType == TYP_LONG)
3915	{
3916	level += `5`;
3917	lvl2 += `5`;
3918	costEx += `3` * IND_COST_EX;
3919	costSz += `4`;
3920	}
3921	#endif // !_TARGET_64BIT_
3922	}
3923	break;
3924
3925	case GT_INTRINSIC:
3926
3927	switch (tree->gtIntrinsic.gtIntrinsicId)
3928	{
3929	case CORINFO_INTRINSIC_Atan2:
3930	case CORINFO_INTRINSIC_Pow:
3931	// These math intrinsics are actually implemented by user calls.
3932	// Increase the Sethi 'complexity' by two to reflect the argument
3933	// register requirement.
3934	level += `2`;
3935	break;
3936	default:
3937	assert(!"Unknown binary GT_INTRINSIC operator");
3938	break;
3939	}
3940
3941	break;
3942
3943	default:
3944	break;
3945	}
3946
3947	/ We need to evalutate constants later as many places in codegen*
3948	can't handle op1 being a constant. This is normally naturally
3949	enforced as constants have the least level of 0. However,
3950	sometimes we end up with a tree like "cns1 < nop(cns2)". In
3951	such cases, both sides have a level of 0. So encourage constants
3952	to be evaluated last in such cases /*
3953
3954	if ((level == `0`) && (level == lvl2) && (op1->OperKind() & GTK_CONST) &&
3955	(tree->OperIsCommutative() \|\| tree->OperIsCompare()))
3956	{
3957	lvl2++;
3958	}
3959
3960	/ We try to swap operands if the second one is more expensive /
3961	bool tryToSwap;
3962	GenTree* opA;
3963	GenTree* opB;
3964
3965	if (tree->gtFlags & GTF_REVERSE_OPS)
3966	{
3967	opA = op2;
3968	opB = op1;
3969	}
3970	else
3971	{
3972	opA = op1;
3973	opB = op2;
3974	}
3975
3976	if (fgOrder == FGOrderLinear)
3977	{
3978	// Don't swap anything if we're in linear order; we're really just interested in the costs.
3979	tryToSwap = false;
3980	}
3981	else if (bReverseInAssignment)
3982	{
3983	// Assignments are special, we want the reverseops flags
3984	// so if possible it was set above.
3985	tryToSwap = false;
3986	}
3987	else if ((oper == GT_INTRINSIC) && IsIntrinsicImplementedByUserCall(tree->AsIntrinsic()->gtIntrinsicId))
3988	{
3989	// We do not swap operand execution order for intrinsics that are implemented by user calls
3990	// because of trickiness around ensuring the execution order does not change during rationalization.
3991	tryToSwap = false;
3992	}
3993	else
3994	{
3995	if (tree->gtFlags & GTF_REVERSE_OPS)
3996	{
3997	tryToSwap = (level > lvl2);
3998	}
3999	else
4000	{
4001	tryToSwap = (level < lvl2);
4002	}
4003
4004	// Try to force extra swapping when in the stress mode:
4005	if (compStressCompile(STRESS_REVERSE_FLAG, `60`) && ((tree->gtFlags & GTF_REVERSE_OPS) == `0`) &&
4006	((op2->OperKind() & GTK_CONST) == `0`))
4007	{
4008	tryToSwap = true;
4009	}
4010	}
4011
4012	if (tryToSwap)
4013	{
4014	bool canSwap = gtCanSwapOrder(opA, opB);
4015
4016	if (canSwap)
4017	{
4018	/ Can we swap the order by commuting the operands? /
4019
4020	switch (oper)
4021	{
4022	case GT_EQ:
4023	case GT_NE:
4024	case GT_LT:
4025	case GT_LE:
4026	case GT_GE:
4027	case GT_GT:
4028	if (GenTree::SwapRelop(oper) != oper)
4029	{
4030	tree->SetOper(GenTree::SwapRelop(oper), GenTree::PRESERVE_VN);
4031	}
4032
4033	__fallthrough;
4034
4035	case GT_ADD:
4036	case GT_MUL:
4037
4038	case GT_OR:
4039	case GT_XOR:
4040	case GT_AND:
4041
4042	/ Swap the operands /
4043
4044	tree->gtOp.gtOp1 = op2;
4045	tree->gtOp.gtOp2 = op1;
4046	break;
4047
4048	case GT_QMARK:
4049	case GT_COLON:
4050	case GT_MKREFANY:
4051	break;
4052
4053	case GT_LIST:
4054	case GT_FIELD_LIST:
4055	break;
4056
4057	default:
4058
4059	/ Mark the operand's evaluation order to be swapped /
4060	if (tree->gtFlags & GTF_REVERSE_OPS)
4061	{
4062	tree->gtFlags &= ~GTF_REVERSE_OPS;
4063	}
4064	else
4065	{
4066	tree->gtFlags \|= GTF_REVERSE_OPS;
4067	}
4068
4069	break;
4070	}
4071	}
4072	}
4073
4074	/ Swap the level counts /
4075	if (tree->gtFlags & GTF_REVERSE_OPS)
4076	{
4077	unsigned tmpl;
4078
4079	tmpl = level;
4080	level = lvl2;
4081	lvl2 = tmpl;
4082	}
4083
4084	/ Compute the sethi number for this binary operator /
4085
4086	if (level < `1`)
4087	{
4088	level = lvl2;
4089	}
4090	else if (level == lvl2)
4091	{
4092	level += `1`;
4093	}
4094
4095	goto DONE;
4096	}
4097
4098	/ See what kind of a special operator we have here /
4099
4100	switch (oper)
4101	{
4102	unsigned lvl2; // Scratch variable
4103
4104	case GT_CALL:
4105
4106	assert(tree->gtFlags & GTF_CALL);
4107
4108	level = `0`;
4109	costEx = `5`;
4110	costSz = `2`;
4111
4112	/ Evaluate the 'this' argument, if present /
4113
4114	if (tree->gtCall.gtCallObjp)
4115	{
4116	GenTree* thisVal = tree->gtCall.gtCallObjp;
4117
4118	lvl2 = gtSetEvalOrder(thisVal);
4119	if (level < lvl2)
4120	{
4121	level = lvl2;
4122	}
4123	costEx += thisVal->gtCostEx;
4124	costSz += thisVal->gtCostSz + `1`;
4125	}
4126
4127	/ Evaluate the arguments, right to left /
4128
4129	if (tree->gtCall.gtCallArgs)
4130	{
4131	const bool isListCallArgs = true;
4132	const bool callArgsInRegs = false;
4133	lvl2 = gtSetListOrder(tree->gtCall.gtCallArgs, isListCallArgs, callArgsInRegs);
4134	if (level < lvl2)
4135	{
4136	level = lvl2;
4137	}
4138	costEx += tree->gtCall.gtCallArgs->gtCostEx;
4139	costSz += tree->gtCall.gtCallArgs->gtCostSz;
4140	}
4141
4142	/ Evaluate the temp register arguments list*
4143	* This is a "hidden" list and its only purpose is to
4144	* extend the life of temps until we make the call */
4145
4146	if (tree->gtCall.gtCallLateArgs)
4147	{
4148	const bool isListCallArgs = true;
4149	const bool callArgsInRegs = true;
4150	lvl2 = gtSetListOrder(tree->gtCall.gtCallLateArgs, isListCallArgs, callArgsInRegs);
4151	if (level < lvl2)
4152	{
4153	level = lvl2;
4154	}
4155	costEx += tree->gtCall.gtCallLateArgs->gtCostEx;
4156	costSz += tree->gtCall.gtCallLateArgs->gtCostSz;
4157	}
4158
4159	if (tree->gtCall.gtCallType == CT_INDIRECT)
4160	{
4161	// pinvoke-calli cookie is a constant, or constant indirection
4162	assert(tree->gtCall.gtCallCookie == nullptr \|\| tree->gtCall.gtCallCookie->gtOper == GT_CNS_INT \|\|
4163	tree->gtCall.gtCallCookie->gtOper == GT_IND);
4164
4165	GenTree* indirect = tree->gtCall.gtCallAddr;
4166
4167	lvl2 = gtSetEvalOrder(indirect);
4168	if (level < lvl2)
4169	{
4170	level = lvl2;
4171	}
4172	costEx += indirect->gtCostEx + IND_COST_EX;
4173	costSz += indirect->gtCostSz;
4174	}
4175	else
4176	{
4177	#ifdef _TARGET_ARM_
4178	if (tree->gtCall.IsVirtualStub())
4179	{
4180	// We generate movw/movt/ldr
4181	costEx += (`1` + IND_COST_EX);
4182	costSz += `8`;
4183	if (tree->gtCall.gtCallMoreFlags & GTF_CALL_M_VIRTSTUB_REL_INDIRECT)
4184	{
4185	// Must use R12 for the ldr target -- REG_JUMP_THUNK_PARAM
4186	costSz += `2`;
4187	}
4188	}
4189	else if (!opts.jitFlags->IsSet(JitFlags::JIT_FLAG_PREJIT))
4190	{
4191	costEx += `2`;
4192	costSz += `6`;
4193	}
4194	costSz += `2`;
4195	#endif
4196	#ifdef _TARGET_XARCH_
4197	costSz += `3`;
4198	#endif
4199	}
4200
4201	level += `1`;
4202
4203	/ Virtual calls are a bit more expensive /
4204	if (tree->gtCall.IsVirtual())
4205	{
4206	costEx += `2` * IND_COST_EX;
4207	costSz += `2`;
4208	}
4209
4210	level += `5`;
4211	costEx += `3` * IND_COST_EX;
4212	break;
4213
4214	case GT_ARR_ELEM:
4215
4216	level = gtSetEvalOrder(tree->gtArrElem.gtArrObj);
4217	costEx = tree->gtArrElem.gtArrObj->gtCostEx;
4218	costSz = tree->gtArrElem.gtArrObj->gtCostSz;
4219
4220	unsigned dim;
4221	for (dim = `0`; dim < tree->gtArrElem.gtArrRank; dim++)
4222	{
4223	lvl2 = gtSetEvalOrder(tree->gtArrElem.gtArrInds[dim]);
4224	if (level < lvl2)
4225	{
4226	level = lvl2;
4227	}
4228	costEx += tree->gtArrElem.gtArrInds[dim]->gtCostEx;
4229	costSz += tree->gtArrElem.gtArrInds[dim]->gtCostSz;
4230	}
4231
4232	level += tree->gtArrElem.gtArrRank;
4233	costEx += `2` + (tree->gtArrElem.gtArrRank * (IND_COST_EX + `1`));
4234	costSz += `2` + (tree->gtArrElem.gtArrRank * `2`);
4235	break;
4236
4237	case GT_ARR_OFFSET:
4238	level = gtSetEvalOrder(tree->gtArrOffs.gtOffset);
4239	costEx = tree->gtArrOffs.gtOffset->gtCostEx;
4240	costSz = tree->gtArrOffs.gtOffset->gtCostSz;
4241	lvl2 = gtSetEvalOrder(tree->gtArrOffs.gtIndex);
4242	level = max(level, lvl2);
4243	costEx += tree->gtArrOffs.gtIndex->gtCostEx;
4244	costSz += tree->gtArrOffs.gtIndex->gtCostSz;
4245	lvl2 = gtSetEvalOrder(tree->gtArrOffs.gtArrObj);
4246	level = max(level, lvl2);
4247	costEx += tree->gtArrOffs.gtArrObj->gtCostEx;
4248	costSz += tree->gtArrOffs.gtArrObj->gtCostSz;
4249	break;
4250
4251	case GT_CMPXCHG:
4252
4253	level = gtSetEvalOrder(tree->gtCmpXchg.gtOpLocation);
4254	costSz = tree->gtCmpXchg.gtOpLocation->gtCostSz;
4255
4256	lvl2 = gtSetEvalOrder(tree->gtCmpXchg.gtOpValue);
4257	if (level < lvl2)
4258	{
4259	level = lvl2;
4260	}
4261	costSz += tree->gtCmpXchg.gtOpValue->gtCostSz;
4262
4263	lvl2 = gtSetEvalOrder(tree->gtCmpXchg.gtOpComparand);
4264	if (level < lvl2)
4265	{
4266	level = lvl2;
4267	}
4268	costSz += tree->gtCmpXchg.gtOpComparand->gtCostSz;
4269
4270	costEx = MAX_COST; // Seriously, what could be more expensive than lock cmpxchg?
4271	costSz += `5`; // size of lock cmpxchg [reg+C], reg
4272	break;
4273
4274	case GT_ARR_BOUNDS_CHECK:
4275	#ifdef FEATURE_SIMD
4276	case GT_SIMD_CHK:
4277	#endif // FEATURE_SIMD
4278	#ifdef FEATURE_HW_INTRINSICS
4279	case GT_HW_INTRINSIC_CHK:
4280	#endif // FEATURE_HW_INTRINSICS
4281
4282	costEx = `4`; // cmp reg,reg and jae throw (not taken)
4283	costSz = `7`; // jump to cold section
4284
4285	level = gtSetEvalOrder(tree->gtBoundsChk.gtIndex);
4286	costEx += tree->gtBoundsChk.gtIndex->gtCostEx;
4287	costSz += tree->gtBoundsChk.gtIndex->gtCostSz;
4288
4289	lvl2 = gtSetEvalOrder(tree->gtBoundsChk.gtArrLen);
4290	if (level < lvl2)
4291	{
4292	level = lvl2;
4293	}
4294	costEx += tree->gtBoundsChk.gtArrLen->gtCostEx;
4295	costSz += tree->gtBoundsChk.gtArrLen->gtCostSz;
4296
4297	break;
4298
4299	case GT_STORE_DYN_BLK:
4300	case GT_DYN_BLK:
4301	{
4302	costEx = `0`;
4303	costSz = `0`;
4304	level = `0`;
4305	if (oper == GT_STORE_DYN_BLK)
4306	{
4307	lvl2 = gtSetEvalOrder(tree->gtDynBlk.Data());
4308	level = max(level, lvl2);
4309	costEx += tree->gtDynBlk.Data()->gtCostEx;
4310	costSz += tree->gtDynBlk.Data()->gtCostSz;
4311	}
4312	lvl2 = gtSetEvalOrder(tree->gtDynBlk.Addr());
4313	level = max(level, lvl2);
4314	costEx = tree->gtDynBlk.Addr()->gtCostEx;
4315	costSz = tree->gtDynBlk.Addr()->gtCostSz;
4316	unsigned sizeLevel = gtSetEvalOrder(tree->gtDynBlk.gtDynamicSize);
4317
4318	// Determine whether the size node should be evaluated first.
4319	// We would like to do this if the sizeLevel is larger than the current level,
4320	// but we have to ensure that we obey ordering constraints.
4321	if (tree->AsDynBlk()->gtEvalSizeFirst != (level < sizeLevel))
4322	{
4323	bool canChange = true;
4324
4325	GenTree* sizeNode = tree->AsDynBlk()->gtDynamicSize;
4326	GenTree* dst = tree->AsDynBlk()->Addr();
4327	GenTree* src = tree->AsDynBlk()->Data();
4328
4329	if (tree->AsDynBlk()->gtEvalSizeFirst)
4330	{
4331	canChange = gtCanSwapOrder(sizeNode, dst);
4332	if (canChange && (src != nullptr))
4333	{
4334	canChange = gtCanSwapOrder(sizeNode, src);
4335	}
4336	}
4337	else
4338	{
4339	canChange = gtCanSwapOrder(dst, sizeNode);
4340	if (canChange && (src != nullptr))
4341	{
4342	gtCanSwapOrder(src, sizeNode);
4343	}
4344	}
4345	if (canChange)
4346	{
4347	tree->AsDynBlk()->gtEvalSizeFirst = (level < sizeLevel);
4348	}
4349	}
4350	level = max(level, sizeLevel);
4351	costEx += tree->gtDynBlk.gtDynamicSize->gtCostEx;
4352	costSz += tree->gtDynBlk.gtDynamicSize->gtCostSz;
4353	}
4354	break;
4355
4356	case GT_INDEX_ADDR:
4357	costEx = `6`; // cmp reg,reg; jae throw; mov reg, [addrmode] (not taken)
4358	costSz = `9`; // jump to cold section
4359
4360	level = gtSetEvalOrder(tree->AsIndexAddr()->Index());
4361	costEx += tree->AsIndexAddr()->Index()->gtCostEx;
4362	costSz += tree->AsIndexAddr()->Index()->gtCostSz;
4363
4364	lvl2 = gtSetEvalOrder(tree->AsIndexAddr()->Arr());
4365	if (level < lvl2)
4366	{
4367	level = lvl2;
4368	}
4369	costEx += tree->AsIndexAddr()->Arr()->gtCostEx;
4370	costSz += tree->AsIndexAddr()->Arr()->gtCostSz;
4371	break;
4372
4373	default:
4374	#ifdef DEBUG
4375	if (verbose)
4376	{
4377	printf("unexpected operator in this tree:\n");
4378	gtDispTree(tree);
4379	}
4380	#endif
4381	NO_WAY("unexpected operator");
4382	}
4383
4384	DONE:
4385
4386	#ifdef FEATURE_HW_INTRINSICS
4387	if ((oper == GT_HWIntrinsic) && (tree->gtGetOp1() == nullptr))
4388	{
4389	// We can have nullary HWIntrinsic nodes, and we must have non-zero cost.
4390	costEx = `1`;
4391	costSz = `1`;
4392	}
4393	#endif // FEATURE_HW_INTRINSICS
4394
4395	// Some path through this function must have set the costs.
4396	assert(costEx != -`1`);
4397	assert(costSz != -`1`);
4398
4399	tree->SetCosts(costEx, costSz);
4400
4401	return level;
4402	}
4403	#ifdef _PREFAST_
4404	#pragma warning(pop)
4405	#endif
4406
4407	/*****************************************************************************
4408	*
4409	* If the given tree is an integer constant that can be used
4410	* in a scaled index address mode as a multiplier (e.g. "[4*index]"), then return
4411	* the scale factor: 2, 4, or 8. Otherwise, return 0. Note that we never return 1,
4412	* to match the behavior of GetScaleIndexShf().
4413	*/
4414
4415	unsigned GenTree::GetScaleIndexMul()
4416	{
4417	if (IsCnsIntOrI() && jitIsScaleIndexMul(gtIntConCommon.IconValue()) && gtIntConCommon.IconValue() != `1`)
4418	{
4419	return (unsigned)gtIntConCommon.IconValue();
4420	}
4421
4422	return `0`;
4423	}
4424
4425	/*****************************************************************************
4426	*
4427	* If the given tree is the right-hand side of a left shift (that is,
4428	* 'y' in the tree 'x' << 'y'), and it is an integer constant that can be used
4429	* in a scaled index address mode as a multiplier (e.g. "[4*index]"), then return
4430	* the scale factor: 2, 4, or 8. Otherwise, return 0.
4431	*/
4432
4433	unsigned GenTree::GetScaleIndexShf()
4434	{
4435	if (IsCnsIntOrI() && jitIsScaleIndexShift(gtIntConCommon.IconValue()))
4436	{
4437	return (unsigned)(`1` << gtIntConCommon.IconValue());
4438	}
4439
4440	return `0`;
4441	}
4442
4443	/*****************************************************************************
4444	*
4445	* If the given tree is a scaled index (i.e. "op * 4" or "op << 2"), returns
4446	* the multiplier: 2, 4, or 8; otherwise returns 0. Note that "1" is never
4447	* returned.
4448	*/
4449
4450	unsigned GenTree::GetScaledIndex()
4451	{
4452	// with (!opts.OptEnabled(CLFLG_CONSTANTFOLD) we can have
4453	// CNS_INT CNS_INT*
4454	//
4455	if (gtOp.gtOp1->IsCnsIntOrI())
4456	{
4457	return `0`;
4458	}
4459
4460	switch (gtOper)
4461	{
4462	case GT_MUL:
4463	return gtOp.gtOp2->GetScaleIndexMul();
4464
4465	case GT_LSH:
4466	return gtOp.gtOp2->GetScaleIndexShf();
4467
4468	default:
4469	assert(!"GenTree::GetScaledIndex() called with illegal gtOper");
4470	break;
4471	}
4472
4473	return `0`;
4474	}
4475
4476	/*****************************************************************************
4477	*
4478	* Returns true if "addr" is a GT_ADD node, at least one of whose arguments is an integer (<= 32 bit)
4479	* constant. If it returns true, it sets "*offset" to (one of the) constant value(s), and
4480	* "*addr" to the other argument.
4481	*/
4482
4483	bool GenTree::IsAddWithI32Const(GenTree** addr, int* offset)
4484	{
4485	if (OperGet() == GT_ADD)
4486	{
4487	if (gtOp.gtOp1->IsIntCnsFitsInI32())
4488	{
4489	offset = (int*)gtOp.gtOp1->gtIntCon.gtIconVal;
4490	*addr = gtOp.gtOp2;
4491	return true;
4492	}
4493	else if (gtOp.gtOp2->IsIntCnsFitsInI32())
4494	{
4495	offset = (int*)gtOp.gtOp2->gtIntCon.gtIconVal;
4496	*addr = gtOp.gtOp1;
4497	return true;
4498	}
4499	}
4500	// Otherwise...
4501	return false;
4502	}
4503
4504	//------------------------------------------------------------------------
4505	// gtGetChildPointer: If 'parent' is the parent of this node, return the pointer
4506	// to the child node so that it can be modified; otherwise, return nullptr.
4507	//
4508	// Arguments:
4509	// parent - The possible parent of this node
4510	//
4511	// Return Value:
4512	// If "child" is a child of "parent", returns a pointer to the child node in the parent
4513	// (i.e. a pointer to a GenTree pointer).
4514	// Otherwise, returns nullptr.
4515	//
4516	// Assumptions:
4517	// 'parent' must be non-null
4518	//
4519	// Notes:
4520	// When FEATURE_MULTIREG_ARGS is defined we can get here with GT_OBJ tree.
4521	// This happens when we have a struct that is passed in multiple registers.
4522	//
4523	// Also note that when UNIX_AMD64_ABI is defined the GT_LDOBJ
4524	// later gets converted to a GT_FIELD_LIST with two GT_LCL_FLDs in Lower/LowerXArch.
4525	//
4526
4527	GenTree** GenTree::gtGetChildPointer(GenTree* parent) const
4528
4529	{
4530	switch (parent->OperGet())
4531	{
4532	default:
4533	if (!parent->OperIsSimple())
4534	{
4535	return nullptr;
4536	}
4537	if (this == parent->gtOp.gtOp1)
4538	{
4539	return &(parent->gtOp.gtOp1);
4540	}
4541	if (this == parent->gtOp.gtOp2)
4542	{
4543	return &(parent->gtOp.gtOp2);
4544	}
4545	break;
4546
4547	case GT_CMPXCHG:
4548	if (this == parent->gtCmpXchg.gtOpLocation)
4549	{
4550	return &(parent->gtCmpXchg.gtOpLocation);
4551	}
4552	if (this == parent->gtCmpXchg.gtOpValue)
4553	{
4554	return &(parent->gtCmpXchg.gtOpValue);
4555	}
4556	if (this == parent->gtCmpXchg.gtOpComparand)
4557	{
4558	return &(parent->gtCmpXchg.gtOpComparand);
4559	}
4560	break;
4561
4562	case GT_ARR_BOUNDS_CHECK:
4563	#ifdef FEATURE_SIMD
4564	case GT_SIMD_CHK:
4565	#endif // FEATURE_SIMD
4566	#ifdef FEATURE_HW_INTRINSICS
4567	case GT_HW_INTRINSIC_CHK:
4568	#endif // FEATURE_HW_INTRINSICS
4569	if (this == parent->gtBoundsChk.gtIndex)
4570	{
4571	return &(parent->gtBoundsChk.gtIndex);
4572	}
4573	if (this == parent->gtBoundsChk.gtArrLen)
4574	{
4575	return &(parent->gtBoundsChk.gtArrLen);
4576	}
4577	if (this == parent->gtBoundsChk.gtIndRngFailBB)
4578	{
4579	return &(parent->gtBoundsChk.gtIndRngFailBB);
4580	}
4581	break;
4582
4583	case GT_ARR_ELEM:
4584	if (this == parent->gtArrElem.gtArrObj)
4585	{
4586	return &(parent->gtArrElem.gtArrObj);
4587	}
4588	for (int i = `0`; i < GT_ARR_MAX_RANK; i++)
4589	{
4590	if (this == parent->gtArrElem.gtArrInds[i])
4591	{
4592	return &(parent->gtArrElem.gtArrInds[i]);
4593	}
4594	}
4595	break;
4596
4597	case GT_ARR_OFFSET:
4598	if (this == parent->gtArrOffs.gtOffset)
4599	{
4600	return &(parent->gtArrOffs.gtOffset);
4601	}
4602	if (this == parent->gtArrOffs.gtIndex)
4603	{
4604	return &(parent->gtArrOffs.gtIndex);
4605	}
4606	if (this == parent->gtArrOffs.gtArrObj)
4607	{
4608	return &(parent->gtArrOffs.gtArrObj);
4609	}
4610	break;
4611
4612	case GT_STORE_DYN_BLK:
4613	case GT_DYN_BLK:
4614	if (this == parent->gtDynBlk.gtOp1)
4615	{
4616	return &(parent->gtDynBlk.gtOp1);
4617	}
4618	if (this == parent->gtDynBlk.gtOp2)
4619	{
4620	return &(parent->gtDynBlk.gtOp2);
4621	}
4622	if (this == parent->gtDynBlk.gtDynamicSize)
4623	{
4624	return &(parent->gtDynBlk.gtDynamicSize);
4625	}
4626	break;
4627
4628	case GT_FIELD:
4629	if (this == parent->AsField()->gtFldObj)
4630	{
4631	return &(parent->AsField()->gtFldObj);
4632	}
4633	break;
4634
4635	case GT_RET_EXPR:
4636	if (this == parent->gtRetExpr.gtInlineCandidate)
4637	{
4638	return &(parent->gtRetExpr.gtInlineCandidate);
4639	}
4640	break;
4641
4642	case GT_CALL:
4643	{
4644	GenTreeCall* call = parent->AsCall();
4645
4646	if (this == call->gtCallObjp)
4647	{
4648	return &(call->gtCallObjp);
4649	}
4650	if (this == call->gtCallArgs)
4651	{
4652	return reinterpret_cast<GenTree**>(&(call->gtCallArgs));
4653	}
4654	if (this == call->gtCallLateArgs)
4655	{
4656	return reinterpret_cast<GenTree**>(&(call->gtCallLateArgs));
4657	}
4658	if (this == call->gtControlExpr)
4659	{
4660	return &(call->gtControlExpr);
4661	}
4662	if (call->gtCallType == CT_INDIRECT)
4663	{
4664	if (this == call->gtCallCookie)
4665	{
4666	return &(call->gtCallCookie);
4667	}
4668	if (this == call->gtCallAddr)
4669	{
4670	return &(call->gtCallAddr);
4671	}
4672	}
4673	}
4674	break;
4675
4676	case GT_STMT:
4677	noway_assert(!"Illegal node for gtGetChildPointer()");
4678	unreached();
4679	}
4680
4681	return nullptr;
4682	}
4683
4684	bool GenTree::TryGetUse(GenTree* def, GenTree*** use)
4685	{
4686	assert(def != nullptr);
4687	assert(use != nullptr);
4688
4689	switch (OperGet())
4690	{
4691	// Leaf nodes
4692	case GT_LCL_VAR:
4693	case GT_LCL_FLD:
4694	case GT_LCL_VAR_ADDR:
4695	case GT_LCL_FLD_ADDR:
4696	case GT_CATCH_ARG:
4697	case GT_LABEL:
4698	case GT_FTN_ADDR:
4699	case GT_RET_EXPR:
4700	case GT_CNS_INT:
4701	case GT_CNS_LNG:
4702	case GT_CNS_DBL:
4703	case GT_CNS_STR:
4704	case GT_MEMORYBARRIER:
4705	case GT_JMP:
4706	case GT_JCC:
4707	case GT_SETCC:
4708	case GT_NO_OP:
4709	case GT_START_NONGC:
4710	case GT_PROF_HOOK:
4711	#if !FEATURE_EH_FUNCLETS
4712	case GT_END_LFIN:
4713	#endif // !FEATURE_EH_FUNCLETS
4714	case GT_PHI_ARG:
4715	case GT_JMPTABLE:
4716	case GT_CLS_VAR:
4717	case GT_CLS_VAR_ADDR:
4718	case GT_ARGPLACE:
4719	case GT_PHYSREG:
4720	case GT_EMITNOP:
4721	case GT_PINVOKE_PROLOG:
4722	case GT_PINVOKE_EPILOG:
4723	case GT_IL_OFFSET:
4724	return false;
4725
4726	// Standard unary operators
4727	case GT_STORE_LCL_VAR:
4728	case GT_STORE_LCL_FLD:
4729	case GT_NOT:
4730	case GT_NEG:
4731	case GT_COPY:
4732	case GT_RELOAD:
4733	case GT_ARR_LENGTH:
4734	case GT_CAST:
4735	case GT_BITCAST:
4736	case GT_CKFINITE:
4737	case GT_LCLHEAP:
4738	case GT_ADDR:
4739	case GT_IND:
4740	case GT_OBJ:
4741	case GT_BLK:
4742	case GT_BOX:
4743	case GT_ALLOCOBJ:
4744	case GT_RUNTIMELOOKUP:
4745	case GT_INIT_VAL:
4746	case GT_JTRUE:
4747	case GT_SWITCH:
4748	case GT_NULLCHECK:
4749	case GT_PUTARG_REG:
4750	case GT_PUTARG_STK:
4751	case GT_RETURNTRAP:
4752	case GT_NOP:
4753	case GT_RETURN:
4754	case GT_RETFILT:
4755	case GT_BSWAP:
4756	case GT_BSWAP16:
4757	if (def == this->AsUnOp()->gtOp1)
4758	{
4759	use = &this*->AsUnOp()->gtOp1;
4760	return true;
4761	}
4762	return false;
4763
4764	// Variadic nodes
4765	case GT_PHI:
4766	assert(this->AsUnOp()->gtOp1 != nullptr);
4767	return this->AsUnOp()->gtOp1->TryGetUseList(def, use);
4768
4769	case GT_FIELD_LIST:
4770	return TryGetUseList(def, use);
4771
4772	#if FEATURE_ARG_SPLIT
4773	case GT_PUTARG_SPLIT:
4774	if (this->AsUnOp()->gtOp1->gtOper == GT_FIELD_LIST)
4775	{
4776	return this->AsUnOp()->gtOp1->TryGetUseList(def, use);
4777	}
4778	if (def == this->AsUnOp()->gtOp1)
4779	{
4780	use = &this*->AsUnOp()->gtOp1;
4781	return true;
4782	}
4783	return false;
4784	#endif // FEATURE_ARG_SPLIT
4785
4786	#ifdef FEATURE_SIMD
4787	case GT_SIMD:
4788	if (this->AsSIMD()->gtSIMDIntrinsicID == SIMDIntrinsicInitN)
4789	{
4790	assert(this->AsSIMD()->gtOp1 != nullptr);
4791	return this->AsSIMD()->gtOp1->TryGetUseList(def, use);
4792	}
4793
4794	return TryGetUseBinOp(def, use);
4795	#endif // FEATURE_SIMD
4796
4797	#ifdef FEATURE_HW_INTRINSICS
4798	case GT_HWIntrinsic:
4799	if ((this->AsHWIntrinsic()->gtOp1 != nullptr) && this->AsHWIntrinsic()->gtOp1->OperIsList())
4800	{
4801	return this->AsHWIntrinsic()->gtOp1->TryGetUseList(def, use);
4802	}
4803
4804	return TryGetUseBinOp(def, use);
4805	#endif // FEATURE_HW_INTRINSICS
4806
4807	// Special nodes
4808	case GT_CMPXCHG:
4809	{
4810	GenTreeCmpXchg* const cmpXchg = this->AsCmpXchg();
4811	if (def == cmpXchg->gtOpLocation)
4812	{
4813	*use = &cmpXchg->gtOpLocation;
4814	return true;
4815	}
4816	if (def == cmpXchg->gtOpValue)
4817	{
4818	*use = &cmpXchg->gtOpValue;
4819	return true;
4820	}
4821	if (def == cmpXchg->gtOpComparand)
4822	{
4823	*use = &cmpXchg->gtOpComparand;
4824	return true;
4825	}
4826	return false;
4827	}
4828
4829	case GT_ARR_BOUNDS_CHECK:
4830	#ifdef FEATURE_SIMD
4831	case GT_SIMD_CHK:
4832	#endif // FEATURE_SIMD
4833	#ifdef FEATURE_HW_INTRINSICS
4834	case GT_HW_INTRINSIC_CHK:
4835	#endif // FEATURE_HW_INTRINSICS
4836	{
4837	GenTreeBoundsChk* const boundsChk = this->AsBoundsChk();
4838	if (def == boundsChk->gtIndex)
4839	{
4840	*use = &boundsChk->gtIndex;
4841	return true;
4842	}
4843	if (def == boundsChk->gtArrLen)
4844	{
4845	*use = &boundsChk->gtArrLen;
4846	return true;
4847	}
4848	return false;
4849	}
4850
4851	case GT_FIELD:
4852	if (def == this->AsField()->gtFldObj)
4853	{
4854	use = &this*->AsField()->gtFldObj;
4855	return true;
4856	}
4857	return false;
4858
4859	case GT_STMT:
4860	if (def == this->AsStmt()->gtStmtExpr)
4861	{
4862	use = &this*->AsStmt()->gtStmtExpr;
4863	return true;
4864	}
4865	return false;
4866
4867	case GT_ARR_ELEM:
4868	{
4869	GenTreeArrElem* const arrElem = this->AsArrElem();
4870	if (def == arrElem->gtArrObj)
4871	{
4872	*use = &arrElem->gtArrObj;
4873	return true;
4874	}
4875	for (unsigned i = `0`; i < arrElem->gtArrRank; i++)
4876	{
4877	if (def == arrElem->gtArrInds[i])
4878	{
4879	*use = &arrElem->gtArrInds[i];
4880	return true;
4881	}
4882	}
4883	return false;
4884	}
4885
4886	case GT_ARR_OFFSET:
4887	{
4888	GenTreeArrOffs* const arrOffs = this->AsArrOffs();
4889	if (def == arrOffs->gtOffset)
4890	{
4891	*use = &arrOffs->gtOffset;
4892	return true;
4893	}
4894	if (def == arrOffs->gtIndex)
4895	{
4896	*use = &arrOffs->gtIndex;
4897	return true;
4898	}
4899	if (def == arrOffs->gtArrObj)
4900	{
4901	*use = &arrOffs->gtArrObj;
4902	return true;
4903	}
4904	return false;
4905	}
4906
4907	case GT_DYN_BLK:
4908	{
4909	GenTreeDynBlk* const dynBlock = this->AsDynBlk();
4910	if (def == dynBlock->gtOp1)
4911	{
4912	*use = &dynBlock->gtOp1;
4913	return true;
4914	}
4915	if (def == dynBlock->gtDynamicSize)
4916	{
4917	*use = &dynBlock->gtDynamicSize;
4918	return true;
4919	}
4920	return false;
4921	}
4922
4923	case GT_STORE_DYN_BLK:
4924	{
4925	GenTreeDynBlk* const dynBlock = this->AsDynBlk();
4926	if (def == dynBlock->gtOp1)
4927	{
4928	*use = &dynBlock->gtOp1;
4929	return true;
4930	}
4931	if (def == dynBlock->gtOp2)
4932	{
4933	*use = &dynBlock->gtOp2;
4934	return true;
4935	}
4936	if (def == dynBlock->gtDynamicSize)
4937	{
4938	*use = &dynBlock->gtDynamicSize;
4939	return true;
4940	}
4941	return false;
4942	}
4943
4944	case GT_CALL:
4945	{
4946	GenTreeCall* const call = this->AsCall();
4947	if (def == call->gtCallObjp)
4948	{
4949	*use = &call->gtCallObjp;
4950	return true;
4951	}
4952	if (def == call->gtControlExpr)
4953	{
4954	*use = &call->gtControlExpr;
4955	return true;
4956	}
4957	if (call->gtCallType == CT_INDIRECT)
4958	{
4959	if (def == call->gtCallCookie)
4960	{
4961	*use = &call->gtCallCookie;
4962	return true;
4963	}
4964	if (def == call->gtCallAddr)
4965	{
4966	*use = &call->gtCallAddr;
4967	return true;
4968	}
4969	}
4970	if ((call->gtCallArgs != nullptr) && call->gtCallArgs->TryGetUseList(def, use))
4971	{
4972	return true;
4973	}
4974
4975	return (call->gtCallLateArgs != nullptr) && call->gtCallLateArgs->TryGetUseList(def, use);
4976	}
4977
4978	// Binary nodes
4979	default:
4980	assert(this->OperIsBinary());
4981	return TryGetUseBinOp(def, use);
4982	}
4983	}
4984
4985	bool GenTree::TryGetUseList(GenTree* def, GenTree*** use)
4986	{
4987	assert(def != nullptr);
4988	assert(use != nullptr);
4989
4990	for (GenTreeArgList* node = this->AsArgList(); node != nullptr; node = node->Rest())
4991	{
4992	if (def == node->gtOp1)
4993	{
4994	*use = &node->gtOp1;
4995	return true;
4996	}
4997	}
4998	return false;
4999	}
5000
5001	bool GenTree::TryGetUseBinOp(GenTree* def, GenTree*** use)
5002	{
5003	assert(def != nullptr);
5004	assert(use != nullptr);
5005	assert(this->OperIsBinary());
5006
5007	GenTreeOp* const binOp = this->AsOp();
5008	if (def == binOp->gtOp1)
5009	{
5010	*use = &binOp->gtOp1;
5011	return true;
5012	}
5013	if (def == binOp->gtOp2)
5014	{
5015	*use = &binOp->gtOp2;
5016	return true;
5017	}
5018	return false;
5019	}
5020
5021	//------------------------------------------------------------------------
5022	// GenTree::ReplaceOperand:
5023	// Replace a given operand to this node with a new operand. If the
5024	// current node is a call node, this will also udpate the call
5025	// argument table if necessary.
5026	//
5027	// Arguments:
5028	// useEdge - the use edge that points to the operand to be replaced.
5029	// replacement - the replacement node.
5030	//
5031	void GenTree::ReplaceOperand(GenTree** useEdge, GenTree* replacement)
5032	{
5033	assert(useEdge != nullptr);
5034	assert(replacement != nullptr);
5035	assert(TryGetUse(*useEdge, &useEdge));
5036
5037	if (OperGet() == GT_CALL)
5038	{
5039	AsCall()->ReplaceCallOperand(useEdge, replacement);
5040	}
5041	else
5042	{
5043	*useEdge = replacement;
5044	}
5045	}
5046
5047	//------------------------------------------------------------------------
5048	// gtGetParent: Get the parent of this node, and optionally capture the
5049	// pointer to the child so that it can be modified.
5050	//
5051	// Arguments:
5052
5053	// parentChildPointer - A pointer to a GenTree* (yes, that's three*
5054	// levels, i.e. GenTree *), which if non-null,
5055	// will be set to point to the field in the parent
5056	// that points to this node.
5057	//
5058	// Return value - The parent of this node.
5059	//
5060	// Notes:
5061	//
5062	// This requires that the execution order must be defined (i.e. gtSetEvalOrder() has been called).
5063	// To enable the child to be replaced, it accepts an argument, parentChildPointer that, if non-null,
5064	// will be set to point to the child pointer in the parent that points to this node.
5065
5066	GenTree* GenTree::gtGetParent(GenTree*** parentChildPtrPtr) const
5067	{
5068	// Find the parent node; it must be after this node in the execution order.
5069	GenTree parentChildPtr = nullptr**;
5070	GenTree* parent;
5071	for (parent = gtNext; parent != nullptr; parent = parent->gtNext)
5072	{
5073	parentChildPtr = gtGetChildPointer(parent);
5074	if (parentChildPtr != nullptr)
5075	{
5076	break;
5077	}
5078	}
5079	if (parentChildPtrPtr != nullptr)
5080	{
5081	*parentChildPtrPtr = parentChildPtr;
5082	}
5083	return parent;
5084	}
5085
5086	//------------------------------------------------------------------------------
5087	// OperRequiresAsgFlag : Check whether the operation requires GTF_ASG flag regardless
5088	// of the children's flags.
5089	//
5090
5091	bool GenTree::OperRequiresAsgFlag()
5092	{
5093	if (OperIs(GT_ASG) \|\| OperIs(GT_XADD, GT_XCHG, GT_LOCKADD, GT_CMPXCHG, GT_MEMORYBARRIER))
5094	{
5095	return true;
5096	}
5097	#ifdef FEATURE_HW_INTRINSICS
5098	if (gtOper == GT_HWIntrinsic)
5099	{
5100	GenTreeHWIntrinsic* hwIntrinsicNode = this->AsHWIntrinsic();
5101	if (hwIntrinsicNode->OperIsMemoryStore())
5102	{
5103	// A MemoryStore operation is an assignment
5104	return true;
5105	}
5106	}
5107	#endif // FEATURE_HW_INTRINSICS
5108	return false;
5109	}
5110
5111	//------------------------------------------------------------------------------
5112	// OperRequiresCallFlag : Check whether the operation requires GTF_CALL flag regardless
5113	// of the children's flags.
5114	//
5115
5116	bool GenTree::OperRequiresCallFlag(Compiler* comp)
5117	{
5118	switch (gtOper)
5119	{
5120	case GT_CALL:
5121	return true;
5122
5123	case GT_INTRINSIC:
5124	return comp->IsIntrinsicImplementedByUserCall(this->AsIntrinsic()->gtIntrinsicId);
5125
5126	#if FEATURE_FIXED_OUT_ARGS && !defined(_TARGET_64BIT_)
5127	case GT_LSH:
5128	case GT_RSH:
5129	case GT_RSZ:
5130
5131	// Variable shifts of a long end up being helper calls, so mark the tree as such in morph.
5132	// This is potentially too conservative, since they'll get treated as having side effects.
5133	// It is important to mark them as calls so if they are part of an argument list,
5134	// they will get sorted and processed properly (for example, it is important to handle
5135	// all nested calls before putting struct arguments in the argument registers). We
5136	// could mark the trees just before argument processing, but it would require a full
5137	// tree walk of the argument tree, so we just do it when morphing, instead, even though we'll
5138	// mark non-argument trees (that will still get converted to calls, anyway).
5139	return (this->TypeGet() == TYP_LONG) && (gtGetOp2()->OperGet() != GT_CNS_INT);
5140	#endif // FEATURE_FIXED_OUT_ARGS && !_TARGET_64BIT_
5141
5142	default:
5143	return false;
5144	}
5145	}
5146
5147	//------------------------------------------------------------------------------
5148	// OperIsImplicitIndir : Check whether the operation contains an implicit
5149	// indirection.
5150	// Arguments:
5151	// this - a GenTree node
5152	//
5153	// Return Value:
5154	// True if the given node contains an implicit indirection
5155	//
5156	// Note that for the GT_HWIntrinsic node we have to examine the
5157	// details of the node to determine its result.
5158	//
5159
5160	bool GenTree::OperIsImplicitIndir() const
5161	{
5162	switch (gtOper)
5163	{
5164	case GT_LOCKADD:
5165	case GT_XADD:
5166	case GT_XCHG:
5167	case GT_CMPXCHG:
5168	case GT_BLK:
5169	case GT_OBJ:
5170	case GT_DYN_BLK:
5171	case GT_STORE_BLK:
5172	case GT_STORE_OBJ:
5173	case GT_STORE_DYN_BLK:
5174	case GT_BOX:
5175	case GT_ARR_INDEX:
5176	case GT_ARR_ELEM:
5177	case GT_ARR_OFFSET:
5178	return true;
5179	#ifdef FEATURE_HW_INTRINSICS
5180	case GT_HWIntrinsic:
5181	{
5182	GenTreeHWIntrinsic* hwIntrinsicNode = (const_cast<GenTree>(this*))->AsHWIntrinsic();
5183	return hwIntrinsicNode->OperIsMemoryLoadOrStore();
5184	}
5185	#endif // FEATURE_HW_INTRINSICS
5186	default:
5187	return false;
5188	}
5189	}
5190
5191	//------------------------------------------------------------------------------
5192	// OperMayThrow : Check whether the operation may throw.
5193	//
5194	//
5195	// Arguments:
5196	// comp - Compiler instance
5197	//
5198	// Return Value:
5199	// True if the given operator may cause an exception
5200
5201	bool GenTree::OperMayThrow(Compiler* comp)
5202	{
5203	GenTree* op;
5204
5205	switch (gtOper)
5206	{
5207	case GT_MOD:
5208	case GT_DIV:
5209	case GT_UMOD:
5210	case GT_UDIV:
5211
5212	/ Division with a non-zero, non-minus-one constant does not throw an exception /
5213
5214	op = gtOp.gtOp2;
5215
5216	if (varTypeIsFloating(op->TypeGet()))
5217	{
5218	return false; // Floating point division does not throw.
5219	}
5220
5221	// For integers only division by 0 or by -1 can throw
5222	if (op->IsIntegralConst() && !op->IsIntegralConst(`0`) && !op->IsIntegralConst(-`1`))
5223	{
5224	return false;
5225	}
5226	return true;
5227
5228	case GT_INTRINSIC:
5229	// If this is an intrinsic that represents the object.GetType(), it can throw an NullReferenceException.
5230	// Report it as may throw.
5231	// Note: Some of the rest of the existing intrinsics could potentially throw an exception (for example
5232	// the array and string element access ones). They are handled differently than the GetType intrinsic
5233	// and are not marked with GTF_EXCEPT. If these are revisited at some point to be marked as
5234	// GTF_EXCEPT,
5235	// the code below might need to be specialized to handle them properly.
5236	if ((this->gtFlags & GTF_EXCEPT) != `0`)
5237	{
5238	return true;
5239	}
5240
5241	break;
5242
5243	case GT_CALL:
5244
5245	CorInfoHelpFunc helper;
5246	helper = comp->eeGetHelperNum(this->AsCall()->gtCallMethHnd);
5247	return ((helper == CORINFO_HELP_UNDEF) \|\| !comp->s_helperCallProperties.NoThrow(helper));
5248
5249	case GT_IND:
5250	case GT_BLK:
5251	case GT_OBJ:
5252	case GT_DYN_BLK:
5253	case GT_STORE_BLK:
5254	case GT_NULLCHECK:
5255	return (((this->gtFlags & GTF_IND_NONFAULTING) == `0`) && comp->fgAddrCouldBeNull(this->AsIndir()->Addr()));
5256
5257	case GT_ARR_LENGTH:
5258	return (((this->gtFlags & GTF_IND_NONFAULTING) == `0`) &&
5259	comp->fgAddrCouldBeNull(this->AsArrLen()->ArrRef()));
5260
5261	case GT_ARR_ELEM:
5262	return comp->fgAddrCouldBeNull(this->gtArrElem.gtArrObj);
5263
5264	case GT_ARR_BOUNDS_CHECK:
5265	case GT_ARR_INDEX:
5266	case GT_ARR_OFFSET:
5267	case GT_LCLHEAP:
5268	case GT_CKFINITE:
5269	#ifdef FEATURE_SIMD
5270	case GT_SIMD_CHK:
5271	#endif // FEATURE_SIMD
5272	#ifdef FEATURE_HW_INTRINSICS
5273	case GT_HW_INTRINSIC_CHK:
5274	#endif // FEATURE_HW_INTRINSICS
5275	case GT_INDEX_ADDR:
5276	return true;
5277
5278	#ifdef FEATURE_HW_INTRINSICS
5279	case GT_HWIntrinsic:
5280	{
5281	GenTreeHWIntrinsic* hwIntrinsicNode = this->AsHWIntrinsic();
5282	assert(hwIntrinsicNode != nullptr);
5283	if (hwIntrinsicNode->OperIsMemoryLoadOrStore())
5284	{
5285	// This operation contains an implicit indirection
5286	// it could throw a null reference exception.
5287	//
5288	return true;
5289	}
5290	}
5291	#endif // FEATURE_HW_INTRINSICS
5292
5293	default:
5294	break;
5295	}
5296
5297	/ Overflow arithmetic operations also throw exceptions /
5298
5299	if (gtOverflowEx())
5300	{
5301	return true;
5302	}
5303
5304	return false;
5305	}
5306
5307	#if DEBUGGABLE_GENTREE
5308	// static
5309	GenTree::VtablePtr GenTree::s_vtablesForOpers[] = {nullptr};
5310	GenTree::VtablePtr GenTree::s_vtableForOp = nullptr;
5311
5312	GenTree::VtablePtr GenTree::GetVtableForOper(genTreeOps oper)
5313	{
5314	noway_assert(oper < GT_COUNT);
5315
5316	// First, check a cache.
5317
5318	if (s_vtablesForOpers[oper] != nullptr)
5319	{
5320	return s_vtablesForOpers[oper];
5321	}
5322
5323	// Otherwise, look up the correct vtable entry. Note that we want the most derived GenTree subtype
5324	// for an oper. E.g., GT_LCL_VAR is defined in GTSTRUCT_3 as GenTreeLclVar and in GTSTRUCT_N as
5325	// GenTreeLclVarCommon. We want the GenTreeLclVar vtable, since nothing should actually be
5326	// instantiated as a GenTreeLclVarCommon.
5327
5328	VtablePtr res = nullptr;
5329	switch (oper)
5330	{
5331
5332	// clang-format off
5333
5334	#define GTSTRUCT_0(nm, tag) /handle explicitly/
5335	#define GTSTRUCT_1(nm, tag) \
5336	case tag: \
5337	{ \
5338	GenTree##nm gt; \
5339	res = reinterpret_cast<VtablePtr>(&gt); \
5340	} \
5341	break;
5342	#define GTSTRUCT_2(nm, tag, tag2) \
5343	case tag: \
5344	case tag2: \
5345	{ \
5346	GenTree##nm gt; \
5347	res = reinterpret_cast<VtablePtr>(&gt); \
5348	} \
5349	break;
5350	#define GTSTRUCT_3(nm, tag, tag2, tag3) \
5351	case tag: \
5352	case tag2: \
5353	case tag3: \
5354	{ \
5355	GenTree##nm gt; \
5356	res = reinterpret_cast<VtablePtr>(&gt); \
5357	} \
5358	break;
5359	#define GTSTRUCT_4(nm, tag, tag2, tag3, tag4) \
5360	case tag: \
5361	case tag2: \
5362	case tag3: \
5363	case tag4: \
5364	{ \
5365	GenTree##nm gt; \
5366	res = reinterpret_cast<VtablePtr>(&gt); \
5367	} \
5368	break;
5369	#define GTSTRUCT_N(nm, ...) /handle explicitly/
5370	#define GTSTRUCT_2_SPECIAL(nm, tag, tag2) /handle explicitly/
5371	#define GTSTRUCT_3_SPECIAL(nm, tag, tag2, tag3) /handle explicitly/
5372	#include "gtstructs.h"
5373
5374	// clang-format on
5375
5376	// Handle the special cases.
5377	// The following opers are in GTSTRUCT_N but no other place (namely, no subtypes).
5378
5379	case GT_STORE_BLK:
5380	case GT_BLK:
5381	{
5382	GenTreeBlk gt;
5383	res = *reinterpret_cast<VtablePtr*>(&gt);
5384	}
5385	break;
5386
5387	case GT_IND:
5388	case GT_NULLCHECK:
5389	{
5390	GenTreeIndir gt;
5391	res = *reinterpret_cast<VtablePtr*>(&gt);
5392	}
5393	break;
5394
5395	// Handle GT_LIST (but not GT_FIELD_LIST, which is also in a GTSTRUCT_1).
5396
5397	case GT_LIST:
5398	{
5399	GenTreeArgList gt;
5400	res = *reinterpret_cast<VtablePtr*>(&gt);
5401	}
5402	break;
5403
5404	// We don't need to handle GTSTRUCT_N for LclVarCommon, since all those allowed opers are specified
5405	// in their proper subtype. Similarly for GenTreeIndir.
5406
5407	default:
5408	{
5409	// Should be unary or binary op.
5410	if (s_vtableForOp == nullptr)
5411	{
5412	unsigned opKind = OperKind(oper);
5413	assert(!IsExOp(opKind));
5414	assert(OperIsSimple(oper) \|\| OperIsLeaf(oper));
5415	// Need to provide non-null operands.
5416	GenTreeIntCon dummyOp(TYP_INT, `0`);
5417	GenTreeOp gt(oper, TYP_INT, &dummyOp, ((opKind & GTK_UNOP) ? nullptr : &dummyOp));
5418	s_vtableForOp = *reinterpret_cast<VtablePtr*>(&gt);
5419	}
5420	res = s_vtableForOp;
5421	break;
5422	}
5423	}
5424	s_vtablesForOpers[oper] = res;
5425	return res;
5426	}
5427
5428	void GenTree::SetVtableForOper(genTreeOps oper)
5429	{
5430	*reinterpret_cast<VtablePtr>(this*) = GetVtableForOper(oper);
5431	}
5432	#endif // DEBUGGABLE_GENTREE
5433
5434	GenTree* Compiler::gtNewOperNode(genTreeOps oper, var_types type, GenTree* op1, GenTree* op2)
5435	{
5436	assert(op1 != nullptr);
5437	assert(op2 != nullptr);
5438
5439	// We should not be allocating nodes that extend GenTreeOp with this;
5440	// should call the appropriate constructor for the extended type.
5441	assert(!GenTree::IsExOp(GenTree::OperKind(oper)));
5442
5443	GenTree* node = new (this, oper) GenTreeOp (oper, type, op1, op2);
5444
5445	return node;
5446	}
5447
5448	GenTree* Compiler::gtNewQmarkNode(var_types type, GenTree* cond, GenTree* colon)
5449	{
5450	compQmarkUsed = true;
5451	cond->gtFlags \|= GTF_RELOP_QMARK;
5452	GenTree* result = new (this, GT_QMARK) GenTreeQmark (type, cond, colon, this);
5453	#ifdef DEBUG
5454	if (compQmarkRationalized)
5455	{
5456	fgCheckQmarkAllowedForm(result);
5457	}
5458	#endif
5459	return result;
5460	}
5461
5462	GenTreeQmark::GenTreeQmark(var_types type, GenTree* cond, GenTree* colonOp, Compiler* comp)
5463	: GenTreeOp (GT_QMARK, type, cond, colonOp)
5464	{
5465	// These must follow a specific form.
5466	assert(cond != nullptr && cond->TypeGet() == TYP_INT);
5467	assert(colonOp != nullptr && colonOp->OperGet() == GT_COLON);
5468	}
5469
5470	GenTreeIntCon* Compiler::gtNewIconNode(ssize_t value, var_types type)
5471	{
5472	return new (this, GT_CNS_INT) GenTreeIntCon (type, value);
5473	}
5474
5475	// return a new node representing the value in a physical register
5476	GenTree* Compiler::gtNewPhysRegNode(regNumber reg, var_types type)
5477	{
5478	assert(genIsValidIntReg(reg) \|\| (reg == REG_SPBASE));
5479	GenTree* result = new (this, GT_PHYSREG) GenTreePhysReg (reg, type);
5480	return result;
5481	}
5482
5483	GenTree* Compiler::gtNewJmpTableNode()
5484	{
5485	GenTree* node = new (this, GT_JMPTABLE) GenTreeJumpTable (TYP_INT);
5486	node->gtJumpTable.gtJumpTableAddr = `0`;
5487	return node;
5488	}
5489
5490	/*****************************************************************************
5491	*
5492	* Converts an annotated token into an icon flags (so that we will later be
5493	* able to tell the type of the handle that will be embedded in the icon
5494	* node)
5495	*/
5496
5497	unsigned Compiler::gtTokenToIconFlags(unsigned token)
5498	{
5499	unsigned flags = `0`;
5500
5501	switch (TypeFromToken(token))
5502	{
5503	case mdtTypeRef:
5504	case mdtTypeDef:
5505	case mdtTypeSpec:
5506	flags = GTF_ICON_CLASS_HDL;
5507	break;
5508
5509	case mdtMethodDef:
5510	flags = GTF_ICON_METHOD_HDL;
5511	break;
5512
5513	case mdtFieldDef:
5514	flags = GTF_ICON_FIELD_HDL;
5515	break;
5516
5517	default:
5518	flags = GTF_ICON_TOKEN_HDL;
5519	break;
5520	}
5521
5522	return flags;
5523	}
5524
5525	//-----------------------------------------------------------------------------------------
5526	// gtNewIndOfIconHandleNode: Creates an indirection GenTree node of a constant handle
5527	//
5528	// Arguments:
5529	// indType - The type returned by the indirection node
5530	// addr - The constant address to read from
5531	// iconFlags - The GTF_ICON flag value that specifies the kind of handle that we have
5532	// isInvariant - The indNode should also be marked as invariant
5533	//
5534	// Return Value:
5535	// Returns a GT_IND node representing value at the address provided by 'value'
5536	//
5537	// Notes:
5538	// The GT_IND node is marked as non-faulting
5539	// If the indType is GT_REF we also mark the indNode as GTF_GLOB_REF
5540	//
5541
5542	GenTree* Compiler::gtNewIndOfIconHandleNode(var_types indType, size_t addr, unsigned iconFlags, bool isInvariant)
5543	{
5544	GenTree* addrNode = gtNewIconHandleNode(addr, iconFlags);
5545	GenTree* indNode = gtNewOperNode(GT_IND, indType, addrNode);
5546
5547	// This indirection won't cause an exception.
5548	//
5549	indNode->gtFlags \|= GTF_IND_NONFAULTING;
5550
5551	// String Literal handles are indirections that return a TYP_REF.
5552	// They are pointers into the GC heap and they are not invariant
5553	// as the address is a reportable GC-root and as such it can be
5554	// modified during a GC collection
5555	//
5556	if (indType == TYP_REF)
5557	{
5558	// This indirection points into the gloabal heap
5559	indNode->gtFlags \|= GTF_GLOB_REF;
5560	}
5561	if (isInvariant)
5562	{
5563	// This indirection also is invariant.
5564	indNode->gtFlags \|= GTF_IND_INVARIANT;
5565	}
5566	return indNode;
5567	}
5568
5569	/*****************************************************************************
5570	*
5571	* Allocates a integer constant entry that represents a HANDLE to something.
5572	* It may not be allowed to embed HANDLEs directly into the JITed code (for eg,
5573	* as arguments to JIT helpers). Get a corresponding value that can be embedded.
5574	* If the handle needs to be accessed via an indirection, pValue points to it.
5575	*/
5576
5577	GenTree* Compiler::gtNewIconEmbHndNode(void* value, void* pValue, unsigned iconFlags, void* compileTimeHandle)
5578	{
5579	GenTree* iconNode;
5580	GenTree* handleNode;
5581
5582	if (value != nullptr)
5583	{
5584	// When 'value' is non-null, pValue is required to be null
5585	assert(pValue == nullptr);
5586
5587	// use 'value' to construct an integer constant node
5588	iconNode = gtNewIconHandleNode((size_t)value, iconFlags);
5589
5590	// 'value' is the handle
5591	handleNode = iconNode;
5592	}
5593	else
5594	{
5595	// When 'value' is null, pValue is required to be non-null
5596	assert(pValue != nullptr);
5597
5598	// use 'pValue' to construct an integer constant node
5599	iconNode = gtNewIconHandleNode((size_t)pValue, iconFlags);
5600
5601	// 'pValue' is an address of a location that contains the handle
5602
5603	// construct the indirection of 'pValue'
5604	handleNode = gtNewOperNode(GT_IND, TYP_I_IMPL, iconNode);
5605
5606	// This indirection won't cause an exception.
5607	handleNode->gtFlags \|= GTF_IND_NONFAULTING;
5608	#if 0
5609	// It should also be invariant, but marking it as such leads to bad diffs.
5610
5611	// This indirection also is invariant.
5612	handleNode->gtFlags \|= GTF_IND_INVARIANT;
5613	#endif
5614	}
5615
5616	iconNode->gtIntCon.gtCompileTimeHandle = (size_t)compileTimeHandle;
5617
5618	return handleNode;
5619	}
5620
5621	/***************************************************************************/
5622	GenTree* Compiler::gtNewStringLiteralNode(InfoAccessType iat, void* pValue)
5623	{
5624	GenTree* tree = nullptr;
5625
5626	switch (iat)
5627	{
5628	case IAT_VALUE: // constructStringLiteral in CoreRT case can return IAT_VALUE
5629	tree = gtNewIconEmbHndNode(pValue, nullptr, GTF_ICON_STR_HDL, nullptr);
5630	tree->gtType = TYP_REF;
5631	tree = gtNewOperNode(GT_NOP, TYP_REF, tree); // prevents constant folding
5632	break;
5633
5634	case IAT_PVALUE: // The value needs to be accessed via an indirection
5635	// Create an indirection
5636	tree = gtNewIndOfIconHandleNode(TYP_REF, (size_t)pValue, GTF_ICON_STR_HDL, false);
5637	break;
5638
5639	case IAT_PPVALUE: // The value needs to be accessed via a double indirection
5640	// Create the first indirection
5641	tree = gtNewIndOfIconHandleNode(TYP_I_IMPL, (size_t)pValue, GTF_ICON_PSTR_HDL, true);
5642
5643	// Create the second indirection
5644	tree = gtNewOperNode(GT_IND, TYP_REF, tree);
5645	// This indirection won't cause an exception.
5646	tree->gtFlags \|= GTF_IND_NONFAULTING;
5647	// This indirection points into the gloabal heap (it is String Object)
5648	tree->gtFlags \|= GTF_GLOB_REF;
5649	break;
5650
5651	default:
5652	noway_assert(!"Unexpected InfoAccessType");
5653	}
5654
5655	return tree;
5656	}
5657
5658	/***************************************************************************/
5659
5660	GenTree* Compiler::gtNewLconNode(__int64 value)
5661	{
5662	#ifdef _TARGET_64BIT_
5663	GenTree* node = new (this, GT_CNS_INT) GenTreeIntCon (TYP_LONG, value);
5664	#else
5665	GenTree* node = new (this, GT_CNS_LNG) GenTreeLngCon(value);
5666	#endif
5667
5668	return node;
5669	}
5670
5671	GenTree* Compiler::gtNewDconNode(double value)
5672	{
5673	GenTree* node = new (this, GT_CNS_DBL) GenTreeDblCon (value);
5674
5675	return node;
5676	}
5677
5678	GenTree* Compiler::gtNewSconNode(int CPX, CORINFO_MODULE_HANDLE scpHandle)
5679	{
5680
5681	#if SMALL_TREE_NODES
5682
5683	/ 'GT_CNS_STR' nodes later get transformed into 'GT_CALL' /
5684
5685	assert(GenTree::s_gtNodeSizes[GT_CALL] > GenTree::s_gtNodeSizes[GT_CNS_STR]);
5686
5687	GenTree* node = new (this, GT_CALL) GenTreeStrCon (CPX, scpHandle DEBUGARG(/largeNode/ true));
5688	#else
5689	GenTree* node = new (this, GT_CNS_STR) GenTreeStrCon(CPX, scpHandle DEBUGARG(/largeNode/ true));
5690	#endif
5691
5692	return node;
5693	}
5694
5695	GenTree* Compiler::gtNewZeroConNode(var_types type)
5696	{
5697	GenTree* zero;
5698	switch (type)
5699	{
5700	case TYP_INT:
5701	zero = gtNewIconNode(`0`);
5702	break;
5703
5704	case TYP_BYREF:
5705	__fallthrough;
5706
5707	case TYP_REF:
5708	zero = gtNewIconNode(`0`);
5709	zero->gtType = type;
5710	break;
5711
5712	case TYP_LONG:
5713	zero = gtNewLconNode(`0`);
5714	break;
5715
5716	case TYP_FLOAT:
5717	zero = gtNewDconNode(`0.0`);
5718	zero->gtType = type;
5719	break;
5720
5721	case TYP_DOUBLE:
5722	zero = gtNewDconNode(`0.0`);
5723	break;
5724
5725	default:
5726	noway_assert(!"Bad type in gtNewZeroConNode");
5727	zero = nullptr;
5728	break;
5729	}
5730	return zero;
5731	}
5732
5733	GenTree* Compiler::gtNewOneConNode(var_types type)
5734	{
5735	GenTree* one;
5736	switch (type)
5737	{
5738	case TYP_INT:
5739	case TYP_UINT:
5740	one = gtNewIconNode(`1`);
5741	break;
5742
5743	case TYP_LONG:
5744	case TYP_ULONG:
5745	one = gtNewLconNode(`1`);
5746	break;
5747
5748	case TYP_FLOAT:
5749	case TYP_DOUBLE:
5750	one = gtNewDconNode(`1.0`);
5751	one->gtType = type;
5752	break;
5753
5754	default:
5755	noway_assert(!"Bad type in gtNewOneConNode");
5756	one = nullptr;
5757	break;
5758	}
5759	return one;
5760	}
5761
5762	#ifdef FEATURE_SIMD
5763	//---------------------------------------------------------------------
5764	// gtNewSIMDVectorZero: create a GT_SIMD node for Vector<T>.Zero
5765	//
5766	// Arguments:
5767	// simdType - simd vector type
5768	// baseType - element type of vector
5769	// size - size of vector in bytes
5770	GenTree* Compiler::gtNewSIMDVectorZero(var_types simdType, var_types baseType, unsigned size)
5771	{
5772	baseType = genActualType(baseType);
5773	GenTree* initVal = gtNewZeroConNode(baseType);
5774	initVal->gtType = baseType;
5775	return gtNewSIMDNode(simdType, initVal, nullptr, SIMDIntrinsicInit, baseType, size);
5776	}
5777
5778	//---------------------------------------------------------------------
5779	// gtNewSIMDVectorOne: create a GT_SIMD node for Vector<T>.One
5780	//
5781	// Arguments:
5782	// simdType - simd vector type
5783	// baseType - element type of vector
5784	// size - size of vector in bytes
5785	GenTree* Compiler::gtNewSIMDVectorOne(var_types simdType, var_types baseType, unsigned size)
5786	{
5787	GenTree* initVal;
5788	if (varTypeIsSmallInt(baseType))
5789	{
5790	unsigned baseSize = genTypeSize(baseType);
5791	int val;
5792	if (baseSize == `1`)
5793	{
5794	val = `0x01010101`;
5795	}
5796	else
5797	{
5798	val = `0x00010001`;
5799	}
5800	initVal = gtNewIconNode(val);
5801	}
5802	else
5803	{
5804	initVal = gtNewOneConNode(baseType);
5805	}
5806
5807	baseType = genActualType(baseType);
5808	initVal->gtType = baseType;
5809	return gtNewSIMDNode(simdType, initVal, nullptr, SIMDIntrinsicInit, baseType, size);
5810	}
5811	#endif // FEATURE_SIMD
5812
5813	GenTreeCall* Compiler::gtNewIndCallNode(GenTree* addr, var_types type, GenTreeArgList* args, IL_OFFSETX ilOffset)
5814	{
5815	return gtNewCallNode(CT_INDIRECT, (CORINFO_METHOD_HANDLE)addr, type, args, ilOffset);
5816	}
5817
5818	GenTreeCall* Compiler::gtNewCallNode(
5819	gtCallTypes callType, CORINFO_METHOD_HANDLE callHnd, var_types type, GenTreeArgList* args, IL_OFFSETX ilOffset)
5820	{
5821	GenTreeCall* node = new (this, GT_CALL) GenTreeCall (genActualType(type));
5822
5823	node->gtFlags \|= (GTF_CALL \| GTF_GLOB_REF);
5824	if (args)
5825	{
5826	node->gtFlags \|= (args->gtFlags & GTF_ALL_EFFECT);
5827	}
5828	node->gtCallType = callType;
5829	node->gtCallMethHnd = callHnd;
5830	node->gtCallArgs = args;
5831	node->gtCallObjp = nullptr;
5832	node->fgArgInfo = nullptr;
5833	node->callSig = nullptr;
5834	node->gtRetClsHnd = nullptr;
5835	node->gtControlExpr = nullptr;
5836	node->gtCallMoreFlags = `0`;
5837
5838	if (callType == CT_INDIRECT)
5839	{
5840	node->gtCallCookie = nullptr;
5841	}
5842	else
5843	{
5844	node->gtInlineCandidateInfo = nullptr;
5845	}
5846	node->gtCallLateArgs = nullptr;
5847	node->gtReturnType = type;
5848
5849	#ifdef FEATURE_READYTORUN_COMPILER
5850	node->gtEntryPoint.addr = nullptr;
5851	node->gtEntryPoint.accessType = IAT_VALUE;
5852	#endif
5853
5854	#if defined(DEBUG) \|\| defined(INLINE_DATA)
5855	// These get updated after call node is built.
5856	node->gtInlineObservation = InlineObservation::CALLEE_UNUSED_INITIAL;
5857	node->gtRawILOffset = BAD_IL_OFFSET;
5858	#endif
5859
5860	// Spec: Managed Retval sequence points needs to be generated while generating debug info for debuggable code.
5861	//
5862	// Implementation note: if not generating MRV info genCallSite2ILOffsetMap will be NULL and
5863	// codegen will pass BAD_IL_OFFSET as IL offset of a call node to emitter, which will cause emitter
5864	// not to emit IP mapping entry.
5865	if (opts.compDbgCode && opts.compDbgInfo)
5866	{
5867	// Managed Retval - IL offset of the call. This offset is used to emit a
5868	// CALL_INSTRUCTION type sequence point while emitting corresponding native call.
5869	//
5870	// TODO-Cleanup:
5871	// a) (Opt) We need not store this offset if the method doesn't return a
5872	// value. Rather it can be made BAD_IL_OFFSET to prevent a sequence
5873	// point being emitted.
5874	//
5875	// b) (Opt) Add new sequence points only if requested by debugger through
5876	// a new boundary type - ICorDebugInfo::BoundaryTypes
5877	if (genCallSite2ILOffsetMap == nullptr)
5878	{
5879	genCallSite2ILOffsetMap = new (getAllocator()) CallSiteILOffsetTable (getAllocator());
5880	}
5881
5882	// Make sure that there are no duplicate entries for a given call node
5883	assert(!genCallSite2ILOffsetMap->Lookup(node));
5884	genCallSite2ILOffsetMap->Set(node, ilOffset);
5885	}
5886
5887	// Initialize gtOtherRegs
5888	node->ClearOtherRegs();
5889
5890	// Initialize spill flags of gtOtherRegs
5891	node->ClearOtherRegFlags();
5892
5893	#if defined(_TARGET_X86_) \|\| defined(_TARGET_ARM_)
5894	// Initialize the multi-reg long return info if necessary
5895	if (varTypeIsLong(node))
5896	{
5897	// The return type will remain as the incoming long type
5898	node->gtReturnType = node->gtType;
5899
5900	// Initialize Return type descriptor of call node
5901	ReturnTypeDesc* retTypeDesc = node->GetReturnTypeDesc();
5902	retTypeDesc->InitializeLongReturnType(this);
5903
5904	// must be a long returned in two registers
5905	assert(retTypeDesc->GetReturnRegCount() == `2`);
5906	}
5907	#endif // defined(_TARGET_X86_) \|\| defined(_TARGET_ARM_)
5908
5909	return node;
5910	}
5911
5912	GenTree* Compiler::gtNewLclvNode(unsigned lnum, var_types type, IL_OFFSETX ILoffs)
5913	{
5914	// We need to ensure that all struct values are normalized.
5915	// It might be nice to assert this in general, but we have assignments of int to long.
5916	if (varTypeIsStruct(type))
5917	{
5918	// Make an exception for implicit by-ref parameters during global morph, since
5919	// their lvType has been updated to byref but their appearances have not yet all
5920	// been rewritten and so may have struct type still.
5921	assert(type == lvaTable[lnum].lvType \|\|
5922	(lvaIsImplicitByRefLocal(lnum) && fgGlobalMorph && (lvaTable[lnum].lvType == TYP_BYREF)));
5923	}
5924	GenTree* node = new (this, GT_LCL_VAR) GenTreeLclVar (type, lnum, ILoffs);
5925
5926	/ Cannot have this assert because the inliner uses this function*
5927	* to add temporaries */
5928
5929	// assert(lnum < lvaCount);
5930
5931	return node;
5932	}
5933
5934	GenTree* Compiler::gtNewLclLNode(unsigned lnum, var_types type, IL_OFFSETX ILoffs)
5935	{
5936	// We need to ensure that all struct values are normalized.
5937	// It might be nice to assert this in general, but we have assignments of int to long.
5938	if (varTypeIsStruct(type))
5939	{
5940	// Make an exception for implicit by-ref parameters during global morph, since
5941	// their lvType has been updated to byref but their appearances have not yet all
5942	// been rewritten and so may have struct type still.
5943	assert(type == lvaTable[lnum].lvType \|\|
5944	(lvaIsImplicitByRefLocal(lnum) && fgGlobalMorph && (lvaTable[lnum].lvType == TYP_BYREF)));
5945	}
5946	#if SMALL_TREE_NODES
5947	/ This local variable node may later get transformed into a large node /
5948
5949	// assert(GenTree::s_gtNodeSizes[GT_CALL] > GenTree::s_gtNodeSizes[GT_LCL_VAR]);
5950
5951	GenTree* node = new (this, GT_CALL) GenTreeLclVar (type, lnum, ILoffs DEBUGARG(/largeNode/ true));
5952	#else
5953	GenTree* node = new (this, GT_LCL_VAR) GenTreeLclVar(type, lnum, ILoffs DEBUGARG(/largeNode/ true));
5954	#endif
5955
5956	return node;
5957	}
5958
5959	GenTreeLclFld* Compiler::gtNewLclFldNode(unsigned lnum, var_types type, unsigned offset)
5960	{
5961	GenTreeLclFld* node = new (this, GT_LCL_FLD) GenTreeLclFld (type, lnum, offset);
5962
5963	/ Cannot have this assert because the inliner uses this function*
5964	* to add temporaries */
5965
5966	// assert(lnum < lvaCount);
5967
5968	node->gtFieldSeq = FieldSeqStore::NotAField();
5969	return node;
5970	}
5971
5972	GenTree* Compiler::gtNewInlineCandidateReturnExpr(GenTree* inlineCandidate, var_types type)
5973
5974	{
5975	assert(GenTree::s_gtNodeSizes[GT_RET_EXPR] == TREE_NODE_SZ_LARGE);
5976
5977	GenTree* node = new (this, GT_RET_EXPR) GenTreeRetExpr (type);
5978
5979	node->gtRetExpr.gtInlineCandidate = inlineCandidate;
5980
5981	if (varTypeIsStruct(inlineCandidate) && !inlineCandidate->OperIsBlkOp())
5982	{
5983	node->gtRetExpr.gtRetClsHnd = gtGetStructHandle(inlineCandidate);
5984	}
5985
5986	// GT_RET_EXPR node eventually might be bashed back to GT_CALL (when inlining is aborted for example).
5987	// Therefore it should carry the GTF_CALL flag so that all the rules about spilling can apply to it as well.
5988	// For example, impImportLeave or CEE_POP need to spill GT_RET_EXPR before empty the evaluation stack.
5989	node->gtFlags \|= GTF_CALL;
5990
5991	return node;
5992	}
5993
5994	GenTreeArgList* Compiler::gtNewListNode(GenTree* op1, GenTreeArgList* op2)
5995	{
5996	assert((op1 != nullptr) && (op1->OperGet() != GT_LIST));
5997
5998	return new (this, GT_LIST) GenTreeArgList (op1, op2);
5999	}
6000
6001	/*****************************************************************************
6002	*
6003	* Create a list out of one value.
6004	*/
6005
6006	GenTreeArgList* Compiler::gtNewArgList(GenTree* arg)
6007	{
6008	return new (this, GT_LIST) GenTreeArgList (arg);
6009	}
6010
6011	/*****************************************************************************
6012	*
6013	* Create a list out of the two values.
6014	*/
6015
6016	GenTreeArgList* Compiler::gtNewArgList(GenTree* arg1, GenTree* arg2)
6017	{
6018	return new (this, GT_LIST) GenTreeArgList (arg1, gtNewArgList(arg2));
6019	}
6020
6021	/*****************************************************************************
6022	*
6023	* Create a list out of the three values.
6024	*/
6025
6026	GenTreeArgList* Compiler::gtNewArgList(GenTree* arg1, GenTree* arg2, GenTree* arg3)
6027	{
6028	return new (this, GT_LIST) GenTreeArgList (arg1, gtNewArgList(arg2, arg3));
6029	}
6030
6031	/*****************************************************************************
6032	*
6033	* Create a list out of the three values.
6034	*/
6035
6036	GenTreeArgList* Compiler::gtNewArgList(GenTree* arg1, GenTree* arg2, GenTree* arg3, GenTree* arg4)
6037	{
6038	return new (this, GT_LIST) GenTreeArgList (arg1, gtNewArgList(arg2, arg3, arg4));
6039	}
6040
6041	/*****************************************************************************
6042	*
6043	* Given a GT_CALL node, access the fgArgInfo and find the entry
6044	* that has the matching argNum and return the fgArgTableEntryPtr
6045	*/
6046
6047	fgArgTabEntry* Compiler::gtArgEntryByArgNum(GenTreeCall* call, unsigned argNum)
6048	{
6049	fgArgInfo* argInfo = call->fgArgInfo;
6050	noway_assert(argInfo != nullptr);
6051	return argInfo->GetArgEntry(argNum);
6052	}
6053
6054	/*****************************************************************************
6055	*
6056	* Given a GT_CALL node, access the fgArgInfo and find the entry
6057	* that has the matching node and return the fgArgTableEntryPtr
6058	*/
6059
6060	fgArgTabEntry* Compiler::gtArgEntryByNode(GenTreeCall* call, GenTree* node)
6061	{
6062	fgArgInfo* argInfo = call->fgArgInfo;
6063	noway_assert(argInfo != nullptr);
6064
6065	unsigned argCount = argInfo->ArgCount();
6066	fgArgTabEntry** argTable = argInfo->ArgTable();
6067	fgArgTabEntry* curArgTabEntry = nullptr;
6068
6069	for (unsigned i = `0`; i < argCount; i++)
6070	{
6071	curArgTabEntry = argTable[i];
6072
6073	if (curArgTabEntry->node == node)
6074	{
6075	return curArgTabEntry;
6076	}
6077	else if (curArgTabEntry->parent != nullptr)
6078	{
6079	assert(curArgTabEntry->parent->OperIsList());
6080	if (curArgTabEntry->parent->Current() == node)
6081	{
6082	return curArgTabEntry;
6083	}
6084	}
6085	else // (curArgTabEntry->parent == NULL)
6086	{
6087	if (call->gtCallObjp == node)
6088	{
6089	return curArgTabEntry;
6090	}
6091	}
6092	}
6093	noway_assert(!"gtArgEntryByNode: node not found");
6094	return nullptr;
6095	}
6096
6097	/*****************************************************************************
6098	*
6099	* Find and return the entry with the given "lateArgInx". Requires that one is found
6100	* (asserts this).
6101	*/
6102	fgArgTabEntry* Compiler::gtArgEntryByLateArgIndex(GenTreeCall* call, unsigned lateArgInx)
6103	{
6104	fgArgInfo* argInfo = call->fgArgInfo;
6105	noway_assert(argInfo != nullptr);
6106	assert(lateArgInx != UINT_MAX);
6107
6108	unsigned argCount = argInfo->ArgCount();
6109	fgArgTabEntry** argTable = argInfo->ArgTable();
6110	fgArgTabEntry* curArgTabEntry = nullptr;
6111
6112	for (unsigned i = `0`; i < argCount; i++)
6113	{
6114	curArgTabEntry = argTable[i];
6115	if (curArgTabEntry->isLateArg() && curArgTabEntry->lateArgInx == lateArgInx)
6116	{
6117	return curArgTabEntry;
6118	}
6119	}
6120	noway_assert(!"gtArgEntryByNode: node not found");
6121	return nullptr;
6122	}
6123
6124	//------------------------------------------------------------------------
6125	// gtArgNodeByLateArgInx: Given a call instruction, find the argument with the given
6126	// late arg index (i.e. the given position in the gtCallLateArgs list).
6127	// Arguments:
6128	// call - the call node
6129	// lateArgInx - the index into the late args list
6130	//
6131	// Return value:
6132	// The late argument node.
6133	//
6134	GenTree* Compiler::gtArgNodeByLateArgInx(GenTreeCall* call, unsigned lateArgInx)
6135	{
6136	GenTree* argx = nullptr;
6137	unsigned regIndex = `0`;
6138
6139	for (GenTreeArgList list = call->gtCall.gtCallLateArgs; list != nullptr*; regIndex++, list = list->Rest())
6140	{
6141	argx = list->Current();
6142	assert(!argx->IsArgPlaceHolderNode()); // No placeholder nodes are in gtCallLateArgs;
6143	if (regIndex == lateArgInx)
6144	{
6145	break;
6146	}
6147	}
6148	noway_assert(argx != nullptr);
6149	return argx;
6150	}
6151
6152	/*****************************************************************************
6153	*
6154	* Given an fgArgTabEntry*, return true if it is the 'this' pointer argument.
6155	*/
6156	bool Compiler::gtArgIsThisPtr(fgArgTabEntry* argEntry)
6157	{
6158	return (argEntry->parent == nullptr);
6159	}
6160
6161	/*****************************************************************************
6162	*
6163	* Create a node that will assign 'src' to 'dst'.
6164	*/
6165
6166	GenTree* Compiler::gtNewAssignNode(GenTree* dst, GenTree* src)
6167	{
6168	/ Mark the target as being assigned /
6169
6170	if ((dst->gtOper == GT_LCL_VAR) \|\| (dst->OperGet() == GT_LCL_FLD))
6171	{
6172	dst->gtFlags \|= GTF_VAR_DEF;
6173	if (dst->IsPartialLclFld(this))
6174	{
6175	// We treat these partial writes as combined uses and defs.
6176	dst->gtFlags \|= GTF_VAR_USEASG;
6177	}
6178	}
6179	dst->gtFlags \|= GTF_DONT_CSE;
6180
6181	/ Create the assignment node /
6182
6183	GenTree* asg = gtNewOperNode(GT_ASG, dst->TypeGet(), dst, src);
6184
6185	/ Mark the expression as containing an assignment /
6186
6187	asg->gtFlags \|= GTF_ASG;
6188
6189	return asg;
6190	}
6191
6192	//------------------------------------------------------------------------
6193	// gtNewObjNode: Creates a new Obj node.
6194	//
6195	// Arguments:
6196	// structHnd - The class handle of the struct type.
6197	// addr - The address of the struct.
6198	//
6199	// Return Value:
6200	// Returns a node representing the struct value at the given address.
6201	//
6202	// Assumptions:
6203	// Any entry and exit conditions, such as required preconditions of
6204	// data structures, memory to be freed by caller, etc.
6205	//
6206	// Notes:
6207	// It will currently return a GT_OBJ node for any struct type, but may
6208	// return a GT_IND or a non-indirection for a scalar type.
6209	// The node will not yet have its GC info initialized. This is because
6210	// we may not need this info if this is an r-value.
6211
6212	GenTree* Compiler::gtNewObjNode(CORINFO_CLASS_HANDLE structHnd, GenTree* addr)
6213	{
6214	var_types nodeType = impNormStructType(structHnd);
6215	assert(varTypeIsStruct(nodeType));
6216	unsigned size = info.compCompHnd->getClassSize(structHnd);
6217
6218	// It would be convenient to set the GC info at this time, but we don't actually require
6219	// it unless this is going to be a destination.
6220	if (!varTypeIsStruct(nodeType))
6221	{
6222	if ((addr->gtOper == GT_ADDR) && (addr->gtGetOp1()->TypeGet() == nodeType))
6223	{
6224	return addr->gtGetOp1();
6225	}
6226	else
6227	{
6228	return gtNewOperNode(GT_IND, nodeType, addr);
6229	}
6230	}
6231	GenTreeBlk* newBlkOrObjNode = new (this, GT_OBJ) GenTreeObj (nodeType, addr, structHnd, size);
6232
6233	// An Obj is not a global reference, if it is known to be a local struct.
6234	if ((addr->gtFlags & GTF_GLOB_REF) == `0`)
6235	{
6236	GenTreeLclVarCommon* lclNode = addr->IsLocalAddrExpr();
6237	if (lclNode != nullptr)
6238	{
6239	newBlkOrObjNode->gtFlags \|= GTF_IND_NONFAULTING;
6240	if (!lvaIsImplicitByRefLocal(lclNode->gtLclNum))
6241	{
6242	newBlkOrObjNode->gtFlags &= ~GTF_GLOB_REF;
6243	}
6244	}
6245	}
6246	return newBlkOrObjNode;
6247	}
6248
6249	//------------------------------------------------------------------------
6250	// gtSetObjGcInfo: Set the GC info on an object node
6251	//
6252	// Arguments:
6253	// objNode - The object node of interest
6254
6255	void Compiler::gtSetObjGcInfo(GenTreeObj* objNode)
6256	{
6257	CORINFO_CLASS_HANDLE structHnd = objNode->gtClass;
6258	var_types nodeType = objNode->TypeGet();
6259	unsigned size = objNode->gtBlkSize;
6260	unsigned slots = `0`;
6261	unsigned gcPtrCount = `0`;
6262	BYTE* gcPtrs = nullptr;
6263
6264	assert(varTypeIsStruct(nodeType));
6265	assert(size == info.compCompHnd->getClassSize(structHnd));
6266	assert(nodeType == impNormStructType(structHnd));
6267
6268	if (nodeType == TYP_STRUCT)
6269	{
6270	if (size >= TARGET_POINTER_SIZE)
6271	{
6272	// Get the GC fields info
6273	var_types simdBaseType; // Dummy argument
6274	slots = roundUp(size, TARGET_POINTER_SIZE) / TARGET_POINTER_SIZE;
6275	gcPtrs = new (this, CMK_ASTNode) BYTE[slots];
6276	nodeType = impNormStructType(structHnd, gcPtrs, &gcPtrCount, &simdBaseType);
6277	}
6278	}
6279	objNode->SetGCInfo(gcPtrs, gcPtrCount, slots);
6280	assert(objNode->gtType == nodeType);
6281	}
6282
6283	//------------------------------------------------------------------------
6284	// gtNewStructVal: Return a node that represents a struct value
6285	//
6286	// Arguments:
6287	// structHnd - The class for the struct
6288	// addr - The address of the struct
6289	//
6290	// Return Value:
6291	// A block, object or local node that represents the struct value pointed to by 'addr'.
6292
6293	GenTree* Compiler::gtNewStructVal(CORINFO_CLASS_HANDLE structHnd, GenTree* addr)
6294	{
6295	if (addr->gtOper == GT_ADDR)
6296	{
6297	GenTree* val = addr->gtGetOp1();
6298	if (val->OperGet() == GT_LCL_VAR)
6299	{
6300	unsigned lclNum = addr->gtGetOp1()->AsLclVarCommon()->gtLclNum;
6301	LclVarDsc* varDsc = &(lvaTable[lclNum]);
6302	if (varTypeIsStruct(varDsc) && (varDsc->lvVerTypeInfo.GetClassHandle() == structHnd) &&
6303	!lvaIsImplicitByRefLocal(lclNum))
6304	{
6305	return addr->gtGetOp1();
6306	}
6307	}
6308	}
6309	return gtNewObjNode(structHnd, addr);
6310	}
6311
6312	//------------------------------------------------------------------------
6313	// gtNewBlockVal: Return a node that represents a possibly untyped block value
6314	//
6315	// Arguments:
6316	// addr - The address of the block
6317	// size - The size of the block
6318	//
6319	// Return Value:
6320	// A block, object or local node that represents the block value pointed to by 'addr'.
6321
6322	GenTree* Compiler::gtNewBlockVal(GenTree* addr, unsigned size)
6323	{
6324	// By default we treat this as an opaque struct type with known size.
6325	var_types blkType = TYP_STRUCT;
6326	if ((addr->gtOper == GT_ADDR) && (addr->gtGetOp1()->OperGet() == GT_LCL_VAR))
6327	{
6328	GenTree* val = addr->gtGetOp1();
6329	#if FEATURE_SIMD
6330	if (varTypeIsSIMD(val))
6331	{
6332	if (genTypeSize(val->TypeGet()) == size)
6333	{
6334	blkType = val->TypeGet();
6335	return addr->gtGetOp1();
6336	}
6337	}
6338	else
6339	#endif // FEATURE_SIMD
6340	if (val->TypeGet() == TYP_STRUCT)
6341	{
6342	GenTreeLclVarCommon* lcl = addr->gtGetOp1()->AsLclVarCommon();
6343	LclVarDsc* varDsc = &(lvaTable[lcl->gtLclNum]);
6344	if ((varDsc->TypeGet() == TYP_STRUCT) && (varDsc->lvExactSize == size))
6345	{
6346	return addr->gtGetOp1();
6347	}
6348	}
6349	}
6350	return new (this, GT_BLK) GenTreeBlk (GT_BLK, blkType, addr, size);
6351	}
6352
6353	// Creates a new assignment node for a CpObj.
6354	// Parameters (exactly the same as MSIL CpObj):
6355	//
6356	// dstAddr - The target to copy the struct to
6357	// srcAddr - The source to copy the struct from
6358	// structHnd - A class token that represents the type of object being copied. May be null
6359	// if FEATURE_SIMD is enabled and the source has a SIMD type.
6360	// isVolatile - Is this marked as volatile memory?
6361
6362	GenTree* Compiler::gtNewCpObjNode(GenTree* dstAddr, GenTree* srcAddr, CORINFO_CLASS_HANDLE structHnd, bool isVolatile)
6363	{
6364	GenTree* lhs = gtNewStructVal(structHnd, dstAddr);
6365	GenTree* src = nullptr;
6366	unsigned size;
6367
6368	if (lhs->OperIsBlk())
6369	{
6370	size = lhs->AsBlk()->gtBlkSize;
6371	if (lhs->OperGet() == GT_OBJ)
6372	{
6373	gtSetObjGcInfo(lhs->AsObj());
6374	}
6375	}
6376	else
6377	{
6378	size = genTypeSize(lhs->gtType);
6379	}
6380
6381	if (srcAddr->OperGet() == GT_ADDR)
6382	{
6383	src = srcAddr->gtOp.gtOp1;
6384	}
6385	else
6386	{
6387	src = gtNewOperNode(GT_IND, lhs->TypeGet(), srcAddr);
6388	}
6389
6390	GenTree* result = gtNewBlkOpNode(lhs, src, size, isVolatile, true);
6391	return result;
6392	}
6393
6394	//------------------------------------------------------------------------
6395	// FixupInitBlkValue: Fixup the init value for an initBlk operation
6396	//
6397	// Arguments:
6398	// asgType - The type of assignment that the initBlk is being transformed into
6399	//
6400	// Return Value:
6401	// Modifies the constant value on this node to be the appropriate "fill"
6402	// value for the initblk.
6403	//
6404	// Notes:
6405	// The initBlk MSIL instruction takes a byte value, which must be
6406	// extended to the size of the assignment when an initBlk is transformed
6407	// to an assignment of a primitive type.
6408	// This performs the appropriate extension.
6409
6410	void GenTreeIntCon::FixupInitBlkValue(var_types asgType)
6411	{
6412	assert(varTypeIsIntegralOrI(asgType));
6413	unsigned size = genTypeSize(asgType);
6414	if (size > `1`)
6415	{
6416	size_t cns = gtIconVal;
6417	cns = cns & `0xFF`;
6418	cns \|= cns << `8`;
6419	if (size >= `4`)
6420	{
6421	cns \|= cns << `16`;
6422	#ifdef _TARGET_64BIT_
6423	if (size == `8`)
6424	{
6425	cns \|= cns << `32`;
6426	}
6427	#endif // _TARGET_64BIT_
6428
6429	// Make the type match for evaluation types.
6430	gtType = asgType;
6431
6432	// if we are initializing a GC type the value being assigned must be zero (null).
6433	assert(!varTypeIsGC(asgType) \|\| (cns == `0`));
6434	}
6435
6436	gtIconVal = cns;
6437	}
6438	}
6439
6440	//
6441	//------------------------------------------------------------------------
6442	// gtBlockOpInit: Initializes a BlkOp GenTree
6443	//
6444	// Arguments:
6445	// result - an assignment node that is to be initialized.
6446	// dst - the target (destination) we want to either initialize or copy to.
6447	// src - the init value for InitBlk or the source struct for CpBlk/CpObj.
6448	// isVolatile - specifies whether this node is a volatile memory operation.
6449	//
6450	// Assumptions:
6451	// 'result' is an assignment that is newly constructed.
6452	// If 'dst' is TYP_STRUCT, then it must be a block node or lclVar.
6453	//
6454	// Notes:
6455	// This procedure centralizes all the logic to both enforce proper structure and
6456	// to properly construct any InitBlk/CpBlk node.
6457
6458	void Compiler::gtBlockOpInit(GenTree* result, GenTree* dst, GenTree* srcOrFillVal, bool isVolatile)
6459	{
6460	if (!result->OperIsBlkOp())
6461	{
6462	assert(dst->TypeGet() != TYP_STRUCT);
6463	return;
6464	}
6465	#ifdef DEBUG
6466	// If the copy involves GC pointers, the caller must have already set
6467	// the node additional members (gtGcPtrs, gtGcPtrCount, gtSlots) on the dst.
6468	if ((dst->gtOper == GT_OBJ) && dst->AsBlk()->HasGCPtr())
6469	{
6470	GenTreeObj* objNode = dst->AsObj();
6471	assert(objNode->gtGcPtrs != nullptr);
6472	assert(!IsUninitialized(objNode->gtGcPtrs));
6473	assert(!IsUninitialized(objNode->gtGcPtrCount));
6474	assert(!IsUninitialized(objNode->gtSlots) && objNode->gtSlots > `0`);
6475
6476	for (unsigned i = `0`; i < objNode->gtGcPtrCount; ++i)
6477	{
6478	CorInfoGCType t = (CorInfoGCType)objNode->gtGcPtrs[i];
6479	switch (t)
6480	{
6481	case TYPE_GC_NONE:
6482	case TYPE_GC_REF:
6483	case TYPE_GC_BYREF:
6484	case TYPE_GC_OTHER:
6485	break;
6486	default:
6487	unreached();
6488	}
6489	}
6490	}
6491	#endif // DEBUG
6492
6493	/ In the case of CpBlk, we want to avoid generating*
6494	* nodes where the source and destination are the same
6495	* because of two reasons, first, is useless, second
6496	* it introduces issues in liveness and also copying
6497	* memory from an overlapping memory location is
6498	* undefined both as per the ECMA standard and also
6499	* the memcpy semantics specify that.
6500	*
6501	* NOTE: In this case we'll only detect the case for addr of a local
6502	* and a local itself, any other complex expressions won't be
6503	* caught.
6504	*
6505	* TODO-Cleanup: though having this logic is goodness (i.e. avoids self-assignment
6506	* of struct vars very early), it was added because fgInterBlockLocalVarLiveness()
6507	* isn't handling self-assignment of struct variables correctly. This issue may not
6508	* surface if struct promotion is ON (which is the case on x86/arm). But still the
6509	* fundamental issue exists that needs to be addressed.
6510	*/
6511	if (result->OperIsCopyBlkOp())
6512	{
6513	GenTree* currSrc = srcOrFillVal;
6514	GenTree* currDst = dst;
6515
6516	if (currSrc->OperIsBlk() && (currSrc->AsBlk()->Addr()->OperGet() == GT_ADDR))
6517	{
6518	currSrc = currSrc->AsBlk()->Addr()->gtGetOp1();
6519	}
6520	if (currDst->OperIsBlk() && (currDst->AsBlk()->Addr()->OperGet() == GT_ADDR))
6521	{
6522	currDst = currDst->AsBlk()->Addr()->gtGetOp1();
6523	}
6524
6525	if (currSrc->OperGet() == GT_LCL_VAR && currDst->OperGet() == GT_LCL_VAR &&
6526	currSrc->gtLclVarCommon.gtLclNum == currDst->gtLclVarCommon.gtLclNum)
6527	{
6528	// Make this a NOP
6529	// TODO-Cleanup: probably doesn't matter, but could do this earlier and avoid creating a GT_ASG
6530	result->gtBashToNOP();
6531	return;
6532	}
6533	}
6534
6535	// Propagate all effect flags from children
6536	result->gtFlags \|= dst->gtFlags & GTF_ALL_EFFECT;
6537	result->gtFlags \|= result->gtOp.gtOp2->gtFlags & GTF_ALL_EFFECT;
6538
6539	result->gtFlags \|= (dst->gtFlags & GTF_EXCEPT) \| (srcOrFillVal->gtFlags & GTF_EXCEPT);
6540
6541	if (isVolatile)
6542	{
6543	result->gtFlags \|= GTF_BLK_VOLATILE;
6544	}
6545
6546	#ifdef FEATURE_SIMD
6547	if (result->OperIsCopyBlkOp() && varTypeIsSIMD(srcOrFillVal))
6548	{
6549	// If the source is a GT_SIMD node of SIMD type, then the dst lclvar struct
6550	// should be labeled as simd intrinsic related struct.
6551	// This is done so that the morpher can transform any field accesses into
6552	// intrinsics, thus avoiding conflicting access methods (fields vs. whole-register).
6553
6554	GenTree* src = srcOrFillVal;
6555	if (src->OperIsIndir() && (src->AsIndir()->Addr()->OperGet() == GT_ADDR))
6556	{
6557	src = src->AsIndir()->Addr()->gtGetOp1();
6558	}
6559	#ifdef FEATURE_HW_INTRINSICS
6560	if ((src->OperGet() == GT_SIMD) \|\| (src->OperGet() == GT_HWIntrinsic))
6561	#else
6562	if (src->OperGet() == GT_SIMD)
6563	#endif // FEATURE_HW_INTRINSICS
6564	{
6565	if (dst->OperIsBlk() && (dst->AsIndir()->Addr()->OperGet() == GT_ADDR))
6566	{
6567	dst = dst->AsIndir()->Addr()->gtGetOp1();
6568	}
6569
6570	if (dst->OperIsLocal() && varTypeIsStruct(dst))
6571	{
6572	setLclRelatedToSIMDIntrinsic(dst);
6573	}
6574	}
6575	}
6576	#endif // FEATURE_SIMD
6577	}
6578
6579	//------------------------------------------------------------------------
6580	// gtNewBlkOpNode: Creates a GenTree for a block (struct) assignment.
6581	//
6582	// Arguments:
6583	// dst - Destination or target to copy to / initialize the buffer.
6584	// srcOrFillVall - the size of the buffer to copy/initialize or zero, in the case of CpObj.
6585	// size - The size of the buffer or a class token (in the case of CpObj).
6586	// isVolatile - Whether this is a volatile memory operation or not.
6587	// isCopyBlock - True if this is a block copy (rather than a block init).
6588	//
6589	// Return Value:
6590	// Returns the newly constructed and initialized block operation.
6591	//
6592	// Notes:
6593	// If size is zero, the dst must be a GT_OBJ with the class handle.
6594	// 'dst' must be a block node or lclVar.
6595	//
6596	GenTree* Compiler::gtNewBlkOpNode(GenTree* dst, GenTree* srcOrFillVal, unsigned size, bool isVolatile, bool isCopyBlock)
6597	{
6598	assert(dst->OperIsBlk() \|\| dst->OperIsLocal());
6599	if (isCopyBlock)
6600	{
6601	srcOrFillVal->gtFlags \|= GTF_DONT_CSE;
6602	if (srcOrFillVal->OperIsIndir() && (srcOrFillVal->gtGetOp1()->gtOper == GT_ADDR))
6603	{
6604	srcOrFillVal = srcOrFillVal->gtGetOp1()->gtGetOp1();
6605	}
6606	}
6607	else
6608	{
6609	// InitBlk
6610	assert(varTypeIsIntegral(srcOrFillVal));
6611	if (varTypeIsStruct(dst))
6612	{
6613	if (!srcOrFillVal->IsIntegralConst(`0`))
6614	{
6615	srcOrFillVal = gtNewOperNode(GT_INIT_VAL, TYP_INT, srcOrFillVal);
6616	}
6617	}
6618	}
6619
6620	GenTree* result = gtNewAssignNode(dst, srcOrFillVal);
6621	gtBlockOpInit(result, dst, srcOrFillVal, isVolatile);
6622	return result;
6623	}
6624
6625	//------------------------------------------------------------------------
6626	// gtNewPutArgReg: Creates a new PutArgReg node.
6627	//
6628	// Arguments:
6629	// type - The actual type of the argument
6630	// arg - The argument node
6631	// argReg - The register that the argument will be passed in
6632	//
6633	// Return Value:
6634	// Returns the newly created PutArgReg node.
6635	//
6636	// Notes:
6637	// The node is generated as GenTreeMultiRegOp on RyuJIT/armel, GenTreeOp on all the other archs.
6638	//
6639	GenTree* Compiler::gtNewPutArgReg(var_types type, GenTree* arg, regNumber argReg)
6640	{
6641	assert(arg != nullptr);
6642
6643	GenTree* node = nullptr;
6644	#if defined(_TARGET_ARM_)
6645	// A PUTARG_REG could be a MultiRegOp on arm since we could move a double register to two int registers.
6646	node = new (this, GT_PUTARG_REG) GenTreeMultiRegOp(GT_PUTARG_REG, type, arg, nullptr);
6647	if (type == TYP_LONG)
6648	{
6649	node->AsMultiRegOp()->gtOtherReg = REG_NEXT(argReg);
6650	}
6651	#else
6652	node = gtNewOperNode(GT_PUTARG_REG, type, arg);
6653	#endif
6654	node->gtRegNum = argReg;
6655
6656	return node;
6657	}
6658
6659	//------------------------------------------------------------------------
6660	// gtNewBitCastNode: Creates a new BitCast node.
6661	//
6662	// Arguments:
6663	// type - The actual type of the argument
6664	// arg - The argument node
6665	// argReg - The register that the argument will be passed in
6666	//
6667	// Return Value:
6668	// Returns the newly created BitCast node.
6669	//
6670	// Notes:
6671	// The node is generated as GenTreeMultiRegOp on RyuJIT/arm, as GenTreeOp on all the other archs.
6672	//
6673	GenTree* Compiler::gtNewBitCastNode(var_types type, GenTree* arg)
6674	{
6675	assert(arg != nullptr);
6676
6677	GenTree* node = nullptr;
6678	#if defined(_TARGET_ARM_)
6679	// A BITCAST could be a MultiRegOp on arm since we could move a double register to two int registers.
6680	node = new (this, GT_BITCAST) GenTreeMultiRegOp(GT_BITCAST, type, arg, nullptr);
6681	#else
6682	node = gtNewOperNode(GT_BITCAST, type, arg);
6683	#endif
6684
6685	return node;
6686	}
6687
6688	//------------------------------------------------------------------------
6689	// gtNewAllocObjNode: Helper to create an object allocation node.
6690	//
6691	// Arguments:
6692	// pResolvedToken - Resolved token for the object being allocated
6693	// useParent - true iff the token represents a child of the object's class
6694	//
6695	// Return Value:
6696	// Returns GT_ALLOCOBJ node that will be later morphed into an
6697	// allocation helper call or local variable allocation on the stack.
6698
6699	GenTreeAllocObj* Compiler::gtNewAllocObjNode(CORINFO_RESOLVED_TOKEN* pResolvedToken, BOOL useParent)
6700	{
6701	const BOOL mustRestoreHandle = TRUE;
6702	BOOL* const pRuntimeLookup = nullptr;
6703	bool usingReadyToRunHelper = false;
6704	CorInfoHelpFunc helper = CORINFO_HELP_UNDEF;
6705	GenTree* opHandle = impTokenToHandle(pResolvedToken, pRuntimeLookup, mustRestoreHandle, useParent);
6706
6707	#ifdef FEATURE_READYTORUN_COMPILER
6708	CORINFO_CONST_LOOKUP lookup = {};
6709
6710	if (opts.IsReadyToRun())
6711	{
6712	helper = CORINFO_HELP_READYTORUN_NEW;
6713	CORINFO_LOOKUP_KIND* const pGenericLookupKind = nullptr;
6714	usingReadyToRunHelper =
6715	info.compCompHnd->getReadyToRunHelper(pResolvedToken, pGenericLookupKind, helper, &lookup);
6716	}
6717	#endif
6718
6719	if (!usingReadyToRunHelper)
6720	{
6721	if (opHandle == nullptr)
6722	{
6723	// We must be backing out of an inline.
6724	assert(compDonotInline());
6725	return nullptr;
6726	}
6727	}
6728
6729	bool helperHasSideEffects;
6730	CorInfoHelpFunc helperTemp =
6731	info.compCompHnd->getNewHelper(pResolvedToken, info.compMethodHnd, &helperHasSideEffects);
6732
6733	if (!usingReadyToRunHelper)
6734	{
6735	helper = helperTemp;
6736	}
6737
6738	// TODO: ReadyToRun: When generic dictionary lookups are necessary, replace the lookup call
6739	// and the newfast call with a single call to a dynamic R2R cell that will:
6740	// 1) Load the context
6741	// 2) Perform the generic dictionary lookup and caching, and generate the appropriate stub
6742	// 3) Allocate and return the new object for boxing
6743	// Reason: performance (today, we'll always use the slow helper for the R2R generics case)
6744
6745	GenTreeAllocObj* allocObj =
6746	gtNewAllocObjNode(helper, helperHasSideEffects, pResolvedToken->hClass, TYP_REF, opHandle);
6747
6748	#ifdef FEATURE_READYTORUN_COMPILER
6749	if (usingReadyToRunHelper)
6750	{
6751	allocObj->gtEntryPoint = lookup;
6752	}
6753	#endif
6754
6755	return allocObj;
6756	}
6757
6758	/*****************************************************************************
6759	*
6760	* Clones the given tree value and returns a copy of the given tree.
6761	* If 'complexOK' is false, the cloning is only done provided the tree
6762	* is not too complex (whatever that may mean);
6763	* If 'complexOK' is true, we try slightly harder to clone the tree.
6764	* In either case, NULL is returned if the tree cannot be cloned
6765	*
6766	* Note that there is the function gtCloneExpr() which does a more
6767	* complete job if you can't handle this function failing.
6768	*/
6769
6770	GenTree* Compiler::gtClone(GenTree* tree, bool complexOK)
6771	{
6772	GenTree* copy;
6773
6774	switch (tree->gtOper)
6775	{
6776	case GT_CNS_INT:
6777
6778	#if defined(LATE_DISASM)
6779	if (tree->IsIconHandle())
6780	{
6781	copy = gtNewIconHandleNode(tree->gtIntCon.gtIconVal, tree->gtFlags, tree->gtIntCon.gtFieldSeq);
6782	copy->gtIntCon.gtCompileTimeHandle = tree->gtIntCon.gtCompileTimeHandle;
6783	copy->gtType = tree->gtType;
6784	}
6785	else
6786	#endif
6787	{
6788	copy = new (this, GT_CNS_INT)
6789	GenTreeIntCon (tree->gtType, tree->gtIntCon.gtIconVal, tree->gtIntCon.gtFieldSeq);
6790	copy->gtIntCon.gtCompileTimeHandle = tree->gtIntCon.gtCompileTimeHandle;
6791	}
6792	break;
6793
6794	case GT_CNS_LNG:
6795	copy = gtNewLconNode(tree->gtLngCon.gtLconVal);
6796	break;
6797
6798	case GT_LCL_VAR:
6799	// Remember that the LclVar node has been cloned. The flag will be set
6800	// on 'copy' as well.
6801	tree->gtFlags \|= GTF_VAR_CLONED;
6802	copy = gtNewLclvNode(tree->gtLclVarCommon.gtLclNum, tree->gtType, tree->gtLclVar.gtLclILoffs);
6803	break;
6804
6805	case GT_LCL_FLD:
6806	case GT_LCL_FLD_ADDR:
6807	// Remember that the LclVar node has been cloned. The flag will be set
6808	// on 'copy' as well.
6809	tree->gtFlags \|= GTF_VAR_CLONED;
6810	copy = new (this, tree->gtOper)
6811	GenTreeLclFld (tree->gtOper, tree->TypeGet(), tree->gtLclFld.gtLclNum, tree->gtLclFld.gtLclOffs);
6812	copy->gtLclFld.gtFieldSeq = tree->gtLclFld.gtFieldSeq;
6813	break;
6814
6815	case GT_CLS_VAR:
6816	copy = new (this, GT_CLS_VAR)
6817	GenTreeClsVar (tree->gtType, tree->gtClsVar.gtClsVarHnd, tree->gtClsVar.gtFieldSeq);
6818	break;
6819
6820	default:
6821	if (!complexOK)
6822	{
6823	return nullptr;
6824	}
6825
6826	if (tree->gtOper == GT_FIELD)
6827	{
6828	GenTree* objp;
6829
6830	// copied from line 9850
6831
6832	objp = nullptr;
6833	if (tree->gtField.gtFldObj)
6834	{
6835	objp = gtClone(tree->gtField.gtFldObj, false);
6836	if (!objp)
6837	{
6838	return objp;
6839	}
6840	}
6841
6842	copy = gtNewFieldRef(tree->TypeGet(), tree->gtField.gtFldHnd, objp, tree->gtField.gtFldOffset);
6843	copy->gtField.gtFldMayOverlap = tree->gtField.gtFldMayOverlap;
6844	#ifdef FEATURE_READYTORUN_COMPILER
6845	copy->gtField.gtFieldLookup = tree->gtField.gtFieldLookup;
6846	#endif
6847	}
6848	else if (tree->OperIs(GT_ADD, GT_SUB))
6849	{
6850	GenTree* op1 = tree->gtOp.gtOp1;
6851	GenTree* op2 = tree->gtOp.gtOp2;
6852
6853	if (op1->OperIsLeaf() && op2->OperIsLeaf())
6854	{
6855	op1 = gtClone(op1);
6856	if (op1 == nullptr)
6857	{
6858	return nullptr;
6859	}
6860	op2 = gtClone(op2);
6861	if (op2 == nullptr)
6862	{
6863	return nullptr;
6864	}
6865
6866	copy = gtNewOperNode(tree->OperGet(), tree->TypeGet(), op1, op2);
6867	}
6868	else
6869	{
6870	return nullptr;
6871	}
6872	}
6873	else if (tree->gtOper == GT_ADDR)
6874	{
6875	GenTree* op1 = gtClone(tree->gtOp.gtOp1);
6876	if (op1 == nullptr)
6877	{
6878	return nullptr;
6879	}
6880	copy = gtNewOperNode(GT_ADDR, tree->TypeGet(), op1);
6881	}
6882	else
6883	{
6884	return nullptr;
6885	}
6886
6887	break;
6888	}
6889
6890	copy->gtFlags \|= tree->gtFlags & ~GTF_NODE_MASK;
6891	#if defined(DEBUG)
6892	copy->gtDebugFlags \|= tree->gtDebugFlags & ~GTF_DEBUG_NODE_MASK;
6893	#endif // defined(DEBUG)
6894
6895	return copy;
6896	}
6897
6898	//------------------------------------------------------------------------
6899	// gtCloneExpr: Create a copy of `tree`, adding flags `addFlags`, mapping
6900	// local `varNum` to int constant `varVal` if it appears at
6901	// the root, and mapping uses of local `deepVarNum` to constant
6902	// `deepVarVal` if they occur beyond the root.
6903	//
6904	// Arguments:
6905	// tree - GenTree to create a copy of
6906	// addFlags - GTF_ flags to add to the copied tree nodes*
6907	// varNum - lclNum to replace at the root, or ~0 for no root replacement
6908	// varVal - If replacing at root, replace local `varNum` with IntCns `varVal`
6909	// deepVarNum - lclNum to replace uses of beyond the root, or ~0 for no replacement
6910	// deepVarVal - If replacing beyond root, replace `deepVarNum` with IntCns `deepVarVal`
6911	//
6912	// Return Value:
6913	// A copy of the given tree with the replacements and added flags specified.
6914	//
6915	// Notes:
6916	// Top-level callers should generally call the overload that doesn't have
6917	// the explicit `deepVarNum` and `deepVarVal` parameters; those are used in
6918	// recursive invocations to avoid replacing defs.
6919
6920	GenTree* Compiler::gtCloneExpr(
6921	GenTree* tree, unsigned addFlags, unsigned varNum, int varVal, unsigned deepVarNum, int deepVarVal)
6922	{
6923	if (tree == nullptr)
6924	{
6925	return nullptr;
6926	}
6927
6928	/ Figure out what kind of a node we have /
6929
6930	genTreeOps oper = tree->OperGet();
6931	unsigned kind = tree->OperKind();
6932	GenTree* copy;
6933
6934	/ Is this a constant or leaf node? /
6935
6936	if (kind & (GTK_CONST \| GTK_LEAF))
6937	{
6938	switch (oper)
6939	{
6940	case GT_CNS_INT:
6941
6942	#if defined(LATE_DISASM)
6943	if (tree->IsIconHandle())
6944	{
6945	copy = gtNewIconHandleNode(tree->gtIntCon.gtIconVal, tree->gtFlags, tree->gtIntCon.gtFieldSeq);
6946	copy->gtIntCon.gtCompileTimeHandle = tree->gtIntCon.gtCompileTimeHandle;
6947	copy->gtType = tree->gtType;
6948	}
6949	else
6950	#endif
6951	{
6952	copy = gtNewIconNode(tree->gtIntCon.gtIconVal, tree->gtType);
6953	copy->gtIntCon.gtCompileTimeHandle = tree->gtIntCon.gtCompileTimeHandle;
6954	copy->gtIntCon.gtFieldSeq = tree->gtIntCon.gtFieldSeq;
6955	}
6956	goto DONE;
6957
6958	case GT_CNS_LNG:
6959	copy = gtNewLconNode(tree->gtLngCon.gtLconVal);
6960	goto DONE;
6961
6962	case GT_CNS_DBL:
6963	copy = gtNewDconNode(tree->gtDblCon.gtDconVal);
6964	copy->gtType = tree->gtType; // keep the same type
6965	goto DONE;
6966
6967	case GT_CNS_STR:
6968	copy = gtNewSconNode(tree->gtStrCon.gtSconCPX, tree->gtStrCon.gtScpHnd);
6969	goto DONE;
6970
6971	case GT_LCL_VAR:
6972
6973	if (tree->gtLclVarCommon.gtLclNum == varNum)
6974	{
6975	copy = gtNewIconNode(varVal, tree->gtType);
6976	if (tree->gtFlags & GTF_VAR_ARR_INDEX)
6977	{
6978	copy->LabelIndex(this);
6979	}
6980	}
6981	else
6982	{
6983	// Remember that the LclVar node has been cloned. The flag will
6984	// be set on 'copy' as well.
6985	tree->gtFlags \|= GTF_VAR_CLONED;
6986	copy = gtNewLclvNode(tree->gtLclVar.gtLclNum, tree->gtType, tree->gtLclVar.gtLclILoffs);
6987	copy->AsLclVarCommon()->SetSsaNum(tree->AsLclVarCommon()->GetSsaNum());
6988	}
6989	copy->gtFlags = tree->gtFlags;
6990	goto DONE;
6991
6992	case GT_LCL_FLD:
6993	if (tree->gtLclFld.gtLclNum == varNum)
6994	{
6995	IMPL_LIMITATION("replacing GT_LCL_FLD with a constant");
6996	}
6997	else
6998	{
6999	// Remember that the LclVar node has been cloned. The flag will
7000	// be set on 'copy' as well.
7001	tree->gtFlags \|= GTF_VAR_CLONED;
7002	copy = new (this, GT_LCL_FLD)
7003	GenTreeLclFld (tree->TypeGet(), tree->gtLclFld.gtLclNum, tree->gtLclFld.gtLclOffs);
7004	copy->gtLclFld.gtFieldSeq = tree->gtLclFld.gtFieldSeq;
7005	copy->gtFlags = tree->gtFlags;
7006	}
7007	goto DONE;
7008
7009	case GT_CLS_VAR:
7010	copy = new (this, GT_CLS_VAR)
7011	GenTreeClsVar (tree->TypeGet(), tree->gtClsVar.gtClsVarHnd, tree->gtClsVar.gtFieldSeq);
7012	goto DONE;
7013
7014	case GT_RET_EXPR:
7015	// GT_RET_EXPR is unique node, that contains a link to a gtInlineCandidate node,
7016	// that is part of another statement. We cannot clone both here and cannot
7017	// create another GT_RET_EXPR that points to the same gtInlineCandidate.
7018	NO_WAY("Cloning of GT_RET_EXPR node not supported");
7019	goto DONE;
7020
7021	case GT_MEMORYBARRIER:
7022	copy = new (this, GT_MEMORYBARRIER) GenTree (GT_MEMORYBARRIER, TYP_VOID);
7023	goto DONE;
7024
7025	case GT_ARGPLACE:
7026	copy = gtNewArgPlaceHolderNode(tree->gtType, tree->gtArgPlace.gtArgPlaceClsHnd);
7027	goto DONE;
7028
7029	case GT_FTN_ADDR:
7030	copy = new (this, oper) GenTreeFptrVal (tree->gtType, tree->gtFptrVal.gtFptrMethod);
7031
7032	#ifdef FEATURE_READYTORUN_COMPILER
7033	copy->gtFptrVal.gtEntryPoint = tree->gtFptrVal.gtEntryPoint;
7034	#endif
7035	goto DONE;
7036
7037	case GT_CATCH_ARG:
7038	case GT_NO_OP:
7039	copy = new (this, oper) GenTree (oper, tree->gtType);
7040	goto DONE;
7041
7042	#if !FEATURE_EH_FUNCLETS
7043	case GT_END_LFIN:
7044	#endif // !FEATURE_EH_FUNCLETS
7045	case GT_JMP:
7046	copy = new (this, oper) GenTreeVal (oper, tree->gtType, tree->gtVal.gtVal1);
7047	goto DONE;
7048
7049	case GT_LABEL:
7050	copy = new (this, oper) GenTreeLabel (tree->gtLabel.gtLabBB);
7051	goto DONE;
7052
7053	default:
7054	NO_WAY("Cloning of node not supported");
7055	goto DONE;
7056	}
7057	}
7058
7059	/ Is it a 'simple' unary/binary operator? /
7060
7061	if (kind & GTK_SMPOP)
7062	{
7063	/ If necessary, make sure we allocate a "fat" tree node /
7064	CLANG_FORMAT_COMMENT_ANCHOR;
7065
7066	#if SMALL_TREE_NODES
7067	switch (oper)
7068	{
7069	/ These nodes sometimes get bashed to "fat" ones /
7070
7071	case GT_MUL:
7072	case GT_DIV:
7073	case GT_MOD:
7074
7075	case GT_UDIV:
7076	case GT_UMOD:
7077
7078	// In the implementation of gtNewLargeOperNode you have
7079	// to give an oper that will create a small node,
7080	// otherwise it asserts.
7081	//
7082	if (GenTree::s_gtNodeSizes[oper] == TREE_NODE_SZ_SMALL)
7083	{
7084	copy = gtNewLargeOperNode(oper, tree->TypeGet(), tree->gtOp.gtOp1,
7085	tree->OperIsBinary() ? tree->gtOp.gtOp2 : nullptr);
7086	}
7087	else // Always a large tree
7088	{
7089	if (tree->OperIsBinary())
7090	{
7091	copy = gtNewOperNode(oper, tree->TypeGet(), tree->gtOp.gtOp1, tree->gtOp.gtOp2);
7092	}
7093	else
7094	{
7095	copy = gtNewOperNode(oper, tree->TypeGet(), tree->gtOp.gtOp1);
7096	}
7097	}
7098	break;
7099
7100	case GT_CAST:
7101	copy =
7102	new (this, LargeOpOpcode()) GenTreeCast (tree->TypeGet(), tree->gtCast.CastOp(), tree->IsUnsigned(),
7103	tree->gtCast.gtCastType DEBUGARG(/largeNode/ TRUE));
7104	break;
7105
7106	// The nodes below this are not bashed, so they can be allocated at their individual sizes.
7107
7108	case GT_LIST:
7109	assert((tree->gtOp.gtOp2 == nullptr) \|\| tree->gtOp.gtOp2->OperIsList());
7110	copy = new (this, GT_LIST) GenTreeArgList (tree->gtOp.gtOp1);
7111	copy->gtOp.gtOp2 = tree->gtOp.gtOp2;
7112	break;
7113
7114	case GT_FIELD_LIST:
7115	copy = new (this, GT_FIELD_LIST) GenTreeFieldList (tree->gtOp.gtOp1, tree->AsFieldList()->gtFieldOffset,
7116	tree->AsFieldList()->gtFieldType, nullptr);
7117	copy->gtOp.gtOp2 = tree->gtOp.gtOp2;
7118	copy->gtFlags = (copy->gtFlags & ~GTF_FIELD_LIST_HEAD) \| (tree->gtFlags & GTF_FIELD_LIST_HEAD);
7119	break;
7120
7121	case GT_INDEX:
7122	{
7123	GenTreeIndex* asInd = tree->AsIndex();
7124	copy = new (this, GT_INDEX)
7125	GenTreeIndex (asInd->TypeGet(), asInd->Arr(), asInd->Index(), asInd->gtIndElemSize);
7126	copy->AsIndex()->gtStructElemClass = asInd->gtStructElemClass;
7127	}
7128	break;
7129
7130	case GT_INDEX_ADDR:
7131	{
7132	GenTreeIndexAddr* asIndAddr = tree->AsIndexAddr();
7133
7134	copy = new (this, GT_INDEX_ADDR)
7135	GenTreeIndexAddr (asIndAddr->Arr(), asIndAddr->Index(), asIndAddr->gtElemType,
7136	asIndAddr->gtStructElemClass, asIndAddr->gtElemSize, asIndAddr->gtLenOffset,
7137	asIndAddr->gtElemOffset);
7138	copy->AsIndexAddr()->gtIndRngFailBB = asIndAddr->gtIndRngFailBB;
7139	}
7140	break;
7141
7142	case GT_ALLOCOBJ:
7143	{
7144	GenTreeAllocObj* asAllocObj = tree->AsAllocObj();
7145	copy = new (this, GT_ALLOCOBJ)
7146	GenTreeAllocObj (tree->TypeGet(), asAllocObj->gtNewHelper, asAllocObj->gtHelperHasSideEffects,
7147	asAllocObj->gtAllocObjClsHnd, asAllocObj->gtOp1);
7148	}
7149	break;
7150
7151	case GT_RUNTIMELOOKUP:
7152	{
7153	GenTreeRuntimeLookup* asRuntimeLookup = tree->AsRuntimeLookup();
7154
7155	copy = new (this, GT_RUNTIMELOOKUP)
7156	GenTreeRuntimeLookup (asRuntimeLookup->gtHnd, asRuntimeLookup->gtHndType, asRuntimeLookup->gtOp1);
7157	}
7158	break;
7159
7160	case GT_ARR_LENGTH:
7161	copy = gtNewArrLen(tree->TypeGet(), tree->gtOp.gtOp1, tree->gtArrLen.ArrLenOffset());
7162	break;
7163
7164	case GT_ARR_INDEX:
7165	copy = new (this, GT_ARR_INDEX)
7166	GenTreeArrIndex (tree->TypeGet(),
7167	gtCloneExpr(tree->gtArrIndex.ArrObj(), addFlags, deepVarNum, deepVarVal),
7168	gtCloneExpr(tree->gtArrIndex.IndexExpr(), addFlags, deepVarNum, deepVarVal),
7169	tree->gtArrIndex.gtCurrDim, tree->gtArrIndex.gtArrRank,
7170	tree->gtArrIndex.gtArrElemType);
7171	break;
7172
7173	case GT_QMARK:
7174	copy = new (this, GT_QMARK) GenTreeQmark (tree->TypeGet(), tree->gtOp.gtOp1, tree->gtOp.gtOp2, this);
7175	break;
7176
7177	case GT_OBJ:
7178	copy = new (this, GT_OBJ)
7179	GenTreeObj (tree->TypeGet(), tree->gtOp.gtOp1, tree->AsObj()->gtClass, tree->gtBlk.gtBlkSize);
7180	copy->AsObj()->CopyGCInfo(tree->AsObj());
7181	copy->gtBlk.gtBlkOpGcUnsafe = tree->gtBlk.gtBlkOpGcUnsafe;
7182	break;
7183
7184	case GT_BLK:
7185	copy = new (this, GT_BLK) GenTreeBlk (GT_BLK, tree->TypeGet(), tree->gtOp.gtOp1, tree->gtBlk.gtBlkSize);
7186	copy->gtBlk.gtBlkOpGcUnsafe = tree->gtBlk.gtBlkOpGcUnsafe;
7187	break;
7188
7189	case GT_DYN_BLK:
7190	copy = new (this, GT_DYN_BLK) GenTreeDynBlk (tree->gtOp.gtOp1, tree->gtDynBlk.gtDynamicSize);
7191	copy->gtBlk.gtBlkOpGcUnsafe = tree->gtBlk.gtBlkOpGcUnsafe;
7192	break;
7193
7194	case GT_BOX:
7195	copy = new (this, GT_BOX)
7196	GenTreeBox (tree->TypeGet(), tree->gtOp.gtOp1, tree->gtBox.gtAsgStmtWhenInlinedBoxValue,
7197	tree->gtBox.gtCopyStmtWhenInlinedBoxValue);
7198	break;
7199
7200	case GT_INTRINSIC:
7201	copy = new (this, GT_INTRINSIC)
7202	GenTreeIntrinsic (tree->TypeGet(), tree->gtOp.gtOp1, tree->gtOp.gtOp2,
7203	tree->gtIntrinsic.gtIntrinsicId, tree->gtIntrinsic.gtMethodHandle);
7204	#ifdef FEATURE_READYTORUN_COMPILER
7205	copy->gtIntrinsic.gtEntryPoint = tree->gtIntrinsic.gtEntryPoint;
7206	#endif
7207	break;
7208
7209	case GT_LEA:
7210	{
7211	GenTreeAddrMode* addrModeOp = tree->AsAddrMode();
7212	copy = new (this, GT_LEA)
7213	GenTreeAddrMode (addrModeOp->TypeGet(), addrModeOp->Base(), addrModeOp->Index(), addrModeOp->gtScale,
7214	static_cast<unsigned>(addrModeOp->Offset()));
7215	}
7216	break;
7217
7218	case GT_COPY:
7219	case GT_RELOAD:
7220	{
7221	copy = new (this, oper) GenTreeCopyOrReload (oper, tree->TypeGet(), tree->gtGetOp1());
7222	}
7223	break;
7224
7225	#ifdef FEATURE_SIMD
7226	case GT_SIMD:
7227	{
7228	GenTreeSIMD* simdOp = tree->AsSIMD();
7229	copy = gtNewSIMDNode(simdOp->TypeGet(), simdOp->gtGetOp1(), simdOp->gtGetOp2IfPresent(),
7230	simdOp->gtSIMDIntrinsicID, simdOp->gtSIMDBaseType, simdOp->gtSIMDSize);
7231	}
7232	break;
7233	#endif
7234
7235	#ifdef FEATURE_HW_INTRINSICS
7236	case GT_HWIntrinsic:
7237	{
7238	GenTreeHWIntrinsic* hwintrinsicOp = tree->AsHWIntrinsic();
7239	copy = new (this, GT_HWIntrinsic)
7240	GenTreeHWIntrinsic (hwintrinsicOp->TypeGet(), hwintrinsicOp->gtGetOp1(),
7241	hwintrinsicOp->gtGetOp2IfPresent(), hwintrinsicOp->gtHWIntrinsicId,
7242	hwintrinsicOp->gtSIMDBaseType, hwintrinsicOp->gtSIMDSize);
7243	copy->AsHWIntrinsic()->gtIndexBaseType = hwintrinsicOp->gtIndexBaseType;
7244	}
7245	break;
7246	#endif
7247
7248	default:
7249	assert(!GenTree::IsExOp(tree->OperKind()) && tree->OperIsSimple());
7250	// We're in the SimpleOp case, so it's always unary or binary.
7251	if (GenTree::OperIsUnary(tree->OperGet()))
7252	{
7253	copy = gtNewOperNode(oper, tree->TypeGet(), tree->gtOp.gtOp1, /doSimplifications/ false);
7254	}
7255	else
7256	{
7257	assert(GenTree::OperIsBinary(tree->OperGet()));
7258	copy = gtNewOperNode(oper, tree->TypeGet(), tree->gtOp.gtOp1, tree->gtOp.gtOp2);
7259	}
7260	break;
7261	}
7262	#else
7263	// We're in the SimpleOp case, so it's always unary or binary.
7264	copy = gtNewOperNode(oper, tree->TypeGet(), tree->gtOp.gtOp1, tree->gtOp.gtOp2);
7265	#endif
7266
7267	// Some flags are conceptually part of the gtOper, and should be copied immediately.
7268	if (tree->gtOverflowEx())
7269	{
7270	copy->gtFlags \|= GTF_OVERFLOW;
7271	}
7272
7273	if (tree->gtOp.gtOp1)
7274	{
7275	if (tree->gtOper == GT_ASG)
7276	{
7277	// Don't replace varNum if it appears as the LHS of an assign.
7278	copy->gtOp.gtOp1 = gtCloneExpr(tree->gtOp.gtOp1, addFlags, -`1`, `0`, deepVarNum, deepVarVal);
7279	}
7280	else
7281	{
7282	copy->gtOp.gtOp1 = gtCloneExpr(tree->gtOp.gtOp1, addFlags, deepVarNum, deepVarVal);
7283	}
7284	}
7285
7286	if (tree->gtGetOp2IfPresent())
7287	{
7288	copy->gtOp.gtOp2 = gtCloneExpr(tree->gtOp.gtOp2, addFlags, deepVarNum, deepVarVal);
7289	}
7290
7291	/ Flags /
7292	addFlags \|= tree->gtFlags;
7293
7294	// Copy any node annotations, if necessary.
7295	switch (tree->gtOper)
7296	{
7297	case GT_STOREIND:
7298	case GT_IND:
7299	case GT_OBJ:
7300	case GT_STORE_OBJ:
7301	{
7302	ArrayInfo arrInfo;
7303	if (!tree->AsIndir()->gtOp1->OperIs(GT_INDEX_ADDR) && TryGetArrayInfo(tree->AsIndir(), &arrInfo))
7304	{
7305	GetArrayInfoMap()->Set(copy, arrInfo);
7306	}
7307	}
7308	break;
7309
7310	default:
7311	break;
7312	}
7313
7314	#ifdef DEBUG
7315	/ GTF_NODE_MASK should not be propagated from 'tree' to 'copy' /
7316	addFlags &= ~GTF_NODE_MASK;
7317	#endif
7318
7319	// Effects flags propagate upwards.
7320	if (copy->gtOp.gtOp1 != nullptr)
7321	{
7322	copy->gtFlags \|= (copy->gtOp.gtOp1->gtFlags & GTF_ALL_EFFECT);
7323	}
7324	if (copy->gtGetOp2IfPresent() != nullptr)
7325	{
7326	copy->gtFlags \|= (copy->gtGetOp2()->gtFlags & GTF_ALL_EFFECT);
7327	}
7328
7329	goto DONE;
7330	}
7331
7332	/ See what kind of a special operator we have here /
7333
7334	switch (oper)
7335	{
7336	case GT_STMT:
7337	copy = gtCloneExpr(tree->gtStmt.gtStmtExpr, addFlags, deepVarNum, deepVarVal);
7338	copy = gtNewStmt(copy, tree->gtStmt.gtStmtILoffsx);
7339	goto DONE;
7340
7341	case GT_CALL:
7342
7343	// We can't safely clone calls that have GT_RET_EXPRs via gtCloneExpr.
7344	// You must use gtCloneCandidateCall for these calls (and then do appropriate other fixup)
7345	if (tree->gtCall.IsInlineCandidate() \|\| tree->gtCall.IsGuardedDevirtualizationCandidate())
7346	{
7347	NO_WAY("Cloning of calls with associated GT_RET_EXPR nodes is not supported");
7348	}
7349
7350	copy = gtCloneExprCallHelper(tree->AsCall(), addFlags, deepVarNum, deepVarVal);
7351	break;
7352
7353	case GT_FIELD:
7354
7355	copy = gtNewFieldRef(tree->TypeGet(), tree->gtField.gtFldHnd, nullptr, tree->gtField.gtFldOffset);
7356
7357	copy->gtField.gtFldObj = tree->gtField.gtFldObj
7358	? gtCloneExpr(tree->gtField.gtFldObj, addFlags, deepVarNum, deepVarVal)
7359	: nullptr;
7360	copy->gtField.gtFldMayOverlap = tree->gtField.gtFldMayOverlap;
7361	#ifdef FEATURE_READYTORUN_COMPILER
7362	copy->gtField.gtFieldLookup = tree->gtField.gtFieldLookup;
7363	#endif
7364
7365	break;
7366
7367	case GT_ARR_ELEM:
7368	{
7369	GenTree* inds[GT_ARR_MAX_RANK];
7370	for (unsigned dim = `0`; dim < tree->gtArrElem.gtArrRank; dim++)
7371	{
7372	inds[dim] = gtCloneExpr(tree->gtArrElem.gtArrInds[dim], addFlags, deepVarNum, deepVarVal);
7373	}
7374	copy = new (this, GT_ARR_ELEM)
7375	GenTreeArrElem (tree->TypeGet(), gtCloneExpr(tree->gtArrElem.gtArrObj, addFlags, deepVarNum, deepVarVal),
7376	tree->gtArrElem.gtArrRank, tree->gtArrElem.gtArrElemSize, tree->gtArrElem.gtArrElemType,
7377	&inds[`0`]);
7378	}
7379	break;
7380
7381	case GT_ARR_OFFSET:
7382	{
7383	copy = new (this, GT_ARR_OFFSET)
7384	GenTreeArrOffs (tree->TypeGet(), gtCloneExpr(tree->gtArrOffs.gtOffset, addFlags, deepVarNum, deepVarVal),
7385	gtCloneExpr(tree->gtArrOffs.gtIndex, addFlags, deepVarNum, deepVarVal),
7386	gtCloneExpr(tree->gtArrOffs.gtArrObj, addFlags, deepVarNum, deepVarVal),
7387	tree->gtArrOffs.gtCurrDim, tree->gtArrOffs.gtArrRank, tree->gtArrOffs.gtArrElemType);
7388	}
7389	break;
7390
7391	case GT_CMPXCHG:
7392	copy = new (this, GT_CMPXCHG)
7393	GenTreeCmpXchg (tree->TypeGet(),
7394	gtCloneExpr(tree->gtCmpXchg.gtOpLocation, addFlags, deepVarNum, deepVarVal),
7395	gtCloneExpr(tree->gtCmpXchg.gtOpValue, addFlags, deepVarNum, deepVarVal),
7396	gtCloneExpr(tree->gtCmpXchg.gtOpComparand, addFlags, deepVarNum, deepVarVal));
7397	break;
7398
7399	case GT_ARR_BOUNDS_CHECK:
7400	#ifdef FEATURE_SIMD
7401	case GT_SIMD_CHK:
7402	#endif // FEATURE_SIMD
7403	#ifdef FEATURE_HW_INTRINSICS
7404	case GT_HW_INTRINSIC_CHK:
7405	#endif // FEATURE_HW_INTRINSICS
7406	copy = new (this, oper)
7407	GenTreeBoundsChk (oper, tree->TypeGet(),
7408	gtCloneExpr(tree->gtBoundsChk.gtIndex, addFlags, deepVarNum, deepVarVal),
7409	gtCloneExpr(tree->gtBoundsChk.gtArrLen, addFlags, deepVarNum, deepVarVal),
7410	tree->gtBoundsChk.gtThrowKind);
7411	copy->gtBoundsChk.gtIndRngFailBB = tree->gtBoundsChk.gtIndRngFailBB;
7412	break;
7413
7414	case GT_STORE_DYN_BLK:
7415	case GT_DYN_BLK:
7416	copy = new (this, oper)
7417	GenTreeDynBlk (gtCloneExpr(tree->gtDynBlk.Addr(), addFlags, deepVarNum, deepVarVal),
7418	gtCloneExpr(tree->gtDynBlk.gtDynamicSize, addFlags, deepVarNum, deepVarVal));
7419	break;
7420
7421	default:
7422	#ifdef DEBUG
7423	gtDispTree(tree);
7424	#endif
7425	NO_WAY("unexpected operator");
7426	}
7427
7428	DONE:
7429
7430	// If it has a zero-offset field seq, copy annotation.
7431	if (tree->TypeGet() == TYP_BYREF)
7432	{
7433	FieldSeqNode* fldSeq = nullptr;
7434	if (GetZeroOffsetFieldMap()->Lookup(tree, &fldSeq))
7435	{
7436	GetZeroOffsetFieldMap()->Set(copy, fldSeq);
7437	}
7438	}
7439
7440	copy->gtVNPair = tree->gtVNPair; // A cloned tree gets the orginal's Value number pair
7441
7442	/ Compute the flags for the copied node. Note that we can do this only*
7443	if we didnt gtFoldExpr(copy) /*
7444
7445	if (copy->gtOper == oper)
7446	{
7447	addFlags \|= tree->gtFlags;
7448
7449	#ifdef DEBUG
7450	/ GTF_NODE_MASK should not be propagated from 'tree' to 'copy' /
7451	addFlags &= ~GTF_NODE_MASK;
7452	#endif
7453	// Some other flags depend on the context of the expression, and should not be preserved.
7454	// For example, GTF_RELOP_QMARK:
7455	if (copy->OperKind() & GTK_RELOP)
7456	{
7457	addFlags &= ~GTF_RELOP_QMARK;
7458	}
7459	// On the other hand, if we're creating such a context, restore this flag.
7460	if (copy->OperGet() == GT_QMARK)
7461	{
7462	copy->gtOp.gtOp1->gtFlags \|= GTF_RELOP_QMARK;
7463	}
7464
7465	copy->gtFlags \|= addFlags;
7466
7467	// Update side effect flags since they may be different from the source side effect flags.
7468	// For example, we may have replaced some locals with constants and made indirections non-throwing.
7469	gtUpdateNodeSideEffects(copy);
7470	}
7471
7472	/ GTF_COLON_COND should be propagated from 'tree' to 'copy' /
7473	copy->gtFlags \|= (tree->gtFlags & GTF_COLON_COND);
7474
7475	#if defined(DEBUG)
7476	// Non-node debug flags should be propagated from 'tree' to 'copy'
7477	copy->gtDebugFlags \|= (tree->gtDebugFlags & ~GTF_DEBUG_NODE_MASK);
7478	#endif
7479
7480	/ Make sure to copy back fields that may have been initialized /
7481
7482	copy->CopyRawCosts(tree);
7483	copy->gtRsvdRegs = tree->gtRsvdRegs;
7484	copy->CopyReg(tree);
7485	return copy;
7486	}
7487
7488	//------------------------------------------------------------------------
7489	// gtCloneExprCallHelper: clone a call tree
7490	//
7491	// Notes:
7492	// Do not invoke this method directly, instead call either gtCloneExpr
7493	// or gtCloneCandidateCall, as appropriate.
7494	//
7495	// Arguments:
7496	// tree - the call to clone
7497	// addFlags - GTF_ flags to add to the copied tree nodes*
7498	// deepVarNum - lclNum to replace uses of beyond the root, or BAD_VAR_NUM for no replacement
7499	// deepVarVal - If replacing beyond root, replace `deepVarNum` with IntCns `deepVarVal`
7500	//
7501	// Returns:
7502	// Cloned copy of call and all subtrees.
7503
7504	GenTreeCall* Compiler::gtCloneExprCallHelper(GenTreeCall* tree, unsigned addFlags, unsigned deepVarNum, int deepVarVal)
7505	{
7506	GenTreeCall* copy = new (this, GT_CALL) GenTreeCall (tree->TypeGet());
7507
7508	copy->gtCallObjp = tree->gtCallObjp ? gtCloneExpr(tree->gtCallObjp, addFlags, deepVarNum, deepVarVal) : nullptr;
7509	copy->gtCallArgs =
7510	tree->gtCallArgs ? gtCloneExpr(tree->gtCallArgs, addFlags, deepVarNum, deepVarVal)->AsArgList() : nullptr;
7511	copy->gtCallMoreFlags = tree->gtCallMoreFlags;
7512	copy->gtCallLateArgs = tree->gtCallLateArgs
7513	? gtCloneExpr(tree->gtCallLateArgs, addFlags, deepVarNum, deepVarVal)->AsArgList()
7514	: nullptr;
7515
7516	#if !FEATURE_FIXED_OUT_ARGS
7517	copy->regArgList = tree->regArgList;
7518	copy->regArgListCount = tree->regArgListCount;
7519	#endif
7520
7521	// The call sig comes from the EE and doesn't change throughout the compilation process, meaning
7522	// we only really need one physical copy of it. Therefore a shallow pointer copy will suffice.
7523	// (Note that this still holds even if the tree we are cloning was created by an inlinee compiler,
7524	// because the inlinee still uses the inliner's memory allocator anyway.)
7525	copy->callSig = tree->callSig;
7526
7527	copy->gtCallType = tree->gtCallType;
7528	copy->gtReturnType = tree->gtReturnType;
7529	copy->gtControlExpr = tree->gtControlExpr;
7530
7531	/ Copy the union /
7532	if (tree->gtCallType == CT_INDIRECT)
7533	{
7534	copy->gtCallCookie =
7535	tree->gtCallCookie ? gtCloneExpr(tree->gtCallCookie, addFlags, deepVarNum, deepVarVal) : nullptr;
7536	copy->gtCallAddr = tree->gtCallAddr ? gtCloneExpr(tree->gtCallAddr, addFlags, deepVarNum, deepVarVal) : nullptr;
7537	}
7538	else if (tree->IsVirtualStub())
7539	{
7540	copy->gtCallMethHnd = tree->gtCallMethHnd;
7541	copy->gtStubCallStubAddr = tree->gtStubCallStubAddr;
7542	}
7543	else
7544	{
7545	copy->gtCallMethHnd = tree->gtCallMethHnd;
7546	copy->gtInlineCandidateInfo = nullptr;
7547	}
7548
7549	if (tree->fgArgInfo)
7550	{
7551	// Create and initialize the fgArgInfo for our copy of the call tree
7552	copy->fgArgInfo = new (this, CMK_Unknown) fgArgInfo (copy, tree);
7553	}
7554	else
7555	{
7556	copy->fgArgInfo = nullptr;
7557	}
7558
7559	copy->gtRetClsHnd = tree->gtRetClsHnd;
7560
7561	#if FEATURE_MULTIREG_RET
7562	copy->gtReturnTypeDesc = tree->gtReturnTypeDesc;
7563	#endif
7564
7565	#ifdef FEATURE_READYTORUN_COMPILER
7566	copy->setEntryPoint(tree->gtEntryPoint);
7567	#endif
7568
7569	#if defined(DEBUG) \|\| defined(INLINE_DATA)
7570	copy->gtInlineObservation = tree->gtInlineObservation;
7571	copy->gtRawILOffset = tree->gtCall.gtRawILOffset;
7572	#endif
7573
7574	copy->CopyOtherRegFlags(tree);
7575
7576	return copy;
7577	}
7578
7579	//------------------------------------------------------------------------
7580	// gtCloneCandidateCall: clone a call that is an inline or guarded
7581	// devirtualization candidate (~ any call that can have a GT_RET_EXPR)
7582	//
7583	// Notes:
7584	// If the call really is a candidate, the caller must take additional steps
7585	// after cloning to re-establish candidate info and the relationship between
7586	// the candidate and any associated GT_RET_EXPR.
7587	//
7588	// Arguments:
7589	// call - the call to clone
7590	//
7591	// Returns:
7592	// Cloned copy of call and all subtrees.
7593
7594	GenTreeCall* Compiler::gtCloneCandidateCall(GenTreeCall* call)
7595	{
7596	assert(call->IsInlineCandidate() \|\| call->IsGuardedDevirtualizationCandidate());
7597
7598	GenTreeCall* result = gtCloneExprCallHelper(call);
7599
7600	// There is some common post-processing in gtCloneExpr that we reproduce
7601	// here, for the fields that make sense for candidate calls.
7602	result->gtFlags \|= call->gtFlags;
7603
7604	#if defined(DEBUG)
7605	result->gtDebugFlags \|= (call->gtDebugFlags & ~GTF_DEBUG_NODE_MASK);
7606	#endif
7607
7608	result->CopyReg(call);
7609
7610	return result;
7611	}
7612
7613	//------------------------------------------------------------------------
7614	// gtReplaceTree: Replace a tree with a new tree.
7615	//
7616	// Arguments:
7617	// stmt - The top-level root stmt of the tree being replaced.
7618	// Must not be null.
7619	// tree - The tree being replaced. Must not be null.
7620	// replacementTree - The replacement tree. Must not be null.
7621	//
7622	// Return Value:
7623	// The tree node that replaces the old tree.
7624	//
7625	// Assumptions:
7626	// The sequencing of the stmt has been done.
7627	//
7628	// Notes:
7629	// The caller must ensure that the original statement has been sequenced,
7630	// and the side effect flags are updated on the statement nodes,
7631	// but this method will sequence 'replacementTree', and insert it into the
7632	// proper place in the statement sequence.
7633
7634	GenTree* Compiler::gtReplaceTree(GenTree* stmt, GenTree* tree, GenTree* replacementTree)
7635	{
7636	assert(fgStmtListThreaded);
7637	assert(tree != nullptr);
7638	assert(stmt != nullptr);
7639	assert(replacementTree != nullptr);
7640
7641	GenTree treePtr = nullptr**;
7642	GenTree* treeParent = tree->gtGetParent(&treePtr);
7643
7644	assert(treeParent != nullptr \|\| tree == stmt->gtStmt.gtStmtExpr);
7645
7646	if (treePtr == nullptr)
7647	{
7648	// Replace the stmt expr and rebuild the linear order for "stmt".
7649	assert(treeParent == nullptr);
7650	assert(fgOrder != FGOrderLinear);
7651	stmt->gtStmt.gtStmtExpr = tree;
7652	fgSetStmtSeq(stmt);
7653	}
7654	else
7655	{
7656	assert(treeParent != nullptr);
7657
7658	// Check to see if the node to be replaced is a call argument and if so,
7659	// set `treeParent` to the call node.
7660	GenTree* cursor = treeParent;
7661	while ((cursor != nullptr) && (cursor->OperGet() == GT_LIST))
7662	{
7663	cursor = cursor->gtNext;
7664	}
7665
7666	if ((cursor != nullptr) && (cursor->OperGet() == GT_CALL))
7667	{
7668	treeParent = cursor;
7669	}
7670
7671	#ifdef DEBUG
7672	GenTree** useEdge;
7673	assert(treeParent->TryGetUse(tree, &useEdge));
7674	assert(useEdge == treePtr);
7675	#endif // DEBUG
7676
7677	GenTree* treeFirstNode = fgGetFirstNode(tree);
7678	GenTree* treeLastNode = tree;
7679	GenTree* treePrevNode = treeFirstNode->gtPrev;
7680	GenTree* treeNextNode = treeLastNode->gtNext;
7681
7682	treeParent->ReplaceOperand(treePtr, replacementTree);
7683
7684	// Build the linear order for "replacementTree".
7685	fgSetTreeSeq(replacementTree, treePrevNode);
7686
7687	// Restore linear-order Prev and Next for "replacementTree".
7688	if (treePrevNode != nullptr)
7689	{
7690	treeFirstNode = fgGetFirstNode(replacementTree);
7691	treeFirstNode->gtPrev = treePrevNode;
7692	treePrevNode->gtNext = treeFirstNode;
7693	}
7694	else
7695	{
7696	// Update the linear oder start of "stmt" if treeFirstNode
7697	// appears to have replaced the original first node.
7698	assert(treeFirstNode == stmt->gtStmt.gtStmtList);
7699	stmt->gtStmt.gtStmtList = fgGetFirstNode(replacementTree);
7700	}
7701
7702	if (treeNextNode != nullptr)
7703	{
7704	treeLastNode = replacementTree;
7705	treeLastNode->gtNext = treeNextNode;
7706	treeNextNode->gtPrev = treeLastNode;
7707	}
7708	}
7709
7710	return replacementTree;
7711	}
7712
7713	//------------------------------------------------------------------------
7714	// gtUpdateSideEffects: Update the side effects of a tree and its ancestors
7715	//
7716	// Arguments:
7717	// stmt - The tree's statement
7718	// tree - Tree to update the side effects for
7719	//
7720	// Note: If tree's order hasn't been established, the method updates side effect
7721	// flags on all statement's nodes.
7722
7723	void Compiler::gtUpdateSideEffects(GenTree* stmt, GenTree* tree)
7724	{
7725	if (fgStmtListThreaded)
7726	{
7727	gtUpdateTreeAncestorsSideEffects(tree);
7728	}
7729	else
7730	{
7731	gtUpdateStmtSideEffects(stmt);
7732	}
7733	}
7734
7735	//------------------------------------------------------------------------
7736	// gtUpdateTreeAncestorsSideEffects: Update the side effects of a tree and its ancestors
7737	// when statement order has been established.
7738	//
7739	// Arguments:
7740	// tree - Tree to update the side effects for
7741
7742	void Compiler::gtUpdateTreeAncestorsSideEffects(GenTree* tree)
7743	{
7744	assert(fgStmtListThreaded);
7745	while (tree != nullptr)
7746	{
7747	gtUpdateNodeSideEffects(tree);
7748	tree = tree->gtGetParent(nullptr);
7749	}
7750	}
7751
7752	//------------------------------------------------------------------------
7753	// gtUpdateStmtSideEffects: Update the side effects for statement tree nodes.
7754	//
7755	// Arguments:
7756	// stmt - The statement to update side effects on
7757
7758	void Compiler::gtUpdateStmtSideEffects(GenTree* stmt)
7759	{
7760	fgWalkTree(&stmt->gtStmt.gtStmtExpr, fgUpdateSideEffectsPre, fgUpdateSideEffectsPost);
7761	}
7762
7763	//------------------------------------------------------------------------
7764	// gtUpdateNodeOperSideEffects: Update the side effects based on the node operation.
7765	//
7766	// Arguments:
7767	// tree - Tree to update the side effects on
7768	//
7769	// Notes:
7770	// This method currently only updates GTF_EXCEPT, GTF_ASG, and GTF_CALL flags.
7771	// The other side effect flags may remain unnecessarily (conservatively) set.
7772	// The caller of this method is expected to update the flags based on the children's flags.
7773
7774	void Compiler::gtUpdateNodeOperSideEffects(GenTree* tree)
7775	{
7776	if (tree->OperMayThrow(this))
7777	{
7778	tree->gtFlags \|= GTF_EXCEPT;
7779	}
7780	else
7781	{
7782	tree->gtFlags &= ~GTF_EXCEPT;
7783	if (tree->OperIsIndirOrArrLength())
7784	{
7785	tree->gtFlags \|= GTF_IND_NONFAULTING;
7786	}
7787	}
7788
7789	if (tree->OperRequiresAsgFlag())
7790	{
7791	tree->gtFlags \|= GTF_ASG;
7792	}
7793	else
7794	{
7795	tree->gtFlags &= ~GTF_ASG;
7796	}
7797
7798	if (tree->OperRequiresCallFlag(this))
7799	{
7800	tree->gtFlags \|= GTF_CALL;
7801	}
7802	else
7803	{
7804	tree->gtFlags &= ~GTF_CALL;
7805	}
7806	}
7807
7808	//------------------------------------------------------------------------
7809	// gtUpdateNodeSideEffects: Update the side effects based on the node operation and
7810	// children's side efects.
7811	//
7812	// Arguments:
7813	// tree - Tree to update the side effects on
7814	//
7815	// Notes:
7816	// This method currently only updates GTF_EXCEPT and GTF_ASG flags. The other side effect
7817	// flags may remain unnecessarily (conservatively) set.
7818
7819	void Compiler::gtUpdateNodeSideEffects(GenTree* tree)
7820	{
7821	gtUpdateNodeOperSideEffects(tree);
7822	unsigned nChildren = tree->NumChildren();
7823	for (unsigned childNum = `0`; childNum < nChildren; childNum++)
7824	{
7825	GenTree* child = tree->GetChild(childNum);
7826	if (child != nullptr)
7827	{
7828	tree->gtFlags \|= (child->gtFlags & GTF_ALL_EFFECT);
7829	}
7830	}
7831	}
7832
7833	//------------------------------------------------------------------------
7834	// fgUpdateSideEffectsPre: Update the side effects based on the tree operation.
7835	//
7836	// Arguments:
7837	// pTree - Pointer to the tree to update the side effects
7838	// fgWalkPre - Walk data
7839	//
7840	// Notes:
7841	// This method currently only updates GTF_EXCEPT and GTF_ASG flags. The other side effect
7842	// flags may remain unnecessarily (conservatively) set.
7843
7844	Compiler::fgWalkResult Compiler::fgUpdateSideEffectsPre(GenTree** pTree, fgWalkData* fgWalkPre)
7845	{
7846	fgWalkPre->compiler->gtUpdateNodeOperSideEffects(*pTree);
7847
7848	return WALK_CONTINUE;
7849	}
7850
7851	//------------------------------------------------------------------------
7852	// fgUpdateSideEffectsPost: Update the side effects of the parent based on the tree's flags.
7853	//
7854	// Arguments:
7855	// pTree - Pointer to the tree
7856	// fgWalkPost - Walk data
7857	//
7858	// Notes:
7859	// The routine is used for updating the stale side effect flags for ancestor
7860	// nodes starting from treeParent up to the top-level stmt expr.
7861
7862	Compiler::fgWalkResult Compiler::fgUpdateSideEffectsPost(GenTree** pTree, fgWalkData* fgWalkPost)
7863	{
7864	GenTree* tree = *pTree;
7865	GenTree* parent = fgWalkPost->parent;
7866	if (parent != nullptr)
7867	{
7868	parent->gtFlags \|= (tree->gtFlags & GTF_ALL_EFFECT);
7869	}
7870	return WALK_CONTINUE;
7871	}
7872
7873	/*****************************************************************************
7874	*
7875	* Compares two trees and returns true when both trees are the same.
7876	* Instead of fully comparing the two trees this method can just return false.
7877	* Thus callers should not assume that the trees are different when false is returned.
7878	* Only when true is returned can the caller perform code optimizations.
7879	* The current implementation only compares a limited set of LEAF/CONST node
7880	* and returns false for all othere trees.
7881	*/
7882	bool Compiler::gtCompareTree(GenTree* op1, GenTree* op2)
7883	{
7884	/ Make sure that both trees are of the same GT node kind /
7885	if (op1->OperGet() != op2->OperGet())
7886	{
7887	return false;
7888	}
7889
7890	/ Make sure that both trees are returning the same type /
7891	if (op1->gtType != op2->gtType)
7892	{
7893	return false;
7894	}
7895
7896	/ Figure out what kind of a node we have /
7897
7898	genTreeOps oper = op1->OperGet();
7899	unsigned kind = op1->OperKind();
7900
7901	/ Is this a constant or leaf node? /
7902
7903	if (kind & (GTK_CONST \| GTK_LEAF))
7904	{
7905	switch (oper)
7906	{
7907	case GT_CNS_INT:
7908	if ((op1->gtIntCon.gtIconVal == op2->gtIntCon.gtIconVal) && GenTree::SameIconHandleFlag(op1, op2))
7909	{
7910	return true;
7911	}
7912	break;
7913
7914	case GT_CNS_LNG:
7915	if (op1->gtLngCon.gtLconVal == op2->gtLngCon.gtLconVal)
7916	{
7917	return true;
7918	}
7919	break;
7920
7921	case GT_CNS_STR:
7922	if (op1->gtStrCon.gtSconCPX == op2->gtStrCon.gtSconCPX)
7923	{
7924	return true;
7925	}
7926	break;
7927
7928	case GT_LCL_VAR:
7929	if (op1->gtLclVarCommon.gtLclNum == op2->gtLclVarCommon.gtLclNum)
7930	{
7931	return true;
7932	}
7933	break;
7934
7935	case GT_CLS_VAR:
7936	if (op1->gtClsVar.gtClsVarHnd == op2->gtClsVar.gtClsVarHnd)
7937	{
7938	return true;
7939	}
7940	break;
7941
7942	default:
7943	// we return false for these unhandled 'oper' kinds
7944	break;
7945	}
7946	}
7947	return false;
7948	}
7949
7950	GenTree* Compiler::gtGetThisArg(GenTreeCall* call)
7951	{
7952	if (call->gtCallObjp != nullptr)
7953	{
7954	if (call->gtCallObjp->gtOper != GT_NOP && call->gtCallObjp->gtOper != GT_ASG)
7955	{
7956	if (!(call->gtCallObjp->gtFlags & GTF_LATE_ARG))
7957	{
7958	return call->gtCallObjp;
7959	}
7960	}
7961
7962	if (call->gtCallLateArgs)
7963	{
7964	regNumber thisReg = REG_ARG_0;
7965	unsigned argNum = `0`;
7966	fgArgTabEntry* thisArgTabEntry = gtArgEntryByArgNum(call, argNum);
7967	GenTree* result = thisArgTabEntry->node;
7968
7969	#if !FEATURE_FIXED_OUT_ARGS
7970	GenTree* lateArgs = call->gtCallLateArgs;
7971	regList list = call->regArgList;
7972	int index = `0`;
7973	while (lateArgs != NULL)
7974	{
7975	assert(lateArgs->gtOper == GT_LIST);
7976	assert(index < call->regArgListCount);
7977	regNumber curArgReg = list[index];
7978	if (curArgReg == thisReg)
7979	{
7980	if (optAssertionPropagatedCurrentStmt)
7981	result = lateArgs->gtOp.gtOp1;
7982
7983	assert(result == lateArgs->gtOp.gtOp1);
7984	}
7985
7986	lateArgs = lateArgs->gtOp.gtOp2;
7987	index++;
7988	}
7989	#endif
7990	return result;
7991	}
7992	}
7993	return nullptr;
7994	}
7995
7996	bool GenTree::gtSetFlags() const
7997	{
7998	//
7999	// When FEATURE_SET_FLAGS (_TARGET_ARM_) is active the method returns true
8000	// when the gtFlags has the flag GTF_SET_FLAGS set
8001	// otherwise the architecture will be have instructions that typically set
8002	// the flags and this method will return true.
8003	//
8004	// Exceptions: GT_IND (load/store) is not allowed to set the flags
8005	// and on XARCH the GT_MUL/GT_DIV and all overflow instructions
8006	// do not set the condition flags
8007	//
8008	// Precondition we have a GTK_SMPOP
8009	//
8010	if (!varTypeIsIntegralOrI(TypeGet()) && (TypeGet() != TYP_VOID))
8011	{
8012	return false;
8013	}
8014
8015	if (((gtFlags & GTF_SET_FLAGS) != `0`) && (gtOper != GT_IND))
8016	{
8017	// GTF_SET_FLAGS is not valid on GT_IND and is overlaid with GTF_NONFAULTING_IND
8018	return true;
8019	}
8020	else
8021	{
8022	return false;
8023	}
8024	}
8025
8026	bool GenTree::gtRequestSetFlags()
8027	{
8028	bool result = false;
8029
8030	#if FEATURE_SET_FLAGS
8031	// This method is a Nop unless FEATURE_SET_FLAGS is defined
8032
8033	// In order to set GTF_SET_FLAGS
8034	// we must have a GTK_SMPOP
8035	// and we have a integer or machine size type (not floating point or TYP_LONG on 32-bit)
8036	//
8037	if (!OperIsSimple())
8038	return false;
8039
8040	if (!varTypeIsIntegralOrI(TypeGet()))
8041	return false;
8042
8043	switch (gtOper)
8044	{
8045	case GT_IND:
8046	case GT_ARR_LENGTH:
8047	// These will turn into simple load from memory instructions
8048	// and we can't force the setting of the flags on load from memory
8049	break;
8050
8051	case GT_MUL:
8052	case GT_DIV:
8053	// These instructions don't set the flags (on x86/x64)
8054	//
8055	break;
8056
8057	default:
8058	// Otherwise we can set the flags for this gtOper
8059	// and codegen must set the condition flags.
8060	//
8061	gtFlags \|= GTF_SET_FLAGS;
8062	result = true;
8063	break;
8064	}
8065	#endif // FEATURE_SET_FLAGS
8066
8067	// Codegen for this tree must set the condition flags if
8068	// this method returns true.
8069	//
8070	return result;
8071	}
8072
8073	unsigned GenTree::NumChildren()
8074	{
8075	if (OperIsConst() \|\| OperIsLeaf())
8076	{
8077	return `0`;
8078	}
8079	else if (OperIsUnary())
8080	{
8081	if (OperGet() == GT_NOP \|\| OperGet() == GT_RETURN \|\| OperGet() == GT_RETFILT)
8082	{
8083	if (gtOp.gtOp1 == nullptr)
8084	{
8085	return `0`;
8086	}
8087	else
8088	{
8089	return `1`;
8090	}
8091	}
8092	else
8093	{
8094	return `1`;
8095	}
8096	}
8097	else if (OperIsBinary())
8098	{
8099	// All binary operators except LEA have at least one arg; the second arg may sometimes be null, however.
8100	if (OperGet() == GT_LEA)
8101	{
8102	unsigned childCount = `0`;
8103	if (gtOp.gtOp1 != nullptr)
8104	{
8105	childCount++;
8106	}
8107	if (gtOp.gtOp2 != nullptr)
8108	{
8109	childCount++;
8110	}
8111	return childCount;
8112	}
8113	#ifdef FEATURE_HW_INTRINSICS
8114	// GT_HWIntrinsic require special handling
8115	if (OperGet() == GT_HWIntrinsic)
8116	{
8117	if (gtOp.gtOp1 == nullptr)
8118	{
8119	return `0`;
8120	}
8121	}
8122	#endif
8123	assert(gtOp.gtOp1 != nullptr);
8124	if (gtOp.gtOp2 == nullptr)
8125	{
8126	return `1`;
8127	}
8128	else
8129	{
8130	return `2`;
8131	}
8132	}
8133	else
8134	{
8135	// Special
8136	switch (OperGet())
8137	{
8138	case GT_CMPXCHG:
8139	return `3`;
8140
8141	case GT_ARR_BOUNDS_CHECK:
8142	#ifdef FEATURE_SIMD
8143	case GT_SIMD_CHK:
8144	#endif // FEATURE_SIMD
8145	#ifdef FEATURE_HW_INTRINSICS
8146	case GT_HW_INTRINSIC_CHK:
8147	#endif // FEATURE_HW_INTRINSICS
8148	return `2`;
8149
8150	case GT_FIELD:
8151	case GT_STMT:
8152	return `1`;
8153
8154	case GT_ARR_ELEM:
8155	return `1` + AsArrElem()->gtArrRank;
8156
8157	case GT_DYN_BLK:
8158	return `2`;
8159
8160	case GT_ARR_OFFSET:
8161	case GT_STORE_DYN_BLK:
8162	return `3`;
8163
8164	case GT_CALL:
8165	{
8166	GenTreeCall* call = AsCall();
8167	unsigned res = `0`; // arg list(s) (including late args).
8168	if (call->gtCallObjp != nullptr)
8169	{
8170	res++; // Add objp?
8171	}
8172	if (call->gtCallArgs != nullptr)
8173	{
8174	res++; // Add args?
8175	}
8176	if (call->gtCallLateArgs != nullptr)
8177	{
8178	res++; // Add late args?
8179	}
8180	if (call->gtControlExpr != nullptr)
8181	{
8182	res++;
8183	}
8184
8185	if (call->gtCallType == CT_INDIRECT)
8186	{
8187	if (call->gtCallCookie != nullptr)
8188	{
8189	res++;
8190	}
8191	if (call->gtCallAddr != nullptr)
8192	{
8193	res++;
8194	}
8195	}
8196	return res;
8197	}
8198	case GT_NONE:
8199	return `0`;
8200	default:
8201	unreached();
8202	}
8203	}
8204	}
8205
8206	GenTree* GenTree::GetChild(unsigned childNum)
8207	{
8208	assert(childNum < NumChildren()); // Precondition.
8209	assert(NumChildren() <= MAX_CHILDREN);
8210	assert(!(OperIsConst() \|\| OperIsLeaf()));
8211	if (OperIsUnary())
8212	{
8213	return AsUnOp()->gtOp1;
8214	}
8215	// Special case for assignment of dynamic block.
8216	// This code is here to duplicate the former case where the size may be evaluated prior to the
8217	// source and destination addresses. In order to do this, we treat the size as a child of the
8218	// assignment.
8219	// TODO-1stClassStructs: Revisit the need to duplicate former behavior, so that we can remove
8220	// these special cases.
8221	if ((OperGet() == GT_ASG) && (gtOp.gtOp1->OperGet() == GT_DYN_BLK) && (childNum == `2`))
8222	{
8223	return gtOp.gtOp1->AsDynBlk()->gtDynamicSize;
8224	}
8225	else if (OperIsBinary())
8226	{
8227	if (OperIsAddrMode())
8228	{
8229	// If this is the first (0th) child, only return op1 if it is non-null
8230	// Otherwise, we return gtOp2.
8231	if (childNum == `0` && AsOp()->gtOp1 != nullptr)
8232	{
8233	return AsOp()->gtOp1;
8234	}
8235	return AsOp()->gtOp2;
8236	}
8237	// TODO-Cleanup: Consider handling ReverseOps here, and then we wouldn't have to handle it in
8238	// fgGetFirstNode(). However, it seems that it causes loop hoisting behavior to change.
8239	if (childNum == `0`)
8240	{
8241	return AsOp()->gtOp1;
8242	}
8243	else
8244	{
8245	return AsOp()->gtOp2;
8246	}
8247	}
8248	else
8249	{
8250	// Special
8251	switch (OperGet())
8252	{
8253	case GT_CMPXCHG:
8254	switch (childNum)
8255	{
8256	case `0`:
8257	return AsCmpXchg()->gtOpLocation;
8258	case `1`:
8259	return AsCmpXchg()->gtOpValue;
8260	case `2`:
8261	return AsCmpXchg()->gtOpComparand;
8262	default:
8263	unreached();
8264	}
8265	case GT_ARR_BOUNDS_CHECK:
8266	#ifdef FEATURE_SIMD
8267	case GT_SIMD_CHK:
8268	#endif // FEATURE_SIMD
8269	#ifdef FEATURE_HW_INTRINSICS
8270	case GT_HW_INTRINSIC_CHK:
8271	#endif // FEATURE_HW_INTRINSICS
8272	switch (childNum)
8273	{
8274	case `0`:
8275	return AsBoundsChk()->gtIndex;
8276	case `1`:
8277	return AsBoundsChk()->gtArrLen;
8278	default:
8279	unreached();
8280	}
8281
8282	case GT_STORE_DYN_BLK:
8283	switch (childNum)
8284	{
8285	case `0`:
8286	return AsDynBlk()->Addr();
8287	case `1`:
8288	return AsDynBlk()->Data();
8289	case `2`:
8290	return AsDynBlk()->gtDynamicSize;
8291	default:
8292	unreached();
8293	}
8294	case GT_DYN_BLK:
8295	switch (childNum)
8296	{
8297	case `0`:
8298	return AsDynBlk()->gtEvalSizeFirst ? AsDynBlk()->gtDynamicSize : AsDynBlk()->Addr();
8299	case `1`:
8300	return AsDynBlk()->gtEvalSizeFirst ? AsDynBlk()->Addr() : AsDynBlk()->gtDynamicSize;
8301	default:
8302	unreached();
8303	}
8304
8305	case GT_FIELD:
8306	return AsField()->gtFldObj;
8307
8308	case GT_STMT:
8309	return AsStmt()->gtStmtExpr;
8310
8311	case GT_ARR_ELEM:
8312	if (childNum == `0`)
8313	{
8314	return AsArrElem()->gtArrObj;
8315	}
8316	else
8317	{
8318	return AsArrElem()->gtArrInds[childNum - `1`];
8319	}
8320
8321	case GT_ARR_OFFSET:
8322	switch (childNum)
8323	{
8324	case `0`:
8325	return AsArrOffs()->gtOffset;
8326	case `1`:
8327	return AsArrOffs()->gtIndex;
8328	case `2`:
8329	return AsArrOffs()->gtArrObj;
8330	default:
8331	unreached();
8332	}
8333
8334	case GT_CALL:
8335	{
8336	// The if chain below assumes that all possible children are non-null.
8337	// If some are null, "virtually skip them."
8338	// If there isn't "virtually skip it."
8339	GenTreeCall* call = AsCall();
8340
8341	if (call->gtCallObjp == nullptr)
8342	{
8343	childNum++;
8344	}
8345	if (childNum >= `1` && call->gtCallArgs == nullptr)
8346	{
8347	childNum++;
8348	}
8349	if (childNum >= `2` && call->gtCallLateArgs == nullptr)
8350	{
8351	childNum++;
8352	}
8353	if (childNum >= `3` && call->gtControlExpr == nullptr)
8354	{
8355	childNum++;
8356	}
8357	if (call->gtCallType == CT_INDIRECT)
8358	{
8359	if (childNum >= `4` && call->gtCallCookie == nullptr)
8360	{
8361	childNum++;
8362	}
8363	}
8364
8365	if (childNum == `0`)
8366	{
8367	return call->gtCallObjp;
8368	}
8369	else if (childNum == `1`)
8370	{
8371	return call->gtCallArgs;
8372	}
8373	else if (childNum == `2`)
8374	{
8375	return call->gtCallLateArgs;
8376	}
8377	else if (childNum == `3`)
8378	{
8379	return call->gtControlExpr;
8380	}
8381	else
8382	{
8383	assert(call->gtCallType == CT_INDIRECT);
8384	if (childNum == `4`)
8385	{
8386	return call->gtCallCookie;
8387	}
8388	else
8389	{
8390	assert(childNum == `5`);
8391	return call->gtCallAddr;
8392	}
8393	}
8394	}
8395	case GT_NONE:
8396	unreached();
8397	default:
8398	unreached();
8399	}
8400	}
8401	}
8402
8403	GenTreeUseEdgeIterator::GenTreeUseEdgeIterator()
8404	: m_advance(nullptr), m_node(nullptr), m_edge(nullptr), m_argList(nullptr), m_state(-`1`)
8405	{
8406	}
8407
8408	GenTreeUseEdgeIterator::GenTreeUseEdgeIterator(GenTree* node)
8409	: m_advance(nullptr), m_node(node), m_edge(nullptr), m_argList(nullptr), m_state(`0`)
8410	{
8411	assert(m_node != nullptr);
8412
8413	// NOTE: the switch statement below must be updated when introducing new nodes.
8414
8415	switch (m_node->OperGet())
8416	{
8417	// Leaf nodes
8418	case GT_LCL_VAR:
8419	case GT_LCL_FLD:
8420	case GT_LCL_VAR_ADDR:
8421	case GT_LCL_FLD_ADDR:
8422	case GT_CATCH_ARG:
8423	case GT_LABEL:
8424	case GT_FTN_ADDR:
8425	case GT_RET_EXPR:
8426	case GT_CNS_INT:
8427	case GT_CNS_LNG:
8428	case GT_CNS_DBL:
8429	case GT_CNS_STR:
8430	case GT_MEMORYBARRIER:
8431	case GT_JMP:
8432	case GT_JCC:
8433	case GT_SETCC:
8434	case GT_NO_OP:
8435	case GT_START_NONGC:
8436	case GT_PROF_HOOK:
8437	#if !FEATURE_EH_FUNCLETS
8438	case GT_END_LFIN:
8439	#endif // !FEATURE_EH_FUNCLETS
8440	case GT_PHI_ARG:
8441	case GT_JMPTABLE:
8442	case GT_CLS_VAR:
8443	case GT_CLS_VAR_ADDR:
8444	case GT_ARGPLACE:
8445	case GT_PHYSREG:
8446	case GT_EMITNOP:
8447	case GT_PINVOKE_PROLOG:
8448	case GT_PINVOKE_EPILOG:
8449	case GT_IL_OFFSET:
8450	m_state = -`1`;
8451	return;
8452
8453	// Standard unary operators
8454	case GT_STORE_LCL_VAR:
8455	case GT_STORE_LCL_FLD:
8456	case GT_NOT:
8457	case GT_NEG:
8458	case GT_COPY:
8459	case GT_RELOAD:
8460	case GT_ARR_LENGTH:
8461	case GT_CAST:
8462	case GT_BITCAST:
8463	case GT_CKFINITE:
8464	case GT_LCLHEAP:
8465	case GT_ADDR:
8466	case GT_IND:
8467	case GT_OBJ:
8468	case GT_BLK:
8469	case GT_BOX:
8470	case GT_ALLOCOBJ:
8471	case GT_RUNTIMELOOKUP:
8472	case GT_INIT_VAL:
8473	case GT_JTRUE:
8474	case GT_SWITCH:
8475	case GT_NULLCHECK:
8476	case GT_PUTARG_REG:
8477	case GT_PUTARG_STK:
8478	case GT_BSWAP:
8479	case GT_BSWAP16:
8480	#if FEATURE_ARG_SPLIT
8481	case GT_PUTARG_SPLIT:
8482	#endif // FEATURE_ARG_SPLIT
8483	case GT_RETURNTRAP:
8484	m_edge = &m_node->AsUnOp()->gtOp1;
8485	assert(m_edge != nullptr*);
8486	m_advance = &GenTreeUseEdgeIterator::Terminate;
8487	return;
8488
8489	// Unary operators with an optional operand
8490	case GT_NOP:
8491	case GT_RETURN:
8492	case GT_RETFILT:
8493	if (m_node->AsUnOp()->gtOp1 == nullptr)
8494	{
8495	assert(m_node->NullOp1Legal());
8496	m_state = -`1`;
8497	}
8498	else
8499	{
8500	m_edge = &m_node->AsUnOp()->gtOp1;
8501	m_advance = &GenTreeUseEdgeIterator::Terminate;
8502	}
8503	return;
8504
8505	// Variadic nodes
8506	case GT_PHI:
8507	SetEntryStateForList(m_node->AsUnOp()->gtOp1);
8508	return;
8509
8510	case GT_FIELD_LIST:
8511	SetEntryStateForList(m_node);
8512	return;
8513
8514	#ifdef FEATURE_SIMD
8515	case GT_SIMD:
8516	if (m_node->AsSIMD()->gtSIMDIntrinsicID == SIMDIntrinsicInitN)
8517	{
8518	SetEntryStateForList(m_node->AsSIMD()->gtOp1);
8519	}
8520	else
8521	{
8522	SetEntryStateForBinOp();
8523	}
8524	return;
8525	#endif // FEATURE_SIMD
8526
8527	#ifdef FEATURE_HW_INTRINSICS
8528	case GT_HWIntrinsic:
8529	if (m_node->AsHWIntrinsic()->gtOp1 == nullptr)
8530	{
8531	assert(m_node->NullOp1Legal());
8532	m_state = -`1`;
8533	}
8534	else if (m_node->AsHWIntrinsic()->gtOp1->OperIsList())
8535	{
8536	SetEntryStateForList(m_node->AsHWIntrinsic()->gtOp1);
8537	}
8538	else
8539	{
8540	SetEntryStateForBinOp();
8541	}
8542	return;
8543	#endif // FEATURE_HW_INTRINSICS
8544
8545	// LEA, which may have no first operand
8546	case GT_LEA:
8547	if (m_node->AsAddrMode()->gtOp1 == nullptr)
8548	{
8549	m_edge = &m_node->AsAddrMode()->gtOp2;
8550	m_advance = &GenTreeUseEdgeIterator::Terminate;
8551	}
8552	else
8553	{
8554	SetEntryStateForBinOp();
8555	}
8556	return;
8557
8558	// Special nodes
8559	case GT_CMPXCHG:
8560	m_edge = &m_node->AsCmpXchg()->gtOpLocation;
8561	assert(m_edge != nullptr*);
8562	m_advance = &GenTreeUseEdgeIterator::AdvanceCmpXchg;
8563	return;
8564
8565	case GT_ARR_BOUNDS_CHECK:
8566	#ifdef FEATURE_SIMD
8567	case GT_SIMD_CHK:
8568	#endif // FEATURE_SIMD
8569	#ifdef FEATURE_HW_INTRINSICS
8570	case GT_HW_INTRINSIC_CHK:
8571	#endif // FEATURE_HW_INTRINSICS
8572	m_edge = &m_node->AsBoundsChk()->gtIndex;
8573	assert(m_edge != nullptr*);
8574	m_advance = &GenTreeUseEdgeIterator::AdvanceBoundsChk;
8575	return;
8576
8577	case GT_FIELD:
8578	if (m_node->AsField()->gtFldObj == nullptr)
8579	{
8580	m_state = -`1`;
8581	}
8582	else
8583	{
8584	m_edge = &m_node->AsField()->gtFldObj;
8585	m_advance = &GenTreeUseEdgeIterator::Terminate;
8586	}
8587	return;
8588
8589	case GT_STMT:
8590	if (m_node->AsStmt()->gtStmtExpr == nullptr)
8591	{
8592	m_state = -`1`;
8593	}
8594	else
8595	{
8596	m_edge = &m_node->AsStmt()->gtStmtExpr;
8597	m_advance = &GenTreeUseEdgeIterator::Terminate;
8598	}
8599	return;
8600
8601	case GT_ARR_ELEM:
8602	m_edge = &m_node->AsArrElem()->gtArrObj;
8603	assert(m_edge != nullptr*);
8604	m_advance = &GenTreeUseEdgeIterator::AdvanceArrElem;
8605	return;
8606
8607	case GT_ARR_OFFSET:
8608	m_edge = &m_node->AsArrOffs()->gtOffset;
8609	assert(m_edge != nullptr*);
8610	m_advance = &GenTreeUseEdgeIterator::AdvanceArrOffset;
8611	return;
8612
8613	case GT_DYN_BLK:
8614	{
8615	GenTreeDynBlk* const dynBlock = m_node->AsDynBlk();
8616	m_edge = dynBlock->gtEvalSizeFirst ? &dynBlock->gtDynamicSize : &dynBlock->gtOp1;
8617	assert(m_edge != nullptr*);
8618	m_advance = &GenTreeUseEdgeIterator::AdvanceDynBlk;
8619	}
8620	return;
8621
8622	case GT_STORE_DYN_BLK:
8623	{
8624	GenTreeDynBlk* const dynBlock = m_node->AsDynBlk();
8625	if (dynBlock->gtEvalSizeFirst)
8626	{
8627	m_edge = &dynBlock->gtDynamicSize;
8628	}
8629	else
8630	{
8631	m_edge = dynBlock->IsReverseOp() ? &dynBlock->gtOp2 : &dynBlock->gtOp1;
8632	}
8633	assert(m_edge != nullptr*);
8634
8635	m_advance = &GenTreeUseEdgeIterator::AdvanceStoreDynBlk;
8636	}
8637	return;
8638
8639	case GT_CALL:
8640	AdvanceCall<CALL_INSTANCE>();
8641	return;
8642
8643	// Binary nodes
8644	default:
8645	assert(m_node->OperIsBinary());
8646	SetEntryStateForBinOp();
8647	return;
8648	}
8649	}
8650
8651	//------------------------------------------------------------------------
8652	// GenTreeUseEdgeIterator::AdvanceCmpXchg: produces the next operand of a CmpXchg node and advances the state.
8653	//
8654	void GenTreeUseEdgeIterator::AdvanceCmpXchg()
8655	{
8656	switch (m_state)
8657	{
8658	case `0`:
8659	m_edge = &m_node->AsCmpXchg()->gtOpValue;
8660	m_state = `1`;
8661	break;
8662	case `1`:
8663	m_edge = &m_node->AsCmpXchg()->gtOpComparand;
8664	m_advance = &GenTreeUseEdgeIterator::Terminate;
8665	break;
8666	default:
8667	unreached();
8668	}
8669
8670	assert(m_edge != nullptr*);
8671	}
8672
8673	//------------------------------------------------------------------------
8674	// GenTreeUseEdgeIterator::AdvanceBoundsChk: produces the next operand of a BoundsChk node and advances the state.
8675	//
8676	void GenTreeUseEdgeIterator::AdvanceBoundsChk()
8677	{
8678	m_edge = &m_node->AsBoundsChk()->gtArrLen;
8679	assert(m_edge != nullptr*);
8680	m_advance = &GenTreeUseEdgeIterator::Terminate;
8681	}
8682
8683	//------------------------------------------------------------------------
8684	// GenTreeUseEdgeIterator::AdvanceArrElem: produces the next operand of a ArrElem node and advances the state.
8685	//
8686	// Because these nodes are variadic, this function uses `m_state` to index into the list of array indices.
8687	//
8688	void GenTreeUseEdgeIterator::AdvanceArrElem()
8689	{
8690	if (m_state < m_node->AsArrElem()->gtArrRank)
8691	{
8692	m_edge = &m_node->AsArrElem()->gtArrInds[m_state];
8693	assert(m_edge != nullptr*);
8694	m_state++;
8695	}
8696	else
8697	{
8698	m_state = -`1`;
8699	}
8700	}
8701
8702	//------------------------------------------------------------------------
8703	// GenTreeUseEdgeIterator::AdvanceArrOffset: produces the next operand of a ArrOffset node and advances the state.
8704	//
8705	void GenTreeUseEdgeIterator::AdvanceArrOffset()
8706	{
8707	switch (m_state)
8708	{
8709	case `0`:
8710	m_edge = &m_node->AsArrOffs()->gtIndex;
8711	m_state = `1`;
8712	break;
8713	case `1`:
8714	m_edge = &m_node->AsArrOffs()->gtArrObj;
8715	m_advance = &GenTreeUseEdgeIterator::Terminate;
8716	break;
8717	default:
8718	unreached();
8719	}
8720
8721	assert(m_edge != nullptr*);
8722	}
8723
8724	//------------------------------------------------------------------------
8725	// GenTreeUseEdgeIterator::AdvanceDynBlk: produces the next operand of a DynBlk node and advances the state.
8726	//
8727	void GenTreeUseEdgeIterator::AdvanceDynBlk()
8728	{
8729	GenTreeDynBlk* const dynBlock = m_node->AsDynBlk();
8730
8731	m_edge = dynBlock->gtEvalSizeFirst ? &dynBlock->gtOp1 : &dynBlock->gtDynamicSize;
8732	assert(m_edge != nullptr*);
8733	m_advance = &GenTreeUseEdgeIterator::Terminate;
8734	}
8735
8736	//------------------------------------------------------------------------
8737	// GenTreeUseEdgeIterator::AdvanceStoreDynBlk: produces the next operand of a StoreDynBlk node and advances the state.
8738	//
8739	// These nodes are moderately complicated but rare enough that templating this function is probably not
8740	// worth the extra complexity.
8741	//
8742	void GenTreeUseEdgeIterator::AdvanceStoreDynBlk()
8743	{
8744	GenTreeDynBlk* const dynBlock = m_node->AsDynBlk();
8745	if (dynBlock->gtEvalSizeFirst)
8746	{
8747	switch (m_state)
8748	{
8749	case `0`:
8750	m_edge = dynBlock->IsReverseOp() ? &dynBlock->gtOp2 : &dynBlock->gtOp1;
8751	m_state = `1`;
8752	break;
8753	case `1`:
8754	m_edge = dynBlock->IsReverseOp() ? &dynBlock->gtOp1 : &dynBlock->gtOp2;
8755	m_advance = &GenTreeUseEdgeIterator::Terminate;
8756	break;
8757	default:
8758	unreached();
8759	}
8760	}
8761	else
8762	{
8763	switch (m_state)
8764	{
8765	case `0`:
8766	m_edge = dynBlock->IsReverseOp() ? &dynBlock->gtOp1 : &dynBlock->gtOp2;
8767	m_state = `1`;
8768	break;
8769	case `1`:
8770	m_edge = &dynBlock->gtDynamicSize;
8771	m_advance = &GenTreeUseEdgeIterator::Terminate;
8772	break;
8773	default:
8774	unreached();
8775	}
8776	}
8777
8778	assert(m_edge != nullptr*);
8779	}
8780
8781	//------------------------------------------------------------------------
8782	// GenTreeUseEdgeIterator::AdvanceBinOp: produces the next operand of a binary node and advances the state.
8783	//
8784	// This function must be instantiated s.t. `ReverseOperands` is `true` iff the node is marked with the
8785	// `GTF_REVERSE_OPS` flag.
8786	//
8787	template <bool ReverseOperands>
8788	void GenTreeUseEdgeIterator::AdvanceBinOp()
8789	{
8790	assert(ReverseOperands == ((m_node->gtFlags & GTF_REVERSE_OPS) != `0`));
8791
8792	m_edge = !ReverseOperands ? &m_node->AsOp()->gtOp2 : &m_node->AsOp()->gtOp1;
8793	assert(m_edge != nullptr*);
8794	m_advance = &GenTreeUseEdgeIterator::Terminate;
8795	}
8796
8797	//------------------------------------------------------------------------
8798	// GenTreeUseEdgeIterator::SetEntryStateForBinOp: produces the first operand of a binary node and chooses
8799	// the appropriate advance function.
8800	//
8801	void GenTreeUseEdgeIterator::SetEntryStateForBinOp()
8802	{
8803	assert(m_node != nullptr);
8804	assert(m_node->OperIsBinary());
8805
8806	GenTreeOp* const node = m_node->AsOp();
8807
8808	if (node->gtOp2 == nullptr)
8809	{
8810	assert(node->gtOp1 != nullptr);
8811	assert(node->NullOp2Legal());
8812	m_edge = &node->gtOp1;
8813	m_advance = &GenTreeUseEdgeIterator::Terminate;
8814	}
8815	else if ((node->gtFlags & GTF_REVERSE_OPS) != `0`)
8816	{
8817	m_edge = &m_node->AsOp()->gtOp2;
8818	m_advance = &GenTreeUseEdgeIterator::AdvanceBinOp<true>;
8819	}
8820	else
8821	{
8822	m_edge = &m_node->AsOp()->gtOp1;
8823	m_advance = &GenTreeUseEdgeIterator::AdvanceBinOp<false>;
8824	}
8825	}
8826
8827	//------------------------------------------------------------------------
8828	// GenTreeUseEdgeIterator::AdvanceList: produces the next operand of a variadic node and advances the state.
8829	//
8830	// This function does not use `m_state` for anything meaningful; it simply walks the `m_argList` until
8831	// there are no further entries.
8832	//
8833	void GenTreeUseEdgeIterator::AdvanceList()
8834	{
8835	assert(m_state == `0`);
8836
8837	if (m_argList == nullptr)
8838	{
8839	m_state = -`1`;
8840	}
8841	else
8842	{
8843	GenTreeArgList* listNode = m_argList->AsArgList();
8844	m_edge = &listNode->gtOp1;
8845	m_argList = listNode->Rest();
8846	}
8847	}
8848
8849	//------------------------------------------------------------------------
8850	// GenTreeUseEdgeIterator::SetEntryStateForList: produces the first operand of a list node.
8851	//
8852	void GenTreeUseEdgeIterator::SetEntryStateForList(GenTree* list)
8853	{
8854	m_argList = list;
8855	m_advance = &GenTreeUseEdgeIterator::AdvanceList;
8856	AdvanceList();
8857	}
8858
8859	//------------------------------------------------------------------------
8860	// GenTreeUseEdgeIterator::AdvanceCall: produces the next operand of a call node and advances the state.
8861	//
8862	// This function is a bit tricky: in order to avoid doing unnecessary work, it is instantiated with the
8863	// state number the iterator will be in when it is called. For example, `AdvanceCall<CALL_INSTANCE>`
8864	// is the instantiation used when the iterator is at the `CALL_INSTANCE` state (i.e. the entry state).
8865	// This sort of templating allows each state to avoid processing earlier states without unnecessary
8866	// duplication of code.
8867	//
8868	// Note that this method expands the argument lists (`gtCallArgs` and `gtCallLateArgs`) into their
8869	// component operands.
8870	//
8871	template <int state>
8872	void GenTreeUseEdgeIterator::AdvanceCall()
8873	{
8874	GenTreeCall* const call = m_node->AsCall();
8875
8876	switch (state)
8877	{
8878	case CALL_INSTANCE:
8879	m_argList = call->gtCallArgs;
8880	m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_ARGS>;
8881	if (call->gtCallObjp != nullptr)
8882	{
8883	m_edge = &call->gtCallObjp;
8884	return;
8885	}
8886	__fallthrough;
8887
8888	case CALL_ARGS:
8889	if (m_argList != nullptr)
8890	{
8891	GenTreeArgList* argNode = m_argList->AsArgList();
8892	m_edge = &argNode->gtOp1;
8893	m_argList = argNode->Rest();
8894	return;
8895	}
8896	m_argList = call->gtCallLateArgs;
8897	m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_LATE_ARGS>;
8898	__fallthrough;
8899
8900	case CALL_LATE_ARGS:
8901	if (m_argList != nullptr)
8902	{
8903	GenTreeArgList* argNode = m_argList->AsArgList();
8904	m_edge = &argNode->gtOp1;
8905	m_argList = argNode->Rest();
8906	return;
8907	}
8908	m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_CONTROL_EXPR>;
8909	__fallthrough;
8910
8911	case CALL_CONTROL_EXPR:
8912	if (call->gtControlExpr != nullptr)
8913	{
8914	if (call->gtCallType == CT_INDIRECT)
8915	{
8916	m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_COOKIE>;
8917	}
8918	else
8919	{
8920	m_advance = &GenTreeUseEdgeIterator::Terminate;
8921	}
8922	m_edge = &call->gtControlExpr;
8923	return;
8924	}
8925	else if (call->gtCallType != CT_INDIRECT)
8926	{
8927	m_state = -`1`;
8928	return;
8929	}
8930	__fallthrough;
8931
8932	case CALL_COOKIE:
8933	assert(call->gtCallType == CT_INDIRECT);
8934
8935	m_advance = &GenTreeUseEdgeIterator::AdvanceCall<CALL_ADDRESS>;
8936	if (call->gtCallCookie != nullptr)
8937	{
8938	m_edge = &call->gtCallCookie;
8939	return;
8940	}
8941	__fallthrough;
8942
8943	case CALL_ADDRESS:
8944	assert(call->gtCallType == CT_INDIRECT);
8945
8946	m_advance = &GenTreeUseEdgeIterator::Terminate;
8947	if (call->gtCallAddr != nullptr)
8948	{
8949	m_edge = &call->gtCallAddr;
8950	}
8951	return;
8952
8953	default:
8954	unreached();
8955	}
8956	}
8957
8958	//------------------------------------------------------------------------
8959	// GenTreeUseEdgeIterator::Terminate: advances the iterator to the terminal state.
8960	//
8961	void GenTreeUseEdgeIterator::Terminate()
8962	{
8963	m_state = -`1`;
8964	}
8965
8966	//------------------------------------------------------------------------
8967	// GenTreeUseEdgeIterator::operator++: advances the iterator to the next operand.
8968	//
8969	GenTreeUseEdgeIterator& GenTreeUseEdgeIterator::operator++()
8970	{
8971	// If we've reached the terminal state, do nothing.
8972	if (m_state != -`1`)
8973	{
8974	(this->*m_advance)();
8975	}
8976
8977	return *this;
8978	}
8979
8980	GenTreeUseEdgeIterator GenTree::UseEdgesBegin()
8981	{
8982	return GenTreeUseEdgeIterator (this);
8983	}
8984
8985	GenTreeUseEdgeIterator GenTree::UseEdgesEnd()
8986	{
8987	return GenTreeUseEdgeIterator ();
8988	}
8989
8990	IteratorPair<GenTreeUseEdgeIterator> GenTree::UseEdges()
8991	{
8992	return MakeIteratorPair(UseEdgesBegin(), UseEdgesEnd());
8993	}
8994
8995	GenTreeOperandIterator GenTree::OperandsBegin()
8996	{
8997	return GenTreeOperandIterator (this);
8998	}
8999
9000	GenTreeOperandIterator GenTree::OperandsEnd()
9001	{
9002	return GenTreeOperandIterator ();
9003	}
9004
9005	IteratorPair<GenTreeOperandIterator> GenTree::Operands()
9006	{
9007	return MakeIteratorPair(OperandsBegin(), OperandsEnd());
9008	}
9009
9010	bool GenTree::Precedes(GenTree* other)
9011	{
9012	assert(other != nullptr);
9013
9014	for (GenTree* node = gtNext; node != nullptr; node = node->gtNext)
9015	{
9016	if (node == other)
9017	{
9018	return true;
9019	}
9020	}
9021
9022	return false;
9023	}
9024
9025	#ifdef DEBUG
9026
9027	/ static / int GenTree::gtDispFlags(unsigned flags, unsigned debugFlags)
9028	{
9029	int charsDisplayed = `11`; // 11 is the "baseline" number of flag characters displayed
9030
9031	printf("%c", (flags & GTF_ASG) ? `'A'` : (IsContained(flags) ? `'c'` : `'-'`));
9032	printf("%c", (flags & GTF_CALL) ? `'C'` : `'-'`);
9033	printf("%c", (flags & GTF_EXCEPT) ? `'X'` : `'-'`);
9034	printf("%c", (flags & GTF_GLOB_REF) ? `'G'` : `'-'`);
9035	printf("%c", (debugFlags & GTF_DEBUG_NODE_MORPHED) ? `'+'` : // First print '+' if GTF_DEBUG_NODE_MORPHED is set
9036	(flags & GTF_ORDER_SIDEEFF) ? `'O'` : `'-'`); // otherwise print 'O' or '-'
9037	printf("%c", (flags & GTF_COLON_COND) ? `'?'` : `'-'`);
9038	printf("%c", (flags & GTF_DONT_CSE) ? `'N'` : // N is for No cse
9039	(flags & GTF_MAKE_CSE) ? `'H'` : `'-'`); // H is for Hoist this expr
9040	printf("%c", (flags & GTF_REVERSE_OPS) ? `'R'` : `'-'`);
9041	printf("%c", (flags & GTF_UNSIGNED) ? `'U'` : (flags & GTF_BOOLEAN) ? `'B'` : `'-'`);
9042	#if FEATURE_SET_FLAGS
9043	printf("%c", (flags & GTF_SET_FLAGS) ? `'S'` : `'-'`);
9044	++charsDisplayed;
9045	#endif
9046	printf("%c", (flags & GTF_LATE_ARG) ? `'L'` : `'-'`);
9047	printf("%c", (flags & GTF_SPILLED) ? `'z'` : (flags & GTF_SPILL) ? `'Z'` : `'-'`);
9048
9049	return charsDisplayed;
9050	}
9051
9052	/***************************************************************************/
9053
9054	void Compiler::gtDispNodeName(GenTree* tree)
9055	{
9056	/ print the node name /
9057
9058	const char* name;
9059
9060	assert(tree);
9061	if (tree->gtOper < GT_COUNT)
9062	{
9063	name = GenTree::OpName(tree->OperGet());
9064	}
9065	else
9066	{
9067	name = "<ERROR>";
9068	}
9069	char buf[`32`];
9070	char* bufp = &buf[`0`];
9071
9072	if ((tree->gtOper == GT_CNS_INT) && tree->IsIconHandle())
9073	{
9074	sprintf_s(bufp, sizeof(buf), " %s(h)%c", name, `0`);
9075	}
9076	else if (tree->gtOper == GT_PUTARG_STK)
9077	{
9078	sprintf_s(bufp, sizeof(buf), " %s [+0x%02x]%c", name, tree->AsPutArgStk()->getArgOffset(), `0`);
9079	}
9080	else if (tree->gtOper == GT_CALL)
9081	{
9082	const char* callType = "CALL";
9083	const char* gtfType = "";
9084	const char* ctType = "";
9085	char gtfTypeBuf[`100`];
9086
9087	if (tree->gtCall.gtCallType == CT_USER_FUNC)
9088	{
9089	if (tree->gtCall.IsVirtual())
9090	{
9091	callType = "CALLV";
9092	}
9093	}
9094	else if (tree->gtCall.gtCallType == CT_HELPER)
9095	{
9096	ctType = " help";
9097	}
9098	else if (tree->gtCall.gtCallType == CT_INDIRECT)
9099	{
9100	ctType = " ind";
9101	}
9102	else
9103	{
9104	assert(!"Unknown gtCallType");
9105	}
9106
9107	if (tree->gtFlags & GTF_CALL_NULLCHECK)
9108	{
9109	gtfType = " nullcheck";
9110	}
9111	if (tree->gtCall.IsVirtualVtable())
9112	{
9113	gtfType = " ind";
9114	}
9115	else if (tree->gtCall.IsVirtualStub())
9116	{
9117	gtfType = " stub";
9118	}
9119	#ifdef FEATURE_READYTORUN_COMPILER
9120	else if (tree->gtCall.IsR2RRelativeIndir())
9121	{
9122	gtfType = " r2r_ind";
9123	}
9124	#endif // FEATURE_READYTORUN_COMPILER
9125	else if (tree->gtFlags & GTF_CALL_UNMANAGED)
9126	{
9127	char* gtfTypeBufWalk = gtfTypeBuf;
9128	gtfTypeBufWalk += SimpleSprintf_s(gtfTypeBufWalk, gtfTypeBuf, sizeof(gtfTypeBuf), " unman");
9129	if (tree->gtFlags & GTF_CALL_POP_ARGS)
9130	{
9131	gtfTypeBufWalk += SimpleSprintf_s(gtfTypeBufWalk, gtfTypeBuf, sizeof(gtfTypeBuf), " popargs");
9132	}
9133	if (tree->gtCall.gtCallMoreFlags & GTF_CALL_M_UNMGD_THISCALL)
9134	{
9135	gtfTypeBufWalk += SimpleSprintf_s(gtfTypeBufWalk, gtfTypeBuf, sizeof(gtfTypeBuf), " thiscall");
9136	}
9137	gtfType = gtfTypeBuf;
9138	}
9139
9140	sprintf_s(bufp, sizeof(buf), " %s%s%s%c", callType, ctType, gtfType, `0`);
9141	}
9142	else if (tree->gtOper == GT_ARR_ELEM)
9143	{
9144	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), " %s[", name);
9145	for (unsigned rank = tree->gtArrElem.gtArrRank - `1`; rank; rank--)
9146	{
9147	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), ",");
9148	}
9149	SimpleSprintf_s(bufp, buf, sizeof(buf), "]");
9150	}
9151	else if (tree->gtOper == GT_ARR_OFFSET \|\| tree->gtOper == GT_ARR_INDEX)
9152	{
9153	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), " %s[", name);
9154	unsigned char currDim;
9155	unsigned char rank;
9156	if (tree->gtOper == GT_ARR_OFFSET)
9157	{
9158	currDim = tree->gtArrOffs.gtCurrDim;
9159	rank = tree->gtArrOffs.gtArrRank;
9160	}
9161	else
9162	{
9163	currDim = tree->gtArrIndex.gtCurrDim;
9164	rank = tree->gtArrIndex.gtArrRank;
9165	}
9166
9167	for (unsigned char dim = `0`; dim < rank; dim++)
9168	{
9169	// Use a defacto standard i,j,k for the dimensions.
9170	// Note that we only support up to rank 3 arrays with these nodes, so we won't run out of characters.
9171	char dimChar = `'*'`;
9172	if (dim == currDim)
9173	{
9174	dimChar = `'i'` + dim;
9175	}
9176	else if (dim > currDim)
9177	{
9178	dimChar = `' '`;
9179	}
9180
9181	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), "%c", dimChar);
9182	if (dim != rank - `1`)
9183	{
9184	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), ",");
9185	}
9186	}
9187	SimpleSprintf_s(bufp, buf, sizeof(buf), "]");
9188	}
9189	else if (tree->gtOper == GT_LEA)
9190	{
9191	GenTreeAddrMode* lea = tree->AsAddrMode();
9192	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), " %s(", name);
9193	if (lea->Base() != nullptr)
9194	{
9195	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), "b+");
9196	}
9197	if (lea->Index() != nullptr)
9198	{
9199	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), "(i*%d)+", lea->gtScale);
9200	}
9201	bufp += SimpleSprintf_s(bufp, buf, sizeof(buf), "%d)", lea->Offset());
9202	}
9203	else if (tree->gtOper == GT_ARR_BOUNDS_CHECK)
9204	{
9205	switch (tree->gtBoundsChk.gtThrowKind)
9206	{
9207	case SCK_RNGCHK_FAIL:
9208	sprintf_s(bufp, sizeof(buf), " %s_Rng", name);
9209	break;
9210	case SCK_ARG_EXCPN:
9211	sprintf_s(bufp, sizeof(buf), " %s_Arg", name);
9212	break;
9213	case SCK_ARG_RNG_EXCPN:
9214	sprintf_s(bufp, sizeof(buf), " %s_ArgRng", name);
9215	break;
9216	default:
9217	unreached();
9218	}
9219	}
9220	else if (tree->gtOverflowEx())
9221	{
9222	sprintf_s(bufp, sizeof(buf), " %s_ovfl%c", name, `0`);
9223	}
9224	else if (tree->OperIsBlk() && !tree->OperIsDynBlk())
9225	{
9226	sprintf_s(bufp, sizeof(buf), " %s(%d)", name, tree->AsBlk()->gtBlkSize);
9227	}
9228	else
9229	{
9230	sprintf_s(bufp, sizeof(buf), " %s%c", name, `0`);
9231	}
9232
9233	if (strlen(buf) < `10`)
9234	{
9235	printf(" %-10s", buf);
9236	}
9237	else
9238	{
9239	printf(" %s", buf);
9240	}
9241	}
9242
9243	void Compiler::gtDispVN(GenTree* tree)
9244	{
9245	if (tree->gtVNPair.GetLiberal() != ValueNumStore::NoVN)
9246	{
9247	assert(tree->gtVNPair.GetConservative() != ValueNumStore::NoVN);
9248	printf(" ");
9249	vnpPrint(tree->gtVNPair, `0`);
9250	}
9251	}
9252
9253	//------------------------------------------------------------------------
9254	// gtDispNode: Print a tree to jitstdout.
9255	//
9256	// Arguments:
9257	// tree - the tree to be printed
9258	// indentStack - the specification for the current level of indentation & arcs
9259	// msg - a contextual method (i.e. from the parent) to print
9260	//
9261	// Return Value:
9262	// None.
9263	//
9264	// Notes:
9265	// 'indentStack' may be null, in which case no indentation or arcs are printed
9266	// 'msg' may be null
9267
9268	void Compiler::gtDispNode(GenTree* tree, IndentStack* indentStack, __in __in_z __in_opt const char* msg, bool isLIR)
9269	{
9270	bool printPointer = true; // always true..
9271	bool printFlags = true; // always true..
9272	bool printCost = true; // always true..
9273
9274	int msgLength = `25`;
9275
9276	GenTree* prev;
9277
9278	if (tree->gtSeqNum)
9279	{
9280	printf("N%03u ", tree->gtSeqNum);
9281	if (tree->gtCostsInitialized)
9282	{
9283	printf("(%3u,%3u) ", tree->gtCostEx, tree->gtCostSz);
9284	}
9285	else
9286	{
9287	printf("(???"
9288	",???"
9289	") "); // This probably indicates a bug: the node has a sequence number, but not costs.
9290	}
9291	}
9292	else
9293	{
9294	if (tree->gtOper == GT_STMT)
9295	{
9296	prev = tree->gtStmt.gtStmtExpr;
9297	}
9298	else
9299	{
9300	prev = tree;
9301	}
9302
9303	bool hasSeqNum = true;
9304	unsigned dotNum = `0`;
9305	do
9306	{
9307	dotNum++;
9308	prev = prev->gtPrev;
9309
9310	if ((prev == nullptr) \|\| (prev == tree))
9311	{
9312	hasSeqNum = false;
9313	break;
9314	}
9315
9316	assert(prev);
9317	} while (prev->gtSeqNum == `0`);
9318
9319	// If we have an indent stack, don't add additional characters,
9320	// as it will mess up the alignment.
9321	bool displayDotNum = tree->gtOper != GT_STMT && hasSeqNum && (indentStack == nullptr);
9322	if (displayDotNum)
9323	{
9324	printf("N%03u.%02u ", prev->gtSeqNum, dotNum);
9325	}
9326	else
9327	{
9328	printf(" ");
9329	}
9330
9331	if (tree->gtCostsInitialized)
9332	{
9333	printf("(%3u,%3u) ", tree->gtCostEx, tree->gtCostSz);
9334	}
9335	else
9336	{
9337	if (displayDotNum)
9338	{
9339	// Do better alignment in this case
9340	printf(" ");
9341	}
9342	else
9343	{
9344	printf(" ");
9345	}
9346	}
9347	}
9348
9349	if (optValnumCSE_phase)
9350	{
9351	if (IS_CSE_INDEX(tree->gtCSEnum))
9352	{
9353	printf("CSE #%02d (%s)", GET_CSE_INDEX(tree->gtCSEnum), (IS_CSE_USE(tree->gtCSEnum) ? "use" : "def"));
9354	}
9355	else
9356	{
9357	printf(" ");
9358	}
9359	}
9360
9361	/ Print the node ID /
9362	printTreeID(tree);
9363	printf(" ");
9364
9365	if (tree->gtOper >= GT_COUNT)
9366	{
9367	printf(" ** ILLEGAL NODE **");
9368	return;
9369	}
9370
9371	if (printFlags)
9372	{
9373	/ First print the flags associated with the node /
9374	switch (tree->gtOper)
9375	{
9376	case GT_LEA:
9377	case GT_BLK:
9378	case GT_OBJ:
9379	case GT_DYN_BLK:
9380	case GT_STORE_BLK:
9381	case GT_STORE_OBJ:
9382	case GT_STORE_DYN_BLK:
9383
9384	case GT_IND:
9385	// We prefer printing V or U
9386	if ((tree->gtFlags & (GTF_IND_VOLATILE \| GTF_IND_UNALIGNED)) == `0`)
9387	{
9388	if (tree->gtFlags & GTF_IND_TGTANYWHERE)
9389	{
9390	printf("*");
9391	--msgLength;
9392	break;
9393	}
9394	if (tree->gtFlags & GTF_IND_INVARIANT)
9395	{
9396	printf("#");
9397	--msgLength;
9398	break;
9399	}
9400	if (tree->gtFlags & GTF_IND_ARR_INDEX)
9401	{
9402	printf("a");
9403	--msgLength;
9404	break;
9405	}
9406	if (tree->gtFlags & GTF_IND_NONFAULTING)
9407	{
9408	printf("n"); // print a n for non-faulting
9409	--msgLength;
9410	break;
9411	}
9412	if (tree->gtFlags & GTF_IND_ASG_LHS)
9413	{
9414	printf("D"); // print a D for definition
9415	--msgLength;
9416	break;
9417	}
9418	}
9419	__fallthrough;
9420
9421	case GT_INDEX:
9422	case GT_INDEX_ADDR:
9423
9424	if ((tree->gtFlags & (GTF_IND_VOLATILE \| GTF_IND_UNALIGNED)) == `0`) // We prefer printing V or U over R
9425	{
9426	if (tree->gtFlags & GTF_INX_REFARR_LAYOUT)
9427	{
9428	printf("R");
9429	--msgLength;
9430	break;
9431	} // R means RefArray
9432	}
9433	__fallthrough;
9434
9435	case GT_FIELD:
9436	case GT_CLS_VAR:
9437	if (tree->gtFlags & GTF_IND_VOLATILE)
9438	{
9439	printf("V");
9440	--msgLength;
9441	break;
9442	}
9443	if (tree->gtFlags & GTF_IND_UNALIGNED)
9444	{
9445	printf("U");
9446	--msgLength;
9447	break;
9448	}
9449	goto DASH;
9450
9451	case GT_ASG:
9452	if (tree->OperIsInitBlkOp())
9453	{
9454	printf("I");
9455	--msgLength;
9456	break;
9457	}
9458	goto DASH;
9459
9460	case GT_CALL:
9461	if (tree->gtCall.IsInlineCandidate())
9462	{
9463	if (tree->gtCall.IsGuardedDevirtualizationCandidate())
9464	{
9465	printf("&");
9466	}
9467	else
9468	{
9469	printf("I");
9470	}
9471	--msgLength;
9472	break;
9473	}
9474	else if (tree->gtCall.IsGuardedDevirtualizationCandidate())
9475	{
9476	printf("G");
9477	--msgLength;
9478	break;
9479	}
9480	if (tree->gtCall.gtCallMoreFlags & GTF_CALL_M_RETBUFFARG)
9481	{
9482	printf("S");
9483	--msgLength;
9484	break;
9485	}
9486	if (tree->gtFlags & GTF_CALL_HOISTABLE)
9487	{
9488	printf("H");
9489	--msgLength;
9490	break;
9491	}
9492
9493	goto DASH;
9494
9495	case GT_MUL:
9496	#if !defined(_TARGET_64BIT_)
9497	case GT_MUL_LONG:
9498	#endif
9499	if (tree->gtFlags & GTF_MUL_64RSLT)
9500	{
9501	printf("L");
9502	--msgLength;
9503	break;
9504	}
9505	goto DASH;
9506
9507	case GT_ADDR:
9508	if (tree->gtFlags & GTF_ADDR_ONSTACK)
9509	{
9510	printf("L");
9511	--msgLength;
9512	break;
9513	} // L means LclVar
9514	goto DASH;
9515
9516	case GT_LCL_FLD:
9517	case GT_LCL_VAR:
9518	case GT_LCL_VAR_ADDR:
9519	case GT_LCL_FLD_ADDR:
9520	case GT_STORE_LCL_FLD:
9521	case GT_STORE_LCL_VAR:
9522	if (tree->gtFlags & GTF_VAR_USEASG)
9523	{
9524	printf("U");
9525	--msgLength;
9526	break;
9527	}
9528	if (tree->gtFlags & GTF_VAR_DEF)
9529	{
9530	printf("D");
9531	--msgLength;
9532	break;
9533	}
9534	if (tree->gtFlags & GTF_VAR_CAST)
9535	{
9536	printf("C");
9537	--msgLength;
9538	break;
9539	}
9540	if (tree->gtFlags & GTF_VAR_ARR_INDEX)
9541	{
9542	printf("i");
9543	--msgLength;
9544	break;
9545	}
9546	goto DASH;
9547
9548	case GT_EQ:
9549	case GT_NE:
9550	case GT_LT:
9551	case GT_LE:
9552	case GT_GE:
9553	case GT_GT:
9554	case GT_TEST_EQ:
9555	case GT_TEST_NE:
9556	if (tree->gtFlags & GTF_RELOP_NAN_UN)
9557	{
9558	printf("N");
9559	--msgLength;
9560	break;
9561	}
9562	if (tree->gtFlags & GTF_RELOP_JMP_USED)
9563	{
9564	printf("J");
9565	--msgLength;
9566	break;
9567	}
9568	if (tree->gtFlags & GTF_RELOP_QMARK)
9569	{
9570	printf("Q");
9571	--msgLength;
9572	break;
9573	}
9574	goto DASH;
9575
9576	case GT_JCMP:
9577	printf((tree->gtFlags & GTF_JCMP_TST) ? "T" : "C");
9578	printf((tree->gtFlags & GTF_JCMP_EQ) ? "EQ" : "NE");
9579	goto DASH;
9580
9581	case GT_FIELD_LIST:
9582	if (tree->gtFlags & GTF_FIELD_LIST_HEAD)
9583	{
9584	printf("H");
9585	--msgLength;
9586	break;
9587	}
9588	goto DASH;
9589
9590	default:
9591	DASH:
9592	printf("-");
9593	--msgLength;
9594	break;
9595	}
9596
9597	/ Then print the general purpose flags /
9598	unsigned flags = tree->gtFlags;
9599
9600	if (tree->OperIsBinary())
9601	{
9602	genTreeOps oper = tree->OperGet();
9603
9604	// Check for GTF_ADDRMODE_NO_CSE flag on add/mul/shl Binary Operators
9605	if ((oper == GT_ADD) \|\| (oper == GT_MUL) \|\| (oper == GT_LSH))
9606	{
9607	if ((tree->gtFlags & GTF_ADDRMODE_NO_CSE) != `0`)
9608	{
9609	flags \|= GTF_DONT_CSE; // Force the GTF_ADDRMODE_NO_CSE flag to print out like GTF_DONT_CSE
9610	}
9611	}
9612	}
9613	else // !tree->OperIsBinary()
9614	{
9615	// the GTF_REVERSE flag only applies to binary operations
9616	flags &= ~GTF_REVERSE_OPS; // we use this value for GTF_VAR_ARR_INDEX above
9617	}
9618
9619	msgLength -= GenTree::gtDispFlags(flags, tree->gtDebugFlags);
9620	/*
9621	printf("%c", (flags & GTF_ASG ) ? 'A' : '-');
9622	printf("%c", (flags & GTF_CALL ) ? 'C' : '-');
9623	printf("%c", (flags & GTF_EXCEPT ) ? 'X' : '-');
9624	printf("%c", (flags & GTF_GLOB_REF ) ? 'G' : '-');
9625	printf("%c", (flags & GTF_ORDER_SIDEEFF ) ? 'O' : '-');
9626	printf("%c", (flags & GTF_COLON_COND ) ? '?' : '-');
9627	printf("%c", (flags & GTF_DONT_CSE ) ? 'N' : // N is for No cse
9628	(flags & GTF_MAKE_CSE ) ? 'H' : '-'); // H is for Hoist this expr
9629	printf("%c", (flags & GTF_REVERSE_OPS ) ? 'R' : '-');
9630	printf("%c", (flags & GTF_UNSIGNED ) ? 'U' :
9631	(flags & GTF_BOOLEAN ) ? 'B' : '-');
9632	printf("%c", (flags & GTF_SET_FLAGS ) ? 'S' : '-');
9633	printf("%c", (flags & GTF_SPILLED ) ? 'z' : '-');
9634	printf("%c", (flags & GTF_SPILL ) ? 'Z' : '-');
9635	*/
9636	}
9637
9638	// If we're printing a node for LIR, we use the space normally associated with the message
9639	// to display the node's temp name (if any)
9640	const bool hasOperands = tree->OperandsBegin() != tree->OperandsEnd();
9641	if (isLIR)
9642	{
9643	assert(msg == nullptr);
9644
9645	// If the tree does not have any operands, we do not display the indent stack. This gives us
9646	// two additional characters for alignment.
9647	if (!hasOperands)
9648	{
9649	msgLength += `1`;
9650	}
9651
9652	if (tree->IsValue())
9653	{
9654	const size_t bufLength = msgLength - `1`;
9655	msg = reinterpret_cast<char>(alloca(bufLength sizeof(char)));
9656	sprintf_s(const_cast<char*>(msg), bufLength, "t%d = %s", tree->gtTreeID, hasOperands ? "" : " ");
9657	}
9658	}
9659
9660	/ print the msg associated with the node /
9661
9662	if (msg == nullptr)
9663	{
9664	msg = "";
9665	}
9666	if (msgLength < `0`)
9667	{
9668	msgLength = `0`;
9669	}
9670
9671	printf(isLIR ? " %+s" : " %-s", msgLength, msg);
9672
9673	/ Indent the node accordingly /
9674	if (!isLIR \|\| hasOperands)
9675	{
9676	printIndent(indentStack);
9677	}
9678
9679	gtDispNodeName(tree);
9680
9681	assert(tree == nullptr \|\| tree->gtOper < GT_COUNT);
9682
9683	if (tree)
9684	{
9685	/ print the type of the node /
9686	if (tree->gtOper != GT_CAST)
9687	{
9688	printf(" %-6s", varTypeName(tree->TypeGet()));
9689	if (tree->gtOper == GT_LCL_VAR \|\| tree->gtOper == GT_STORE_LCL_VAR)
9690	{
9691	LclVarDsc* varDsc = &lvaTable[tree->gtLclVarCommon.gtLclNum];
9692	if (varDsc->lvAddrExposed)
9693	{
9694	printf("(AX)"); // Variable has address exposed.
9695	}
9696
9697	if (varDsc->lvUnusedStruct)
9698	{
9699	assert(varDsc->lvPromoted);
9700	printf("(U)"); // Unused struct
9701	}
9702	else if (varDsc->lvPromoted)
9703	{
9704	if (varTypeIsPromotable(varDsc))
9705	{
9706	printf("(P)"); // Promoted struct
9707	}
9708	else
9709	{
9710	// Promoted implicit by-refs can have this state during
9711	// global morph while they are being rewritten
9712	assert(fgGlobalMorph);
9713	printf("(P?!)"); // Promoted struct
9714	}
9715	}
9716	}
9717
9718	if (tree->gtOper == GT_STMT)
9719	{
9720	if (opts.compDbgInfo)
9721	{
9722	IL_OFFSET endIL = tree->gtStmt.gtStmtLastILoffs;
9723
9724	printf("(IL ");
9725	if (tree->gtStmt.gtStmtILoffsx == BAD_IL_OFFSET)
9726	{
9727	printf(" ???");
9728	}
9729	else
9730	{
9731	printf("0x%03X", jitGetILoffs(tree->gtStmt.gtStmtILoffsx));
9732	}
9733	printf("...");
9734	if (endIL == BAD_IL_OFFSET)
9735	{
9736	printf(" ???");
9737	}
9738	else
9739	{
9740	printf("0x%03X", endIL);
9741	}
9742	printf(")");
9743	}
9744	}
9745
9746	if (tree->IsArgPlaceHolderNode() && (tree->gtArgPlace.gtArgPlaceClsHnd != nullptr))
9747	{
9748	printf(" => [clsHnd=%08X]", dspPtr(tree->gtArgPlace.gtArgPlaceClsHnd));
9749	}
9750
9751	if (tree->gtOper == GT_RUNTIMELOOKUP)
9752	{
9753	#ifdef _TARGET_64BIT_
9754	printf(" 0x%llx", dspPtr(tree->gtRuntimeLookup.gtHnd));
9755	#else
9756	printf(" 0x%x", dspPtr(tree->gtRuntimeLookup.gtHnd));
9757	#endif
9758
9759	switch (tree->gtRuntimeLookup.gtHndType)
9760	{
9761	case CORINFO_HANDLETYPE_CLASS:
9762	printf(" class");
9763	break;
9764	case CORINFO_HANDLETYPE_METHOD:
9765	printf(" method");
9766	break;
9767	case CORINFO_HANDLETYPE_FIELD:
9768	printf(" field");
9769	break;
9770	default:
9771	printf(" unknown");
9772	break;
9773	}
9774	}
9775	}
9776
9777	// for tracking down problems in reguse prediction or liveness tracking
9778
9779	if (verbose && `0`)
9780	{
9781	printf(" RR=");
9782	dspRegMask(tree->gtRsvdRegs);
9783	printf("\n");
9784	}
9785	}
9786	}
9787
9788	void Compiler::gtDispRegVal(GenTree* tree)
9789	{
9790	switch (tree->GetRegTag())
9791	{
9792	// Don't display NOREG; the absence of this tag will imply this state
9793	// case GenTree::GT_REGTAG_NONE: printf(" NOREG"); break;
9794
9795	case GenTree::GT_REGTAG_REG:
9796	printf(" REG %s", compRegVarName(tree->gtRegNum));
9797	break;
9798
9799	default:
9800	break;
9801	}
9802
9803	if (tree->IsMultiRegCall())
9804	{
9805	// 0th reg is gtRegNum, which is already printed above.
9806	// Print the remaining regs of a multi-reg call node.
9807	GenTreeCall* call = tree->AsCall();
9808	unsigned regCount = call->GetReturnTypeDesc()->TryGetReturnRegCount();
9809	for (unsigned i = `1`; i < regCount; ++i)
9810	{
9811	printf(",%s", compRegVarName(call->GetRegNumByIdx(i)));
9812	}
9813	}
9814	else if (tree->IsCopyOrReloadOfMultiRegCall())
9815	{
9816	GenTreeCopyOrReload* copyOrReload = tree->AsCopyOrReload();
9817	GenTreeCall* call = tree->gtGetOp1()->AsCall();
9818	unsigned regCount = call->GetReturnTypeDesc()->TryGetReturnRegCount();
9819	for (unsigned i = `1`; i < regCount; ++i)
9820	{
9821	printf(",%s", compRegVarName(copyOrReload->GetRegNumByIdx(i)));
9822	}
9823	}
9824
9825	#if FEATURE_MULTIREG_RET
9826	if (tree->IsCopyOrReload())
9827	{
9828	for (int i = `1`; i < MAX_RET_REG_COUNT; i++)
9829	{
9830	regNumber reg = (regNumber)tree->AsCopyOrReload()->GetRegNumByIdx(i);
9831	if (reg == REG_NA)
9832	{
9833	break;
9834	}
9835	printf(",%s", compRegVarName(reg));
9836	}
9837	}
9838	#endif
9839
9840	#if defined(_TARGET_ARM_)
9841	if (tree->OperIsMultiRegOp() && (tree->AsMultiRegOp()->gtOtherReg != REG_NA))
9842	{
9843	printf(",%s", compRegVarName(tree->AsMultiRegOp()->gtOtherReg));
9844	}
9845	#endif
9846	}
9847
9848	// We usually/commonly don't expect to print anything longer than this string,
9849	#define LONGEST_COMMON_LCL_VAR_DISPLAY "V99 PInvokeFrame"
9850	#define LONGEST_COMMON_LCL_VAR_DISPLAY_LENGTH (sizeof(LONGEST_COMMON_LCL_VAR_DISPLAY))
9851	#define BUF_SIZE (LONGEST_COMMON_LCL_VAR_DISPLAY_LENGTH * 2)
9852
9853	void Compiler::gtGetLclVarNameInfo(unsigned lclNum, const char** ilKindOut, const char** ilNameOut, unsigned* ilNumOut)
9854	{
9855	const char* ilKind = nullptr;
9856	const char* ilName = nullptr;
9857
9858	unsigned ilNum = compMap2ILvarNum(lclNum);
9859
9860	if (ilNum == (unsigned)ICorDebugInfo::RETBUF_ILNUM)
9861	{
9862	ilName = "RetBuf";
9863	}
9864	else if (ilNum == (unsigned)ICorDebugInfo::VARARGS_HND_ILNUM)
9865	{
9866	ilName = "VarArgHandle";
9867	}
9868	else if (ilNum == (unsigned)ICorDebugInfo::TYPECTXT_ILNUM)
9869	{
9870	ilName = "TypeCtx";
9871	}
9872	else if (ilNum == (unsigned)ICorDebugInfo::UNKNOWN_ILNUM)
9873	{
9874	#if FEATURE_ANYCSE
9875	if (lclNumIsTrueCSE(lclNum))
9876	{
9877	ilKind = "cse";
9878	ilNum = lclNum - optCSEstart;
9879	}
9880	else if (lclNum >= optCSEstart)
9881	{
9882	// Currently any new LclVar's introduced after the CSE phase
9883	// are believed to be created by the "rationalizer" that is what is meant by the "rat" prefix.
9884	ilKind = "rat";
9885	ilNum = lclNum - (optCSEstart + optCSEcount);
9886	}
9887	else
9888	#endif // FEATURE_ANYCSE
9889	{
9890	if (lclNum == info.compLvFrameListRoot)
9891	{
9892	ilName = "FramesRoot";
9893	}
9894	else if (lclNum == lvaInlinedPInvokeFrameVar)
9895	{
9896	ilName = "PInvokeFrame";
9897	}
9898	else if (lclNum == lvaGSSecurityCookie)
9899	{
9900	ilName = "GsCookie";
9901	}
9902	#if FEATURE_FIXED_OUT_ARGS
9903	else if (lclNum == lvaPInvokeFrameRegSaveVar)
9904	{
9905	ilName = "PInvokeFrameRegSave";
9906	}
9907	else if (lclNum == lvaOutgoingArgSpaceVar)
9908	{
9909	ilName = "OutArgs";
9910	}
9911	#endif // FEATURE_FIXED_OUT_ARGS
9912	#ifdef _TARGET_ARM_
9913	else if (lclNum == lvaPromotedStructAssemblyScratchVar)
9914	{
9915	ilName = "PromotedStructScratch";
9916	}
9917	#endif // _TARGET_ARM_
9918	#if !FEATURE_EH_FUNCLETS
9919	else if (lclNum == lvaShadowSPslotsVar)
9920	{
9921	ilName = "EHSlots";
9922	}
9923	#endif // !FEATURE_EH_FUNCLETS
9924	#ifdef JIT32_GCENCODER
9925	else if (lclNum == lvaLocAllocSPvar)
9926	{
9927	ilName = "LocAllocSP";
9928	}
9929	#endif // JIT32_GCENCODER
9930	#if FEATURE_EH_FUNCLETS
9931	else if (lclNum == lvaPSPSym)
9932	{
9933	ilName = "PSPSym";
9934	}
9935	#endif // FEATURE_EH_FUNCLETS
9936	else
9937	{
9938	ilKind = "tmp";
9939	if (compIsForInlining())
9940	{
9941	ilNum = lclNum - impInlineInfo->InlinerCompiler->info.compLocalsCount;
9942	}
9943	else
9944	{
9945	ilNum = lclNum - info.compLocalsCount;
9946	}
9947	}
9948	}
9949	}
9950	else if (lclNum < (compIsForInlining() ? impInlineInfo->InlinerCompiler->info.compArgsCount : info.compArgsCount))
9951	{
9952	if (ilNum == `0` && !info.compIsStatic)
9953	{
9954	ilName = "this";
9955	}
9956	else
9957	{
9958	ilKind = "arg";
9959	}
9960	}
9961	else
9962	{
9963	if (!lvaTable[lclNum].lvIsStructField)
9964	{
9965	ilKind = "loc";
9966	}
9967	if (compIsForInlining())
9968	{
9969	ilNum -= impInlineInfo->InlinerCompiler->info.compILargsCount;
9970	}
9971	else
9972	{
9973	ilNum -= info.compILargsCount;
9974	}
9975	}
9976
9977	*ilKindOut = ilKind;
9978	*ilNameOut = ilName;
9979	*ilNumOut = ilNum;
9980	}
9981
9982	/***************************************************************************/
9983	int Compiler::gtGetLclVarName(unsigned lclNum, char* buf, unsigned buf_remaining)
9984	{
9985	char* bufp_next = buf;
9986	unsigned charsPrinted = `0`;
9987	int sprintf_result;
9988
9989	sprintf_result = sprintf_s(bufp_next, buf_remaining, "V%02u", lclNum);
9990
9991	if (sprintf_result < `0`)
9992	{
9993	return sprintf_result;
9994	}
9995
9996	charsPrinted += sprintf_result;
9997	bufp_next += sprintf_result;
9998	buf_remaining -= sprintf_result;
9999
10000	const char* ilKind = nullptr;
10001	const char* ilName = nullptr;
10002	unsigned ilNum = `0`;
10003
10004	gtGetLclVarNameInfo(lclNum, &ilKind, &ilName, &ilNum);
10005
10006	if (ilName != nullptr)
10007	{
10008	sprintf_result = sprintf_s(bufp_next, buf_remaining, " %s", ilName);
10009	if (sprintf_result < `0`)
10010	{
10011	return sprintf_result;
10012	}
10013	charsPrinted += sprintf_result;
10014	bufp_next += sprintf_result;
10015	buf_remaining -= sprintf_result;
10016	}
10017	else if (ilKind != nullptr)
10018	{
10019	sprintf_result = sprintf_s(bufp_next, buf_remaining, " %s%d", ilKind, ilNum);
10020	if (sprintf_result < `0`)
10021	{
10022	return sprintf_result;
10023	}
10024	charsPrinted += sprintf_result;
10025	bufp_next += sprintf_result;
10026	buf_remaining -= sprintf_result;
10027	}
10028
10029	assert(charsPrinted > `0`);
10030	assert(buf_remaining > `0`);
10031
10032	return (int)charsPrinted;
10033	}
10034
10035	/*****************************************************************************
10036	* Get the local var name, and create a copy of the string that can be used in debug output.
10037	*/
10038	char* Compiler::gtGetLclVarName(unsigned lclNum)
10039	{
10040	char buf[BUF_SIZE];
10041	int charsPrinted = gtGetLclVarName(lclNum, buf, _countof(buf));
10042	if (charsPrinted < `0`)
10043	{
10044	return nullptr;
10045	}
10046
10047	char* retBuf = new (this, CMK_DebugOnly) char[charsPrinted + `1`];
10048	strcpy_s(retBuf, charsPrinted + `1`, buf);
10049	return retBuf;
10050	}
10051
10052	/***************************************************************************/
10053	void Compiler::gtDispLclVar(unsigned lclNum, bool padForBiggestDisp)
10054	{
10055	char buf[BUF_SIZE];
10056	int charsPrinted = gtGetLclVarName(lclNum, buf, _countof(buf));
10057
10058	if (charsPrinted < `0`)
10059	{
10060	return;
10061	}
10062
10063	printf("%s", buf);
10064
10065	if (padForBiggestDisp && (charsPrinted < LONGEST_COMMON_LCL_VAR_DISPLAY_LENGTH))
10066	{
10067	printf("%*c", LONGEST_COMMON_LCL_VAR_DISPLAY_LENGTH - charsPrinted, `' '`);
10068	}
10069	}
10070
10071	/***************************************************************************/
10072	void Compiler::gtDispConst(GenTree* tree)
10073	{
10074	assert(tree->OperKind() & GTK_CONST);
10075
10076	switch (tree->gtOper)
10077	{
10078	case GT_CNS_INT:
10079	if (tree->IsIconHandle(GTF_ICON_STR_HDL))
10080	{
10081	const wchar_t* str = eeGetCPString(tree->gtIntCon.gtIconVal);
10082	if (str != nullptr)
10083	{
10084	printf(" 0x%X \"%S\"", dspPtr(tree->gtIntCon.gtIconVal), str);
10085	}
10086	else
10087	{
10088	// Note that eGetCPString isn't currently implemented on Linux/ARM
10089	// and instead always returns nullptr
10090	printf(" 0x%X [ICON_STR_HDL]", dspPtr(tree->gtIntCon.gtIconVal));
10091	}
10092	}
10093	else
10094	{
10095	ssize_t dspIconVal = tree->IsIconHandle() ? dspPtr(tree->gtIntCon.gtIconVal) : tree->gtIntCon.gtIconVal;
10096
10097	if (tree->TypeGet() == TYP_REF)
10098	{
10099	assert(tree->gtIntCon.gtIconVal == `0`);
10100	printf(" null");
10101	}
10102	else if ((tree->gtIntCon.gtIconVal > -`1000`) && (tree->gtIntCon.gtIconVal < `1000`))
10103	{
10104	printf(" %ld", dspIconVal);
10105	#ifdef _TARGET_64BIT_
10106	}
10107	else if ((tree->gtIntCon.gtIconVal & `0xFFFFFFFF00000000LL`) != `0`)
10108	{
10109	printf(" 0x%llx", dspIconVal);
10110	#endif
10111	}
10112	else
10113	{
10114	printf(" 0x%X", dspIconVal);
10115	}
10116
10117	if (tree->IsIconHandle())
10118	{
10119	switch (tree->GetIconHandleFlag())
10120	{
10121	case GTF_ICON_SCOPE_HDL:
10122	printf(" scope");
10123	break;
10124	case GTF_ICON_CLASS_HDL:
10125	printf(" class");
10126	break;
10127	case GTF_ICON_METHOD_HDL:
10128	printf(" method");
10129	break;
10130	case GTF_ICON_FIELD_HDL:
10131	printf(" field");
10132	break;
10133	case GTF_ICON_STATIC_HDL:
10134	printf(" static");
10135	break;
10136	case GTF_ICON_STR_HDL:
10137	unreached(); // This case is handled above
10138	break;
10139	case GTF_ICON_PSTR_HDL:
10140	printf(" pstr");
10141	break;
10142	case GTF_ICON_PTR_HDL:
10143	printf(" ptr");
10144	break;
10145	case GTF_ICON_VARG_HDL:
10146	printf(" vararg");
10147	break;
10148	case GTF_ICON_PINVKI_HDL:
10149	printf(" pinvoke");
10150	break;
10151	case GTF_ICON_TOKEN_HDL:
10152	printf(" token");
10153	break;
10154	case GTF_ICON_TLS_HDL:
10155	printf(" tls");
10156	break;
10157	case GTF_ICON_FTN_ADDR:
10158	printf(" ftn");
10159	break;
10160	case GTF_ICON_CIDMID_HDL:
10161	printf(" cid/mid");
10162	break;
10163	case GTF_ICON_BBC_PTR:
10164	printf(" bbc");
10165	break;
10166	default:
10167	printf(" UNKNOWN");
10168	break;
10169	}
10170	}
10171
10172	if ((tree->gtFlags & GTF_ICON_FIELD_OFF) != `0`)
10173	{
10174	printf(" field offset");
10175	}
10176
10177	#ifdef FEATURE_SIMD
10178	if ((tree->gtFlags & GTF_ICON_SIMD_COUNT) != `0`)
10179	{
10180	printf(" Vector<T>.Count");
10181	}
10182	#endif
10183
10184	if ((tree->IsReuseRegVal()) != `0`)
10185	{
10186	printf(" reuse reg val");
10187	}
10188	}
10189
10190	gtDispFieldSeq(tree->gtIntCon.gtFieldSeq);
10191
10192	break;
10193
10194	case GT_CNS_LNG:
10195	printf(" 0x%016I64x", tree->gtLngCon.gtLconVal);
10196	break;
10197
10198	case GT_CNS_DBL:
10199	if (((__int64)&tree->gtDblCon.gtDconVal) == (__int64**)I64(`0x8000000000000000`))
10200	{
10201	printf(" -0.00000");
10202	}
10203	else
10204	{
10205	printf(" %#.17g", tree->gtDblCon.gtDconVal);
10206	}
10207	break;
10208	case GT_CNS_STR:
10209	printf("<string constant>");
10210	break;
10211	default:
10212	assert(!"unexpected constant node");
10213	}
10214
10215	gtDispRegVal(tree);
10216	}
10217
10218	void Compiler::gtDispFieldSeq(FieldSeqNode* pfsn)
10219	{
10220	if (pfsn == FieldSeqStore::NotAField() \|\| (pfsn == nullptr))
10221	{
10222	return;
10223	}
10224
10225	// Otherwise...
10226	printf(" Fseq[");
10227	while (pfsn != nullptr)
10228	{
10229	assert(pfsn != FieldSeqStore::NotAField()); // Can't exist in a field sequence list except alone
10230	CORINFO_FIELD_HANDLE fldHnd = pfsn->m_fieldHnd;
10231	// First check the "pseudo" field handles...
10232	if (fldHnd == FieldSeqStore::FirstElemPseudoField)
10233	{
10234	printf("#FirstElem");
10235	}
10236	else if (fldHnd == FieldSeqStore::ConstantIndexPseudoField)
10237	{
10238	printf("#ConstantIndex");
10239	}
10240	else
10241	{
10242	printf("%s", eeGetFieldName(fldHnd));
10243	}
10244	pfsn = pfsn->m_next;
10245	if (pfsn != nullptr)
10246	{
10247	printf(", ");
10248	}
10249	}
10250	printf("]");
10251	}
10252
10253	//------------------------------------------------------------------------
10254	// gtDispLeaf: Print a single leaf node to jitstdout.
10255	//
10256	// Arguments:
10257	// tree - the tree to be printed
10258	// indentStack - the specification for the current level of indentation & arcs
10259	//
10260	// Return Value:
10261	// None.
10262	//
10263	// Notes:
10264	// 'indentStack' may be null, in which case no indentation or arcs are printed
10265
10266	void Compiler::gtDispLeaf(GenTree* tree, IndentStack* indentStack)
10267	{
10268	if (tree->OperKind() & GTK_CONST)
10269	{
10270	gtDispConst(tree);
10271	return;
10272	}
10273
10274	bool isLclFld = false;
10275
10276	switch (tree->gtOper)
10277	{
10278	unsigned varNum;
10279	LclVarDsc* varDsc;
10280
10281	case GT_LCL_FLD:
10282	case GT_LCL_FLD_ADDR:
10283	case GT_STORE_LCL_FLD:
10284	isLclFld = true;
10285	__fallthrough;
10286
10287	case GT_PHI_ARG:
10288	case GT_LCL_VAR:
10289	case GT_LCL_VAR_ADDR:
10290	case GT_STORE_LCL_VAR:
10291	printf(" ");
10292	varNum = tree->gtLclVarCommon.gtLclNum;
10293	varDsc = &lvaTable[varNum];
10294	gtDispLclVar(varNum);
10295	if (tree->gtLclVarCommon.HasSsaName())
10296	{
10297	if (tree->gtFlags & GTF_VAR_USEASG)
10298	{
10299	assert(tree->gtFlags & GTF_VAR_DEF);
10300	printf("ud:%d->%d", tree->gtLclVarCommon.gtSsaNum, GetSsaNumForLocalVarDef(tree));
10301	}
10302	else
10303	{
10304	printf("%s:%d", (tree->gtFlags & GTF_VAR_DEF) ? "d" : "u", tree->gtLclVarCommon.gtSsaNum);
10305	}
10306	}
10307
10308	if (isLclFld)
10309	{
10310	printf("[+%u]", tree->gtLclFld.gtLclOffs);
10311	gtDispFieldSeq(tree->gtLclFld.gtFieldSeq);
10312	}
10313
10314	if (varDsc->lvRegister)
10315	{
10316	printf(" ");
10317	varDsc->PrintVarReg();
10318	}
10319	else if (tree->InReg())
10320	{
10321	printf(" %s", compRegVarName(tree->gtRegNum));
10322	}
10323
10324	if (varDsc->lvPromoted)
10325	{
10326	if (!varTypeIsPromotable(varDsc) && !varDsc->lvUnusedStruct)
10327	{
10328	// Promoted implicit byrefs can get in this state while they are being rewritten
10329	// in global morph.
10330	assert(fgGlobalMorph);
10331	}
10332	else
10333	{
10334	CORINFO_CLASS_HANDLE typeHnd = varDsc->lvVerTypeInfo.GetClassHandle();
10335	CORINFO_FIELD_HANDLE fldHnd;
10336
10337	for (unsigned i = varDsc->lvFieldLclStart; i < varDsc->lvFieldLclStart + varDsc->lvFieldCnt; ++i)
10338	{
10339	LclVarDsc* fieldVarDsc = &lvaTable[i];
10340	const char* fieldName;
10341	#if !defined(_TARGET_64BIT_)
10342	if (varTypeIsLong(varDsc))
10343	{
10344	fieldName = (i == `0`) ? "lo" : "hi";
10345	}
10346	else
10347	#endif // !defined(_TARGET_64BIT_)
10348	{
10349	fldHnd = info.compCompHnd->getFieldInClass(typeHnd, fieldVarDsc->lvFldOrdinal);
10350	fieldName = eeGetFieldName(fldHnd);
10351	}
10352
10353	printf("\n");
10354	printf(" ");
10355	printIndent(indentStack);
10356	printf(" %-6s V%02u.%s (offs=0x%02x) -> ", varTypeName(fieldVarDsc->TypeGet()),
10357	tree->gtLclVarCommon.gtLclNum, fieldName, fieldVarDsc->lvFldOffset);
10358	gtDispLclVar(i);
10359
10360	if (fieldVarDsc->lvRegister)
10361	{
10362	printf(" ");
10363	fieldVarDsc->PrintVarReg();
10364	}
10365
10366	if (fieldVarDsc->lvTracked && fgLocalVarLivenessDone && // Includes local variable liveness
10367	((tree->gtFlags & GTF_VAR_DEATH) != `0`))
10368	{
10369	printf(" (last use)");
10370	}
10371	}
10372	}
10373	}
10374	else // a normal not-promoted lclvar
10375	{
10376	if (varDsc->lvTracked && fgLocalVarLivenessDone && ((tree->gtFlags & GTF_VAR_DEATH) != `0`))
10377	{
10378	printf(" (last use)");
10379	}
10380	}
10381	break;
10382
10383	case GT_JMP:
10384	{
10385	const char* methodName;
10386	const char* className;
10387
10388	methodName = eeGetMethodName((CORINFO_METHOD_HANDLE)tree->gtVal.gtVal1, &className);
10389	printf(" %s.%s\n", className, methodName);
10390	}
10391	break;
10392
10393	case GT_CLS_VAR:
10394	printf(" Hnd=%#x", dspPtr(tree->gtClsVar.gtClsVarHnd));
10395	gtDispFieldSeq(tree->gtClsVar.gtFieldSeq);
10396	break;
10397
10398	case GT_CLS_VAR_ADDR:
10399	printf(" Hnd=%#x", dspPtr(tree->gtClsVar.gtClsVarHnd));
10400	break;
10401
10402	case GT_LABEL:
10403	if (tree->gtLabel.gtLabBB)
10404	{
10405	printf(" dst=" FMT_BB, tree->gtLabel.gtLabBB->bbNum);
10406	}
10407	else
10408	{
10409	printf(" dst=<null>");
10410	}
10411
10412	break;
10413
10414	case GT_FTN_ADDR:
10415	{
10416	const char* methodName;
10417	const char* className;
10418
10419	methodName = eeGetMethodName((CORINFO_METHOD_HANDLE)tree->gtFptrVal.gtFptrMethod, &className);
10420	printf(" %s.%s\n", className, methodName);
10421	}
10422	break;
10423
10424	#if !FEATURE_EH_FUNCLETS
10425	case GT_END_LFIN:
10426	printf(" endNstLvl=%d", tree->gtVal.gtVal1);
10427	break;
10428	#endif // !FEATURE_EH_FUNCLETS
10429
10430	// Vanilla leaves. No qualifying information available. So do nothing
10431
10432	case GT_NO_OP:
10433	case GT_START_NONGC:
10434	case GT_PROF_HOOK:
10435	case GT_CATCH_ARG:
10436	case GT_MEMORYBARRIER:
10437	case GT_ARGPLACE:
10438	case GT_PINVOKE_PROLOG:
10439	case GT_JMPTABLE:
10440	break;
10441
10442	case GT_RET_EXPR:
10443	printf("(inl return from call ");
10444	printTreeID(tree->gtRetExpr.gtInlineCandidate);
10445	printf(")");
10446	break;
10447
10448	case GT_PHYSREG:
10449	printf(" %s", getRegName(tree->gtPhysReg.gtSrcReg, varTypeIsFloating(tree)));
10450	break;
10451
10452	case GT_IL_OFFSET:
10453	printf(" IL offset: ");
10454	if (tree->gtStmt.gtStmtILoffsx == BAD_IL_OFFSET)
10455	{
10456	printf("???");
10457	}
10458	else
10459	{
10460	printf("0x%x", jitGetILoffs(tree->gtStmt.gtStmtILoffsx));
10461	}
10462	break;
10463
10464	case GT_JCC:
10465	case GT_SETCC:
10466	printf(" cond=%s", GenTree::OpName(tree->AsCC()->gtCondition));
10467	break;
10468	case GT_JCMP:
10469	printf(" cond=%s%s", (tree->gtFlags & GTF_JCMP_TST) ? "TEST_" : "",
10470	(tree->gtFlags & GTF_JCMP_EQ) ? "EQ" : "NE");
10471
10472	default:
10473	assert(!"don't know how to display tree leaf node");
10474	}
10475
10476	gtDispRegVal(tree);
10477	}
10478
10479	//------------------------------------------------------------------------
10480	// gtDispLeaf: Print a child node to jitstdout.
10481	//
10482	// Arguments:
10483	// tree - the tree to be printed
10484	// indentStack - the specification for the current level of indentation & arcs
10485	// arcType - the type of arc to use for this child
10486	// msg - a contextual method (i.e. from the parent) to print
10487	// topOnly - a boolean indicating whether to print the children, or just the top node
10488	//
10489	// Return Value:
10490	// None.
10491	//
10492	// Notes:
10493	// 'indentStack' may be null, in which case no indentation or arcs are printed
10494	// 'msg' has a default value of null
10495	// 'topOnly' is an optional argument that defaults to false
10496
10497	void Compiler::gtDispChild(GenTree* child,
10498	IndentStack* indentStack,
10499	IndentInfo arcType,
10500	__in_opt const char* msg, / = nullptr /
10501	bool topOnly) / = false /
10502	{
10503	indentStack->Push(arcType);
10504	gtDispTree(child, indentStack, msg, topOnly);
10505	indentStack->Pop();
10506	}
10507
10508	#ifdef FEATURE_SIMD
10509	// Intrinsic Id to name map
10510	extern const char* const simdIntrinsicNames[] = {
10511	#define SIMD_INTRINSIC(mname, inst, id, name, r, ac, arg1, arg2, arg3, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10) name,
10512	#include "simdintrinsiclist.h"
10513	};
10514	#endif // FEATURE_SIMD
10515
10516	/***************************************************************************/
10517
10518	void Compiler::gtDispTree(GenTree* tree,
10519	IndentStack* indentStack, / = nullptr /
10520	__in __in_z __in_opt const char* msg, / = nullptr /
10521	bool topOnly, / = false /
10522	bool isLIR) / = false /
10523	{
10524	if (tree == nullptr)
10525	{
10526	printf(" [%08X] <NULL>\n", tree);
10527	printf(""); // null string means flush
10528	return;
10529	}
10530
10531	if (indentStack == nullptr)
10532	{
10533	indentStack = new (this, CMK_DebugOnly) IndentStack (this);
10534	}
10535
10536	if (IsUninitialized(tree))
10537	{
10538	/ Value used to initalize nodes /
10539	printf("Uninitialized tree node!");
10540	return;
10541	}
10542
10543	if (tree->gtOper >= GT_COUNT)
10544	{
10545	gtDispNode(tree, indentStack, msg, isLIR);
10546	printf("Bogus operator!");
10547	return;
10548	}
10549
10550	/ Is tree a leaf node? /
10551
10552	if (tree->OperIsLeaf() \|\| tree->OperIsLocalStore()) // local stores used to be leaves
10553	{
10554	gtDispNode(tree, indentStack, msg, isLIR);
10555	gtDispLeaf(tree, indentStack);
10556	gtDispVN(tree);
10557	printf("\n");
10558	if (tree->OperIsLocalStore() && !topOnly)
10559	{
10560	gtDispChild(tree->gtOp.gtOp1, indentStack, IINone);
10561	}
10562	return;
10563	}
10564
10565	// Determine what kind of arc to propagate.
10566	IndentInfo myArc = IINone;
10567	IndentInfo lowerArc = IINone;
10568	if (indentStack->Depth() > `0`)
10569	{
10570	myArc = indentStack->Pop();
10571	switch (myArc)
10572	{
10573	case IIArcBottom:
10574	indentStack->Push(IIArc);
10575	lowerArc = IINone;
10576	break;
10577	case IIArc:
10578	indentStack->Push(IIArc);
10579	lowerArc = IIArc;
10580	break;
10581	case IIArcTop:
10582	indentStack->Push(IINone);
10583	lowerArc = IIArc;
10584	break;
10585	case IIEmbedded:
10586	indentStack->Push(IIEmbedded);
10587	lowerArc = IIEmbedded;
10588	break;
10589	case IINone:
10590	indentStack->Push(IINone);
10591	lowerArc = IINone;
10592	break;
10593	default:
10594	unreached();
10595	break;
10596	}
10597	}
10598
10599	// Special case formatting for PHI nodes -- arg lists like calls.
10600
10601	if (tree->OperGet() == GT_PHI)
10602	{
10603	gtDispNode(tree, indentStack, msg, isLIR);
10604	gtDispVN(tree);
10605	printf("\n");
10606
10607	if (!topOnly)
10608	{
10609	if (tree->gtOp.gtOp1 != nullptr)
10610	{
10611	IndentInfo arcType = IIArcTop;
10612	for (GenTreeArgList* args = tree->gtOp.gtOp1->AsArgList(); args != nullptr; args = args->Rest())
10613	{
10614	if (args->Rest() == nullptr)
10615	{
10616	arcType = IIArcBottom;
10617	}
10618	gtDispChild(args->Current(), indentStack, arcType);
10619	arcType = IIArc;
10620	}
10621	}
10622	}
10623	return;
10624	}
10625
10626	/ Is it a 'simple' unary/binary operator? /
10627
10628	const char* childMsg = nullptr;
10629
10630	if (tree->OperIsSimple())
10631	{
10632	if (!topOnly)
10633	{
10634	if (tree->gtGetOp2IfPresent())
10635	{
10636	// Label the childMsgs of the GT_COLON operator
10637	// op2 is the then part
10638
10639	if (tree->gtOper == GT_COLON)
10640	{
10641	childMsg = "then";
10642	}
10643	gtDispChild(tree->gtOp.gtOp2, indentStack, IIArcTop, childMsg, topOnly);
10644	}
10645	}
10646
10647	// Now, get the right type of arc for this node
10648	if (myArc != IINone)
10649	{
10650	indentStack->Pop();
10651	indentStack->Push(myArc);
10652	}
10653
10654	gtDispNode(tree, indentStack, msg, isLIR);
10655
10656	// Propagate lowerArc to the lower children.
10657	if (indentStack->Depth() > `0`)
10658	{
10659	(void)indentStack->Pop();
10660	indentStack->Push(lowerArc);
10661	}
10662
10663	if (tree->gtOper == GT_CAST)
10664	{
10665	/ Format a message that explains the effect of this GT_CAST /
10666
10667	var_types fromType = genActualType(tree->gtCast.CastOp()->TypeGet());
10668	var_types toType = tree->CastToType();
10669	var_types finalType = tree->TypeGet();
10670
10671	/ if GTF_UNSIGNED is set then force fromType to an unsigned type /
10672	if (tree->gtFlags & GTF_UNSIGNED)
10673	{
10674	fromType = genUnsignedType(fromType);
10675	}
10676
10677	if (finalType != toType)
10678	{
10679	printf(" %s <-", varTypeName(finalType));
10680	}
10681
10682	printf(" %s <- %s", varTypeName(toType), varTypeName(fromType));
10683	}
10684
10685	if (tree->gtOper == GT_OBJ && (tree->gtFlags & GTF_VAR_DEATH))
10686	{
10687	printf(" (last use)");
10688	}
10689	if (tree->OperIsBlkOp())
10690	{
10691	if (tree->OperIsCopyBlkOp())
10692	{
10693	printf(" (copy)");
10694	}
10695	else if (tree->OperIsInitBlkOp())
10696	{
10697	printf(" (init)");
10698	}
10699	if (tree->OperIsStoreBlk() && (tree->AsBlk()->gtBlkOpKind != GenTreeBlk::BlkOpKindInvalid))
10700	{
10701	switch (tree->AsBlk()->gtBlkOpKind)
10702	{
10703	case GenTreeBlk::BlkOpKindRepInstr:
10704	printf(" (RepInstr)");
10705	break;
10706	case GenTreeBlk::BlkOpKindUnroll:
10707	printf(" (Unroll)");
10708	break;
10709	case GenTreeBlk::BlkOpKindHelper:
10710	printf(" (Helper)");
10711	break;
10712	default:
10713	unreached();
10714	}
10715	}
10716	}
10717	else if (tree->OperIsFieldList())
10718	{
10719	printf(" %s at offset %d", varTypeName(tree->AsFieldList()->gtFieldType),
10720	tree->AsFieldList()->gtFieldOffset);
10721	}
10722	#if FEATURE_PUT_STRUCT_ARG_STK
10723	else if (tree->OperGet() == GT_PUTARG_STK)
10724	{
10725	printf(" (%d slots)", tree->AsPutArgStk()->gtNumSlots);
10726	if (tree->AsPutArgStk()->gtPutArgStkKind != GenTreePutArgStk::Kind::Invalid)
10727	{
10728	switch (tree->AsPutArgStk()->gtPutArgStkKind)
10729	{
10730	case GenTreePutArgStk::Kind::RepInstr:
10731	printf(" (RepInstr)");
10732	break;
10733	case GenTreePutArgStk::Kind::Unroll:
10734	printf(" (Unroll)");
10735	break;
10736	case GenTreePutArgStk::Kind::Push:
10737	printf(" (Push)");
10738	break;
10739	case GenTreePutArgStk::Kind::PushAllSlots:
10740	printf(" (PushAllSlots)");
10741	break;
10742	default:
10743	unreached();
10744	}
10745	}
10746	}
10747	#endif // FEATURE_PUT_STRUCT_ARG_STK
10748
10749	if (tree->gtOper == GT_INTRINSIC)
10750	{
10751	switch (tree->gtIntrinsic.gtIntrinsicId)
10752	{
10753	case CORINFO_INTRINSIC_Sin:
10754	printf(" sin");
10755	break;
10756	case CORINFO_INTRINSIC_Cos:
10757	printf(" cos");
10758	break;
10759	case CORINFO_INTRINSIC_Cbrt:
10760	printf(" cbrt");
10761	break;
10762	case CORINFO_INTRINSIC_Sqrt:
10763	printf(" sqrt");
10764	break;
10765	case CORINFO_INTRINSIC_Abs:
10766	printf(" abs");
10767	break;
10768	case CORINFO_INTRINSIC_Round:
10769	printf(" round");
10770	break;
10771	case CORINFO_INTRINSIC_Cosh:
10772	printf(" cosh");
10773	break;
10774	case CORINFO_INTRINSIC_Sinh:
10775	printf(" sinh");
10776	break;
10777	case CORINFO_INTRINSIC_Tan:
10778	printf(" tan");
10779	break;
10780	case CORINFO_INTRINSIC_Tanh:
10781	printf(" tanh");
10782	break;
10783	case CORINFO_INTRINSIC_Asin:
10784	printf(" asin");
10785	break;
10786	case CORINFO_INTRINSIC_Asinh:
10787	printf(" asinh");
10788	break;
10789	case CORINFO_INTRINSIC_Acos:
10790	printf(" acos");
10791	break;
10792	case CORINFO_INTRINSIC_Acosh:
10793	printf(" acosh");
10794	break;
10795	case CORINFO_INTRINSIC_Atan:
10796	printf(" atan");
10797	break;
10798	case CORINFO_INTRINSIC_Atan2:
10799	printf(" atan2");
10800	break;
10801	case CORINFO_INTRINSIC_Atanh:
10802	printf(" atanh");
10803	break;
10804	case CORINFO_INTRINSIC_Log10:
10805	printf(" log10");
10806	break;
10807	case CORINFO_INTRINSIC_Pow:
10808	printf(" pow");
10809	break;
10810	case CORINFO_INTRINSIC_Exp:
10811	printf(" exp");
10812	break;
10813	case CORINFO_INTRINSIC_Ceiling:
10814	printf(" ceiling");
10815	break;
10816	case CORINFO_INTRINSIC_Floor:
10817	printf(" floor");
10818	break;
10819	case CORINFO_INTRINSIC_Object_GetType:
10820	printf(" objGetType");
10821	break;
10822
10823	default:
10824	unreached();
10825	}
10826	}
10827
10828	#ifdef FEATURE_SIMD
10829	if (tree->gtOper == GT_SIMD)
10830	{
10831	printf(" %s %s", varTypeName(tree->gtSIMD.gtSIMDBaseType),
10832	simdIntrinsicNames[tree->gtSIMD.gtSIMDIntrinsicID]);
10833	}
10834	#endif // FEATURE_SIMD
10835
10836	#ifdef FEATURE_HW_INTRINSICS
10837	if (tree->gtOper == GT_HWIntrinsic)
10838	{
10839	printf(" %s %s",
10840	tree->gtHWIntrinsic.gtSIMDBaseType == TYP_UNKNOWN ? ""
10841	: varTypeName(tree->gtHWIntrinsic.gtSIMDBaseType),
10842	HWIntrinsicInfo::lookupName(tree->gtHWIntrinsic.gtHWIntrinsicId));
10843	}
10844	#endif // FEATURE_HW_INTRINSICS
10845
10846	gtDispRegVal(tree);
10847	gtDispVN(tree);
10848	printf("\n");
10849
10850	if (!topOnly && tree->gtOp.gtOp1)
10851	{
10852
10853	// Label the child of the GT_COLON operator
10854	// op1 is the else part
10855
10856	if (tree->gtOper == GT_COLON)
10857	{
10858	childMsg = "else";
10859	}
10860	else if (tree->gtOper == GT_QMARK)
10861	{
10862	childMsg = " if";
10863	}
10864	gtDispChild(tree->gtOp.gtOp1, indentStack, IIArcBottom, childMsg, topOnly);
10865	}
10866
10867	return;
10868	}
10869
10870	// Now, get the right type of arc for this node
10871	if (myArc != IINone)
10872	{
10873	indentStack->Pop();
10874	indentStack->Push(myArc);
10875	}
10876	gtDispNode(tree, indentStack, msg, isLIR);
10877
10878	// Propagate lowerArc to the lower children.
10879	if (indentStack->Depth() > `0`)
10880	{
10881	(void)indentStack->Pop();
10882	indentStack->Push(lowerArc);
10883	}
10884
10885	// See what kind of a special operator we have here, and handle its special children.
10886
10887	switch (tree->gtOper)
10888	{
10889	case GT_FIELD:
10890	if (FieldSeqStore::IsPseudoField(tree->gtField.gtFldHnd))
10891	{
10892	printf(" #PseudoField:0x%x", tree->gtField.gtFldOffset);
10893	}
10894	else
10895	{
10896	printf(" %s", eeGetFieldName(tree->gtField.gtFldHnd), `0`);
10897	}
10898
10899	if (tree->gtField.gtFldObj && !topOnly)
10900	{
10901	gtDispVN(tree);
10902	printf("\n");
10903	gtDispChild(tree->gtField.gtFldObj, indentStack, IIArcBottom);
10904	}
10905	else
10906	{
10907	gtDispRegVal(tree);
10908	gtDispVN(tree);
10909	printf("\n");
10910	}
10911	break;
10912
10913	case GT_CALL:
10914	{
10915	GenTreeCall* call = tree->AsCall();
10916	assert(call->gtFlags & GTF_CALL);
10917	unsigned numChildren = call->NumChildren();
10918	GenTree* lastChild = nullptr;
10919	if (numChildren != `0`)
10920	{
10921	lastChild = call->GetChild(numChildren - `1`);
10922	}
10923
10924	if (call->gtCallType != CT_INDIRECT)
10925	{
10926	const char* methodName;
10927	const char* className;
10928
10929	methodName = eeGetMethodName(call->gtCallMethHnd, &className);
10930
10931	printf(" %s.%s", className, methodName);
10932	}
10933
10934	if ((call->gtFlags & GTF_CALL_UNMANAGED) && (call->gtCallMoreFlags & GTF_CALL_M_FRAME_VAR_DEATH))
10935	{
10936	printf(" (FramesRoot last use)");
10937	}
10938
10939	if (((call->gtFlags & GTF_CALL_INLINE_CANDIDATE) != `0`) && (call->gtInlineCandidateInfo != nullptr) &&
10940	(call->gtInlineCandidateInfo->exactContextHnd != nullptr))
10941	{
10942	printf(" (exactContextHnd=0x%p)", dspPtr(call->gtInlineCandidateInfo->exactContextHnd));
10943	}
10944
10945	gtDispVN(call);
10946	if (call->IsMultiRegCall())
10947	{
10948	gtDispRegVal(call);
10949	}
10950	printf("\n");
10951
10952	if (!topOnly)
10953	{
10954	char buf[`64`];
10955	char* bufp;
10956
10957	bufp = &buf[`0`];
10958
10959	if ((call->gtCallObjp != nullptr) && (call->gtCallObjp->gtOper != GT_NOP) &&
10960	(!call->gtCallObjp->IsArgPlaceHolderNode()))
10961	{
10962	if (call->gtCallObjp->gtOper == GT_ASG)
10963	{
10964	sprintf_s(bufp, sizeof(buf), "this SETUP%c", `0`);
10965	}
10966	else
10967	{
10968	sprintf_s(bufp, sizeof(buf), "this in %s%c", compRegVarName(REG_ARG_0), `0`);
10969	}
10970	gtDispChild(call->gtCallObjp, indentStack, (call->gtCallObjp == lastChild) ? IIArcBottom : IIArc,
10971	bufp, topOnly);
10972	}
10973
10974	if (call->gtCallArgs)
10975	{
10976	gtDispArgList(call, indentStack);
10977	}
10978
10979	if (call->gtCallType == CT_INDIRECT)
10980	{
10981	gtDispChild(call->gtCallAddr, indentStack, (call->gtCallAddr == lastChild) ? IIArcBottom : IIArc,
10982	"calli tgt", topOnly);
10983	}
10984
10985	if (call->gtControlExpr != nullptr)
10986	{
10987	gtDispChild(call->gtControlExpr, indentStack,
10988	(call->gtControlExpr == lastChild) ? IIArcBottom : IIArc, "control expr", topOnly);
10989	}
10990
10991	#if !FEATURE_FIXED_OUT_ARGS
10992	regList list = call->regArgList;
10993	#endif
10994	/ process the late argument list /
10995	int lateArgIndex = `0`;
10996	for (GenTreeArgList* lateArgs = call->gtCallLateArgs; lateArgs;
10997	(lateArgIndex++, lateArgs = lateArgs->Rest()))
10998	{
10999	GenTree* argx;
11000
11001	argx = lateArgs->Current();
11002
11003	IndentInfo arcType = (lateArgs->Rest() == nullptr) ? IIArcBottom : IIArc;
11004	gtGetLateArgMsg(call, argx, lateArgIndex, -`1`, bufp, sizeof(buf));
11005	gtDispChild(argx, indentStack, arcType, bufp, topOnly);
11006	}
11007	}
11008	}
11009	break;
11010
11011	case GT_STMT:
11012	printf("\n");
11013
11014	if (!topOnly)
11015	{
11016	gtDispChild(tree->gtStmt.gtStmtExpr, indentStack, IIArcBottom);
11017	}
11018	break;
11019
11020	case GT_ARR_ELEM:
11021	gtDispVN(tree);
11022	printf("\n");
11023
11024	if (!topOnly)
11025	{
11026	gtDispChild(tree->gtArrElem.gtArrObj, indentStack, IIArc, nullptr, topOnly);
11027
11028	unsigned dim;
11029	for (dim = `0`; dim < tree->gtArrElem.gtArrRank; dim++)
11030	{
11031	IndentInfo arcType = ((dim + `1`) == tree->gtArrElem.gtArrRank) ? IIArcBottom : IIArc;
11032	gtDispChild(tree->gtArrElem.gtArrInds[dim], indentStack, arcType, nullptr, topOnly);
11033	}
11034	}
11035	break;
11036
11037	case GT_ARR_OFFSET:
11038	gtDispVN(tree);
11039	printf("\n");
11040	if (!topOnly)
11041	{
11042	gtDispChild(tree->gtArrOffs.gtOffset, indentStack, IIArc, nullptr, topOnly);
11043	gtDispChild(tree->gtArrOffs.gtIndex, indentStack, IIArc, nullptr, topOnly);
11044	gtDispChild(tree->gtArrOffs.gtArrObj, indentStack, IIArcBottom, nullptr, topOnly);
11045	}
11046	break;
11047
11048	case GT_CMPXCHG:
11049	gtDispVN(tree);
11050	printf("\n");
11051	if (!topOnly)
11052	{
11053	gtDispChild(tree->gtCmpXchg.gtOpLocation, indentStack, IIArc, nullptr, topOnly);
11054	gtDispChild(tree->gtCmpXchg.gtOpValue, indentStack, IIArc, nullptr, topOnly);
11055	gtDispChild(tree->gtCmpXchg.gtOpComparand, indentStack, IIArcBottom, nullptr, topOnly);
11056	}
11057	break;
11058
11059	case GT_ARR_BOUNDS_CHECK:
11060	#ifdef FEATURE_SIMD
11061	case GT_SIMD_CHK:
11062	#endif // FEATURE_SIMD
11063	#ifdef FEATURE_HW_INTRINSICS
11064	case GT_HW_INTRINSIC_CHK:
11065	#endif // FEATURE_HW_INTRINSICS
11066	gtDispVN(tree);
11067	printf("\n");
11068	if (!topOnly)
11069	{
11070	gtDispChild(tree->gtBoundsChk.gtIndex, indentStack, IIArc, nullptr, topOnly);
11071	gtDispChild(tree->gtBoundsChk.gtArrLen, indentStack, IIArcBottom, nullptr, topOnly);
11072	}
11073	break;
11074
11075	case GT_STORE_DYN_BLK:
11076	case GT_DYN_BLK:
11077	if (tree->OperIsCopyBlkOp())
11078	{
11079	printf(" (copy)");
11080	}
11081	else if (tree->OperIsInitBlkOp())
11082	{
11083	printf(" (init)");
11084	}
11085	gtDispVN(tree);
11086	printf("\n");
11087	if (!topOnly)
11088	{
11089	if (tree->gtDynBlk.Data() != nullptr)
11090	{
11091	gtDispChild(tree->gtDynBlk.Data(), indentStack, IIArc, nullptr, topOnly);
11092	}
11093	gtDispChild(tree->gtDynBlk.Addr(), indentStack, IIArc, nullptr, topOnly);
11094	gtDispChild(tree->gtDynBlk.gtDynamicSize, indentStack, IIArcBottom, nullptr, topOnly);
11095	}
11096	break;
11097
11098	default:
11099	printf("<DON'T KNOW HOW TO DISPLAY THIS NODE> :");
11100	printf(""); // null string means flush
11101	break;
11102	}
11103	}
11104
11105	//------------------------------------------------------------------------
11106	// gtGetArgMsg: Construct a message about the given argument
11107	//
11108	// Arguments:
11109	// call - The call for which 'arg' is an argument
11110	// arg - The argument for which a message should be constructed
11111	// argNum - The ordinal number of the arg in the argument list
11112	// listCount - When printing in LIR form this is the count for a GT_FIELD_LIST
11113	// or -1 if we are not printing in LIR form
11114	// bufp - A pointer to the buffer into which the message is written
11115	// bufLength - The length of the buffer pointed to by bufp
11116	//
11117	// Return Value:
11118	// No return value, but bufp is written.
11119	//
11120	// Assumptions:
11121	// 'call' must be a call node
11122	// 'arg' must be an argument to 'call' (else gtArgEntryByNode will assert)
11123
11124	void Compiler::gtGetArgMsg(
11125	GenTreeCall* call, GenTree* arg, unsigned argNum, int listCount, char* bufp, unsigned bufLength)
11126	{
11127	if (call->gtCallLateArgs != nullptr)
11128	{
11129	fgArgTabEntry* curArgTabEntry = gtArgEntryByArgNum(call, argNum);
11130	assert(curArgTabEntry);
11131
11132	if (arg->gtFlags & GTF_LATE_ARG)
11133	{
11134	sprintf_s(bufp, bufLength, "arg%d SETUP%c", argNum, `0`);
11135	}
11136	else
11137	{
11138	#ifdef _TARGET_ARM_
11139	if (curArgTabEntry->isSplit)
11140	{
11141	regNumber firstReg = curArgTabEntry->regNum;
11142	if (listCount == -`1`)
11143	{
11144	if (curArgTabEntry->numRegs == `1`)
11145	{
11146	sprintf_s(bufp, bufLength, "arg%d %s out+%02x%c", argNum, compRegVarName(firstReg),
11147	(curArgTabEntry->slotNum) * TARGET_POINTER_SIZE, `0`);
11148	}
11149	else
11150	{
11151	regNumber lastReg = REG_STK;
11152	char separator = (curArgTabEntry->numRegs == `2`) ? `','` : `'-'`;
11153	if (curArgTabEntry->isHfaRegArg)
11154	{
11155	unsigned lastRegNum = genMapFloatRegNumToRegArgNum(firstReg) + curArgTabEntry->numRegs - `1`;
11156	lastReg = genMapFloatRegArgNumToRegNum(lastRegNum);
11157	}
11158	else
11159	{
11160	unsigned lastRegNum = genMapIntRegNumToRegArgNum(firstReg) + curArgTabEntry->numRegs - `1`;
11161	lastReg = genMapIntRegArgNumToRegNum(lastRegNum);
11162	}
11163	sprintf_s(bufp, bufLength, "arg%d %s%c%s out+%02x%c", argNum, compRegVarName(firstReg),
11164	separator, compRegVarName(lastReg), (curArgTabEntry->slotNum) * TARGET_POINTER_SIZE,
11165	`0`);
11166	}
11167	}
11168	else
11169	{
11170	unsigned curArgNum = BAD_VAR_NUM;
11171	bool isFloat = curArgTabEntry->isHfaRegArg;
11172	if (isFloat)
11173	{
11174	curArgNum = genMapFloatRegNumToRegArgNum(firstReg) + listCount;
11175	}
11176	else
11177	{
11178	curArgNum = genMapIntRegNumToRegArgNum(firstReg) + listCount;
11179	}
11180
11181	if (!isFloat && curArgNum < MAX_REG_ARG)
11182	{
11183	regNumber curReg = genMapIntRegArgNumToRegNum(curArgNum);
11184	sprintf_s(bufp, bufLength, "arg%d m%d %s%c", argNum, listCount, compRegVarName(curReg), `0`);
11185	}
11186	else if (isFloat && curArgNum < MAX_FLOAT_REG_ARG)
11187	{
11188	regNumber curReg = genMapFloatRegArgNumToRegNum(curArgNum);
11189	sprintf_s(bufp, bufLength, "arg%d m%d %s%c", argNum, listCount, compRegVarName(curReg), `0`);
11190	}
11191	else
11192	{
11193	unsigned stackSlot = listCount - curArgTabEntry->numRegs;
11194	sprintf_s(bufp, bufLength, "arg%d m%d out+%02x%c", argNum, listCount,
11195	stackSlot * TARGET_POINTER_SIZE, `0`);
11196	}
11197	}
11198	return;
11199	}
11200	#endif // _TARGET_ARM_
11201	#if FEATURE_FIXED_OUT_ARGS
11202	if (listCount == -`1`)
11203	{
11204	sprintf_s(bufp, bufLength, "arg%d out+%02x%c", argNum, curArgTabEntry->slotNum * TARGET_POINTER_SIZE,
11205	`0`);
11206	}
11207	else // listCount is 0,1,2 or 3
11208	{
11209	assert(listCount <= MAX_ARG_REG_COUNT);
11210	sprintf_s(bufp, bufLength, "arg%d out+%02x%c", argNum,
11211	(curArgTabEntry->slotNum + listCount) * TARGET_POINTER_SIZE, `0`);
11212	}
11213	#else
11214	sprintf_s(bufp, bufLength, "arg%d on STK%c", argNum, `0`);
11215	#endif
11216	}
11217	}
11218	else
11219	{
11220	sprintf_s(bufp, bufLength, "arg%d%c", argNum, `0`);
11221	}
11222	}
11223
11224	//------------------------------------------------------------------------
11225	// gtGetLateArgMsg: Construct a message about the given argument
11226	//
11227	// Arguments:
11228	// call - The call for which 'arg' is an argument
11229	// argx - The argument for which a message should be constructed
11230	// lateArgIndex - The ordinal number of the arg in the lastArg list
11231	// listCount - When printing in LIR form this is the count for a multireg GT_FIELD_LIST
11232	// or -1 if we are not printing in LIR form
11233	// bufp - A pointer to the buffer into which the message is written
11234	// bufLength - The length of the buffer pointed to by bufp
11235	//
11236	// Return Value:
11237	// No return value, but bufp is written.
11238	//
11239	// Assumptions:
11240	// 'call' must be a call node
11241	// 'arg' must be an argument to 'call' (else gtArgEntryByNode will assert)
11242
11243	void Compiler::gtGetLateArgMsg(
11244	GenTreeCall* call, GenTree* argx, int lateArgIndex, int listCount, char* bufp, unsigned bufLength)
11245	{
11246	assert(!argx->IsArgPlaceHolderNode()); // No place holders nodes are in gtCallLateArgs;
11247
11248	fgArgTabEntry* curArgTabEntry = gtArgEntryByLateArgIndex(call, lateArgIndex);
11249	assert(curArgTabEntry);
11250	regNumber argReg = curArgTabEntry->regNum;
11251
11252	#if !FEATURE_FIXED_OUT_ARGS
11253	assert(lateArgIndex < call->regArgListCount);
11254	assert(argReg == call->regArgList[lateArgIndex]);
11255	#else
11256	if (argReg == REG_STK)
11257	{
11258	sprintf_s(bufp, bufLength, "arg%d in out+%02x%c", curArgTabEntry->argNum,
11259	curArgTabEntry->slotNum * TARGET_POINTER_SIZE, `0`);
11260	}
11261	else
11262	#endif
11263	{
11264	if (gtArgIsThisPtr(curArgTabEntry))
11265	{
11266	sprintf_s(bufp, bufLength, "this in %s%c", compRegVarName(argReg), `0`);
11267	}
11268	#ifdef _TARGET_ARM_
11269	else if (curArgTabEntry->isSplit)
11270	{
11271	regNumber firstReg = curArgTabEntry->regNum;
11272	unsigned argNum = curArgTabEntry->argNum;
11273	if (listCount == -`1`)
11274	{
11275	if (curArgTabEntry->numRegs == `1`)
11276	{
11277	sprintf_s(bufp, bufLength, "arg%d %s out+%02x%c", argNum, compRegVarName(firstReg),
11278	(curArgTabEntry->slotNum) * TARGET_POINTER_SIZE, `0`);
11279	}
11280	else
11281	{
11282	regNumber lastReg = REG_STK;
11283	char separator = (curArgTabEntry->numRegs == `2`) ? `','` : `'-'`;
11284	if (curArgTabEntry->isHfaRegArg)
11285	{
11286	unsigned lastRegNum = genMapFloatRegNumToRegArgNum(firstReg) + curArgTabEntry->numRegs - `1`;
11287	lastReg = genMapFloatRegArgNumToRegNum(lastRegNum);
11288	}
11289	else
11290	{
11291	unsigned lastRegNum = genMapIntRegNumToRegArgNum(firstReg) + curArgTabEntry->numRegs - `1`;
11292	lastReg = genMapIntRegArgNumToRegNum(lastRegNum);
11293	}
11294	sprintf_s(bufp, bufLength, "arg%d %s%c%s out+%02x%c", argNum, compRegVarName(firstReg), separator,
11295	compRegVarName(lastReg), (curArgTabEntry->slotNum) * TARGET_POINTER_SIZE, `0`);
11296	}
11297	}
11298	else
11299	{
11300	unsigned curArgNum = BAD_VAR_NUM;
11301	bool isFloat = curArgTabEntry->isHfaRegArg;
11302	if (isFloat)
11303	{
11304	curArgNum = genMapFloatRegNumToRegArgNum(firstReg) + listCount;
11305	}
11306	else
11307	{
11308	curArgNum = genMapIntRegNumToRegArgNum(firstReg) + listCount;
11309	}
11310
11311	if (!isFloat && curArgNum < MAX_REG_ARG)
11312	{
11313	regNumber curReg = genMapIntRegArgNumToRegNum(curArgNum);
11314	sprintf_s(bufp, bufLength, "arg%d m%d %s%c", argNum, listCount, compRegVarName(curReg), `0`);
11315	}
11316	else if (isFloat && curArgNum < MAX_FLOAT_REG_ARG)
11317	{
11318	regNumber curReg = genMapFloatRegArgNumToRegNum(curArgNum);
11319	sprintf_s(bufp, bufLength, "arg%d m%d %s%c", argNum, listCount, compRegVarName(curReg), `0`);
11320	}
11321	else
11322	{
11323	unsigned stackSlot = listCount - curArgTabEntry->numRegs;
11324	sprintf_s(bufp, bufLength, "arg%d m%d out+%02x%c", argNum, listCount,
11325	stackSlot * TARGET_POINTER_SIZE, `0`);
11326	}
11327	}
11328	return;
11329	}
11330	#endif // _TARGET_ARM_
11331	else
11332	{
11333	#if FEATURE_MULTIREG_ARGS
11334	if (curArgTabEntry->numRegs >= `2`)
11335	{
11336	// listCount could be -1 but it is signed, so this comparison is OK.
11337	assert(listCount <= MAX_ARG_REG_COUNT);
11338	char separator = (curArgTabEntry->numRegs == `2`) ? `','` : `'-'`;
11339	sprintf_s(bufp, bufLength, "arg%d %s%c%s%c", curArgTabEntry->argNum, compRegVarName(argReg), separator,
11340	compRegVarName(curArgTabEntry->getRegNum(curArgTabEntry->numRegs - `1`)), `0`);
11341	}
11342	else
11343	#endif
11344	{
11345	sprintf_s(bufp, bufLength, "arg%d in %s%c", curArgTabEntry->argNum, compRegVarName(argReg), `0`);
11346	}
11347	}
11348	}
11349	}
11350
11351	//------------------------------------------------------------------------
11352	// gtDispArgList: Dump the tree for a call arg list
11353	//
11354	// Arguments:
11355	// call - The call to dump arguments for
11356	// indentStack - the specification for the current level of indentation & arcs
11357	//
11358	// Return Value:
11359	// None.
11360	//
11361	void Compiler::gtDispArgList(GenTreeCall* call, IndentStack* indentStack)
11362	{
11363	GenTree* args = call->gtCallArgs;
11364	unsigned argnum = `0`;
11365	const int BufLength = `256`;
11366	char buf[BufLength];
11367	char* bufp = &buf[`0`];
11368	unsigned numChildren = call->NumChildren();
11369	assert(numChildren != `0`);
11370	bool argListIsLastChild = (args == call->GetChild(numChildren - `1`));
11371
11372	IndentInfo arcType = IIArc;
11373	if (call->gtCallObjp != nullptr)
11374	{
11375	argnum++;
11376	}
11377
11378	while (args != nullptr)
11379	{
11380	assert(args->gtOper == GT_LIST);
11381	GenTree* arg = args->gtOp.gtOp1;
11382	if (!arg->IsNothingNode() && !arg->IsArgPlaceHolderNode())
11383	{
11384	gtGetArgMsg(call, arg, argnum, -`1`, bufp, BufLength);
11385	if (argListIsLastChild && (args->gtOp.gtOp2 == nullptr))
11386	{
11387	arcType = IIArcBottom;
11388	}
11389	gtDispChild(arg, indentStack, arcType, bufp, false);
11390	}
11391	args = args->gtOp.gtOp2;
11392	argnum++;
11393	}
11394	}
11395
11396	//------------------------------------------------------------------------
11397	// gtDispArgList: Dump the tree for a call arg list
11398	//
11399	// Arguments:
11400	// tree - The call for which 'arg' is an argument
11401	// indentStack - the specification for the current level of indentation & arcs
11402	//
11403	// Return Value:
11404	// None.
11405	//
11406	// Assumptions:
11407	// 'tree' must be a GT_LIST node
11408
11409	void Compiler::gtDispTreeList(GenTree* tree, IndentStack* indentStack / = nullptr /)
11410	{
11411	for (/--/; tree != nullptr; tree = tree->gtNext)
11412	{
11413	gtDispTree(tree, indentStack);
11414	printf("\n");
11415	}
11416	}
11417
11418	//------------------------------------------------------------------------
11419	// Compiler::gtDispRange: dumps a range of LIR.
11420	//
11421	// Arguments:
11422	// range - the range of LIR to display.
11423	//
11424	void Compiler::gtDispRange(LIR::ReadOnlyRange const& range)
11425	{
11426	for (GenTree* node : range)
11427	{
11428	gtDispLIRNode(node);
11429	}
11430	}
11431
11432	//------------------------------------------------------------------------
11433	// Compiler::gtDispTreeRange: dumps the LIR range that contains all of the
11434	// nodes in the dataflow tree rooted at a given
11435	// node.
11436	//
11437	// Arguments:
11438	// containingRange - the LIR range that contains the root node.
11439	// tree - the root of the dataflow tree.
11440	//
11441	void Compiler::gtDispTreeRange(LIR::Range& containingRange, GenTree* tree)
11442	{
11443	bool unused;
11444	gtDispRange(containingRange.GetTreeRange(tree, &unused));
11445	}
11446
11447	//------------------------------------------------------------------------
11448	// Compiler::gtDispLIRNode: dumps a single LIR node.
11449	//
11450	// Arguments:
11451	// node - the LIR node to dump.
11452	// prefixMsg - an optional prefix for each line of output.
11453	//
11454	void Compiler::gtDispLIRNode(GenTree* node, const char* prefixMsg / = nullptr /)
11455	{
11456	auto displayOperand = [](GenTree* operand, const char* message, IndentInfo operandArc, IndentStack& indentStack,
11457	size_t prefixIndent) {
11458	assert(operand != nullptr);
11459	assert(message != nullptr);
11460
11461	if (prefixIndent != `0`)
11462	{
11463	printf("%s", (int*)prefixIndent, "");
11464	}
11465
11466	// 49 spaces for alignment
11467	printf("%-49s", "");
11468	#if FEATURE_SET_FLAGS
11469	// additional flag enlarges the flag field by one character
11470	printf(" ");
11471	#endif
11472
11473	indentStack.Push(operandArc);
11474	indentStack.print();
11475	indentStack.Pop();
11476	operandArc = IIArc;
11477
11478	printf(" t%-5d %-6s %s\n", operand->gtTreeID, varTypeName(operand->TypeGet()), message);
11479	};
11480
11481	IndentStack indentStack(this);
11482
11483	size_t prefixIndent = `0`;
11484	if (prefixMsg != nullptr)
11485	{
11486	prefixIndent = strlen(prefixMsg);
11487	}
11488
11489	const int bufLength = `256`;
11490	char buf[bufLength];
11491
11492	const bool nodeIsCall = node->IsCall();
11493
11494	// Visit operands
11495	IndentInfo operandArc = IIArcTop;
11496	for (GenTree* operand : node->Operands())
11497	{
11498	if (operand->IsArgPlaceHolderNode() \|\| !operand->IsValue())
11499	{
11500	// Either of these situations may happen with calls.
11501	continue;
11502	}
11503
11504	if (nodeIsCall)
11505	{
11506	GenTreeCall* call = node->AsCall();
11507	if (operand == call->gtCallObjp)
11508	{
11509	sprintf_s(buf, sizeof(buf), "this in %s", compRegVarName(REG_ARG_0));
11510	displayOperand (operand, buf, operandArc, indentStack, prefixIndent);
11511	}
11512	else if (operand == call->gtCallAddr)
11513	{
11514	displayOperand (operand, "calli tgt", operandArc, indentStack, prefixIndent);
11515	}
11516	else if (operand == call->gtControlExpr)
11517	{
11518	displayOperand (operand, "control expr", operandArc, indentStack, prefixIndent);
11519	}
11520	else if (operand == call->gtCallCookie)
11521	{
11522	displayOperand (operand, "cookie", operandArc, indentStack, prefixIndent);
11523	}
11524	else
11525	{
11526	fgArgTabEntry* curArgTabEntry = gtArgEntryByNode(call, operand);
11527	assert(curArgTabEntry);
11528
11529	if (operand->OperGet() == GT_LIST)
11530	{
11531	int listIndex = `0`;
11532	for (GenTreeArgList* element = operand->AsArgList(); element != nullptr; element = element->Rest())
11533	{
11534	operand = element->Current();
11535	if (curArgTabEntry->lateArgInx == (unsigned)-`1`)
11536	{
11537	gtGetArgMsg(call, operand, curArgTabEntry->argNum, listIndex, buf, sizeof(buf));
11538	}
11539	else
11540	{
11541	gtGetLateArgMsg(call, operand, curArgTabEntry->lateArgInx, listIndex, buf, sizeof(buf));
11542	}
11543
11544	displayOperand (operand, buf, operandArc, indentStack, prefixIndent);
11545	operandArc = IIArc;
11546	}
11547	}
11548	else
11549	{
11550	if (!curArgTabEntry->isLateArg())
11551	{
11552	gtGetArgMsg(call, operand, curArgTabEntry->argNum, -`1`, buf, sizeof(buf));
11553	}
11554	else
11555	{
11556	gtGetLateArgMsg(call, operand, curArgTabEntry->lateArgInx, -`1`, buf, sizeof(buf));
11557	}
11558
11559	displayOperand (operand, buf, operandArc, indentStack, prefixIndent);
11560	}
11561	}
11562	}
11563	else if (node->OperIsDynBlkOp())
11564	{
11565	if (operand == node->AsBlk()->Addr())
11566	{
11567	displayOperand (operand, "lhs", operandArc, indentStack, prefixIndent);
11568	}
11569	else if (operand == node->AsBlk()->Data())
11570	{
11571	displayOperand (operand, "rhs", operandArc, indentStack, prefixIndent);
11572	}
11573	else
11574	{
11575	assert(operand == node->AsDynBlk()->gtDynamicSize);
11576	displayOperand (operand, "size", operandArc, indentStack, prefixIndent);
11577	}
11578	}
11579	else if (node->OperGet() == GT_DYN_BLK)
11580	{
11581	if (operand == node->AsBlk()->Addr())
11582	{
11583	displayOperand (operand, "lhs", operandArc, indentStack, prefixIndent);
11584	}
11585	else
11586	{
11587	assert(operand == node->AsDynBlk()->gtDynamicSize);
11588	displayOperand (operand, "size", operandArc, indentStack, prefixIndent);
11589	}
11590	}
11591	else if (node->OperIs(GT_ASG))
11592	{
11593	if (operand == node->gtGetOp1())
11594	{
11595	displayOperand (operand, "lhs", operandArc, indentStack, prefixIndent);
11596	}
11597	else
11598	{
11599	displayOperand (operand, "rhs", operandArc, indentStack, prefixIndent);
11600	}
11601	}
11602	else
11603	{
11604	displayOperand (operand, "", operandArc, indentStack, prefixIndent);
11605	}
11606
11607	operandArc = IIArc;
11608	}
11609
11610	// Visit the operator
11611
11612	if (prefixMsg != nullptr)
11613	{
11614	printf("%s", prefixMsg);
11615	}
11616
11617	const bool topOnly = true;
11618	const bool isLIR = true;
11619	gtDispTree(node, &indentStack, nullptr, topOnly, isLIR);
11620	}
11621
11622	/***************************************************************************/
11623	#endif // DEBUG
11624
11625	/*****************************************************************************
11626	*
11627	* Check if the given node can be folded,
11628	* and call the methods to perform the folding
11629	*/
11630
11631	GenTree* Compiler::gtFoldExpr(GenTree* tree)
11632	{
11633	unsigned kind = tree->OperKind();
11634
11635	/ We must have a simple operation to fold /
11636
11637	// If we're in CSE, it's not safe to perform tree
11638	// folding given that it can will potentially
11639	// change considered CSE candidates.
11640	if (optValnumCSE_phase)
11641	{
11642	return tree;
11643	}
11644
11645	if (!(kind & GTK_SMPOP))
11646	{
11647	return tree;
11648	}
11649
11650	GenTree* op1 = tree->gtOp.gtOp1;
11651
11652	/ Filter out non-foldable trees that can have constant children /
11653
11654	assert(kind & (GTK_UNOP \| GTK_BINOP));
11655	switch (tree->gtOper)
11656	{
11657	case GT_RETFILT:
11658	case GT_RETURN:
11659	case GT_IND:
11660	return tree;
11661	default:
11662	break;
11663	}
11664
11665	/ try to fold the current node /
11666
11667	if ((kind & GTK_UNOP) && op1)
11668	{
11669	if (op1->OperKind() & GTK_CONST)
11670	{
11671	return gtFoldExprConst(tree);
11672	}
11673	}
11674	else if ((kind & GTK_BINOP) && op1 && tree->gtOp.gtOp2 &&
11675	// Don't take out conditionals for debugging
11676	(opts.OptimizationEnabled() \|\| !tree->OperIsCompare()))
11677	{
11678	GenTree* op2 = tree->gtOp.gtOp2;
11679
11680	// The atomic operations are exempted here because they are never computable statically;
11681	// one of their arguments is an address.
11682	if (((op1->OperKind() & op2->OperKind()) & GTK_CONST) && !tree->OperIsAtomicOp())
11683	{
11684	/ both nodes are constants - fold the expression /
11685	return gtFoldExprConst(tree);
11686	}
11687	else if ((op1->OperKind() \| op2->OperKind()) & GTK_CONST)
11688	{
11689	/ at least one is a constant - see if we have a*
11690	* special operator that can use only one constant
11691	* to fold - e.g. booleans */
11692
11693	return gtFoldExprSpecial(tree);
11694	}
11695	else if (tree->OperIsCompare())
11696	{
11697	/ comparisons of two local variables can sometimes be folded /
11698
11699	return gtFoldExprCompare(tree);
11700	}
11701	else if (op2->OperGet() == GT_COLON)
11702	{
11703	assert(tree->OperGet() == GT_QMARK);
11704
11705	GenTree* colon_op1 = op2->gtOp.gtOp1;
11706	GenTree* colon_op2 = op2->gtOp.gtOp2;
11707
11708	if (gtCompareTree(colon_op1, colon_op2))
11709	{
11710	// Both sides of the GT_COLON are the same tree
11711
11712	GenTree* sideEffList = nullptr;
11713	gtExtractSideEffList(op1, &sideEffList);
11714
11715	// Clear colon flags only if the qmark itself is not conditionaly executed
11716	if ((tree->gtFlags & GTF_COLON_COND) == `0`)
11717	{
11718	fgWalkTreePre(&colon_op2, gtClearColonCond);
11719	}
11720
11721	if (sideEffList == nullptr)
11722	{
11723	// No side-effects, just return colon_op2
11724	return colon_op2;
11725	}
11726	else
11727	{
11728	#ifdef DEBUG
11729	if (verbose)
11730	{
11731	printf("\nIdentical GT_COLON trees with side effects! Extracting side effects...\n");
11732	gtDispTree(sideEffList);
11733	printf("\n");
11734	}
11735	#endif
11736	// Change the GT_COLON into a GT_COMMA node with the side-effects
11737	op2->ChangeOper(GT_COMMA);
11738	op2->gtFlags \|= (sideEffList->gtFlags & GTF_ALL_EFFECT);
11739	op2->gtOp.gtOp1 = sideEffList;
11740	return op2;
11741	}
11742	}
11743	}
11744	}
11745
11746	/ Return the original node (folded/bashed or not) /
11747
11748	return tree;
11749	}
11750
11751	//------------------------------------------------------------------------
11752	// gtFoldExprCall: see if a call is foldable
11753	//
11754	// Arguments:
11755	// call - call to examine
11756	//
11757	// Returns:
11758	// The original call if no folding happened.
11759	// An alternative tree if folding happens.
11760	//
11761	// Notes:
11762	// Checks for calls to Type.op_Equality, Type.op_Inequality, and
11763	// Enum.HasFlag, and if the call is to one of these,
11764	// attempts to optimize.
11765
11766	GenTree* Compiler::gtFoldExprCall(GenTreeCall* call)
11767	{
11768	// Can only fold calls to special intrinsics.
11769	if ((call->gtCallMoreFlags & GTF_CALL_M_SPECIAL_INTRINSIC) == `0`)
11770	{
11771	return call;
11772	}
11773
11774	// Defer folding if not optimizing.
11775	if (opts.OptimizationDisabled())
11776	{
11777	return call;
11778	}
11779
11780	// Fetch id of the intrinsic.
11781	const CorInfoIntrinsics methodID = info.compCompHnd->getIntrinsicID(call->gtCallMethHnd);
11782
11783	switch (methodID)
11784	{
11785	case CORINFO_INTRINSIC_TypeEQ:
11786	case CORINFO_INTRINSIC_TypeNEQ:
11787	{
11788	noway_assert(call->TypeGet() == TYP_INT);
11789	GenTree* op1 = call->gtCallArgs->gtOp.gtOp1;
11790	GenTree* op2 = call->gtCallArgs->gtOp.gtOp2->gtOp.gtOp1;
11791
11792	// If either operand is known to be a RuntimeType, this can be folded
11793	GenTree* result = gtFoldTypeEqualityCall(methodID, op1, op2);
11794	if (result != nullptr)
11795	{
11796	return result;
11797	}
11798	break;
11799	}
11800
11801	default:
11802	break;
11803	}
11804
11805	// Check for a new-style jit intrinsic.
11806	const NamedIntrinsic ni = lookupNamedIntrinsic(call->gtCallMethHnd);
11807
11808	if (ni == NI_System_Enum_HasFlag)
11809	{
11810	GenTree* thisOp = call->gtCallObjp;
11811	GenTree* flagOp = call->gtCallArgs->gtOp.gtOp1;
11812	GenTree* result = gtOptimizeEnumHasFlag(thisOp, flagOp);
11813
11814	if (result != nullptr)
11815	{
11816	return result;
11817	}
11818	}
11819
11820	return call;
11821	}
11822
11823	//------------------------------------------------------------------------
11824	// gtFoldTypeEqualityCall: see if a (potential) type equality call is foldable
11825	//
11826	// Arguments:
11827	// methodID -- type equality intrinsic ID
11828	// op1 -- first argument to call
11829	// op2 -- second argument to call
11830	//
11831	// Returns:
11832	// nulltpr if no folding happened.
11833	// An alternative tree if folding happens.
11834	//
11835	// Notes:
11836	// If either operand is known to be a a RuntimeType, then the type
11837	// equality methods will simply check object identity and so we can
11838	// fold the call into a simple compare of the call's operands.
11839
11840	GenTree* Compiler::gtFoldTypeEqualityCall(CorInfoIntrinsics methodID, GenTree* op1, GenTree* op2)
11841	{
11842	// The method must be be a type equality intrinsic
11843	assert(methodID == CORINFO_INTRINSIC_TypeEQ \|\| methodID == CORINFO_INTRINSIC_TypeNEQ);
11844
11845	if ((gtGetTypeProducerKind(op1) == TPK_Unknown) && (gtGetTypeProducerKind(op2) == TPK_Unknown))
11846	{
11847	return nullptr;
11848	}
11849
11850	const genTreeOps simpleOp = (methodID == CORINFO_INTRINSIC_TypeEQ) ? GT_EQ : GT_NE;
11851
11852	JITDUMP("\nFolding call to Type:op_%s to a simple compare via %s\n",
11853	methodID == CORINFO_INTRINSIC_TypeEQ ? "Equality" : "Inequality", GenTree::OpName(simpleOp));
11854
11855	GenTree* compare = gtNewOperNode(simpleOp, TYP_INT, op1, op2);
11856
11857	return compare;
11858	}
11859
11860	/*****************************************************************************
11861	*
11862	* Some comparisons can be folded:
11863	*
11864	* locA == locA
11865	* classVarA == classVarA
11866	* locA + locB == locB + locA
11867	*
11868	*/
11869
11870	GenTree* Compiler::gtFoldExprCompare(GenTree* tree)
11871	{
11872	GenTree* op1 = tree->gtOp.gtOp1;
11873	GenTree* op2 = tree->gtOp.gtOp2;
11874
11875	assert(tree->OperIsCompare());
11876
11877	/ Filter out cases that cannot be folded here /
11878
11879	/ Do not fold floats or doubles (e.g. NaN != Nan) /
11880
11881	if (varTypeIsFloating(op1->TypeGet()))
11882	{
11883	return tree;
11884	}
11885
11886	/ Currently we can only fold when the two subtrees exactly match /
11887
11888	if ((tree->gtFlags & GTF_SIDE_EFFECT) \|\| GenTree::Compare(op1, op2, true) == false)
11889	{
11890	return tree; / return unfolded tree /
11891	}
11892
11893	GenTree* cons;
11894
11895	switch (tree->gtOper)
11896	{
11897	case GT_EQ:
11898	case GT_LE:
11899	case GT_GE:
11900	cons = gtNewIconNode(true); / Folds to GT_CNS_INT(true) /
11901	break;
11902
11903	case GT_NE:
11904	case GT_LT:
11905	case GT_GT:
11906	cons = gtNewIconNode(false); / Folds to GT_CNS_INT(false) /
11907	break;
11908
11909	default:
11910	assert(!"Unexpected relOp");
11911	return tree;
11912	}
11913
11914	/ The node has beeen folded into 'cons' /
11915
11916	if (fgGlobalMorph)
11917	{
11918	fgMorphTreeDone(cons);
11919	}
11920	else
11921	{
11922	cons->gtNext = tree->gtNext;
11923	cons->gtPrev = tree->gtPrev;
11924	}
11925
11926	return cons;
11927	}
11928
11929	//------------------------------------------------------------------------
11930	// gtCreateHandleCompare: generate a type handle comparison
11931	//
11932	// Arguments:
11933	// oper -- comparison operation (equal/not equal)
11934	// op1 -- first operand
11935	// op2 -- second operand
11936	// typeCheckInliningResult -- indicates how the comparison should happen
11937	//
11938	// Returns:
11939	// Type comparison tree
11940	//
11941
11942	GenTree* Compiler::gtCreateHandleCompare(genTreeOps oper,
11943	GenTree* op1,
11944	GenTree* op2,
11945	CorInfoInlineTypeCheck typeCheckInliningResult)
11946	{
11947	// If we can compare pointers directly, just emit the binary operation
11948	if (typeCheckInliningResult == CORINFO_INLINE_TYPECHECK_PASS)
11949	{
11950	return gtNewOperNode(oper, TYP_INT, op1, op2);
11951	}
11952
11953	assert(typeCheckInliningResult == CORINFO_INLINE_TYPECHECK_USE_HELPER);
11954
11955	// Emit a call to a runtime helper
11956	GenTreeArgList* helperArgs = gtNewArgList(op1, op2);
11957	GenTree* ret = gtNewHelperCallNode(CORINFO_HELP_ARE_TYPES_EQUIVALENT, TYP_INT, helperArgs);
11958	if (oper == GT_EQ)
11959	{
11960	ret = gtNewOperNode(GT_NE, TYP_INT, ret, gtNewIconNode(`0`, TYP_INT));
11961	}
11962	else
11963	{
11964	assert(oper == GT_NE);
11965	ret = gtNewOperNode(GT_EQ, TYP_INT, ret, gtNewIconNode(`0`, TYP_INT));
11966	}
11967
11968	return ret;
11969	}
11970
11971	//------------------------------------------------------------------------
11972	// gtFoldTypeCompare: see if a type comparison can be further simplified
11973	//
11974	// Arguments:
11975	// tree -- tree possibly comparing types
11976	//
11977	// Returns:
11978	// An alternative tree if folding happens.
11979	// Original tree otherwise.
11980	//
11981	// Notes:
11982	// Checks for
11983	// typeof(...) == obj.GetType()
11984	// typeof(...) == typeof(...)
11985	//
11986	// And potentially optimizes away the need to obtain actual
11987	// RuntimeType objects to do the comparison.
11988
11989	GenTree* Compiler::gtFoldTypeCompare(GenTree* tree)
11990	{
11991	// Only handle EQ and NE
11992	// (maybe relop vs null someday)
11993	const genTreeOps oper = tree->OperGet();
11994	if ((oper != GT_EQ) && (oper != GT_NE))
11995	{
11996	return tree;
11997	}
11998
11999	// Screen for the right kinds of operands
12000	GenTree* const op1 = tree->gtOp.gtOp1;
12001	const TypeProducerKind op1Kind = gtGetTypeProducerKind(op1);
12002	if (op1Kind == TPK_Unknown)
12003	{
12004	return tree;
12005	}
12006
12007	GenTree* const op2 = tree->gtOp.gtOp2;
12008	const TypeProducerKind op2Kind = gtGetTypeProducerKind(op2);
12009	if (op2Kind == TPK_Unknown)
12010	{
12011	return tree;
12012	}
12013
12014	// We must have a handle on one side or the other here to optimize,
12015	// otherwise we can't be sure that optimizing is sound.
12016	const bool op1IsFromHandle = (op1Kind == TPK_Handle);
12017	const bool op2IsFromHandle = (op2Kind == TPK_Handle);
12018
12019	if (!(op1IsFromHandle \|\| op2IsFromHandle))
12020	{
12021	return tree;
12022	}
12023
12024	// If both types are created via handles, we can simply compare
12025	// handles (or the indirection cells for handles) instead of the
12026	// types that they'd create.
12027	if (op1IsFromHandle && op2IsFromHandle)
12028	{
12029	JITDUMP("Optimizing compare of types-from-handles to instead compare handles\n");
12030	GenTree* op1ClassFromHandle = tree->gtOp.gtOp1->gtCall.gtCallArgs->gtOp.gtOp1;
12031	GenTree* op2ClassFromHandle = tree->gtOp.gtOp2->gtCall.gtCallArgs->gtOp.gtOp1;
12032	GenTree* op1TunneledHandle = nullptr;
12033	GenTree* op2TunneledHandle = nullptr;
12034	CORINFO_CLASS_HANDLE cls1Hnd = NO_CLASS_HANDLE;
12035	CORINFO_CLASS_HANDLE cls2Hnd = NO_CLASS_HANDLE;
12036	unsigned runtimeLookupCount = `0`;
12037
12038	// Try and find class handles from op1 and op2
12039	cls1Hnd = gtGetHelperArgClassHandle(op1ClassFromHandle, &runtimeLookupCount, &op1TunneledHandle);
12040	cls2Hnd = gtGetHelperArgClassHandle(op2ClassFromHandle, &runtimeLookupCount, &op2TunneledHandle);
12041
12042	// If we have both class handles, try and resolve the type equality test completely.
12043	bool resolveFailed = false;
12044
12045	if ((cls1Hnd != NO_CLASS_HANDLE) && (cls2Hnd != NO_CLASS_HANDLE))
12046	{
12047	JITDUMP("Asking runtime to compare %p (%s) and %p (%s) for equality\n", dspPtr(cls1Hnd),
12048	info.compCompHnd->getClassName(cls1Hnd), dspPtr(cls2Hnd), info.compCompHnd->getClassName(cls2Hnd));
12049	TypeCompareState s = info.compCompHnd->compareTypesForEquality(cls1Hnd, cls2Hnd);
12050
12051	if (s != TypeCompareState::May)
12052	{
12053	// Type comparison result is known.
12054	const bool typesAreEqual = (s == TypeCompareState::Must);
12055	const bool operatorIsEQ = (oper == GT_EQ);
12056	const int compareResult = operatorIsEQ ^ typesAreEqual ? `0` : `1`;
12057	JITDUMP("Runtime reports comparison is known at jit time: %u\n", compareResult);
12058	GenTree* result = gtNewIconNode(compareResult);
12059
12060	// Any runtime lookups that fed into this compare are
12061	// now dead code, so they no longer require the runtime context.
12062	assert(lvaGenericsContextUseCount >= runtimeLookupCount);
12063	lvaGenericsContextUseCount -= runtimeLookupCount;
12064	return result;
12065	}
12066	else
12067	{
12068	resolveFailed = true;
12069	}
12070	}
12071
12072	if (resolveFailed)
12073	{
12074	JITDUMP("Runtime reports comparison is NOT known at jit time\n");
12075	}
12076	else
12077	{
12078	JITDUMP("Could not find handle for %s%s\n", (cls1Hnd == NO_CLASS_HANDLE) ? " cls1" : "",
12079	(cls2Hnd == NO_CLASS_HANDLE) ? " cls2" : "");
12080	}
12081
12082	// We can't answer the equality comparison definitively at jit
12083	// time, but can still simplfy the comparison.
12084	//
12085	// Find out how we can compare the two handles.
12086	// NOTE: We're potentially passing NO_CLASS_HANDLE, but the runtime knows what to do with it here.
12087	CorInfoInlineTypeCheck inliningKind =
12088	info.compCompHnd->canInlineTypeCheck(cls1Hnd, CORINFO_INLINE_TYPECHECK_SOURCE_TOKEN);
12089
12090	// If the first type needs helper, check the other type: it might be okay with a simple compare.
12091	if (inliningKind == CORINFO_INLINE_TYPECHECK_USE_HELPER)
12092	{
12093	inliningKind = info.compCompHnd->canInlineTypeCheck(cls2Hnd, CORINFO_INLINE_TYPECHECK_SOURCE_TOKEN);
12094	}
12095
12096	assert(inliningKind == CORINFO_INLINE_TYPECHECK_PASS \|\| inliningKind == CORINFO_INLINE_TYPECHECK_USE_HELPER);
12097
12098	// If we successfully tunneled through both operands, compare
12099	// the tunneled values, otherwise compare the original values.
12100	GenTree* compare;
12101	if ((op1TunneledHandle != nullptr) && (op2TunneledHandle != nullptr))
12102	{
12103	compare = gtCreateHandleCompare(oper, op1TunneledHandle, op2TunneledHandle, inliningKind);
12104	}
12105	else
12106	{
12107	compare = gtCreateHandleCompare(oper, op1ClassFromHandle, op2ClassFromHandle, inliningKind);
12108	}
12109
12110	// Drop any now-irrelvant flags
12111	compare->gtFlags \|= tree->gtFlags & (GTF_RELOP_JMP_USED \| GTF_RELOP_QMARK \| GTF_DONT_CSE);
12112
12113	return compare;
12114	}
12115
12116	// Just one operand creates a type from a handle.
12117	//
12118	// If the other operand is fetching the type from an object,
12119	// we can sometimes optimize the type compare into a simpler
12120	// method table comparison.
12121	//
12122	// TODO: if other operand is null...
12123	if ((op1Kind != TPK_GetType) && (op2Kind != TPK_GetType))
12124	{
12125	return tree;
12126	}
12127
12128	GenTree* const opHandle = op1IsFromHandle ? op1 : op2;
12129	GenTree* const opOther = op1IsFromHandle ? op2 : op1;
12130
12131	// Tunnel through the handle operand to get at the class handle involved.
12132	GenTree* const opHandleArgument = opHandle->gtCall.gtCallArgs->gtOp.gtOp1;
12133	CORINFO_CLASS_HANDLE clsHnd = gtGetHelperArgClassHandle(opHandleArgument);
12134
12135	// If we couldn't find the class handle, give up.
12136	if (clsHnd == NO_CLASS_HANDLE)
12137	{
12138	return tree;
12139	}
12140
12141	// Ask the VM if this type can be equality tested by a simple method
12142	// table comparison.
12143	CorInfoInlineTypeCheck typeCheckInliningResult =
12144	info.compCompHnd->canInlineTypeCheck(clsHnd, CORINFO_INLINE_TYPECHECK_SOURCE_VTABLE);
12145	if (typeCheckInliningResult == CORINFO_INLINE_TYPECHECK_NONE)
12146	{
12147	return tree;
12148	}
12149
12150	// We're good to go.
12151	JITDUMP("Optimizing compare of obj.GetType()"
12152	" and type-from-handle to compare method table pointer\n");
12153
12154	// opHandleArgument is the method table we're looking for.
12155	GenTree* const knownMT = opHandleArgument;
12156
12157	// Fetch object method table from the object itself.
12158	GenTree* objOp = nullptr;
12159
12160	// Note we may see intrinsified or regular calls to GetType
12161	if (opOther->OperGet() == GT_INTRINSIC)
12162	{
12163	objOp = opOther->gtUnOp.gtOp1;
12164	}
12165	else
12166	{
12167	assert(opOther->OperGet() == GT_CALL);
12168	objOp = opOther->gtCall.gtCallObjp;
12169	}
12170
12171	GenTree* const objMT = gtNewOperNode(GT_IND, TYP_I_IMPL, objOp);
12172
12173	// Update various flags
12174	objMT->gtFlags \|= GTF_EXCEPT;
12175	compCurBB->bbFlags \|= BBF_HAS_VTABREF;
12176	optMethodFlags \|= OMF_HAS_VTABLEREF;
12177
12178	// Compare the two method tables
12179	GenTree* const compare = gtCreateHandleCompare(oper, objMT, knownMT, typeCheckInliningResult);
12180
12181	// Drop any now irrelevant flags
12182	compare->gtFlags \|= tree->gtFlags & (GTF_RELOP_JMP_USED \| GTF_RELOP_QMARK \| GTF_DONT_CSE);
12183
12184	// And we're done
12185	return compare;
12186	}
12187
12188	//------------------------------------------------------------------------
12189	// gtGetHelperArgClassHandle: find the compile time class handle from
12190	// a helper call argument tree
12191	//
12192	// Arguments:
12193	// tree - tree that passes the handle to the helper
12194	// runtimeLookupCount [optional, in/out] - incremented if tree was a runtime lookup
12195	// handleTree [optional, out] - set to the literal operand tree for indirect handles
12196	//
12197	// Returns:
12198	// The compile time class handle if known.
12199	//
12200	CORINFO_CLASS_HANDLE Compiler::gtGetHelperArgClassHandle(GenTree* tree,
12201	unsigned* runtimeLookupCount,
12202	GenTree** handleTree)
12203	{
12204	CORINFO_CLASS_HANDLE result = NO_CLASS_HANDLE;
12205
12206	// Walk through any wrapping nop.
12207	if ((tree->gtOper == GT_NOP) && (tree->gtType == TYP_I_IMPL))
12208	{
12209	tree = tree->gtOp.gtOp1;
12210	}
12211
12212	// The handle could be a literal constant
12213	if ((tree->OperGet() == GT_CNS_INT) && (tree->TypeGet() == TYP_I_IMPL))
12214	{
12215	assert(tree->IsIconHandle(GTF_ICON_CLASS_HDL));
12216	result = (CORINFO_CLASS_HANDLE)tree->gtIntCon.gtCompileTimeHandle;
12217	}
12218	// Or the result of a runtime lookup
12219	else if (tree->OperGet() == GT_RUNTIMELOOKUP)
12220	{
12221	result = tree->AsRuntimeLookup()->GetClassHandle();
12222
12223	if (runtimeLookupCount != nullptr)
12224	{
12225	runtimeLookupCount = runtimeLookupCount + `1`;
12226	}
12227	}
12228	// Or something reached indirectly
12229	else if (tree->gtOper == GT_IND)
12230	{
12231	// The handle indirs we are looking for will be marked as non-faulting.
12232	// Certain others (eg from refanytype) may not be.
12233	if (tree->gtFlags & GTF_IND_NONFAULTING)
12234	{
12235	GenTree* handleTreeInternal = tree->gtOp.gtOp1;
12236
12237	if ((handleTreeInternal->OperGet() == GT_CNS_INT) && (handleTreeInternal->TypeGet() == TYP_I_IMPL))
12238	{
12239	// These handle constants should be class handles.
12240	assert(handleTreeInternal->IsIconHandle(GTF_ICON_CLASS_HDL));
12241	result = (CORINFO_CLASS_HANDLE)handleTreeInternal->gtIntCon.gtCompileTimeHandle;
12242
12243	if (handleTree != nullptr)
12244	{
12245	*handleTree = handleTreeInternal;
12246	}
12247	}
12248	}
12249	}
12250
12251	return result;
12252	}
12253
12254	/*****************************************************************************
12255	*
12256	* Some binary operators can be folded even if they have only one
12257	* operand constant - e.g. boolean operators, add with 0
12258	* multiply with 1, etc
12259	*/
12260
12261	GenTree* Compiler::gtFoldExprSpecial(GenTree* tree)
12262	{
12263	GenTree* op1 = tree->gtOp.gtOp1;
12264	GenTree* op2 = tree->gtOp.gtOp2;
12265	genTreeOps oper = tree->OperGet();
12266
12267	GenTree* op;
12268	GenTree* cons;
12269	ssize_t val;
12270
12271	assert(tree->OperKind() & GTK_BINOP);
12272
12273	/ Filter out operators that cannot be folded here /
12274	if (oper == GT_CAST)
12275	{
12276	return tree;
12277	}
12278
12279	/ We only consider TYP_INT for folding*
12280	* Do not fold pointer arithmetic (e.g. addressing modes!) */
12281
12282	if (oper != GT_QMARK && !varTypeIsIntOrI(tree->gtType))
12283	{
12284	return tree;
12285	}
12286
12287	/ Find out which is the constant node /
12288
12289	if (op1->IsCnsIntOrI())
12290	{
12291	op = op2;
12292	cons = op1;
12293	}
12294	else if (op2->IsCnsIntOrI())
12295	{
12296	op = op1;
12297	cons = op2;
12298	}
12299	else
12300	{
12301	return tree;
12302	}
12303
12304	/ Get the constant value /
12305
12306	val = cons->gtIntConCommon.IconValue();
12307
12308	/ Here op is the non-constant operand, val is the constant,*
12309	first is true if the constant is op1 /*
12310
12311	switch (oper)
12312	{
12313	case GT_EQ:
12314	case GT_NE:
12315	case GT_GT:
12316
12317	// Optimize boxed value classes; these are always false. This IL is
12318	// generated when a generic value is tested against null:
12319	// <T> ... foo(T x) { ... if ((object)x == null) ...
12320	if (val == `0` && op->IsBoxedValue())
12321	{
12322	JITDUMP("\nAttempting to optimize BOX(valueType) %s null [%06u]\n", GenTree::OpName(oper),
12323	dspTreeID(tree));
12324
12325	// We don't expect GT_GT with signed compares, and we
12326	// can't predict the result if we do see it, since the
12327	// boxed object addr could have its high bit set.
12328	if ((oper == GT_GT) && !tree->IsUnsigned())
12329	{
12330	JITDUMP(" bailing; unexpected signed compare via GT_GT\n");
12331	}
12332	else
12333	{
12334	// The tree under the box must be side effect free
12335	// since we will drop it if we optimize.
12336	assert(!gtTreeHasSideEffects(op->gtBox.gtOp.gtOp1, GTF_SIDE_EFFECT));
12337
12338	// See if we can optimize away the box and related statements.
12339	GenTree* boxSourceTree = gtTryRemoveBoxUpstreamEffects(op);
12340	bool didOptimize = (boxSourceTree != nullptr);
12341
12342	// If optimization succeeded, remove the box.
12343	if (didOptimize)
12344	{
12345	// Set up the result of the compare.
12346	int compareResult = `0`;
12347	if (oper == GT_GT)
12348	{
12349	// GT_GT(null, box) == false
12350	// GT_GT(box, null) == true
12351	compareResult = (op1 == op);
12352	}
12353	else if (oper == GT_EQ)
12354	{
12355	// GT_EQ(box, null) == false
12356	// GT_EQ(null, box) == false
12357	compareResult = `0`;
12358	}
12359	else
12360	{
12361	assert(oper == GT_NE);
12362	// GT_NE(box, null) == true
12363	// GT_NE(null, box) == true
12364	compareResult = `1`;
12365	}
12366
12367	JITDUMP("\nSuccess: replacing BOX(valueType) %s null with %d\n", GenTree::OpName(oper),
12368	compareResult);
12369
12370	op = gtNewIconNode(compareResult);
12371
12372	if (fgGlobalMorph)
12373	{
12374	fgMorphTreeDone(op);
12375	}
12376	else
12377	{
12378	op->gtNext = tree->gtNext;
12379	op->gtPrev = tree->gtPrev;
12380	}
12381
12382	return op;
12383	}
12384	}
12385	}
12386
12387	break;
12388
12389	case GT_ADD:
12390	if (val == `0`)
12391	{
12392	goto DONE_FOLD;
12393	}
12394	break;
12395
12396	case GT_MUL:
12397	if (val == `1`)
12398	{
12399	goto DONE_FOLD;
12400	}
12401	else if (val == `0`)
12402	{
12403	/ Multiply by zero - return the 'zero' node, but not if side effects /
12404	if (!(op->gtFlags & GTF_SIDE_EFFECT))
12405	{
12406	op = cons;
12407	goto DONE_FOLD;
12408	}
12409	}
12410	break;
12411
12412	case GT_DIV:
12413	case GT_UDIV:
12414	if ((op2 == cons) && (val == `1`) && !(op1->OperKind() & GTK_CONST))
12415	{
12416	goto DONE_FOLD;
12417	}
12418	break;
12419
12420	case GT_SUB:
12421	if ((op2 == cons) && (val == `0`) && !(op1->OperKind() & GTK_CONST))
12422	{
12423	goto DONE_FOLD;
12424	}
12425	break;
12426
12427	case GT_AND:
12428	if (val == `0`)
12429	{
12430	/ AND with zero - return the 'zero' node, but not if side effects /
12431
12432	if (!(op->gtFlags & GTF_SIDE_EFFECT))
12433	{
12434	op = cons;
12435	goto DONE_FOLD;
12436	}
12437	}
12438	else
12439	{
12440	/ The GTF_BOOLEAN flag is set for nodes that are part*
12441	* of a boolean expression, thus all their children
12442	* are known to evaluate to only 0 or 1 */
12443
12444	if (tree->gtFlags & GTF_BOOLEAN)
12445	{
12446
12447	/ The constant value must be 1*
12448	* AND with 1 stays the same */
12449	assert(val == `1`);
12450	goto DONE_FOLD;
12451	}
12452	}
12453	break;
12454
12455	case GT_OR:
12456	if (val == `0`)
12457	{
12458	goto DONE_FOLD;
12459	}
12460	else if (tree->gtFlags & GTF_BOOLEAN)
12461	{
12462	/ The constant value must be 1 - OR with 1 is 1 /
12463
12464	assert(val == `1`);
12465
12466	/ OR with one - return the 'one' node, but not if side effects /
12467
12468	if (!(op->gtFlags & GTF_SIDE_EFFECT))
12469	{
12470	op = cons;
12471	goto DONE_FOLD;
12472	}
12473	}
12474	break;
12475
12476	case GT_LSH:
12477	case GT_RSH:
12478	case GT_RSZ:
12479	case GT_ROL:
12480	case GT_ROR:
12481	if (val == `0`)
12482	{
12483	if (op2 == cons)
12484	{
12485	goto DONE_FOLD;
12486	}
12487	else if (!(op->gtFlags & GTF_SIDE_EFFECT))
12488	{
12489	op = cons;
12490	goto DONE_FOLD;
12491	}
12492	}
12493	break;
12494
12495	case GT_QMARK:
12496	{
12497	assert(op1 == cons && op2 == op && op2->gtOper == GT_COLON);
12498	assert(op2->gtOp.gtOp1 && op2->gtOp.gtOp2);
12499
12500	assert(val == `0` \|\| val == `1`);
12501
12502	GenTree* opToDelete;
12503	if (val)
12504	{
12505	op = op2->AsColon()->ThenNode();
12506	opToDelete = op2->AsColon()->ElseNode();
12507	}
12508	else
12509	{
12510	op = op2->AsColon()->ElseNode();
12511	opToDelete = op2->AsColon()->ThenNode();
12512	}
12513
12514	// Clear colon flags only if the qmark itself is not conditionaly executed
12515	if ((tree->gtFlags & GTF_COLON_COND) == `0`)
12516	{
12517	fgWalkTreePre(&op, gtClearColonCond);
12518	}
12519	}
12520
12521	goto DONE_FOLD;
12522
12523	default:
12524	break;
12525	}
12526
12527	/ The node is not foldable /
12528
12529	return tree;
12530
12531	DONE_FOLD:
12532
12533	/ The node has beeen folded into 'op' /
12534
12535	// If there was an assigment update, we just morphed it into
12536	// a use, update the flags appropriately
12537	if (op->gtOper == GT_LCL_VAR)
12538	{
12539	assert(tree->OperIs(GT_ASG) \|\| (op->gtFlags & (GTF_VAR_USEASG \| GTF_VAR_DEF)) == `0`);
12540
12541	op->gtFlags &= ~(GTF_VAR_USEASG \| GTF_VAR_DEF);
12542	}
12543
12544	op->gtNext = tree->gtNext;
12545	op->gtPrev = tree->gtPrev;
12546
12547	return op;
12548	}
12549
12550	//------------------------------------------------------------------------
12551	// gtTryRemoveBoxUpstreamEffects: given an unused value type box,
12552	// try and remove the upstream allocation and unnecessary parts of
12553	// the copy.
12554	//
12555	// Arguments:
12556	// op - the box node to optimize
12557	// options - controls whether and how trees are modified
12558	// (see notes)
12559	//
12560	// Return Value:
12561	// A tree representing the original value to box, if removal
12562	// is successful/possible (but see note). nullptr if removal fails.
12563	//
12564	// Notes:
12565	// Value typed box gets special treatment because it has associated
12566	// side effects that can be removed if the box result is not used.
12567	//
12568	// By default (options == BR_REMOVE_AND_NARROW) this method will
12569	// try and remove unnecessary trees and will try and reduce remaning
12570	// operations to the minimal set, possibly narrowing the width of
12571	// loads from the box source if it is a struct.
12572	//
12573	// To perform a trial removal, pass BR_DONT_REMOVE. This can be
12574	// useful to determine if this optimization should only be
12575	// performed if some other conditions hold true.
12576	//
12577	// To remove but not alter the access to the box source, pass
12578	// BR_REMOVE_BUT_NOT_NARROW.
12579	//
12580	// To remove and return the tree for the type handle used for
12581	// the boxed newobj, pass BR_REMOVE_BUT_NOT_NARROW_WANT_TYPE_HANDLE.
12582	// This can be useful when the only part of the box that is "live"
12583	// is its type.
12584	//
12585	// If removal fails, is is possible that a subsequent pass may be
12586	// able to optimize. Blocking side effects may now be minimized
12587	// (null or bounds checks might have been removed) or might be
12588	// better known (inline return placeholder updated with the actual
12589	// return expression). So the box is perhaps best left as is to
12590	// help trigger this re-examination.
12591
12592	GenTree* Compiler::gtTryRemoveBoxUpstreamEffects(GenTree* op, BoxRemovalOptions options)
12593	{
12594	assert(op->IsBoxedValue());
12595
12596	// grab related parts for the optimization
12597	GenTreeBox* box = op->AsBox();
12598	GenTree* asgStmt = box->gtAsgStmtWhenInlinedBoxValue;
12599	GenTree* copyStmt = box->gtCopyStmtWhenInlinedBoxValue;
12600
12601	assert(asgStmt->gtOper == GT_STMT);
12602	assert(copyStmt->gtOper == GT_STMT);
12603
12604	JITDUMP("gtTryRemoveBoxUpstreamEffects: %s to %s of BOX (valuetype)"
12605	" [%06u] (assign/newobj [%06u] copy [%06u])\n",
12606	(options == BR_DONT_REMOVE) ? "checking if it is possible" : "attempting",
12607	(options == BR_MAKE_LOCAL_COPY) ? "make local unboxed version" : "remove side effects", dspTreeID(op),
12608	dspTreeID(asgStmt), dspTreeID(copyStmt));
12609
12610	// If we don't recognize the form of the assign, bail.
12611	GenTree* asg = asgStmt->gtStmt.gtStmtExpr;
12612	if (asg->gtOper != GT_ASG)
12613	{
12614	JITDUMP(" bailing; unexpected assignment op %s\n", GenTree::OpName(asg->gtOper));
12615	return nullptr;
12616	}
12617
12618	// If we're eventually going to return the type handle, remember it now.
12619	GenTree* boxTypeHandle = nullptr;
12620	if ((options == BR_REMOVE_AND_NARROW_WANT_TYPE_HANDLE) \|\| (options == BR_DONT_REMOVE_WANT_TYPE_HANDLE))
12621	{
12622	GenTree* asgSrc = asg->gtOp.gtOp2;
12623	genTreeOps asgSrcOper = asgSrc->OperGet();
12624
12625	// Allocation may be via AllocObj or via helper call, depending
12626	// on when this is invoked and whether the jit is using AllocObj
12627	// for R2R allocations.
12628	if (asgSrcOper == GT_ALLOCOBJ)
12629	{
12630	GenTreeAllocObj* allocObj = asgSrc->AsAllocObj();
12631	boxTypeHandle = allocObj->gtOp.gtOp1;
12632	}
12633	else if (asgSrcOper == GT_CALL)
12634	{
12635	GenTreeCall* newobjCall = asgSrc->AsCall();
12636	GenTree* newobjArgs = newobjCall->gtCallArgs;
12637
12638	// In R2R expansions the handle may not be an explicit operand to the helper,
12639	// so we can't remove the box.
12640	if (newobjArgs == nullptr)
12641	{
12642	assert(newobjCall->IsHelperCall(this, CORINFO_HELP_READYTORUN_NEW));
12643	JITDUMP(" bailing; newobj via R2R helper\n");
12644	return nullptr;
12645	}
12646
12647	boxTypeHandle = newobjArgs->AsArgList()->Current();
12648	}
12649	else
12650	{
12651	unreached();
12652	}
12653
12654	assert(boxTypeHandle != nullptr);
12655	}
12656
12657	// If we don't recognize the form of the copy, bail.
12658	GenTree* copy = copyStmt->gtStmt.gtStmtExpr;
12659	if (copy->gtOper != GT_ASG)
12660	{
12661	// GT_RET_EXPR is a tolerable temporary failure.
12662	// The jit will revisit this optimization after
12663	// inlining is done.
12664	if (copy->gtOper == GT_RET_EXPR)
12665	{
12666	JITDUMP(" bailing; must wait for replacement of copy %s\n", GenTree::OpName(copy->gtOper));
12667	}
12668	else
12669	{
12670	// Anything else is a missed case we should
12671	// figure out how to handle. One known case
12672	// is GT_COMMAs enclosing the GT_ASG we are
12673	// looking for.
12674	JITDUMP(" bailing; unexpected copy op %s\n", GenTree::OpName(copy->gtOper));
12675	}
12676	return nullptr;
12677	}
12678
12679	// Handle case where we are optimizing the box into a local copy
12680	if (options == BR_MAKE_LOCAL_COPY)
12681	{
12682	// Drill into the box to get at the box temp local and the box type
12683	GenTree* boxTemp = box->BoxOp();
12684	assert(boxTemp->IsLocal());
12685	const unsigned boxTempLcl = boxTemp->AsLclVar()->GetLclNum();
12686	assert(lvaTable[boxTempLcl].lvType == TYP_REF);
12687	CORINFO_CLASS_HANDLE boxClass = lvaTable[boxTempLcl].lvClassHnd;
12688	assert(boxClass != nullptr);
12689
12690	// Verify that the copyDst has the expected shape
12691	// (blk\|obj\|ind (add (boxTempLcl, ptr-size)))
12692	//
12693	// The shape here is constrained to the patterns we produce
12694	// over in impImportAndPushBox for the inlined box case.
12695	GenTree* copyDst = copy->gtOp.gtOp1;
12696
12697	if (!copyDst->OperIs(GT_BLK, GT_IND, GT_OBJ))
12698	{
12699	JITDUMP("Unexpected copy dest operator %s\n", GenTree::OpName(copyDst->gtOper));
12700	return nullptr;
12701	}
12702
12703	GenTree* copyDstAddr = copyDst->gtOp.gtOp1;
12704	if (copyDstAddr->OperGet() != GT_ADD)
12705	{
12706	JITDUMP("Unexpected copy dest address tree\n");
12707	return nullptr;
12708	}
12709
12710	GenTree* copyDstAddrOp1 = copyDstAddr->gtOp.gtOp1;
12711	if ((copyDstAddrOp1->OperGet() != GT_LCL_VAR) \|\| (copyDstAddrOp1->gtLclVarCommon.gtLclNum != boxTempLcl))
12712	{
12713	JITDUMP("Unexpected copy dest address 1st addend\n");
12714	return nullptr;
12715	}
12716
12717	GenTree* copyDstAddrOp2 = copyDstAddr->gtOp.gtOp2;
12718	if (!copyDstAddrOp2->IsIntegralConst(TARGET_POINTER_SIZE))
12719	{
12720	JITDUMP("Unexpected copy dest address 2nd addend\n");
12721	return nullptr;
12722	}
12723
12724	// Screening checks have all passed. Do the transformation.
12725	//
12726	// Retype the box temp to be a struct
12727	JITDUMP("Retyping box temp V%02u to struct %s\n", boxTempLcl, eeGetClassName(boxClass));
12728	lvaTable[boxTempLcl].lvType = TYP_UNDEF;
12729	const bool isUnsafeValueClass = false;
12730	lvaSetStruct(boxTempLcl, boxClass, isUnsafeValueClass);
12731	var_types boxTempType = lvaTable[boxTempLcl].lvType;
12732
12733	// Remove the newobj and assigment to box temp
12734	JITDUMP("Bashing NEWOBJ [%06u] to NOP\n", dspTreeID(asg));
12735	asg->gtBashToNOP();
12736
12737	// Update the copy from the value to be boxed to the box temp
12738	GenTree* newDst = gtNewOperNode(GT_ADDR, TYP_BYREF, gtNewLclvNode(boxTempLcl, boxTempType));
12739	copyDst->gtOp.gtOp1 = newDst;
12740
12741	// Return the address of the now-struct typed box temp
12742	GenTree* retValue = gtNewOperNode(GT_ADDR, TYP_BYREF, gtNewLclvNode(boxTempLcl, boxTempType));
12743
12744	return retValue;
12745	}
12746
12747	// If the copy is a struct copy, make sure we know how to isolate
12748	// any source side effects.
12749	GenTree* copySrc = copy->gtOp.gtOp2;
12750
12751	// If the copy source is from a pending inline, wait for it to resolve.
12752	if (copySrc->gtOper == GT_RET_EXPR)
12753	{
12754	JITDUMP(" bailing; must wait for replacement of copy source %s\n", GenTree::OpName(copySrc->gtOper));
12755	return nullptr;
12756	}
12757
12758	bool hasSrcSideEffect = false;
12759	bool isStructCopy = false;
12760
12761	if (gtTreeHasSideEffects(copySrc, GTF_SIDE_EFFECT))
12762	{
12763	hasSrcSideEffect = true;
12764
12765	if (varTypeIsStruct(copySrc->gtType))
12766	{
12767	isStructCopy = true;
12768
12769	if ((copySrc->gtOper != GT_OBJ) && (copySrc->gtOper != GT_IND) && (copySrc->gtOper != GT_FIELD))
12770	{
12771	// We don't know how to handle other cases, yet.
12772	JITDUMP(" bailing; unexpected copy source struct op with side effect %s\n",
12773	GenTree::OpName(copySrc->gtOper));
12774	return nullptr;
12775	}
12776	}
12777	}
12778
12779	// If this was a trial removal, we're done.
12780	if (options == BR_DONT_REMOVE)
12781	{
12782	return copySrc;
12783	}
12784
12785	if (options == BR_DONT_REMOVE_WANT_TYPE_HANDLE)
12786	{
12787	return boxTypeHandle;
12788	}
12789
12790	// Otherwise, proceed with the optimization.
12791	//
12792	// Change the assignment expression to a NOP.
12793	JITDUMP("\nBashing NEWOBJ [%06u] to NOP\n", dspTreeID(asg));
12794	asg->gtBashToNOP();
12795
12796	// Change the copy expression so it preserves key
12797	// source side effects.
12798	JITDUMP("\nBashing COPY [%06u]", dspTreeID(copy));
12799
12800	if (!hasSrcSideEffect)
12801	{
12802	// If there were no copy source side effects just bash
12803	// the copy to a NOP.
12804	copy->gtBashToNOP();
12805	JITDUMP(" to NOP; no source side effects.\n");
12806	}
12807	else if (!isStructCopy)
12808	{
12809	// For scalar types, go ahead and produce the
12810	// value as the copy is fairly cheap and likely
12811	// the optimizer can trim things down to just the
12812	// minimal side effect parts.
12813	copyStmt->gtStmt.gtStmtExpr = copySrc;
12814	JITDUMP(" to scalar read via [%06u]\n", dspTreeID(copySrc));
12815	}
12816	else
12817	{
12818	// For struct types read the first byte of the
12819	// source struct; there's no need to read the
12820	// entire thing, and no place to put it.
12821	assert(copySrc->gtOper == GT_OBJ \|\| copySrc->gtOper == GT_IND \|\| copySrc->gtOper == GT_FIELD);
12822	copyStmt->gtStmt.gtStmtExpr = copySrc;
12823
12824	if (options == BR_REMOVE_AND_NARROW \|\| options == BR_REMOVE_AND_NARROW_WANT_TYPE_HANDLE)
12825	{
12826	JITDUMP(" to read first byte of struct via modified [%06u]\n", dspTreeID(copySrc));
12827	copySrc->ChangeOper(GT_IND);
12828	copySrc->gtType = TYP_BYTE;
12829	}
12830	else
12831	{
12832	JITDUMP(" to read entire struct via modified [%06u]\n", dspTreeID(copySrc));
12833	}
12834	}
12835
12836	if (fgStmtListThreaded)
12837	{
12838	fgSetStmtSeq(asgStmt);
12839	fgSetStmtSeq(copyStmt);
12840	}
12841
12842	// Box effects were successfully optimized.
12843
12844	if (options == BR_REMOVE_AND_NARROW_WANT_TYPE_HANDLE)
12845	{
12846	return boxTypeHandle;
12847	}
12848	else
12849	{
12850	return copySrc;
12851	}
12852	}
12853
12854	//------------------------------------------------------------------------
12855	// gtOptimizeEnumHasFlag: given the operands for a call to Enum.HasFlag,
12856	// try and optimize the call to a simple and/compare tree.
12857	//
12858	// Arguments:
12859	// thisOp - first argument to the call
12860	// flagOp - second argument to the call
12861	//
12862	// Return Value:
12863	// A new cmp/amd tree if successful. nullptr on failure.
12864	//
12865	// Notes:
12866	// If successful, may allocate new temps and modify connected
12867	// statements.
12868
12869	GenTree* Compiler::gtOptimizeEnumHasFlag(GenTree* thisOp, GenTree* flagOp)
12870	{
12871	JITDUMP("Considering optimizing call to Enum.HasFlag....\n");
12872
12873	// Operands must be boxes
12874	if (!thisOp->IsBoxedValue() \|\| !flagOp->IsBoxedValue())
12875	{
12876	JITDUMP("bailing, need both inputs to be BOXes\n");
12877	return nullptr;
12878	}
12879
12880	// Operands must have same type
12881	bool isExactThis = false;
12882	bool isNonNullThis = false;
12883	CORINFO_CLASS_HANDLE thisHnd = gtGetClassHandle(thisOp, &isExactThis, &isNonNullThis);
12884
12885	if (thisHnd == nullptr)
12886	{
12887	JITDUMP("bailing, can't find type for 'this' operand\n");
12888	return nullptr;
12889	}
12890
12891	// A boxed thisOp should have exact type and non-null instance
12892	assert(isExactThis);
12893	assert(isNonNullThis);
12894
12895	bool isExactFlag = false;
12896	bool isNonNullFlag = false;
12897	CORINFO_CLASS_HANDLE flagHnd = gtGetClassHandle(flagOp, &isExactFlag, &isNonNullFlag);
12898
12899	if (flagHnd == nullptr)
12900	{
12901	JITDUMP("bailing, can't find type for 'flag' operand\n");
12902	return nullptr;
12903	}
12904
12905	// A boxed flagOp should have exact type and non-null instance
12906	assert(isExactFlag);
12907	assert(isNonNullFlag);
12908
12909	if (flagHnd != thisHnd)
12910	{
12911	JITDUMP("bailing, operand types differ\n");
12912	return nullptr;
12913	}
12914
12915	// If we have a shared type instance we can't safely check type
12916	// equality, so bail.
12917	DWORD classAttribs = info.compCompHnd->getClassAttribs(thisHnd);
12918	if (classAttribs & CORINFO_FLG_SHAREDINST)
12919	{
12920	JITDUMP("bailing, have shared instance type\n");
12921	return nullptr;
12922	}
12923
12924	// Simulate removing the box for thisOP. We need to know that it can
12925	// be safely removed before we can optimize.
12926	GenTree* thisVal = gtTryRemoveBoxUpstreamEffects(thisOp, BR_DONT_REMOVE);
12927	if (thisVal == nullptr)
12928	{
12929	// Note we may fail here if the this operand comes from
12930	// a call. We should be able to retry this post-inlining.
12931	JITDUMP("bailing, can't undo box of 'this' operand\n");
12932	return nullptr;
12933	}
12934
12935	GenTree* flagVal = gtTryRemoveBoxUpstreamEffects(flagOp, BR_REMOVE_BUT_NOT_NARROW);
12936	if (flagVal == nullptr)
12937	{
12938	// Note we may fail here if the flag operand comes from
12939	// a call. We should be able to retry this post-inlining.
12940	JITDUMP("bailing, can't undo box of 'flag' operand\n");
12941	return nullptr;
12942	}
12943
12944	// Yes, both boxes can be cleaned up. Optimize.
12945	JITDUMP("Optimizing call to Enum.HasFlag\n");
12946
12947	// Undo the boxing of thisOp and prepare to operate directly
12948	// on the original enum values.
12949	thisVal = gtTryRemoveBoxUpstreamEffects(thisOp, BR_REMOVE_BUT_NOT_NARROW);
12950
12951	// Our trial removal above should guarantee successful removal here.
12952	assert(thisVal != nullptr);
12953
12954	// We should have a consistent view of the type
12955	var_types type = thisVal->TypeGet();
12956	assert(type == flagVal->TypeGet());
12957
12958	// The thisVal and flagVal trees come from earlier statements.
12959	//
12960	// Unless they are invariant values, we need to evaluate them both
12961	// to temps at those points to safely transmit the values here.
12962	//
12963	// Also we need to use the flag twice, so we need two trees for it.
12964	GenTree* thisValOpt = nullptr;
12965	GenTree* flagValOpt = nullptr;
12966	GenTree* flagValOptCopy = nullptr;
12967
12968	if (thisVal->IsIntegralConst())
12969	{
12970	thisValOpt = gtClone(thisVal);
12971	assert(thisValOpt != nullptr);
12972	}
12973	else
12974	{
12975	const unsigned thisTmp = lvaGrabTemp(true DEBUGARG("Enum:HasFlag this temp"));
12976	GenTree* thisAsg = gtNewTempAssign(thisTmp, thisVal);
12977	GenTree* thisAsgStmt = thisOp->AsBox()->gtCopyStmtWhenInlinedBoxValue;
12978	thisAsgStmt->gtStmt.gtStmtExpr = thisAsg;
12979	thisValOpt = gtNewLclvNode(thisTmp, type);
12980	}
12981
12982	if (flagVal->IsIntegralConst())
12983	{
12984	flagValOpt = gtClone(flagVal);
12985	assert(flagValOpt != nullptr);
12986	flagValOptCopy = gtClone(flagVal);
12987	assert(flagValOptCopy != nullptr);
12988	}
12989	else
12990	{
12991	const unsigned flagTmp = lvaGrabTemp(true DEBUGARG("Enum:HasFlag flag temp"));
12992	GenTree* flagAsg = gtNewTempAssign(flagTmp, flagVal);
12993	GenTree* flagAsgStmt = flagOp->AsBox()->gtCopyStmtWhenInlinedBoxValue;
12994	flagAsgStmt->gtStmt.gtStmtExpr = flagAsg;
12995	flagValOpt = gtNewLclvNode(flagTmp, type);
12996	flagValOptCopy = gtNewLclvNode(flagTmp, type);
12997	}
12998
12999	// Turn the call into (thisValTmp & flagTmp) == flagTmp.
13000	GenTree* andTree = gtNewOperNode(GT_AND, type, thisValOpt, flagValOpt);
13001	GenTree* cmpTree = gtNewOperNode(GT_EQ, TYP_INT, andTree, flagValOptCopy);
13002
13003	JITDUMP("Optimized call to Enum.HasFlag\n");
13004
13005	return cmpTree;
13006	}
13007
13008	/*****************************************************************************
13009	*
13010	* Fold the given constant tree.
13011	*/
13012
13013	#ifdef _PREFAST_
13014	#pragma warning(push)
13015	#pragma warning(disable : 21000) // Suppress PREFast warning about overly large function
13016	#endif
13017	GenTree* Compiler::gtFoldExprConst(GenTree* tree)
13018	{
13019	unsigned kind = tree->OperKind();
13020
13021	SSIZE_T i1, i2, itemp;
13022	INT64 lval1, lval2, ltemp;
13023	float f1, f2;
13024	double d1, d2;
13025	var_types switchType;
13026	FieldSeqNode* fieldSeq = FieldSeqStore::NotAField(); // default unless we override it when folding
13027
13028	assert(kind & (GTK_UNOP \| GTK_BINOP));
13029
13030	GenTree* op1 = tree->gtOp.gtOp1;
13031	GenTree* op2 = tree->gtGetOp2IfPresent();
13032
13033	if (!opts.OptEnabled(CLFLG_CONSTANTFOLD))
13034	{
13035	return tree;
13036	}
13037
13038	if (tree->OperGet() == GT_NOP)
13039	{
13040	return tree;
13041	}
13042
13043	#ifdef FEATURE_SIMD
13044	if (tree->OperGet() == GT_SIMD)
13045	{
13046	return tree;
13047	}
13048	#endif // FEATURE_SIMD
13049
13050	if (tree->gtOper == GT_ALLOCOBJ)
13051	{
13052	return tree;
13053	}
13054
13055	if (tree->gtOper == GT_RUNTIMELOOKUP)
13056	{
13057	return tree;
13058	}
13059
13060	if (kind & GTK_UNOP)
13061	{
13062	assert(op1->OperKind() & GTK_CONST);
13063
13064	switch (op1->gtType)
13065	{
13066	case TYP_INT:
13067
13068	/ Fold constant INT unary operator /
13069
13070	if (!op1->gtIntCon.ImmedValCanBeFolded(this, tree->OperGet()))
13071	{
13072	return tree;
13073	}
13074
13075	i1 = (int)op1->gtIntCon.gtIconVal;
13076
13077	// If we fold a unary oper, then the folded constant
13078	// is considered a ConstantIndexField if op1 was one
13079	//
13080
13081	if ((op1->gtIntCon.gtFieldSeq != nullptr) && op1->gtIntCon.gtFieldSeq->IsConstantIndexFieldSeq())
13082	{
13083	fieldSeq = op1->gtIntCon.gtFieldSeq;
13084	}
13085
13086	switch (tree->gtOper)
13087	{
13088	case GT_NOT:
13089	i1 = ~i1;
13090	break;
13091
13092	case GT_NEG:
13093	i1 = -i1;
13094	break;
13095
13096	case GT_BSWAP:
13097	i1 = ((i1 >> `24`) & `0xFF`) \| ((i1 >> `8`) & `0xFF00`) \| ((i1 << `8`) & `0xFF0000`) \|
13098	((i1 << `24`) & `0xFF000000`);
13099	break;
13100
13101	case GT_BSWAP16:
13102	i1 = ((i1 >> `8`) & `0xFF`) \| ((i1 << `8`) & `0xFF00`);
13103	break;
13104
13105	case GT_CAST:
13106	// assert (genActualType(tree->CastToType()) == tree->gtType);
13107	switch (tree->CastToType())
13108	{
13109	case TYP_BYTE:
13110	itemp = INT32(INT8(i1));
13111	goto CHK_OVF;
13112
13113	case TYP_SHORT:
13114	itemp = INT32(INT16(i1));
13115	CHK_OVF:
13116	if (tree->gtOverflow() && ((itemp != i1) \|\| ((tree->gtFlags & GTF_UNSIGNED) && i1 < `0`)))
13117	{
13118	goto INT_OVF;
13119	}
13120	i1 = itemp;
13121	goto CNS_INT;
13122
13123	case TYP_USHORT:
13124	itemp = INT32(UINT16(i1));
13125	if (tree->gtOverflow())
13126	{
13127	if (itemp != i1)
13128	{
13129	goto INT_OVF;
13130	}
13131	}
13132	i1 = itemp;
13133	goto CNS_INT;
13134
13135	case TYP_BOOL:
13136	case TYP_UBYTE:
13137	itemp = INT32(UINT8(i1));
13138	if (tree->gtOverflow())
13139	{
13140	if (itemp != i1)
13141	{
13142	goto INT_OVF;
13143	}
13144	}
13145	i1 = itemp;
13146	goto CNS_INT;
13147
13148	case TYP_UINT:
13149	if (!(tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && i1 < `0`)
13150	{
13151	goto INT_OVF;
13152	}
13153	goto CNS_INT;
13154
13155	case TYP_INT:
13156	if ((tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && i1 < `0`)
13157	{
13158	goto INT_OVF;
13159	}
13160	goto CNS_INT;
13161
13162	case TYP_ULONG:
13163	if (tree->IsUnsigned())
13164	{
13165	lval1 = UINT64(UINT32(i1));
13166	}
13167	else
13168	{
13169	if (tree->gtOverflow() && (i1 < `0`))
13170	{
13171	goto LNG_OVF;
13172	}
13173	lval1 = UINT64(INT32(i1));
13174	}
13175	goto CNS_LONG;
13176
13177	case TYP_LONG:
13178	if (tree->IsUnsigned())
13179	{
13180	lval1 = INT64(UINT32(i1));
13181	}
13182	else
13183	{
13184	lval1 = INT64(INT32(i1));
13185	}
13186	goto CNS_LONG;
13187
13188	case TYP_FLOAT:
13189	if (tree->gtFlags & GTF_UNSIGNED)
13190	{
13191	f1 = forceCastToFloat(UINT32(i1));
13192	}
13193	else
13194	{
13195	f1 = forceCastToFloat(INT32(i1));
13196	}
13197	d1 = f1;
13198	goto CNS_DOUBLE;
13199
13200	case TYP_DOUBLE:
13201	if (tree->gtFlags & GTF_UNSIGNED)
13202	{
13203	d1 = (double)UINT32(i1);
13204	}
13205	else
13206	{
13207	d1 = (double)INT32(i1);
13208	}
13209	goto CNS_DOUBLE;
13210
13211	default:
13212	assert(!"BAD_TYP");
13213	break;
13214	}
13215	return tree;
13216
13217	default:
13218	return tree;
13219	}
13220
13221	goto CNS_INT;
13222
13223	case TYP_LONG:
13224
13225	/ Fold constant LONG unary operator /
13226
13227	if (!op1->gtIntConCommon.ImmedValCanBeFolded(this, tree->OperGet()))
13228	{
13229	return tree;
13230	}
13231
13232	lval1 = op1->gtIntConCommon.LngValue();
13233
13234	switch (tree->gtOper)
13235	{
13236	case GT_NOT:
13237	lval1 = ~lval1;
13238	break;
13239
13240	case GT_NEG:
13241	lval1 = -lval1;
13242	break;
13243
13244	case GT_BSWAP:
13245	lval1 = ((lval1 >> `56`) & `0xFF`) \| ((lval1 >> `40`) & `0xFF00`) \| ((lval1 >> `24`) & `0xFF0000`) \|
13246	((lval1 >> `8`) & `0xFF000000`) \| ((lval1 << `8`) & `0xFF00000000`) \|
13247	((lval1 << `24`) & `0xFF0000000000`) \| ((lval1 << `40`) & `0xFF000000000000`) \|
13248	((lval1 << `56`) & `0xFF00000000000000`);
13249	break;
13250
13251	case GT_CAST:
13252	assert(genActualType(tree->CastToType()) == tree->gtType);
13253	switch (tree->CastToType())
13254	{
13255	case TYP_BYTE:
13256	i1 = INT32(INT8(lval1));
13257	goto CHECK_INT_OVERFLOW;
13258
13259	case TYP_SHORT:
13260	i1 = INT32(INT16(lval1));
13261	goto CHECK_INT_OVERFLOW;
13262
13263	case TYP_USHORT:
13264	i1 = INT32(UINT16(lval1));
13265	goto CHECK_UINT_OVERFLOW;
13266
13267	case TYP_UBYTE:
13268	i1 = INT32(UINT8(lval1));
13269	goto CHECK_UINT_OVERFLOW;
13270
13271	case TYP_INT:
13272	i1 = INT32(lval1);
13273
13274	CHECK_INT_OVERFLOW:
13275	if (tree->gtOverflow())
13276	{
13277	if (i1 != lval1)
13278	{
13279	goto INT_OVF;
13280	}
13281	if ((tree->gtFlags & GTF_UNSIGNED) && i1 < `0`)
13282	{
13283	goto INT_OVF;
13284	}
13285	}
13286	goto CNS_INT;
13287
13288	case TYP_UINT:
13289	i1 = UINT32(lval1);
13290
13291	CHECK_UINT_OVERFLOW:
13292	if (tree->gtOverflow() && UINT32(i1) != lval1)
13293	{
13294	goto INT_OVF;
13295	}
13296	goto CNS_INT;
13297
13298	case TYP_ULONG:
13299	if (!(tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && lval1 < `0`)
13300	{
13301	goto LNG_OVF;
13302	}
13303	goto CNS_LONG;
13304
13305	case TYP_LONG:
13306	if ((tree->gtFlags & GTF_UNSIGNED) && tree->gtOverflow() && lval1 < `0`)
13307	{
13308	goto LNG_OVF;
13309	}
13310	goto CNS_LONG;
13311
13312	case TYP_FLOAT:
13313	case TYP_DOUBLE:
13314	if ((tree->gtFlags & GTF_UNSIGNED) && lval1 < `0`)
13315	{
13316	d1 = FloatingPointUtils::convertUInt64ToDouble((unsigned __int64)lval1);
13317	}
13318	else
13319	{
13320	d1 = (double)lval1;
13321	}
13322
13323	if (tree->CastToType() == TYP_FLOAT)
13324	{
13325	f1 = forceCastToFloat(d1); // truncate precision
13326	d1 = f1;
13327	}
13328	goto CNS_DOUBLE;
13329	default:
13330	assert(!"BAD_TYP");
13331	break;
13332	}
13333	return tree;
13334
13335	default:
13336	return tree;
13337	}
13338
13339	goto CNS_LONG;
13340
13341	case TYP_FLOAT:
13342	case TYP_DOUBLE:
13343	assert(op1->gtOper == GT_CNS_DBL);
13344
13345	/ Fold constant DOUBLE unary operator /
13346
13347	d1 = op1->gtDblCon.gtDconVal;
13348
13349	switch (tree->gtOper)
13350	{
13351	case GT_NEG:
13352	d1 = -d1;
13353	break;
13354
13355	case GT_CAST:
13356
13357	if (tree->gtOverflowEx())
13358	{
13359	return tree;
13360	}
13361
13362	assert(genActualType(tree->CastToType()) == tree->gtType);
13363
13364	if ((op1->gtType == TYP_FLOAT && !_finite(forceCastToFloat(d1))) \|\|
13365	(op1->gtType == TYP_DOUBLE && !_finite(d1)))
13366	{
13367	// The floating point constant is not finite. The ECMA spec says, in
13368	// III 3.27, that "...if overflow occurs converting a floating point type
13369	// to an integer, ..., the value returned is unspecified." However, it would
13370	// at least be desirable to have the same value returned for casting an overflowing
13371	// constant to an int as would obtained by passing that constant as a parameter
13372	// then casting that parameter to an int type. We will assume that the C compiler's
13373	// cast logic will yield the desired result (and trust testing to tell otherwise).
13374	// Cross-compilation is an issue here; if that becomes an important scenario, we should
13375	// capture the target-specific values of overflow casts to the various integral types as
13376	// constants in a target-specific function.
13377	CLANG_FORMAT_COMMENT_ANCHOR;
13378
13379	// Don't fold conversions of +inf/-inf to integral value on all platforms
13380	// as the value returned by JIT helper doesn't match with the C compiler's cast result.
13381	// We want the behavior to be same with or without folding.
13382	return tree;
13383	}
13384
13385	if (d1 <= -`1.0` && varTypeIsUnsigned(tree->CastToType()))
13386	{
13387	// Don't fold conversions of these cases becasue the result is unspecified per ECMA spec
13388	// and the native math doing the fold doesn't match the run-time computation on all
13389	// platforms.
13390	// We want the behavior to be same with or without folding.
13391	return tree;
13392	}
13393
13394	switch (tree->CastToType())
13395	{
13396	case TYP_BYTE:
13397	i1 = INT32(INT8(d1));
13398	goto CNS_INT;
13399
13400	case TYP_SHORT:
13401	i1 = INT32(INT16(d1));
13402	goto CNS_INT;
13403
13404	case TYP_USHORT:
13405	i1 = INT32(UINT16(d1));
13406	goto CNS_INT;
13407
13408	case TYP_UBYTE:
13409	i1 = INT32(UINT8(d1));
13410	goto CNS_INT;
13411
13412	case TYP_INT:
13413	i1 = INT32(d1);
13414	goto CNS_INT;
13415
13416	case TYP_UINT:
13417	i1 = forceCastToUInt32(d1);
13418	goto CNS_INT;
13419
13420	case TYP_LONG:
13421	lval1 = INT64(d1);
13422	goto CNS_LONG;
13423
13424	case TYP_ULONG:
13425	lval1 = FloatingPointUtils::convertDoubleToUInt64(d1);
13426	goto CNS_LONG;
13427
13428	case TYP_FLOAT:
13429	d1 = forceCastToFloat(d1);
13430	goto CNS_DOUBLE;
13431
13432	case TYP_DOUBLE:
13433	if (op1->gtType == TYP_FLOAT)
13434	{
13435	d1 = forceCastToFloat(d1); // truncate precision
13436	}
13437	goto CNS_DOUBLE; // redundant cast
13438
13439	default:
13440	assert(!"BAD_TYP");
13441	break;
13442	}
13443	return tree;
13444
13445	default:
13446	return tree;
13447	}
13448	goto CNS_DOUBLE;
13449
13450	default:
13451	/ not a foldable typ - e.g. RET const /
13452	return tree;
13453	}
13454	}
13455
13456	/ We have a binary operator /
13457
13458	assert(kind & GTK_BINOP);
13459	assert(op2);
13460	assert(op1->OperKind() & GTK_CONST);
13461	assert(op2->OperKind() & GTK_CONST);
13462
13463	if (tree->gtOper == GT_COMMA)
13464	{
13465	return op2;
13466	}
13467
13468	if (tree->OperIsAnyList())
13469	{
13470	return tree;
13471	}
13472
13473	switchType = op1->gtType;
13474
13475	// Normally we will just switch on op1 types, but for the case where
13476	// only op2 is a GC type and op1 is not a GC type, we use the op2 type.
13477	// This makes us handle this as a case of folding for GC type.
13478	//
13479	if (varTypeIsGC(op2->gtType) && !varTypeIsGC(op1->gtType))
13480	{
13481	switchType = op2->gtType;
13482	}
13483
13484	switch (switchType)
13485	{
13486
13487	/-------------------------------------------------------------------------*
13488	* Fold constant REF of BYREF binary operator
13489	* These can only be comparisons or null pointers
13490	*/
13491
13492	case TYP_REF:
13493
13494	/ String nodes are an RVA at this point /
13495
13496	if (op1->gtOper == GT_CNS_STR \|\| op2->gtOper == GT_CNS_STR)
13497	{
13498	return tree;
13499	}
13500
13501	__fallthrough;
13502
13503	case TYP_BYREF:
13504
13505	i1 = op1->gtIntConCommon.IconValue();
13506	i2 = op2->gtIntConCommon.IconValue();
13507
13508	switch (tree->gtOper)
13509	{
13510	case GT_EQ:
13511	i1 = (i1 == i2);
13512	goto FOLD_COND;
13513
13514	case GT_NE:
13515	i1 = (i1 != i2);
13516	goto FOLD_COND;
13517
13518	case GT_ADD:
13519	noway_assert(tree->gtType != TYP_REF);
13520	// We only fold a GT_ADD that involves a null reference.
13521	if (((op1->TypeGet() == TYP_REF) && (i1 == `0`)) \|\| ((op2->TypeGet() == TYP_REF) && (i2 == `0`)))
13522	{
13523	#ifdef DEBUG
13524	if (verbose)
13525	{
13526	printf("\nFolding operator with constant nodes into a constant:\n");
13527	gtDispTree(tree);
13528	}
13529	#endif
13530	// Fold into GT_IND of null byref
13531	tree->ChangeOperConst(GT_CNS_INT);
13532	tree->gtType = TYP_BYREF;
13533	tree->gtIntCon.gtIconVal = `0`;
13534	tree->gtIntCon.gtFieldSeq = FieldSeqStore::NotAField();
13535	if (vnStore != nullptr)
13536	{
13537	fgValueNumberTreeConst(tree);
13538	}
13539	#ifdef DEBUG
13540	if (verbose)
13541	{
13542	printf("\nFolded to null byref:\n");
13543	gtDispTree(tree);
13544	}
13545	#endif
13546	goto DONE;
13547	}
13548
13549	default:
13550	break;
13551	}
13552
13553	return tree;
13554
13555	/-------------------------------------------------------------------------*
13556	* Fold constant INT binary operator
13557	*/
13558
13559	case TYP_INT:
13560
13561	if (tree->OperIsCompare() && (tree->gtType == TYP_BYTE))
13562	{
13563	tree->gtType = TYP_INT;
13564	}
13565
13566	assert(tree->gtType == TYP_INT \|\| varTypeIsGC(tree->TypeGet()) \|\| tree->gtOper == GT_MKREFANY);
13567
13568	// No GC pointer types should be folded here...
13569	//
13570	assert(!varTypeIsGC(op1->gtType) && !varTypeIsGC(op2->gtType));
13571
13572	if (!op1->gtIntConCommon.ImmedValCanBeFolded(this, tree->OperGet()))
13573	{
13574	return tree;
13575	}
13576
13577	if (!op2->gtIntConCommon.ImmedValCanBeFolded(this, tree->OperGet()))
13578	{
13579	return tree;
13580	}
13581
13582	i1 = op1->gtIntConCommon.IconValue();
13583	i2 = op2->gtIntConCommon.IconValue();
13584
13585	switch (tree->gtOper)
13586	{
13587	case GT_EQ:
13588	i1 = (INT32(i1) == INT32(i2));
13589	break;
13590	case GT_NE:
13591	i1 = (INT32(i1) != INT32(i2));
13592	break;
13593
13594	case GT_LT:
13595	if (tree->gtFlags & GTF_UNSIGNED)
13596	{
13597	i1 = (UINT32(i1) < UINT32(i2));
13598	}
13599	else
13600	{
13601	i1 = (INT32(i1) < INT32(i2));
13602	}
13603	break;
13604
13605	case GT_LE:
13606	if (tree->gtFlags & GTF_UNSIGNED)
13607	{
13608	i1 = (UINT32(i1) <= UINT32(i2));
13609	}
13610	else
13611	{
13612	i1 = (INT32(i1) <= INT32(i2));
13613	}
13614	break;
13615
13616	case GT_GE:
13617	if (tree->gtFlags & GTF_UNSIGNED)
13618	{
13619	i1 = (UINT32(i1) >= UINT32(i2));
13620	}
13621	else
13622	{
13623	i1 = (INT32(i1) >= INT32(i2));
13624	}
13625	break;
13626
13627	case GT_GT:
13628	if (tree->gtFlags & GTF_UNSIGNED)
13629	{
13630	i1 = (UINT32(i1) > UINT32(i2));
13631	}
13632	else
13633	{
13634	i1 = (INT32(i1) > INT32(i2));
13635	}
13636	break;
13637
13638	case GT_ADD:
13639	itemp = i1 + i2;
13640	if (tree->gtOverflow())
13641	{
13642	if (tree->gtFlags & GTF_UNSIGNED)
13643	{
13644	if (INT64(UINT32(itemp)) != INT64(UINT32(i1)) + INT64(UINT32(i2)))
13645	{
13646	goto INT_OVF;
13647	}
13648	}
13649	else
13650	{
13651	if (INT64(INT32(itemp)) != INT64(INT32(i1)) + INT64(INT32(i2)))
13652	{
13653	goto INT_OVF;
13654	}
13655	}
13656	}
13657	i1 = itemp;
13658	fieldSeq = GetFieldSeqStore()->Append(op1->gtIntCon.gtFieldSeq, op2->gtIntCon.gtFieldSeq);
13659	break;
13660	case GT_SUB:
13661	itemp = i1 - i2;
13662	if (tree->gtOverflow())
13663	{
13664	if (tree->gtFlags & GTF_UNSIGNED)
13665	{
13666	if (INT64(UINT32(itemp)) != ((INT64)((UINT32)i1) - (INT64)((UINT32)i2)))
13667	{
13668	goto INT_OVF;
13669	}
13670	}
13671	else
13672	{
13673	if (INT64(INT32(itemp)) != INT64(INT32(i1)) - INT64(INT32(i2)))
13674	{
13675	goto INT_OVF;
13676	}
13677	}
13678	}
13679	i1 = itemp;
13680	break;
13681	case GT_MUL:
13682	itemp = i1 * i2;
13683	if (tree->gtOverflow())
13684	{
13685	if (tree->gtFlags & GTF_UNSIGNED)
13686	{
13687	if (INT64(UINT32(itemp)) != ((INT64)((UINT32)i1) * (INT64)((UINT32)i2)))
13688	{
13689	goto INT_OVF;
13690	}
13691	}
13692	else
13693	{
13694	if (INT64(INT32(itemp)) != INT64(INT32(i1)) * INT64(INT32(i2)))
13695	{
13696	goto INT_OVF;
13697	}
13698	}
13699	}
13700	// For the very particular case of the "constant array index" pseudo-field, we
13701	// assume that multiplication is by the field width, and preserves that field.
13702	// This could obviously be made more robust by a more complicated set of annotations...
13703	if ((op1->gtIntCon.gtFieldSeq != nullptr) && op1->gtIntCon.gtFieldSeq->IsConstantIndexFieldSeq())
13704	{
13705	assert(op2->gtIntCon.gtFieldSeq == FieldSeqStore::NotAField());
13706	fieldSeq = op1->gtIntCon.gtFieldSeq;
13707	}
13708	else if ((op2->gtIntCon.gtFieldSeq != nullptr) &&
13709	op2->gtIntCon.gtFieldSeq->IsConstantIndexFieldSeq())
13710	{
13711	assert(op1->gtIntCon.gtFieldSeq == FieldSeqStore::NotAField());
13712	fieldSeq = op2->gtIntCon.gtFieldSeq;
13713	}
13714	i1 = itemp;
13715	break;
13716
13717	case GT_OR:
13718	i1 \|= i2;
13719	break;
13720	case GT_XOR:
13721	i1 ^= i2;
13722	break;
13723	case GT_AND:
13724	i1 &= i2;
13725	break;
13726
13727	case GT_LSH:
13728	i1 <<= (i2 & `0x1f`);
13729	break;
13730	case GT_RSH:
13731	i1 >>= (i2 & `0x1f`);
13732	break;
13733	case GT_RSZ:
13734	/ logical shift -> make it unsigned to not propagate the sign bit /
13735	i1 = UINT32(i1) >> (i2 & `0x1f`);
13736	break;
13737	case GT_ROL:
13738	i1 = (i1 << (i2 & `0x1f`)) \| (UINT32(i1) >> ((`32` - i2) & `0x1f`));
13739	break;
13740	case GT_ROR:
13741	i1 = (i1 << ((`32` - i2) & `0x1f`)) \| (UINT32(i1) >> (i2 & `0x1f`));
13742	break;
13743
13744	/ DIV and MOD can generate an INT 0 - if division by 0*
13745	* or overflow - when dividing MIN by -1 */
13746
13747	case GT_DIV:
13748	case GT_MOD:
13749	case GT_UDIV:
13750	case GT_UMOD:
13751	if (INT32(i2) == `0`)
13752	{
13753	// Division by zero:
13754	// We have to evaluate this expression and throw an exception
13755	return tree;
13756	}
13757	else if ((INT32(i2) == -`1`) && (UINT32(i1) == `0x80000000`))
13758	{
13759	// Overflow Division:
13760	// We have to evaluate this expression and throw an exception
13761	return tree;
13762	}
13763
13764	if (tree->gtOper == GT_DIV)
13765	{
13766	i1 = INT32(i1) / INT32(i2);
13767	}
13768	else if (tree->gtOper == GT_MOD)
13769	{
13770	i1 = INT32(i1) % INT32(i2);
13771	}
13772	else if (tree->gtOper == GT_UDIV)
13773	{
13774	i1 = UINT32(i1) / UINT32(i2);
13775	}
13776	else
13777	{
13778	assert(tree->gtOper == GT_UMOD);
13779	i1 = UINT32(i1) % UINT32(i2);
13780	}
13781	break;
13782
13783	default:
13784	return tree;
13785	}
13786
13787	/ We get here after folding to a GT_CNS_INT type*
13788	* change the node to the new type / value and make sure the node sizes are OK */
13789	CNS_INT:
13790	FOLD_COND:
13791
13792	#ifdef DEBUG
13793	if (verbose)
13794	{
13795	printf("\nFolding operator with constant nodes into a constant:\n");
13796	gtDispTree(tree);
13797	}
13798	#endif
13799
13800	#ifdef _TARGET_64BIT_
13801	// Some operations are performed as 64 bit instead of 32 bit so the upper 32 bits
13802	// need to be discarded. Since constant values are stored as ssize_t and the node
13803	// has TYP_INT the result needs to be sign extended rather than zero extended.
13804	i1 = INT32(i1);
13805	#endif // _TARGET_64BIT_
13806
13807	/ Also all conditional folding jumps here since the node hanging from*
13808	* GT_JTRUE has to be a GT_CNS_INT - value 0 or 1 */
13809
13810	tree->ChangeOperConst(GT_CNS_INT);
13811	tree->gtType = TYP_INT;
13812	tree->gtIntCon.gtIconVal = i1;
13813	tree->gtIntCon.gtFieldSeq = fieldSeq;
13814	if (vnStore != nullptr)
13815	{
13816	fgValueNumberTreeConst(tree);
13817	}
13818	#ifdef DEBUG
13819	if (verbose)
13820	{
13821	printf("Bashed to int constant:\n");
13822	gtDispTree(tree);
13823	}
13824	#endif
13825	goto DONE;
13826
13827	/ This operation is going to cause an overflow exception. Morph into*
13828	an overflow helper. Put a dummy constant value for code generation.
13829
13830	We could remove all subsequent trees in the current basic block,
13831	unless this node is a child of GT_COLON
13832
13833	NOTE: Since the folded value is not constant we should not change the
13834	"tree" node - otherwise we confuse the logic that checks if the folding
13835	was successful - instead use one of the operands, e.g. op1
13836	*/
13837
13838	LNG_OVF:
13839	// Don't fold overflow operations if not global morph phase.
13840	// The reason for this is that this optimization is replacing a gentree node
13841	// with another new gentree node. Say a GT_CALL(arglist) has one 'arg'
13842	// involving overflow arithmetic. During assertion prop, it is possible
13843	// that the 'arg' could be constant folded and the result could lead to an
13844	// overflow. In such a case 'arg' will get replaced with GT_COMMA node
13845	// but fgMorphArgs() - see the logic around "if(lateArgsComputed)" - doesn't
13846	// update args table. For this reason this optimization is enabled only
13847	// for global morphing phase.
13848	//
13849	// TODO-CQ: Once fgMorphArgs() is fixed this restriction could be removed.
13850	CLANG_FORMAT_COMMENT_ANCHOR;
13851
13852	if (!fgGlobalMorph)
13853	{
13854	assert(tree->gtOverflow());
13855	return tree;
13856	}
13857
13858	op1 = gtNewLconNode(`0`);
13859	if (vnStore != nullptr)
13860	{
13861	op1->gtVNPair.SetBoth(vnStore->VNZeroForType(TYP_LONG));
13862	}
13863	goto OVF;
13864
13865	INT_OVF:
13866	// Don't fold overflow operations if not global morph phase.
13867	// The reason for this is that this optimization is replacing a gentree node
13868	// with another new gentree node. Say a GT_CALL(arglist) has one 'arg'
13869	// involving overflow arithmetic. During assertion prop, it is possible
13870	// that the 'arg' could be constant folded and the result could lead to an
13871	// overflow. In such a case 'arg' will get replaced with GT_COMMA node
13872	// but fgMorphArgs() - see the logic around "if(lateArgsComputed)" - doesn't
13873	// update args table. For this reason this optimization is enabled only
13874	// for global morphing phase.
13875	//
13876	// TODO-CQ: Once fgMorphArgs() is fixed this restriction could be removed.
13877
13878	if (!fgGlobalMorph)
13879	{
13880	assert(tree->gtOverflow());
13881	return tree;
13882	}
13883
13884	op1 = gtNewIconNode(`0`);
13885	if (vnStore != nullptr)
13886	{
13887	op1->gtVNPair.SetBoth(vnStore->VNZeroForType(TYP_INT));
13888	}
13889	goto OVF;
13890
13891	OVF:
13892	#ifdef DEBUG
13893	if (verbose)
13894	{
13895	printf("\nFolding binary operator with constant nodes into a comma throw:\n");
13896	gtDispTree(tree);
13897	}
13898	#endif
13899	/ We will change the cast to a GT_COMMA and attach the exception helper as gtOp.gtOp1.*
13900	* The constant expression zero becomes op2. */
13901
13902	assert(tree->gtOverflow());
13903	assert(tree->gtOper == GT_ADD \|\| tree->gtOper == GT_SUB \|\| tree->gtOper == GT_CAST \|\|
13904	tree->gtOper == GT_MUL);
13905	assert(op1);
13906
13907	op2 = op1;
13908	op1 = gtNewHelperCallNode(CORINFO_HELP_OVERFLOW, TYP_VOID,
13909	gtNewArgList(gtNewIconNode(compCurBB->bbTryIndex)));
13910
13911	// op1 is a call to the JIT helper that throws an Overflow exception
13912	// attach the ExcSet for VNF_OverflowExc(Void) to this call
13913
13914	if (vnStore != nullptr)
13915	{
13916	op1->gtVNPair =
13917	vnStore->VNPWithExc(ValueNumPair (ValueNumStore::VNForVoid(), ValueNumStore::VNForVoid()),
13918	vnStore->VNPExcSetSingleton(
13919	vnStore->VNPairForFunc(TYP_REF, VNF_OverflowExc, vnStore->VNPForVoid())));
13920	}
13921
13922	tree = gtNewOperNode(GT_COMMA, tree->gtType, op1, op2);
13923
13924	return tree;
13925
13926	/-------------------------------------------------------------------------*
13927	* Fold constant LONG binary operator
13928	*/
13929
13930	case TYP_LONG:
13931
13932	// No GC pointer types should be folded here...
13933	//
13934	assert(!varTypeIsGC(op1->gtType) && !varTypeIsGC(op2->gtType));
13935
13936	// op1 is known to be a TYP_LONG, op2 is normally a TYP_LONG, unless we have a shift operator in which case
13937	// it is a TYP_INT
13938	//
13939	assert((op2->gtType == TYP_LONG) \|\| (op2->gtType == TYP_INT));
13940
13941	if (!op1->gtIntConCommon.ImmedValCanBeFolded(this, tree->OperGet()))
13942	{
13943	return tree;
13944	}
13945
13946	if (!op2->gtIntConCommon.ImmedValCanBeFolded(this, tree->OperGet()))
13947	{
13948	return tree;
13949	}
13950
13951	lval1 = op1->gtIntConCommon.LngValue();
13952
13953	// For the shift operators we can have a op2 that is a TYP_INT and thus will be GT_CNS_INT
13954	if (op2->OperGet() == GT_CNS_INT)
13955	{
13956	lval2 = op2->gtIntConCommon.IconValue();
13957	}
13958	else
13959	{
13960	lval2 = op2->gtIntConCommon.LngValue();
13961	}
13962
13963	switch (tree->gtOper)
13964	{
13965	case GT_EQ:
13966	i1 = (lval1 == lval2);
13967	goto FOLD_COND;
13968	case GT_NE:
13969	i1 = (lval1 != lval2);
13970	goto FOLD_COND;
13971
13972	case GT_LT:
13973	if (tree->gtFlags & GTF_UNSIGNED)
13974	{
13975	i1 = (UINT64(lval1) < UINT64(lval2));
13976	}
13977	else
13978	{
13979	i1 = (lval1 < lval2);
13980	}
13981	goto FOLD_COND;
13982
13983	case GT_LE:
13984	if (tree->gtFlags & GTF_UNSIGNED)
13985	{
13986	i1 = (UINT64(lval1) <= UINT64(lval2));
13987	}
13988	else
13989	{
13990	i1 = (lval1 <= lval2);
13991	}
13992	goto FOLD_COND;
13993
13994	case GT_GE:
13995	if (tree->gtFlags & GTF_UNSIGNED)
13996	{
13997	i1 = (UINT64(lval1) >= UINT64(lval2));
13998	}
13999	else
14000	{
14001	i1 = (lval1 >= lval2);
14002	}
14003	goto FOLD_COND;
14004
14005	case GT_GT:
14006	if (tree->gtFlags & GTF_UNSIGNED)
14007	{
14008	i1 = (UINT64(lval1) > UINT64(lval2));
14009	}
14010	else
14011	{
14012	i1 = (lval1 > lval2);
14013	}
14014	goto FOLD_COND;
14015
14016	case GT_ADD:
14017	ltemp = lval1 + lval2;
14018
14019	LNG_ADD_CHKOVF:
14020	/ For the SIGNED case - If there is one positive and one negative operand, there can be no overflow*
14021	* If both are positive, the result has to be positive, and similary for negatives.
14022	*
14023	* For the UNSIGNED case - If a UINT32 operand is bigger than the result then OVF */
14024
14025	if (tree->gtOverflow())
14026	{
14027	if (tree->gtFlags & GTF_UNSIGNED)
14028	{
14029	if ((UINT64(lval1) > UINT64(ltemp)) \|\| (UINT64(lval2) > UINT64(ltemp)))
14030	{
14031	goto LNG_OVF;
14032	}
14033	}
14034	else if (((lval1 < `0`) == (lval2 < `0`)) && ((lval1 < `0`) != (ltemp < `0`)))
14035	{
14036	goto LNG_OVF;
14037	}
14038	}
14039	lval1 = ltemp;
14040	break;
14041
14042	case GT_SUB:
14043	ltemp = lval1 - lval2;
14044	if (tree->gtOverflow())
14045	{
14046	if (tree->gtFlags & GTF_UNSIGNED)
14047	{
14048	if (UINT64(lval2) > UINT64(lval1))
14049	{
14050	goto LNG_OVF;
14051	}
14052	}
14053	else
14054	{
14055	/ If both operands are +ve or both are -ve, there can be no*
14056	overflow. Else use the logic for : lval1 + (-lval2) /*
14057
14058	if ((lval1 < `0`) != (lval2 < `0`))
14059	{
14060	if (lval2 == INT64_MIN)
14061	{
14062	goto LNG_OVF;
14063	}
14064	lval2 = -lval2;
14065	goto LNG_ADD_CHKOVF;
14066	}
14067	}
14068	}
14069	lval1 = ltemp;
14070	break;
14071
14072	case GT_MUL:
14073	ltemp = lval1 * lval2;
14074
14075	if (tree->gtOverflow() && lval2 != `0`)
14076	{
14077
14078	if (tree->gtFlags & GTF_UNSIGNED)
14079	{
14080	UINT64 ultemp = ltemp;
14081	UINT64 ulval1 = lval1;
14082	UINT64 ulval2 = lval2;
14083	if ((ultemp / ulval2) != ulval1)
14084	{
14085	goto LNG_OVF;
14086	}
14087	}
14088	else
14089	{
14090	// This does a multiply and then reverses it. This test works great except for MIN_INT *
14091	//-1. In that case we mess up the sign on ltmp. Make sure to double check the sign.
14092	// if either is 0, then no overflow
14093	if (lval1 != `0`) // lval2 checked above.
14094	{
14095	if (((lval1 < `0`) == (lval2 < `0`)) && (ltemp < `0`))
14096	{
14097	goto LNG_OVF;
14098	}
14099	if (((lval1 < `0`) != (lval2 < `0`)) && (ltemp > `0`))
14100	{
14101	goto LNG_OVF;
14102	}
14103
14104	// TODO-Amd64-Unix: Remove the code that disables optimizations for this method when the
14105	// clang
14106	// optimizer is fixed and/or the method implementation is refactored in a simpler code.
14107	// There is a bug in the clang-3.5 optimizer. The issue is that in release build the
14108	// optimizer is mistyping (or just wrongly decides to use 32 bit operation for a corner
14109	// case of MIN_LONG) the args of the (ltemp / lval2) to int (it does a 32 bit div
14110	// operation instead of 64 bit.). For the case of lval1 and lval2 equal to MIN_LONG
14111	// (0x8000000000000000) this results in raising a SIGFPE.
14112	// Optimizations disabled for now. See compiler.h.
14113	if ((ltemp / lval2) != lval1)
14114	{
14115	goto LNG_OVF;
14116	}
14117	}
14118	}
14119	}
14120
14121	lval1 = ltemp;
14122	break;
14123
14124	case GT_OR:
14125	lval1 \|= lval2;
14126	break;
14127	case GT_XOR:
14128	lval1 ^= lval2;
14129	break;
14130	case GT_AND:
14131	lval1 &= lval2;
14132	break;
14133
14134	case GT_LSH:
14135	lval1 <<= (lval2 & `0x3f`);
14136	break;
14137	case GT_RSH:
14138	lval1 >>= (lval2 & `0x3f`);
14139	break;
14140	case GT_RSZ:
14141	/ logical shift -> make it unsigned to not propagate the sign bit /
14142	lval1 = UINT64(lval1) >> (lval2 & `0x3f`);
14143	break;
14144	case GT_ROL:
14145	lval1 = (lval1 << (lval2 & `0x3f`)) \| (UINT64(lval1) >> ((`64` - lval2) & `0x3f`));
14146	break;
14147	case GT_ROR:
14148	lval1 = (lval1 << ((`64` - lval2) & `0x3f`)) \| (UINT64(lval1) >> (lval2 & `0x3f`));
14149	break;
14150
14151	// Both DIV and IDIV on x86 raise an exception for min_int (and min_long) / -1. So we preserve
14152	// that behavior here.
14153	case GT_DIV:
14154	if (!lval2)
14155	{
14156	return tree;
14157	}
14158
14159	if (UINT64(lval1) == UI64(`0x8000000000000000`) && lval2 == INT64(-`1`))
14160	{
14161	return tree;
14162	}
14163	lval1 /= lval2;
14164	break;
14165
14166	case GT_MOD:
14167	if (!lval2)
14168	{
14169	return tree;
14170	}
14171	if (UINT64(lval1) == UI64(`0x8000000000000000`) && lval2 == INT64(-`1`))
14172	{
14173	return tree;
14174	}
14175	lval1 %= lval2;
14176	break;
14177
14178	case GT_UDIV:
14179	if (!lval2)
14180	{
14181	return tree;
14182	}
14183	if (UINT64(lval1) == UI64(`0x8000000000000000`) && lval2 == INT64(-`1`))
14184	{
14185	return tree;
14186	}
14187	lval1 = UINT64(lval1) / UINT64(lval2);
14188	break;
14189
14190	case GT_UMOD:
14191	if (!lval2)
14192	{
14193	return tree;
14194	}
14195	if (UINT64(lval1) == UI64(`0x8000000000000000`) && lval2 == INT64(-`1`))
14196	{
14197	return tree;
14198	}
14199	lval1 = UINT64(lval1) % UINT64(lval2);
14200	break;
14201	default:
14202	return tree;
14203	}
14204
14205	CNS_LONG:
14206
14207	if (fieldSeq != FieldSeqStore::NotAField())
14208	{
14209	return tree;
14210	}
14211
14212	#ifdef DEBUG
14213	if (verbose)
14214	{
14215	printf("\nFolding long operator with constant nodes into a constant:\n");
14216	gtDispTree(tree);
14217	}
14218	#endif
14219	assert((GenTree::s_gtNodeSizes[GT_CNS_NATIVELONG] == TREE_NODE_SZ_SMALL) \|\|
14220	(tree->gtDebugFlags & GTF_DEBUG_NODE_LARGE));
14221
14222	tree->ChangeOperConst(GT_CNS_NATIVELONG);
14223	tree->gtIntConCommon.SetLngValue(lval1);
14224	if (vnStore != nullptr)
14225	{
14226	fgValueNumberTreeConst(tree);
14227	}
14228
14229	#ifdef DEBUG
14230	if (verbose)
14231	{
14232	printf("Bashed to long constant:\n");
14233	gtDispTree(tree);
14234	}
14235	#endif
14236	goto DONE;
14237
14238	/-------------------------------------------------------------------------*
14239	* Fold constant FLOAT or DOUBLE binary operator
14240	*/
14241
14242	case TYP_FLOAT:
14243	case TYP_DOUBLE:
14244
14245	if (tree->gtOverflowEx())
14246	{
14247	return tree;
14248	}
14249
14250	assert(op1->gtOper == GT_CNS_DBL);
14251	d1 = op1->gtDblCon.gtDconVal;
14252
14253	assert(varTypeIsFloating(op2->gtType));
14254	assert(op2->gtOper == GT_CNS_DBL);
14255	d2 = op2->gtDblCon.gtDconVal;
14256
14257	/ Special case - check if we have NaN operands.*
14258	* For comparisons if not an unordered operation always return 0.
14259	* For unordered operations (i.e. the GTF_RELOP_NAN_UN flag is set)
14260	* the result is always true - return 1. */
14261
14262	if (_isnan(d1) \|\| _isnan(d2))
14263	{
14264	#ifdef DEBUG
14265	if (verbose)
14266	{
14267	printf("Double operator(s) is NaN\n");
14268	}
14269	#endif
14270	if (tree->OperKind() & GTK_RELOP)
14271	{
14272	if (tree->gtFlags & GTF_RELOP_NAN_UN)
14273	{
14274	/ Unordered comparison with NaN always succeeds /
14275	i1 = `1`;
14276	goto FOLD_COND;
14277	}
14278	else
14279	{
14280	/ Normal comparison with NaN always fails /
14281	i1 = `0`;
14282	goto FOLD_COND;
14283	}
14284	}
14285	}
14286
14287	switch (tree->gtOper)
14288	{
14289	case GT_EQ:
14290	i1 = (d1 == d2);
14291	goto FOLD_COND;
14292	case GT_NE:
14293	i1 = (d1 != d2);
14294	goto FOLD_COND;
14295
14296	case GT_LT:
14297	i1 = (d1 < d2);
14298	goto FOLD_COND;
14299	case GT_LE:
14300	i1 = (d1 <= d2);
14301	goto FOLD_COND;
14302	case GT_GE:
14303	i1 = (d1 >= d2);
14304	goto FOLD_COND;
14305	case GT_GT:
14306	i1 = (d1 > d2);
14307	goto FOLD_COND;
14308
14309	// Floating point arithmetic should be done in declared
14310	// precision while doing constant folding. For this reason though TYP_FLOAT
14311	// constants are stored as double constants, while performing float arithmetic,
14312	// double constants should be converted to float. Here is an example case
14313	// where performing arithmetic in double precision would lead to incorrect
14314	// results.
14315	//
14316	// Example:
14317	// float a = float.MaxValue;
14318	// float b = aa; This will produce +inf in single precision and 1.1579207543382391e+077 in double*
14319	// precision.
14320	// flaot c = b/b; This will produce NaN in single precision and 1 in double precision.
14321	case GT_ADD:
14322	if (op1->TypeGet() == TYP_FLOAT)
14323	{
14324	f1 = forceCastToFloat(d1);
14325	f2 = forceCastToFloat(d2);
14326	d1 = forceCastToFloat(f1 + f2);
14327	}
14328	else
14329	{
14330	d1 += d2;
14331	}
14332	break;
14333
14334	case GT_SUB:
14335	if (op1->TypeGet() == TYP_FLOAT)
14336	{
14337	f1 = forceCastToFloat(d1);
14338	f2 = forceCastToFloat(d2);
14339	d1 = forceCastToFloat(f1 - f2);
14340	}
14341	else
14342	{
14343	d1 -= d2;
14344	}
14345	break;
14346
14347	case GT_MUL:
14348	if (op1->TypeGet() == TYP_FLOAT)
14349	{
14350	f1 = forceCastToFloat(d1);
14351	f2 = forceCastToFloat(d2);
14352	d1 = forceCastToFloat(f1 * f2);
14353	}
14354	else
14355	{
14356	d1 *= d2;
14357	}
14358	break;
14359
14360	case GT_DIV:
14361	if (!d2)
14362	{
14363	return tree;
14364	}
14365	if (op1->TypeGet() == TYP_FLOAT)
14366	{
14367	f1 = forceCastToFloat(d1);
14368	f2 = forceCastToFloat(d2);
14369	d1 = forceCastToFloat(f1 / f2);
14370	}
14371	else
14372	{
14373	d1 /= d2;
14374	}
14375	break;
14376
14377	default:
14378	return tree;
14379	}
14380
14381	CNS_DOUBLE:
14382
14383	#ifdef DEBUG
14384	if (verbose)
14385	{
14386	printf("\nFolding fp operator with constant nodes into a fp constant:\n");
14387	gtDispTree(tree);
14388	}
14389	#endif
14390
14391	assert((GenTree::s_gtNodeSizes[GT_CNS_DBL] == TREE_NODE_SZ_SMALL) \|\|
14392	(tree->gtDebugFlags & GTF_DEBUG_NODE_LARGE));
14393
14394	tree->ChangeOperConst(GT_CNS_DBL);
14395	tree->gtDblCon.gtDconVal = d1;
14396	if (vnStore != nullptr)
14397	{
14398	fgValueNumberTreeConst(tree);
14399	}
14400	#ifdef DEBUG
14401	if (verbose)
14402	{
14403	printf("Bashed to fp constant:\n");
14404	gtDispTree(tree);
14405	}
14406	#endif
14407	goto DONE;
14408
14409	default:
14410	/ not a foldable typ /
14411	return tree;
14412	}
14413
14414	//-------------------------------------------------------------------------
14415
14416	DONE:
14417
14418	/ Make sure no side effect flags are set on this constant node /
14419
14420	tree->gtFlags &= ~GTF_ALL_EFFECT;
14421
14422	return tree;
14423	}
14424	#ifdef _PREFAST_
14425	#pragma warning(pop)
14426	#endif
14427
14428	//------------------------------------------------------------------------
14429	// gtNewTempAssign: Create an assignment of the given value to a temp.
14430	//
14431	// Arguments:
14432	// tmp - local number for a compiler temp
14433	// val - value to assign to the temp
14434	// pAfterStmt - statement to insert any additional statements after
14435	// ilOffset - il offset for new statements
14436	// block - block to insert any additional statements in
14437	//
14438	// Return Value:
14439	// Normally a new assignment node.
14440	// However may return a nop node if val is simply a reference to the temp.
14441	//
14442	// Notes:
14443	// Self-assignments may be represented via NOPs.
14444	//
14445	// May update the type of the temp, if it was previously unknown.
14446	//
14447	// May set compFloatingPointUsed.
14448
14449	GenTree* Compiler::gtNewTempAssign(
14450	unsigned tmp, GenTree* val, GenTree** pAfterStmt, IL_OFFSETX ilOffset, BasicBlock* block)
14451	{
14452	// Self-assignment is a nop.
14453	if (val->OperGet() == GT_LCL_VAR && val->gtLclVarCommon.gtLclNum == tmp)
14454	{
14455	return gtNewNothingNode();
14456	}
14457
14458	LclVarDsc* varDsc = lvaTable + tmp;
14459
14460	if (varDsc->TypeGet() == TYP_I_IMPL && val->TypeGet() == TYP_BYREF)
14461	{
14462	impBashVarAddrsToI(val);
14463	}
14464
14465	var_types valTyp = val->TypeGet();
14466	if (val->OperGet() == GT_LCL_VAR && lvaTable[val->gtLclVar.gtLclNum].lvNormalizeOnLoad())
14467	{
14468	valTyp = lvaGetRealType(val->gtLclVar.gtLclNum);
14469	val->gtType = valTyp;
14470	}
14471	var_types dstTyp = varDsc->TypeGet();
14472
14473	/ If the variable's lvType is not yet set then set it here /
14474	if (dstTyp == TYP_UNDEF)
14475	{
14476	varDsc->lvType = dstTyp = genActualType(valTyp);
14477	if (varTypeIsGC(dstTyp))
14478	{
14479	varDsc->lvStructGcCount = `1`;
14480	}
14481	#if FEATURE_SIMD
14482	else if (varTypeIsSIMD(dstTyp))
14483	{
14484	varDsc->lvSIMDType = `1`;
14485	}
14486	#endif
14487	}
14488
14489	#ifdef DEBUG
14490	/ Make sure the actual types match /
14491	if (genActualType(valTyp) != genActualType(dstTyp))
14492	{
14493	// Plus some other exceptions that are apparently legal:
14494	// 1) TYP_REF or BYREF = TYP_I_IMPL
14495	bool ok = false;
14496	if (varTypeIsGC(dstTyp) && (valTyp == TYP_I_IMPL))
14497	{
14498	ok = true;
14499	}
14500	// 2) TYP_DOUBLE = TYP_FLOAT or TYP_FLOAT = TYP_DOUBLE
14501	else if (varTypeIsFloating(dstTyp) && varTypeIsFloating(valTyp))
14502	{
14503	ok = true;
14504	}
14505
14506	if (!ok)
14507	{
14508	gtDispTree(val);
14509	assert(!"Incompatible types for gtNewTempAssign");
14510	}
14511	}
14512	#endif
14513
14514	// Floating Point assignments can be created during inlining
14515	// see "Zero init inlinee locals:" in fgInlinePrependStatements
14516	// thus we may need to set compFloatingPointUsed to true here.
14517	//
14518	if (varTypeIsFloating(dstTyp) && (compFloatingPointUsed == false))
14519	{
14520	compFloatingPointUsed = true;
14521	}
14522
14523	/ Create the assignment node /
14524
14525	GenTree* asg;
14526	GenTree* dest = gtNewLclvNode(tmp, dstTyp);
14527	dest->gtFlags \|= GTF_VAR_DEF;
14528
14529	// With first-class structs, we should be propagating the class handle on all non-primitive
14530	// struct types. We don't have a convenient way to do that for all SIMD temps, since some
14531	// internal trees use SIMD types that are not used by the input IL. In this case, we allow
14532	// a null type handle and derive the necessary information about the type from its varType.
14533	CORINFO_CLASS_HANDLE structHnd = gtGetStructHandleIfPresent(val);
14534	if (varTypeIsStruct(valTyp) && ((structHnd != NO_CLASS_HANDLE) \|\| (varTypeIsSIMD(valTyp))))
14535	{
14536	// The struct value may be be a child of a GT_COMMA.
14537	GenTree* valx = val->gtEffectiveVal(/commaOnly/ true);
14538
14539	if (structHnd != NO_CLASS_HANDLE)
14540	{
14541	lvaSetStruct(tmp, structHnd, false);
14542	}
14543	else
14544	{
14545	assert(valx->gtOper != GT_OBJ);
14546	}
14547	dest->gtFlags \|= GTF_DONT_CSE;
14548	valx->gtFlags \|= GTF_DONT_CSE;
14549	asg = impAssignStruct(dest, val, structHnd, (unsigned)CHECK_SPILL_NONE, pAfterStmt, ilOffset, block);
14550	}
14551	else
14552	{
14553	asg = gtNewAssignNode(dest, val);
14554	}
14555
14556	if (compRationalIRForm)
14557	{
14558	Rationalizer::RewriteAssignmentIntoStoreLcl(asg->AsOp());
14559	}
14560
14561	return asg;
14562	}
14563
14564	/*****************************************************************************
14565	*
14566	* Create a helper call to access a COM field (iff 'assg' is non-zero this is
14567	* an assignment and 'assg' is the new value).
14568	*/
14569
14570	GenTree* Compiler::gtNewRefCOMfield(GenTree* objPtr,
14571	CORINFO_RESOLVED_TOKEN* pResolvedToken,
14572	CORINFO_ACCESS_FLAGS access,
14573	CORINFO_FIELD_INFO* pFieldInfo,
14574	var_types lclTyp,
14575	CORINFO_CLASS_HANDLE structType,
14576	GenTree* assg)
14577	{
14578	assert(pFieldInfo->fieldAccessor == CORINFO_FIELD_INSTANCE_HELPER \|\|
14579	pFieldInfo->fieldAccessor == CORINFO_FIELD_INSTANCE_ADDR_HELPER \|\|
14580	pFieldInfo->fieldAccessor == CORINFO_FIELD_STATIC_ADDR_HELPER);
14581
14582	/ If we can't access it directly, we need to call a helper function /
14583	GenTreeArgList* args = nullptr;
14584	var_types helperType = TYP_BYREF;
14585
14586	if (pFieldInfo->fieldAccessor == CORINFO_FIELD_INSTANCE_HELPER)
14587	{
14588	if (access & CORINFO_ACCESS_SET)
14589	{
14590	assert(assg != nullptr);
14591	// helper needs pointer to struct, not struct itself
14592	if (pFieldInfo->helper == CORINFO_HELP_SETFIELDSTRUCT)
14593	{
14594	assert(structType != nullptr);
14595	assg = impGetStructAddr(assg, structType, (unsigned)CHECK_SPILL_ALL, true);
14596	}
14597	else if (lclTyp == TYP_DOUBLE && assg->TypeGet() == TYP_FLOAT)
14598	{
14599	assg = gtNewCastNode(TYP_DOUBLE, assg, false, TYP_DOUBLE);
14600	}
14601	else if (lclTyp == TYP_FLOAT && assg->TypeGet() == TYP_DOUBLE)
14602	{
14603	assg = gtNewCastNode(TYP_FLOAT, assg, false, TYP_FLOAT);
14604	}
14605
14606	args = gtNewArgList(assg);
14607	helperType = TYP_VOID;
14608	}
14609	else if (access & CORINFO_ACCESS_GET)
14610	{
14611	helperType = lclTyp;
14612
14613	// The calling convention for the helper does not take into
14614	// account optimization of primitive structs.
14615	if ((pFieldInfo->helper == CORINFO_HELP_GETFIELDSTRUCT) && !varTypeIsStruct(lclTyp))
14616	{
14617	helperType = TYP_STRUCT;
14618	}
14619	}
14620	}
14621
14622	if (pFieldInfo->helper == CORINFO_HELP_GETFIELDSTRUCT \|\| pFieldInfo->helper == CORINFO_HELP_SETFIELDSTRUCT)
14623	{
14624	assert(pFieldInfo->structType != nullptr);
14625	args = gtNewListNode(gtNewIconEmbClsHndNode(pFieldInfo->structType), args);
14626	}
14627
14628	GenTree* fieldHnd = impTokenToHandle(pResolvedToken);
14629	if (fieldHnd == nullptr)
14630	{ // compDonotInline()
14631	return nullptr;
14632	}
14633
14634	args = gtNewListNode(fieldHnd, args);
14635
14636	// If it's a static field, we shouldn't have an object node
14637	// If it's an instance field, we have an object node
14638	assert((pFieldInfo->fieldAccessor != CORINFO_FIELD_STATIC_ADDR_HELPER) ^ (objPtr == nullptr));
14639
14640	if (objPtr != nullptr)
14641	{
14642	args = gtNewListNode(objPtr, args);
14643	}
14644
14645	GenTreeCall* call = gtNewHelperCallNode(pFieldInfo->helper, genActualType(helperType), args);
14646
14647	#if FEATURE_MULTIREG_RET
14648	if (varTypeIsStruct(call))
14649	{
14650	// Initialize Return type descriptor of call node.
14651	ReturnTypeDesc* retTypeDesc = call->GetReturnTypeDesc();
14652	retTypeDesc->InitializeStructReturnType(this, structType);
14653	}
14654	#endif // FEATURE_MULTIREG_RET
14655
14656	GenTree* result = call;
14657
14658	if (pFieldInfo->fieldAccessor == CORINFO_FIELD_INSTANCE_HELPER)
14659	{
14660	if (access & CORINFO_ACCESS_GET)
14661	{
14662	if (pFieldInfo->helper == CORINFO_HELP_GETFIELDSTRUCT)
14663	{
14664	if (!varTypeIsStruct(lclTyp))
14665	{
14666	// get the result as primitive type
14667	result = impGetStructAddr(result, structType, (unsigned)CHECK_SPILL_ALL, true);
14668	result = gtNewOperNode(GT_IND, lclTyp, result);
14669	}
14670	}
14671	else if (varTypeIsIntegral(lclTyp) && genTypeSize(lclTyp) < genTypeSize(TYP_INT))
14672	{
14673	// The helper does not extend the small return types.
14674	result = gtNewCastNode(genActualType(lclTyp), result, false, lclTyp);
14675	}
14676	}
14677	}
14678	else
14679	{
14680	// OK, now do the indirection
14681	if (access & CORINFO_ACCESS_GET)
14682	{
14683	if (varTypeIsStruct(lclTyp))
14684	{
14685	result = gtNewObjNode(structType, result);
14686	}
14687	else
14688	{
14689	result = gtNewOperNode(GT_IND, lclTyp, result);
14690	}
14691	result->gtFlags \|= (GTF_EXCEPT \| GTF_GLOB_REF);
14692	}
14693	else if (access & CORINFO_ACCESS_SET)
14694	{
14695	if (varTypeIsStruct(lclTyp))
14696	{
14697	result = impAssignStructPtr(result, assg, structType, (unsigned)CHECK_SPILL_ALL);
14698	}
14699	else
14700	{
14701	result = gtNewOperNode(GT_IND, lclTyp, result);
14702	result->gtFlags \|= (GTF_EXCEPT \| GTF_GLOB_REF \| GTF_IND_TGTANYWHERE);
14703	result = gtNewAssignNode(result, assg);
14704	}
14705	}
14706	}
14707
14708	return result;
14709	}
14710
14711	/*****************************************************************************
14712	*
14713	* Return true if the given node (excluding children trees) contains side effects.
14714	* Note that it does not recurse, and children need to be handled separately.
14715	* It may return false even if the node has GTF_SIDE_EFFECT (because of its children).
14716	*
14717	* Similar to OperMayThrow() (but handles GT_CALLs specially), but considers
14718	* assignments too.
14719	*/
14720
14721	bool Compiler::gtNodeHasSideEffects(GenTree* tree, unsigned flags)
14722	{
14723	if (flags & GTF_ASG)
14724	{
14725	// TODO-Cleanup: This only checks for GT_ASG but according to OperRequiresAsgFlag there
14726	// are many more opers that are considered to have an assignment side effect: atomic ops
14727	// (GT_CMPXCHG & co.), GT_MEMORYBARRIER (not classified as an atomic op) and HW intrinsic
14728	// memory stores. Atomic ops have special handling in gtExtractSideEffList but the others
14729	// will simply be dropped is they are ever subject to an "extract side effects" operation.
14730	// It is possible that the reason no bugs have yet been observed in this area is that the
14731	// other nodes are likely to always be tree roots.
14732	if (tree->OperIs(GT_ASG))
14733	{
14734	return true;
14735	}
14736	}
14737
14738	// Are there only GTF_CALL side effects remaining? (and no other side effect kinds)
14739	if (flags & GTF_CALL)
14740	{
14741	if (tree->OperGet() == GT_CALL)
14742	{
14743	GenTreeCall* const call = tree->AsCall();
14744	const bool ignoreExceptions = (flags & GTF_EXCEPT) == `0`;
14745	const bool ignoreCctors = (flags & GTF_IS_IN_CSE) != `0`; // We can CSE helpers that run cctors.
14746	if (!call->HasSideEffects(this, ignoreExceptions, ignoreCctors))
14747	{
14748	// If this call is otherwise side effect free, check its arguments.
14749	for (GenTreeArgList* args = call->gtCallArgs; args != nullptr; args = args->Rest())
14750	{
14751	if (gtTreeHasSideEffects(args->Current(), flags))
14752	{
14753	return true;
14754	}
14755	}
14756	// I'm a little worried that args that assign to temps that are late args will look like
14757	// side effects...but better to be conservative for now.
14758	for (GenTreeArgList* args = call->gtCallLateArgs; args != nullptr; args = args->Rest())
14759	{
14760	if (gtTreeHasSideEffects(args->Current(), flags))
14761	{
14762	return true;
14763	}
14764	}
14765
14766	// Otherwise:
14767	return false;
14768	}
14769
14770	// Otherwise the GT_CALL is considered to have side-effects.
14771	return true;
14772	}
14773	}
14774
14775	if (flags & GTF_EXCEPT)
14776	{
14777	if (tree->OperMayThrow(this))
14778	{
14779	return true;
14780	}
14781	}
14782
14783	// Expressions declared as CSE by (e.g.) hoisting code are considered to have relevant side
14784	// effects (if we care about GTF_MAKE_CSE).
14785	if ((flags & GTF_MAKE_CSE) && (tree->gtFlags & GTF_MAKE_CSE))
14786	{
14787	return true;
14788	}
14789
14790	return false;
14791	}
14792
14793	/*****************************************************************************
14794	* Returns true if the expr tree has any side effects.
14795	*/
14796
14797	bool Compiler::gtTreeHasSideEffects(GenTree* tree, unsigned flags / = GTF_SIDE_EFFECT/)
14798	{
14799	// These are the side effect flags that we care about for this tree
14800	unsigned sideEffectFlags = tree->gtFlags & flags;
14801
14802	// Does this tree have any Side-effect flags set that we care about?
14803	if (sideEffectFlags == `0`)
14804	{
14805	// no it doesn't..
14806	return false;
14807	}
14808
14809	if (sideEffectFlags == GTF_CALL)
14810	{
14811	if (tree->OperGet() == GT_CALL)
14812	{
14813	// Generally all trees that contain GT_CALL nodes are considered to have side-effects.
14814	//
14815	if (tree->gtCall.gtCallType == CT_HELPER)
14816	{
14817	// If this node is a helper call we may not care about the side-effects.
14818	// Note that gtNodeHasSideEffects checks the side effects of the helper itself
14819	// as well as the side effects of its arguments.
14820	return gtNodeHasSideEffects(tree, flags);
14821	}
14822	}
14823	else if (tree->OperGet() == GT_INTRINSIC)
14824	{
14825	if (gtNodeHasSideEffects(tree, flags))
14826	{
14827	return true;
14828	}
14829
14830	if (gtNodeHasSideEffects(tree->gtOp.gtOp1, flags))
14831	{
14832	return true;
14833	}
14834
14835	if ((tree->gtOp.gtOp2 != nullptr) && gtNodeHasSideEffects(tree->gtOp.gtOp2, flags))
14836	{
14837	return true;
14838	}
14839
14840	return false;
14841	}
14842	}
14843
14844	return true;
14845	}
14846
14847	GenTree* Compiler::gtBuildCommaList(GenTree* list, GenTree* expr)
14848	{
14849	// 'list' starts off as null,
14850	// and when it is null we haven't started the list yet.
14851	//
14852	if (list != nullptr)
14853	{
14854	// Create a GT_COMMA that appends 'expr' in front of the remaining set of expressions in (list)*
14855	GenTree* result = gtNewOperNode(GT_COMMA, TYP_VOID, expr, list);
14856
14857	// Set the flags in the comma node
14858	result->gtFlags \|= (list->gtFlags & GTF_ALL_EFFECT);
14859	result->gtFlags \|= (expr->gtFlags & GTF_ALL_EFFECT);
14860
14861	// 'list' and 'expr' should have valuenumbers defined for both or for neither one (unless we are remorphing,
14862	// in which case a prior transform involving either node may have discarded or otherwise invalidated the value
14863	// numbers).
14864	assert((list->gtVNPair.BothDefined() == expr->gtVNPair.BothDefined()) \|\| !fgGlobalMorph);
14865
14866	// Set the ValueNumber 'gtVNPair' for the new GT_COMMA node
14867	//
14868	if (list->gtVNPair.BothDefined() && expr->gtVNPair.BothDefined())
14869	{
14870	// The result of a GT_COMMA node is op2, the normal value number is op2vnp
14871	// But we also need to include the union of side effects from op1 and op2.
14872	// we compute this value into exceptions_vnp.
14873	ValueNumPair op1vnp;
14874	ValueNumPair op1Xvnp = ValueNumStore::VNPForEmptyExcSet();
14875	ValueNumPair op2vnp;
14876	ValueNumPair op2Xvnp = ValueNumStore::VNPForEmptyExcSet();
14877
14878	vnStore->VNPUnpackExc(expr->gtVNPair, &op1vnp, &op1Xvnp);
14879	vnStore->VNPUnpackExc(list->gtVNPair, &op2vnp, &op2Xvnp);
14880
14881	ValueNumPair exceptions_vnp = ValueNumStore::VNPForEmptyExcSet();
14882
14883	exceptions_vnp = vnStore->VNPExcSetUnion(exceptions_vnp, op1Xvnp);
14884	exceptions_vnp = vnStore->VNPExcSetUnion(exceptions_vnp, op2Xvnp);
14885
14886	result->gtVNPair = vnStore->VNPWithExc(op2vnp, exceptions_vnp);
14887	}
14888
14889	return result;
14890	}
14891	else
14892	{
14893	// The 'expr' will start the list of expressions
14894	return expr;
14895	}
14896	}
14897
14898	//------------------------------------------------------------------------
14899	// gtExtractSideEffList: Extracts side effects from the given expression.
14900	//
14901	// Arguments:
14902	// expr - the expression tree to extract side effects from
14903	// pList - pointer to a (possibly null) GT_COMMA list that
14904	// will contain the extracted side effects
14905	// flags - side effect flags to be considered
14906	// ignoreRoot - ignore side effects on the expression root node
14907	//
14908	// Notes:
14909	// Side effects are prepended to the GT_COMMA list such that op1 of
14910	// each comma node holds the side effect tree and op2 points to the
14911	// next comma node. The original side effect execution order is preserved.
14912	//
14913	void Compiler::gtExtractSideEffList(GenTree* expr,
14914	GenTree** pList,
14915	unsigned flags / = GTF_SIDE_EFFECT/,
14916	bool ignoreRoot / = false /)
14917	{
14918	class SideEffectExtractor final : public GenTreeVisitor<SideEffectExtractor>
14919	{
14920	public:
14921	const unsigned m_flags;
14922	ArrayStack<GenTree*> m_sideEffects;
14923
14924	enum
14925	{
14926	DoPreOrder = true,
14927	UseExecutionOrder = true
14928	};
14929
14930	SideEffectExtractor(Compiler* compiler, unsigned flags)
14931	: GenTreeVisitor (compiler), m_flags(flags), m_sideEffects (compiler->getAllocator(CMK_SideEffects))
14932	{
14933	}
14934
14935	fgWalkResult PreOrderVisit(GenTree** use, GenTree* user)
14936	{
14937	GenTree* node = *use;
14938
14939	bool treeHasSideEffects = m_compiler->gtTreeHasSideEffects(node, m_flags);
14940
14941	if (treeHasSideEffects)
14942	{
14943	if (m_compiler->gtNodeHasSideEffects(node, m_flags))
14944	{
14945	m_sideEffects.Push(node);
14946	return Compiler::WALK_SKIP_SUBTREES;
14947	}
14948
14949	// TODO-Cleanup: These have GTF_ASG set but for some reason gtNodeHasSideEffects ignores
14950	// them. See the related gtNodeHasSideEffects comment as well.
14951	// Also, these nodes must always be preserved, no matter what side effect flags are passed
14952	// in. But then it should never be the case that gtExtractSideEffList gets called without
14953	// specifying GTF_ASG so there doesn't seem to be any reason to be inconsistent with
14954	// gtNodeHasSideEffects and make this check unconditionally.
14955	if (node->OperIsAtomicOp())
14956	{
14957	m_sideEffects.Push(node);
14958	return Compiler::WALK_SKIP_SUBTREES;
14959	}
14960
14961	if ((m_flags & GTF_EXCEPT) != `0`)
14962	{
14963	// Special case - GT_ADDR of GT_IND nodes of TYP_STRUCT have to be kept together.
14964	if (node->OperIs(GT_ADDR) && node->gtGetOp1()->OperIsIndir() &&
14965	(node->gtGetOp1()->TypeGet() == TYP_STRUCT))
14966	{
14967	#ifdef DEBUG
14968	if (m_compiler->verbose)
14969	{
14970	printf("Keep the GT_ADDR and GT_IND together:\n");
14971	}
14972	#endif
14973	m_sideEffects.Push(node);
14974	return Compiler::WALK_SKIP_SUBTREES;
14975	}
14976	}
14977
14978	// Generally all GT_CALL nodes are considered to have side-effects.
14979	// So if we get here it must be a helper call that we decided it does
14980	// not have side effects that we needed to keep.
14981	assert(!node->OperIs(GT_CALL) \|\| (node->AsCall()->gtCallType == CT_HELPER));
14982	}
14983
14984	if ((m_flags & GTF_IS_IN_CSE) != `0`)
14985	{
14986	// If we're doing CSE then we also need to unmark CSE nodes. This will fail for CSE defs,
14987	// those need to be extracted as if they're side effects.
14988	if (!UnmarkCSE(node))
14989	{
14990	m_sideEffects.Push(node);
14991	return Compiler::WALK_SKIP_SUBTREES;
14992	}
14993
14994	// The existence of CSE defs and uses is not propagated up the tree like side
14995	// effects are. We need to continue visiting the tree as if it has side effects.
14996	treeHasSideEffects = true;
14997	}
14998
14999	return treeHasSideEffects ? Compiler::WALK_CONTINUE : Compiler::WALK_SKIP_SUBTREES;
15000	}
15001
15002	private:
15003	bool UnmarkCSE(GenTree* node)
15004	{
15005	assert(m_compiler->optValnumCSE_phase);
15006
15007	if (m_compiler->optUnmarkCSE(node))
15008	{
15009	// The call to optUnmarkCSE(node) should have cleared any CSE info.
15010	assert(!IS_CSE_INDEX(node->gtCSEnum));
15011	return true;
15012	}
15013	else
15014	{
15015	assert(IS_CSE_DEF(node->gtCSEnum));
15016	#ifdef DEBUG
15017	if (m_compiler->verbose)
15018	{
15019	printf("Preserving the CSE def #%02d at ", GET_CSE_INDEX(node->gtCSEnum));
15020	m_compiler->printTreeID(node);
15021	}
15022	#endif
15023	return false;
15024	}
15025	}
15026	};
15027
15028	assert(!expr->OperIs(GT_STMT));
15029
15030	SideEffectExtractor extractor(this, flags);
15031
15032	if (ignoreRoot)
15033	{
15034	for (GenTree* op : expr->Operands())
15035	{
15036	extractor.WalkTree(&op, nullptr);
15037	}
15038	}
15039	else
15040	{
15041	extractor.WalkTree(&expr, nullptr);
15042	}
15043
15044	GenTree* list = *pList;
15045
15046	// The extractor returns side effects in execution order but gtBuildCommaList prepends
15047	// to the comma-based side effect list so we have to build the list in reverse order.
15048	// This is also why the list cannot be built while traversing the tree.
15049	// The number of side effects is usually small (<= 4), less than the ArrayStack's
15050	// built-in size, so memory allocation is avoided.
15051	while (!extractor.m_sideEffects.Empty())
15052	{
15053	list = gtBuildCommaList(list, extractor.m_sideEffects.Pop());
15054	}
15055
15056	*pList = list;
15057	}
15058
15059	/*****************************************************************************
15060	*
15061	* For debugging only - displays a tree node list and makes sure all the
15062	* links are correctly set.
15063	*/
15064
15065	#ifdef DEBUG
15066
15067	void dispNodeList(GenTree* list, bool verbose)
15068	{
15069	GenTree* last = nullptr;
15070	GenTree* next;
15071
15072	if (!list)
15073	{
15074	return;
15075	}
15076
15077	for (;;)
15078	{
15079	next = list->gtNext;
15080
15081	if (verbose)
15082	{
15083	printf("%08X -> %08X -> %08X\n", last, list, next);
15084	}
15085
15086	assert(!last \|\| last->gtNext == list);
15087
15088	assert(next == nullptr \|\| next->gtPrev == list);
15089
15090	if (!next)
15091	{
15092	break;
15093	}
15094
15095	last = list;
15096	list = next;
15097	}
15098	printf(""); // null string means flush
15099	}
15100
15101	/*****************************************************************************
15102	* Callback to assert that the nodes of a qmark-colon subtree are marked
15103	*/
15104
15105	/ static /
15106	Compiler::fgWalkResult Compiler::gtAssertColonCond(GenTree** pTree, fgWalkData* data)
15107	{
15108	assert(data->pCallbackData == nullptr);
15109
15110	assert((*pTree)->gtFlags & GTF_COLON_COND);
15111
15112	return WALK_CONTINUE;
15113	}
15114	#endif // DEBUG
15115
15116	/*****************************************************************************
15117	* Callback to mark the nodes of a qmark-colon subtree that are conditionally
15118	* executed.
15119	*/
15120
15121	/ static /
15122	Compiler::fgWalkResult Compiler::gtMarkColonCond(GenTree** pTree, fgWalkData* data)
15123	{
15124	assert(data->pCallbackData == nullptr);
15125
15126	(*pTree)->gtFlags \|= GTF_COLON_COND;
15127
15128	return WALK_CONTINUE;
15129	}
15130
15131	/*****************************************************************************
15132	* Callback to clear the conditionally executed flags of nodes that no longer
15133	will be conditionally executed. Note that when we find another colon we must
15134	stop, as the nodes below this one WILL be conditionally executed. This callback
15135	is called when folding a qmark condition (ie the condition is constant).
15136	*/
15137
15138	/ static /
15139	Compiler::fgWalkResult Compiler::gtClearColonCond(GenTree** pTree, fgWalkData* data)
15140	{
15141	GenTree* tree = *pTree;
15142
15143	assert(data->pCallbackData == nullptr);
15144
15145	if (tree->OperGet() == GT_COLON)
15146	{
15147	// Nodes below this will be conditionally executed.
15148	return WALK_SKIP_SUBTREES;
15149	}
15150
15151	tree->gtFlags &= ~GTF_COLON_COND;
15152	return WALK_CONTINUE;
15153	}
15154
15155	struct FindLinkData
15156	{
15157	GenTree* nodeToFind;
15158	GenTree** result;
15159	};
15160
15161	/*****************************************************************************
15162	*
15163	* Callback used by the tree walker to implement fgFindLink()
15164	*/
15165	static Compiler::fgWalkResult gtFindLinkCB(GenTree** pTree, Compiler::fgWalkData* cbData)
15166	{
15167	FindLinkData* data = (FindLinkData*)cbData->pCallbackData;
15168	if (*pTree == data->nodeToFind)
15169	{
15170	data->result = pTree;
15171	return Compiler::WALK_ABORT;
15172	}
15173
15174	return Compiler::WALK_CONTINUE;
15175	}
15176
15177	GenTree** Compiler::gtFindLink(GenTree* stmt, GenTree* node)
15178	{
15179	assert(stmt->gtOper == GT_STMT);
15180
15181	FindLinkData data = {node, nullptr};
15182
15183	fgWalkResult result = fgWalkTreePre(&stmt->gtStmt.gtStmtExpr, gtFindLinkCB, &data);
15184
15185	if (result == WALK_ABORT)
15186	{
15187	assert(data.nodeToFind == *data.result);
15188	return data.result;
15189	}
15190	else
15191	{
15192	return nullptr;
15193	}
15194	}
15195
15196	/*****************************************************************************
15197	*
15198	* Callback that checks if a tree node has oper type GT_CATCH_ARG
15199	*/
15200
15201	static Compiler::fgWalkResult gtFindCatchArg(GenTree** pTree, Compiler::fgWalkData* / data /)
15202	{
15203	return ((*pTree)->OperGet() == GT_CATCH_ARG) ? Compiler::WALK_ABORT : Compiler::WALK_CONTINUE;
15204	}
15205
15206	/***************************************************************************/
15207	bool Compiler::gtHasCatchArg(GenTree* tree)
15208	{
15209	if (((tree->gtFlags & GTF_ORDER_SIDEEFF) != `0`) && (fgWalkTreePre(&tree, gtFindCatchArg) == WALK_ABORT))
15210	{
15211	return true;
15212	}
15213	return false;
15214	}
15215
15216	//------------------------------------------------------------------------
15217	// gtHasCallOnStack:
15218	//
15219	// Arguments:
15220	// parentStack: a context (stack of parent nodes)
15221	//
15222	// Return Value:
15223	// returns true if any of the parent nodes are a GT_CALL
15224	//
15225	// Assumptions:
15226	// We have a stack of parent nodes. This generally requires that
15227	// we are performing a recursive tree walk using struct fgWalkData
15228	//
15229	//------------------------------------------------------------------------
15230	/ static / bool Compiler::gtHasCallOnStack(GenTreeStack* parentStack)
15231	{
15232	for (int i = `0`; i < parentStack->Height(); i++)
15233	{
15234	GenTree* node = parentStack->Index(i);
15235	if (node->OperGet() == GT_CALL)
15236	{
15237	return true;
15238	}
15239	}
15240	return false;
15241	}
15242
15243	//------------------------------------------------------------------------
15244	// gtGetTypeProducerKind: determine if a tree produces a runtime type, and
15245	// if so, how.
15246	//
15247	// Arguments:
15248	// tree - tree to examine
15249	//
15250	// Return Value:
15251	// TypeProducerKind for the tree.
15252	//
15253	// Notes:
15254	// Checks to see if this tree returns a RuntimeType value, and if so,
15255	// how that value is determined.
15256	//
15257	// Currently handles these cases
15258	// 1) The result of Object::GetType
15259	// 2) The result of typeof(...)
15260	// 3) A null reference
15261	// 4) Tree is otherwise known to have type RuntimeType
15262	//
15263	// The null reference case is surprisingly common because operator
15264	// overloading turns the otherwise innocuous
15265	//
15266	// Type t = ....;
15267	// if (t == null)
15268	//
15269	// into a method call.
15270
15271	Compiler::TypeProducerKind Compiler::gtGetTypeProducerKind(GenTree* tree)
15272	{
15273	if (tree->gtOper == GT_CALL)
15274	{
15275	if (tree->gtCall.gtCallType == CT_HELPER)
15276	{
15277	if (gtIsTypeHandleToRuntimeTypeHelper(tree->AsCall()))
15278	{
15279	return TPK_Handle;
15280	}
15281	}
15282	else if (tree->gtCall.gtCallMoreFlags & GTF_CALL_M_SPECIAL_INTRINSIC)
15283	{
15284	if (info.compCompHnd->getIntrinsicID(tree->gtCall.gtCallMethHnd) == CORINFO_INTRINSIC_Object_GetType)
15285	{
15286	return TPK_GetType;
15287	}
15288	}
15289	}
15290	else if ((tree->gtOper == GT_INTRINSIC) && (tree->gtIntrinsic.gtIntrinsicId == CORINFO_INTRINSIC_Object_GetType))
15291	{
15292	return TPK_GetType;
15293	}
15294	else if ((tree->gtOper == GT_CNS_INT) && (tree->gtIntCon.gtIconVal == `0`))
15295	{
15296	return TPK_Null;
15297	}
15298	else
15299	{
15300	bool isExact = false;
15301	bool isNonNull = false;
15302	CORINFO_CLASS_HANDLE clsHnd = gtGetClassHandle(tree, &isExact, &isNonNull);
15303
15304	if (clsHnd != NO_CLASS_HANDLE && clsHnd == info.compCompHnd->getBuiltinClass(CLASSID_RUNTIME_TYPE))
15305	{
15306	return TPK_Other;
15307	}
15308	}
15309	return TPK_Unknown;
15310	}
15311
15312	//------------------------------------------------------------------------
15313	// gtIsTypeHandleToRuntimeTypeHelperCall -- see if tree is constructing
15314	// a RuntimeType from a handle
15315	//
15316	// Arguments:
15317	// tree - tree to examine
15318	//
15319	// Return Value:
15320	// True if so
15321
15322	bool Compiler::gtIsTypeHandleToRuntimeTypeHelper(GenTreeCall* call)
15323	{
15324	return call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE) \|\|
15325	call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE_MAYBENULL);
15326	}
15327
15328	//------------------------------------------------------------------------
15329	// gtIsTypeHandleToRuntimeTypeHandleHelperCall -- see if tree is constructing
15330	// a RuntimeTypeHandle from a handle
15331	//
15332	// Arguments:
15333	// tree - tree to examine
15334	// pHelper - optional pointer to a variable that receives the type of the helper
15335	//
15336	// Return Value:
15337	// True if so
15338
15339	bool Compiler::gtIsTypeHandleToRuntimeTypeHandleHelper(GenTreeCall* call, CorInfoHelpFunc* pHelper)
15340	{
15341	CorInfoHelpFunc helper = CORINFO_HELP_UNDEF;
15342
15343	if (call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPEHANDLE))
15344	{
15345	helper = CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPEHANDLE;
15346	}
15347	else if (call->gtCallMethHnd == eeFindHelper(CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPEHANDLE_MAYBENULL))
15348	{
15349	helper = CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPEHANDLE_MAYBENULL;
15350	}
15351
15352	if (pHelper != nullptr)
15353	{
15354	*pHelper = helper;
15355	}
15356
15357	return helper != CORINFO_HELP_UNDEF;
15358	}
15359
15360	bool Compiler::gtIsActiveCSE_Candidate(GenTree* tree)
15361	{
15362	return (optValnumCSE_phase && IS_CSE_INDEX(tree->gtCSEnum));
15363	}
15364
15365	/***************************************************************************/
15366
15367	struct ComplexityStruct
15368	{
15369	unsigned m_numNodes;
15370	unsigned m_nodeLimit;
15371	ComplexityStruct(unsigned nodeLimit) : m_numNodes(`0`), m_nodeLimit(nodeLimit)
15372	{
15373	}
15374	};
15375
15376	static Compiler::fgWalkResult ComplexityExceedsWalker(GenTree** pTree, Compiler::fgWalkData* data)
15377	{
15378	ComplexityStruct* pComplexity = (ComplexityStruct*)data->pCallbackData;
15379	if (++pComplexity->m_numNodes > pComplexity->m_nodeLimit)
15380	{
15381	return Compiler::WALK_ABORT;
15382	}
15383	else
15384	{
15385	return Compiler::WALK_CONTINUE;
15386	}
15387	}
15388
15389	bool Compiler::gtComplexityExceeds(GenTree** tree, unsigned limit)
15390	{
15391	ComplexityStruct complexity(limit);
15392	if (fgWalkTreePre(tree, &ComplexityExceedsWalker, &complexity) == WALK_ABORT)
15393	{
15394	return true;
15395	}
15396	else
15397	{
15398	return false;
15399	}
15400	}
15401
15402	bool GenTree::IsPhiNode()
15403	{
15404	return (OperGet() == GT_PHI_ARG) \|\| (OperGet() == GT_PHI) \|\| IsPhiDefn();
15405	}
15406
15407	bool GenTree::IsPhiDefn()
15408	{
15409	bool res = ((OperGet() == GT_ASG) && (gtOp.gtOp2 != nullptr) && (gtOp.gtOp2->OperGet() == GT_PHI)) \|\|
15410	((OperGet() == GT_STORE_LCL_VAR) && (gtOp.gtOp1 != nullptr) && (gtOp.gtOp1->OperGet() == GT_PHI));
15411	assert(!res \|\| OperGet() == GT_STORE_LCL_VAR \|\| gtOp.gtOp1->OperGet() == GT_LCL_VAR);
15412	return res;
15413	}
15414
15415	bool GenTree::IsPhiDefnStmt()
15416	{
15417	if (OperGet() != GT_STMT)
15418	{
15419	return false;
15420	}
15421	GenTree* asg = gtStmt.gtStmtExpr;
15422	return asg->IsPhiDefn();
15423	}
15424
15425	// IsPartialLclFld: Check for a GT_LCL_FLD whose type is a different size than the lclVar.
15426	//
15427	// Arguments:
15428	// comp - the Compiler object.
15429	//
15430	// Return Value:
15431	// Returns "true" iff 'this' is a GT_LCL_FLD or GT_STORE_LCL_FLD on which the type
15432	// is not the same size as the type of the GT_LCL_VAR
15433
15434	bool GenTree::IsPartialLclFld(Compiler* comp)
15435	{
15436	return ((gtOper == GT_LCL_FLD) &&
15437	(comp->lvaTable[this->gtLclVarCommon.gtLclNum].lvExactSize != genTypeSize(gtType)));
15438	}
15439
15440	bool GenTree::DefinesLocal(Compiler* comp, GenTreeLclVarCommon** pLclVarTree, bool* pIsEntire)
15441	{
15442	GenTreeBlk* blkNode = nullptr;
15443	if (OperIs(GT_ASG))
15444	{
15445	if (gtOp.gtOp1->IsLocal())
15446	{
15447	GenTreeLclVarCommon* lclVarTree = gtOp.gtOp1->AsLclVarCommon();
15448	*pLclVarTree = lclVarTree;
15449	if (pIsEntire != nullptr)
15450	{
15451	if (lclVarTree->IsPartialLclFld(comp))
15452	{
15453	pIsEntire = false*;
15454	}
15455	else
15456	{
15457	pIsEntire = true*;
15458	}
15459	}
15460	return true;
15461	}
15462	else if (gtOp.gtOp1->OperGet() == GT_IND)
15463	{
15464	GenTree* indArg = gtOp.gtOp1->gtOp.gtOp1;
15465	return indArg->DefinesLocalAddr(comp, genTypeSize(gtOp.gtOp1->TypeGet()), pLclVarTree, pIsEntire);
15466	}
15467	else if (gtOp.gtOp1->OperIsBlk())
15468	{
15469	blkNode = gtOp.gtOp1->AsBlk();
15470	}
15471	}
15472	else if (OperIsBlk())
15473	{
15474	blkNode = this->AsBlk();
15475	}
15476	if (blkNode != nullptr)
15477	{
15478	GenTree* destAddr = blkNode->Addr();
15479	unsigned width = blkNode->gtBlkSize;
15480	// Do we care about whether this assigns the entire variable?
15481	if (pIsEntire != nullptr && width == `0`)
15482	{
15483	assert(blkNode->gtOper == GT_DYN_BLK);
15484	GenTree* blockWidth = blkNode->AsDynBlk()->gtDynamicSize;
15485	if (blockWidth->IsCnsIntOrI())
15486	{
15487	if (blockWidth->IsIconHandle())
15488	{
15489	// If it's a handle, it must be a class handle. We only create such block operations
15490	// for initialization of struct types, so the type of the argument(s) will match this
15491	// type, by construction, and be "entire".
15492	assert(blockWidth->IsIconHandle(GTF_ICON_CLASS_HDL));
15493	width = comp->info.compCompHnd->getClassSize(
15494	CORINFO_CLASS_HANDLE(blockWidth->gtIntConCommon.IconValue()));
15495	}
15496	else
15497	{
15498	ssize_t swidth = blockWidth->AsIntConCommon()->IconValue();
15499	assert(swidth >= `0`);
15500	// cpblk of size zero exists in the wild (in yacc-generated code in SQL) and is valid IL.
15501	if (swidth == `0`)
15502	{
15503	return false;
15504	}
15505	width = unsigned(swidth);
15506	}
15507	}
15508	}
15509	return destAddr->DefinesLocalAddr(comp, width, pLclVarTree, pIsEntire);
15510	}
15511	// Otherwise...
15512	return false;
15513	}
15514
15515	// Returns true if this GenTree defines a result which is based on the address of a local.
15516	bool GenTree::DefinesLocalAddr(Compiler* comp, unsigned width, GenTreeLclVarCommon** pLclVarTree, bool* pIsEntire)
15517	{
15518	if (OperGet() == GT_ADDR \|\| OperGet() == GT_LCL_VAR_ADDR)
15519	{
15520	GenTree* addrArg = this;
15521	if (OperGet() == GT_ADDR)
15522	{
15523	addrArg = gtOp.gtOp1;
15524	}
15525
15526	if (addrArg->IsLocal() \|\| addrArg->OperIsLocalAddr())
15527	{
15528	GenTreeLclVarCommon* addrArgLcl = addrArg->AsLclVarCommon();
15529	*pLclVarTree = addrArgLcl;
15530	if (pIsEntire != nullptr)
15531	{
15532	unsigned lclOffset = `0`;
15533	if (addrArg->OperIsLocalField())
15534	{
15535	lclOffset = addrArg->gtLclFld.gtLclOffs;
15536	}
15537
15538	if (lclOffset != `0`)
15539	{
15540	// We aren't updating the bytes at [0..lclOffset-1] so pIsEntire should be set to false*
15541	pIsEntire = false*;
15542	}
15543	else
15544	{
15545	unsigned lclNum = addrArgLcl->GetLclNum();
15546	unsigned varWidth = comp->lvaLclExactSize(lclNum);
15547	if (comp->lvaTable[lclNum].lvNormalizeOnStore())
15548	{
15549	// It's normalize on store, so use the full storage width -- writing to low bytes won't
15550	// necessarily yield a normalized value.
15551	varWidth = genTypeStSz(var_types(comp->lvaTable[lclNum].lvType)) * sizeof(int);
15552	}
15553	*pIsEntire = (varWidth == width);
15554	}
15555	}
15556	return true;
15557	}
15558	else if (addrArg->OperGet() == GT_IND)
15559	{
15560	// A GT_ADDR of a GT_IND can both be optimized away, recurse using the child of the GT_IND
15561	return addrArg->gtOp.gtOp1->DefinesLocalAddr(comp, width, pLclVarTree, pIsEntire);
15562	}
15563	}
15564	else if (OperGet() == GT_ADD)
15565	{
15566	if (gtOp.gtOp1->IsCnsIntOrI())
15567	{
15568	// If we just adding a zero then we allow an IsEntire match against width
15569	// otherwise we change width to zero to disallow an IsEntire Match
15570	return gtOp.gtOp2->DefinesLocalAddr(comp, gtOp.gtOp1->IsIntegralConst(`0`) ? width : `0`, pLclVarTree,
15571	pIsEntire);
15572	}
15573	else if (gtOp.gtOp2->IsCnsIntOrI())
15574	{
15575	// If we just adding a zero then we allow an IsEntire match against width
15576	// otherwise we change width to zero to disallow an IsEntire Match
15577	return gtOp.gtOp1->DefinesLocalAddr(comp, gtOp.gtOp2->IsIntegralConst(`0`) ? width : `0`, pLclVarTree,
15578	pIsEntire);
15579	}
15580	}
15581	// Post rationalization we could have GT_IND(GT_LEA(..)) trees.
15582	else if (OperGet() == GT_LEA)
15583	{
15584	// This method gets invoked during liveness computation and therefore it is critical
15585	// that we don't miss 'use' of any local. The below logic is making the assumption
15586	// that in case of LEA(base, index, offset) - only base can be a GT_LCL_VAR_ADDR
15587	// and index is not.
15588	CLANG_FORMAT_COMMENT_ANCHOR;
15589
15590	#ifdef DEBUG
15591	GenTree* index = gtOp.gtOp2;
15592	if (index != nullptr)
15593	{
15594	assert(!index->DefinesLocalAddr(comp, width, pLclVarTree, pIsEntire));
15595	}
15596	#endif // DEBUG
15597
15598	// base
15599	GenTree* base = gtOp.gtOp1;
15600	if (base != nullptr)
15601	{
15602	// Lea could have an Indir as its base.
15603	if (base->OperGet() == GT_IND)
15604	{
15605	base = base->gtOp.gtOp1->gtEffectiveVal(/commas only/ true);
15606	}
15607	return base->DefinesLocalAddr(comp, width, pLclVarTree, pIsEntire);
15608	}
15609	}
15610	// Otherwise...
15611	return false;
15612	}
15613
15614	//------------------------------------------------------------------------
15615	// IsLocalExpr: Determine if this is a LclVarCommon node and return some
15616	// additional info about it in the two out parameters.
15617	//
15618	// Arguments:
15619	// comp - The Compiler instance
15620	// pLclVarTree - An "out" argument that returns the local tree as a
15621	// LclVarCommon, if it is indeed local.
15622	// pFldSeq - An "out" argument that returns the value numbering field
15623	// sequence for the node, if any.
15624	//
15625	// Return Value:
15626	// Returns true, and sets the out arguments accordingly, if this is
15627	// a LclVarCommon node.
15628
15629	bool GenTree::IsLocalExpr(Compiler* comp, GenTreeLclVarCommon pLclVarTree, FieldSeqNode pFldSeq)
15630	{
15631	if (IsLocal()) // Note that this covers "GT_LCL_FLD."
15632	{
15633	*pLclVarTree = AsLclVarCommon();
15634	if (OperGet() == GT_LCL_FLD)
15635	{
15636	// Otherwise, prepend this field to whatever we've already accumulated outside in.
15637	pFldSeq = comp->GetFieldSeqStore()->Append(AsLclFld()->gtFieldSeq, pFldSeq);
15638	}
15639	return true;
15640	}
15641	else
15642	{
15643	return false;
15644	}
15645	}
15646
15647	// If this tree evaluates some sum of a local address and some constants,
15648	// return the node for the local being addressed
15649
15650	GenTreeLclVarCommon* GenTree::IsLocalAddrExpr()
15651	{
15652	if (OperGet() == GT_ADDR)
15653	{
15654	return gtOp.gtOp1->IsLocal() ? gtOp.gtOp1->AsLclVarCommon() : nullptr;
15655	}
15656	else if (OperIsLocalAddr())
15657	{
15658	return this->AsLclVarCommon();
15659	}
15660	else if (OperGet() == GT_ADD)
15661	{
15662	if (gtOp.gtOp1->OperGet() == GT_CNS_INT)
15663	{
15664	return gtOp.gtOp2->IsLocalAddrExpr();
15665	}
15666	else if (gtOp.gtOp2->OperGet() == GT_CNS_INT)
15667	{
15668	return gtOp.gtOp1->IsLocalAddrExpr();
15669	}
15670	}
15671	// Otherwise...
15672	return nullptr;
15673	}
15674
15675	bool GenTree::IsLocalAddrExpr(Compiler* comp, GenTreeLclVarCommon pLclVarTree, FieldSeqNode pFldSeq)
15676	{
15677	if (OperGet() == GT_ADDR)
15678	{
15679	assert(!comp->compRationalIRForm);
15680	GenTree* addrArg = gtOp.gtOp1;
15681	if (addrArg->IsLocal()) // Note that this covers "GT_LCL_FLD."
15682	{
15683	*pLclVarTree = addrArg->AsLclVarCommon();
15684	if (addrArg->OperGet() == GT_LCL_FLD)
15685	{
15686	// Otherwise, prepend this field to whatever we've already accumulated outside in.
15687	pFldSeq = comp->GetFieldSeqStore()->Append(addrArg->AsLclFld()->gtFieldSeq, pFldSeq);
15688	}
15689	return true;
15690	}
15691	else
15692	{
15693	return false;
15694	}
15695	}
15696	else if (OperIsLocalAddr())
15697	{
15698	pLclVarTree = this*->AsLclVarCommon();
15699	if (this->OperGet() == GT_LCL_FLD_ADDR)
15700	{
15701	pFldSeq = comp->GetFieldSeqStore()->Append(this->AsLclFld()->gtFieldSeq, pFldSeq);
15702	}
15703	return true;
15704	}
15705	else if (OperGet() == GT_ADD)
15706	{
15707	if (gtOp.gtOp1->OperGet() == GT_CNS_INT)
15708	{
15709	if (gtOp.gtOp1->AsIntCon()->gtFieldSeq == nullptr)
15710	{
15711	return false;
15712	}
15713	// Otherwise, prepend this field to whatever we've already accumulated outside in.
15714	pFldSeq = comp->GetFieldSeqStore()->Append(gtOp.gtOp1->AsIntCon()->gtFieldSeq, pFldSeq);
15715	return gtOp.gtOp2->IsLocalAddrExpr(comp, pLclVarTree, pFldSeq);
15716	}
15717	else if (gtOp.gtOp2->OperGet() == GT_CNS_INT)
15718	{
15719	if (gtOp.gtOp2->AsIntCon()->gtFieldSeq == nullptr)
15720	{
15721	return false;
15722	}
15723	// Otherwise, prepend this field to whatever we've already accumulated outside in.
15724	pFldSeq = comp->GetFieldSeqStore()->Append(gtOp.gtOp2->AsIntCon()->gtFieldSeq, pFldSeq);
15725	return gtOp.gtOp1->IsLocalAddrExpr(comp, pLclVarTree, pFldSeq);
15726	}
15727	}
15728	// Otherwise...
15729	return false;
15730	}
15731
15732	//------------------------------------------------------------------------
15733	// IsLclVarUpdateTree: Determine whether this is an assignment tree of the
15734	// form Vn = Vn 'oper' 'otherTree' where Vn is a lclVar
15735	//
15736	// Arguments:
15737	// pOtherTree - An "out" argument in which 'otherTree' will be returned.
15738	// pOper - An "out" argument in which 'oper' will be returned.
15739	//
15740	// Return Value:
15741	// If the tree is of the above form, the lclNum of the variable being
15742	// updated is returned, and 'pOtherTree' and 'pOper' are set.
15743	// Otherwise, returns BAD_VAR_NUM.
15744	//
15745	// Notes:
15746	// 'otherTree' can have any shape.
15747	// We avoid worrying about whether the op is commutative by only considering the
15748	// first operand of the rhs. It is expected that most trees of this form will
15749	// already have the lclVar on the lhs.
15750	// TODO-CQ: Evaluate whether there are missed opportunities due to this, or
15751	// whether gtSetEvalOrder will already have put the lclVar on the lhs in
15752	// the cases of interest.
15753
15754	unsigned GenTree::IsLclVarUpdateTree(GenTree** pOtherTree, genTreeOps* pOper)
15755	{
15756	unsigned lclNum = BAD_VAR_NUM;
15757	if (OperIs(GT_ASG))
15758	{
15759	GenTree* lhs = gtOp.gtOp1;
15760	if (lhs->OperGet() == GT_LCL_VAR)
15761	{
15762	unsigned lhsLclNum = lhs->AsLclVarCommon()->gtLclNum;
15763	GenTree* rhs = gtOp.gtOp2;
15764	if (rhs->OperIsBinary() && (rhs->gtOp.gtOp1->gtOper == GT_LCL_VAR) &&
15765	(rhs->gtOp.gtOp1->AsLclVarCommon()->gtLclNum == lhsLclNum))
15766	{
15767	lclNum = lhsLclNum;
15768	*pOtherTree = rhs->gtOp.gtOp2;
15769	*pOper = rhs->gtOper;
15770	}
15771	}
15772	}
15773	return lclNum;
15774	}
15775
15776	//------------------------------------------------------------------------
15777	// canBeContained: check whether this tree node may be a subcomponent of its parent for purposes
15778	// of code generation.
15779	//
15780	// Return value: returns true if it is possible to contain this node and false otherwise.
15781	bool GenTree::canBeContained() const
15782	{
15783	assert(IsLIR());
15784
15785	if (gtHasReg())
15786	{
15787	return false;
15788	}
15789
15790	// It is not possible for nodes that do not produce values or that are not containable values
15791	// to be contained.
15792	if (((OperKind() & (GTK_NOVALUE \| GTK_NOCONTAIN)) != `0`) \|\| (OperIsHWIntrinsic() && !isContainableHWIntrinsic()))
15793	{
15794	return false;
15795	}
15796
15797	return true;
15798	}
15799
15800	//------------------------------------------------------------------------
15801	// isContained: check whether this tree node is a subcomponent of its parent for codegen purposes
15802	//
15803	// Return Value:
15804	// Returns true if there is no code generated explicitly for this node.
15805	// Essentially, it will be rolled into the code generation for the parent.
15806	//
15807	// Assumptions:
15808	// This method relies upon the value of the GTF_CONTAINED flag.
15809	// Therefore this method is only valid after Lowering.
15810	// Also note that register allocation or other subsequent phases may cause
15811	// nodes to become contained (or not) and therefore this property may change.
15812	//
15813	bool GenTree::isContained() const
15814	{
15815	assert(IsLIR());
15816	const bool isMarkedContained = ((gtFlags & GTF_CONTAINED) != `0`);
15817
15818	#ifdef DEBUG
15819	if (!canBeContained())
15820	{
15821	assert(!isMarkedContained);
15822	}
15823
15824	// these actually produce a register (the flags reg, we just don't model it)
15825	// and are a separate instruction from the branch that consumes the result.
15826	// They can only produce a result if the child is a SIMD equality comparison.
15827	else if (OperKind() & GTK_RELOP)
15828	{
15829	// We have to cast away const-ness since AsOp() method is non-const.
15830	GenTree* childNode = const_cast<GenTree>(this*)->AsOp()->gtOp1;
15831	assert((isMarkedContained == false) \|\| childNode->IsSIMDEqualityOrInequality());
15832	}
15833
15834	// these either produce a result in register or set flags reg.
15835	else if (IsSIMDEqualityOrInequality())
15836	{
15837	assert(!isMarkedContained);
15838	}
15839
15840	// if it's contained it can't be unused.
15841	if (isMarkedContained)
15842	{
15843	assert(!IsUnusedValue());
15844	}
15845	#endif // DEBUG
15846	return isMarkedContained;
15847	}
15848
15849	// return true if node is contained and an indir
15850	bool GenTree::isContainedIndir() const
15851	{
15852	return isIndir() && isContained();
15853	}
15854
15855	bool GenTree::isIndirAddrMode()
15856	{
15857	return isIndir() && AsIndir()->Addr()->OperIsAddrMode() && AsIndir()->Addr()->isContained();
15858	}
15859
15860	bool GenTree::isIndir() const
15861	{
15862	return OperGet() == GT_IND \|\| OperGet() == GT_STOREIND;
15863	}
15864
15865	bool GenTreeIndir::HasBase()
15866	{
15867	return Base() != nullptr;
15868	}
15869
15870	bool GenTreeIndir::HasIndex()
15871	{
15872	return Index() != nullptr;
15873	}
15874
15875	GenTree* GenTreeIndir::Base()
15876	{
15877	GenTree* addr = Addr();
15878
15879	if (isIndirAddrMode())
15880	{
15881	GenTree* result = addr->AsAddrMode()->Base();
15882	if (result != nullptr)
15883	{
15884	result = result->gtEffectiveVal();
15885	}
15886	return result;
15887	}
15888	else
15889	{
15890	return addr; // TODO: why do we return 'addr' here, but we return 'nullptr' in the equivalent Index() case?
15891	}
15892	}
15893
15894	GenTree* GenTreeIndir::Index()
15895	{
15896	if (isIndirAddrMode())
15897	{
15898	GenTree* result = Addr()->AsAddrMode()->Index();
15899	if (result != nullptr)
15900	{
15901	result = result->gtEffectiveVal();
15902	}
15903	return result;
15904	}
15905	else
15906	{
15907	return nullptr;
15908	}
15909	}
15910
15911	unsigned GenTreeIndir::Scale()
15912	{
15913	if (HasIndex())
15914	{
15915	return Addr()->AsAddrMode()->gtScale;
15916	}
15917	else
15918	{
15919	return `1`;
15920	}
15921	}
15922
15923	ssize_t GenTreeIndir::Offset()
15924	{
15925	if (isIndirAddrMode())
15926	{
15927	return Addr()->AsAddrMode()->Offset();
15928	}
15929	else if (Addr()->gtOper == GT_CLS_VAR_ADDR)
15930	{
15931	return static_cast<ssize_t>(reinterpret_cast<intptr_t>(Addr()->gtClsVar.gtClsVarHnd));
15932	}
15933	else if (Addr()->IsCnsIntOrI() && Addr()->isContained())
15934	{
15935	return Addr()->AsIntConCommon()->IconValue();
15936	}
15937	else
15938	{
15939	return `0`;
15940	}
15941	}
15942
15943	//------------------------------------------------------------------------
15944	// GenTreeIntConCommon::ImmedValNeedsReloc: does this immediate value needs recording a relocation with the VM?
15945	//
15946	// Arguments:
15947	// comp - Compiler instance
15948	//
15949	// Return Value:
15950	// True if this immediate value requires us to record a relocation for it; false otherwise.
15951
15952	bool GenTreeIntConCommon::ImmedValNeedsReloc(Compiler* comp)
15953	{
15954	return comp->opts.compReloc && (gtOper == GT_CNS_INT) && IsIconHandle();
15955	}
15956
15957	//------------------------------------------------------------------------
15958	// ImmedValCanBeFolded: can this immediate value be folded for op?
15959	//
15960	// Arguments:
15961	// comp - Compiler instance
15962	// op - Tree operator
15963	//
15964	// Return Value:
15965	// True if this immediate value can be folded for op; false otherwise.
15966
15967	bool GenTreeIntConCommon::ImmedValCanBeFolded(Compiler* comp, genTreeOps op)
15968	{
15969	// In general, immediate values that need relocations can't be folded.
15970	// There are cases where we do want to allow folding of handle comparisons
15971	// (e.g., typeof(T) == typeof(int)).
15972	return !ImmedValNeedsReloc(comp) \|\| (op == GT_EQ) \|\| (op == GT_NE);
15973	}
15974
15975	#ifdef _TARGET_AMD64_
15976	// Returns true if this absolute address fits within the base of an addr mode.
15977	// On Amd64 this effectively means, whether an absolute indirect address can
15978	// be encoded as 32-bit offset relative to IP or zero.
15979	bool GenTreeIntConCommon::FitsInAddrBase(Compiler* comp)
15980	{
15981	#ifdef DEBUG
15982	// Early out if PC-rel encoding of absolute addr is disabled.
15983	if (!comp->opts.compEnablePCRelAddr)
15984	{
15985	return false;
15986	}
15987	#endif
15988
15989	if (comp->opts.compReloc)
15990	{
15991	// During Ngen JIT is always asked to generate relocatable code.
15992	// Hence JIT will try to encode only icon handles as pc-relative offsets.
15993	return IsIconHandle() && (IMAGE_REL_BASED_REL32 == comp->eeGetRelocTypeHint((void*)IconValue()));
15994	}
15995	else
15996	{
15997	// During Jitting, we are allowed to generate non-relocatable code.
15998	// On Amd64 we can encode an absolute indirect addr as an offset relative to zero or RIP.
15999	// An absolute indir addr that can fit within 32-bits can ben encoded as an offset relative
16000	// to zero. All other absolute indir addr could be attempted to be encoded as RIP relative
16001	// based on reloc hint provided by VM. RIP relative encoding is preferred over relative
16002	// to zero, because the former is one byte smaller than the latter. For this reason
16003	// we check for reloc hint first and then whether addr fits in 32-bits next.
16004	//
16005	// VM starts off with an initial state to allow both data and code address to be encoded as
16006	// pc-relative offsets. Hence JIT will attempt to encode all absolute addresses as pc-relative
16007	// offsets. It is possible while jitting a method, an address could not be encoded as a
16008	// pc-relative offset. In that case VM will note the overflow and will trigger re-jitting
16009	// of the method with reloc hints turned off for all future methods. Second time around
16010	// jitting will succeed since JIT will not attempt to encode data addresses as pc-relative
16011	// offsets. Note that JIT will always attempt to relocate code addresses (.e.g call addr).
16012	// After an overflow, VM will assume any relocation recorded is for a code address and will
16013	// emit jump thunk if it cannot be encoded as pc-relative offset.
16014	return (IMAGE_REL_BASED_REL32 == comp->eeGetRelocTypeHint((void*)IconValue())) \|\| FitsInI32();
16015	}
16016	}
16017
16018	// Returns true if this icon value is encoded as addr needs recording a relocation with VM
16019	bool GenTreeIntConCommon::AddrNeedsReloc(Compiler* comp)
16020	{
16021	if (comp->opts.compReloc)
16022	{
16023	// During Ngen JIT is always asked to generate relocatable code.
16024	// Hence JIT will try to encode only icon handles as pc-relative offsets.
16025	return IsIconHandle() && (IMAGE_REL_BASED_REL32 == comp->eeGetRelocTypeHint((void*)IconValue()));
16026	}
16027	else
16028	{
16029	return IMAGE_REL_BASED_REL32 == comp->eeGetRelocTypeHint((void*)IconValue());
16030	}
16031	}
16032
16033	#elif defined(_TARGET_X86_)
16034	// Returns true if this absolute address fits within the base of an addr mode.
16035	// On x86 all addresses are 4-bytes and can be directly encoded in an addr mode.
16036	bool GenTreeIntConCommon::FitsInAddrBase(Compiler* comp)
16037	{
16038	#ifdef DEBUG
16039	// Early out if PC-rel encoding of absolute addr is disabled.
16040	if (!comp->opts.compEnablePCRelAddr)
16041	{
16042	return false;
16043	}
16044	#endif
16045
16046	return IsCnsIntOrI();
16047	}
16048
16049	// Returns true if this icon value is encoded as addr needs recording a relocation with VM
16050	bool GenTreeIntConCommon::AddrNeedsReloc(Compiler* comp)
16051	{
16052	// If generating relocatable code, icons should be reported for recording relocatons.
16053	return comp->opts.compReloc && IsIconHandle();
16054	}
16055	#endif //_TARGET_X86_
16056
16057	bool GenTree::IsFieldAddr(Compiler* comp, GenTree pObj, GenTree pStatic, FieldSeqNode** pFldSeq)
16058	{
16059	FieldSeqNode* newFldSeq = nullptr;
16060	GenTree* baseAddr = nullptr;
16061	bool mustBeStatic = false;
16062
16063	FieldSeqNode* statStructFldSeq = nullptr;
16064	if (TypeGet() == TYP_REF)
16065	{
16066	// Recognize struct static field patterns...
16067	if (OperGet() == GT_IND)
16068	{
16069	GenTree* addr = gtOp.gtOp1;
16070	GenTreeIntCon* icon = nullptr;
16071	if (addr->OperGet() == GT_CNS_INT)
16072	{
16073	icon = addr->AsIntCon();
16074	}
16075	else if (addr->OperGet() == GT_ADD)
16076	{
16077	// op1 should never be a field sequence (or any other kind of handle)
16078	assert((addr->gtOp.gtOp1->gtOper != GT_CNS_INT) \|\| !addr->gtOp.gtOp1->IsIconHandle());
16079	if (addr->gtOp.gtOp2->OperGet() == GT_CNS_INT)
16080	{
16081	icon = addr->gtOp.gtOp2->AsIntCon();
16082	}
16083	}
16084	if (icon != nullptr && !icon->IsIconHandle(GTF_ICON_STR_HDL) // String handles are a source of TYP_REFs.
16085	&& icon->gtFieldSeq != nullptr &&
16086	icon->gtFieldSeq->m_next == nullptr // A static field should be a singleton
16087	// TODO-Review: A pseudoField here indicates an issue - this requires investigation
16088	// See test case src\ddsuites\src\clr\x86\CoreMangLib\Dev\Globalization\CalendarRegressions.exe
16089	&& !(FieldSeqStore::IsPseudoField(icon->gtFieldSeq->m_fieldHnd)) &&
16090	icon->gtFieldSeq != FieldSeqStore::NotAField()) // Ignore non-fields.
16091	{
16092	statStructFldSeq = icon->gtFieldSeq;
16093	}
16094	else
16095	{
16096	addr = addr->gtEffectiveVal();
16097
16098	// Perhaps it's a direct indirection of a helper call or a cse with a zero offset annotation.
16099	if ((addr->OperGet() == GT_CALL) \|\| (addr->OperGet() == GT_LCL_VAR))
16100	{
16101	FieldSeqNode* zeroFieldSeq = nullptr;
16102	if (comp->GetZeroOffsetFieldMap()->Lookup(addr, &zeroFieldSeq))
16103	{
16104	if (zeroFieldSeq->m_next == nullptr)
16105	{
16106	statStructFldSeq = zeroFieldSeq;
16107	}
16108	}
16109	}
16110	}
16111	}
16112	else if (OperGet() == GT_CLS_VAR)
16113	{
16114	GenTreeClsVar* clsVar = AsClsVar();
16115	if (clsVar->gtFieldSeq != nullptr && clsVar->gtFieldSeq->m_next == nullptr)
16116	{
16117	statStructFldSeq = clsVar->gtFieldSeq;
16118	}
16119	}
16120	else if (OperIsLocal())
16121	{
16122	// If we have a GT_LCL_VAR, it can be result of a CSE substitution
16123	// If it is then the CSE assignment will have a ValueNum that
16124	// describes the RHS of the CSE assignment.
16125	//
16126	// The CSE could be a pointer to a boxed struct
16127	//
16128	GenTreeLclVarCommon* lclVar = AsLclVarCommon();
16129	ValueNum vn = gtVNPair.GetLiberal();
16130	if (vn != ValueNumStore::NoVN)
16131	{
16132	// Is the ValueNum a MapSelect involving a SharedStatic helper?
16133	VNFuncApp funcApp1;
16134	if (comp->vnStore->GetVNFunc(vn, &funcApp1) && (funcApp1.m_func == VNF_MapSelect) &&
16135	(comp->vnStore->IsSharedStatic(funcApp1.m_args[`1`])))
16136	{
16137	ValueNum mapVN = funcApp1.m_args[`0`];
16138	// Is this new 'mapVN' ValueNum, a MapSelect involving a handle?
16139	VNFuncApp funcApp2;
16140	if (comp->vnStore->GetVNFunc(mapVN, &funcApp2) && (funcApp2.m_func == VNF_MapSelect) &&
16141	(comp->vnStore->IsVNHandle(funcApp2.m_args[`1`])))
16142	{
16143	ValueNum fldHndVN = funcApp2.m_args[`1`];
16144	// Is this new 'fldHndVN' VNhandle a FieldHandle?
16145	unsigned flags = comp->vnStore->GetHandleFlags(fldHndVN);
16146	if (flags == GTF_ICON_FIELD_HDL)
16147	{
16148	CORINFO_FIELD_HANDLE fieldHnd =
16149	CORINFO_FIELD_HANDLE(comp->vnStore->ConstantValue<ssize_t>(fldHndVN));
16150
16151	// Record this field sequence in 'statStructFldSeq' as it is likely to be a Boxed Struct
16152	// field access.
16153	statStructFldSeq = comp->GetFieldSeqStore()->CreateSingleton(fieldHnd);
16154	}
16155	}
16156	}
16157	}
16158	}
16159
16160	if (statStructFldSeq != nullptr)
16161	{
16162	assert(statStructFldSeq->m_next == nullptr);
16163	// Is this a pointer to a boxed struct?
16164	if (comp->gtIsStaticFieldPtrToBoxedStruct(TYP_REF, statStructFldSeq->m_fieldHnd))
16165	{
16166	pFldSeq = comp->GetFieldSeqStore()->Append(statStructFldSeq, pFldSeq);
16167	pObj = nullptr*;
16168	pStatic = this*;
16169	return true;
16170	}
16171	}
16172
16173	// Otherwise...
16174	pObj = this*;
16175	pStatic = nullptr*;
16176	return true;
16177	}
16178	else if (OperGet() == GT_ADD)
16179	{
16180	// If one operator is a field sequence/handle, the other operator must not also be a field sequence/handle.
16181	if ((gtOp.gtOp1->OperGet() == GT_CNS_INT) && gtOp.gtOp1->IsIconHandle())
16182	{
16183	assert((gtOp.gtOp2->gtOper != GT_CNS_INT) \|\| !gtOp.gtOp2->IsIconHandle());
16184	newFldSeq = gtOp.gtOp1->AsIntCon()->gtFieldSeq;
16185	baseAddr = gtOp.gtOp2;
16186	}
16187	else if (gtOp.gtOp2->OperGet() == GT_CNS_INT)
16188	{
16189	assert((gtOp.gtOp1->gtOper != GT_CNS_INT) \|\| !gtOp.gtOp1->IsIconHandle());
16190	newFldSeq = gtOp.gtOp2->AsIntCon()->gtFieldSeq;
16191	baseAddr = gtOp.gtOp1;
16192	}
16193	}
16194	else
16195	{
16196	// Check if "this" has a zero-offset annotation.
16197	if (!comp->GetZeroOffsetFieldMap()->Lookup(this, &newFldSeq))
16198	{
16199	// If not, this is not a field address.
16200	return false;
16201	}
16202	else
16203	{
16204	baseAddr = this;
16205	mustBeStatic = true;
16206	}
16207	}
16208
16209	// If not we don't have a field seq, it's not a field address.
16210	if (newFldSeq == nullptr \|\| newFldSeq == FieldSeqStore::NotAField())
16211	{
16212	return false;
16213	}
16214
16215	// Prepend this field to whatever we've already accumulated (outside-in).
16216	pFldSeq = comp->GetFieldSeqStore()->Append(newFldSeq, pFldSeq);
16217
16218	// Is it a static or instance field?
16219	if (!FieldSeqStore::IsPseudoField(newFldSeq->m_fieldHnd) &&
16220	comp->info.compCompHnd->isFieldStatic(newFldSeq->m_fieldHnd))
16221	{
16222	// It is a static field. We're done.
16223	pObj = nullptr*;
16224	*pStatic = baseAddr;
16225	return true;
16226	}
16227	else if ((baseAddr != nullptr) && !mustBeStatic)
16228	{
16229	// It's an instance field...but it must be for a struct field, since we've not yet encountered
16230	// a "TYP_REF" address. Analyze the reset of the address.
16231	return baseAddr->gtEffectiveVal()->IsFieldAddr(comp, pObj, pStatic, pFldSeq);
16232	}
16233
16234	// Otherwise...
16235	return false;
16236	}
16237
16238	bool Compiler::gtIsStaticFieldPtrToBoxedStruct(var_types fieldNodeType, CORINFO_FIELD_HANDLE fldHnd)
16239	{
16240	if (fieldNodeType != TYP_REF)
16241	{
16242	return false;
16243	}
16244	noway_assert(fldHnd != nullptr);
16245	CorInfoType cit = info.compCompHnd->getFieldType(fldHnd);
16246	var_types fieldTyp = JITtype2varType(cit);
16247	return fieldTyp != TYP_REF;
16248	}
16249
16250	#ifdef FEATURE_SIMD
16251	//------------------------------------------------------------------------
16252	// gtGetSIMDZero: Get a zero value of the appropriate SIMD type.
16253	//
16254	// Arguments:
16255	// var_types - The simdType
16256	// baseType - The base type we need
16257	// simdHandle - The handle for the SIMD type
16258	//
16259	// Return Value:
16260	// A node generating the appropriate Zero, if we are able to discern it,
16261	// otherwise null (note that this shouldn't happen, but callers should
16262	// be tolerant of this case).
16263
16264	GenTree* Compiler::gtGetSIMDZero(var_types simdType, var_types baseType, CORINFO_CLASS_HANDLE simdHandle)
16265	{
16266	bool found = false;
16267	bool isHWSIMD = true;
16268	noway_assert(m_simdHandleCache != nullptr);
16269
16270	// First, determine whether this is Vector<T>.
16271	if (simdType == getSIMDVectorType())
16272	{
16273	switch (baseType)
16274	{
16275	case TYP_FLOAT:
16276	found = (simdHandle == m_simdHandleCache->SIMDFloatHandle);
16277	break;
16278	case TYP_DOUBLE:
16279	found = (simdHandle == m_simdHandleCache->SIMDDoubleHandle);
16280	break;
16281	case TYP_INT:
16282	found = (simdHandle == m_simdHandleCache->SIMDIntHandle);
16283	break;
16284	case TYP_USHORT:
16285	found = (simdHandle == m_simdHandleCache->SIMDUShortHandle);
16286	break;
16287	case TYP_UBYTE:
16288	found = (simdHandle == m_simdHandleCache->SIMDUByteHandle);
16289	break;
16290	case TYP_SHORT:
16291	found = (simdHandle == m_simdHandleCache->SIMDShortHandle);
16292	break;
16293	case TYP_BYTE:
16294	found = (simdHandle == m_simdHandleCache->SIMDByteHandle);
16295	break;
16296	case TYP_LONG:
16297	found = (simdHandle == m_simdHandleCache->SIMDLongHandle);
16298	break;
16299	case TYP_UINT:
16300	found = (simdHandle == m_simdHandleCache->SIMDUIntHandle);
16301	break;
16302	case TYP_ULONG:
16303	found = (simdHandle == m_simdHandleCache->SIMDULongHandle);
16304	break;
16305	default:
16306	break;
16307	}
16308	if (found)
16309	{
16310	isHWSIMD = false;
16311	}
16312	}
16313
16314	if (!found)
16315	{
16316	// We must still have isHWSIMD set to true, and the only non-HW types left are the fixed types.
16317	switch (simdType)
16318	{
16319	case TYP_SIMD8:
16320	switch (baseType)
16321	{
16322	case TYP_FLOAT:
16323	if (simdHandle == m_simdHandleCache->SIMDVector2Handle)
16324	{
16325	isHWSIMD = false;
16326	}
16327	#if defined(_TARGET_ARM64_) && defined(FEATURE_HW_INTRINSICS)
16328	else
16329	{
16330	assert(simdHandle == m_simdHandleCache->Vector64FloatHandle);
16331	}
16332	break;
16333	case TYP_INT:
16334	assert(simdHandle == m_simdHandleCache->Vector64IntHandle);
16335	break;
16336	case TYP_USHORT:
16337	assert(simdHandle == m_simdHandleCache->Vector64UShortHandle);
16338	break;
16339	case TYP_UBYTE:
16340	assert(simdHandle == m_simdHandleCache->Vector64UByteHandle);
16341	break;
16342	case TYP_SHORT:
16343	assert(simdHandle == m_simdHandleCache->Vector64ShortHandle);
16344	break;
16345	case TYP_BYTE:
16346	assert(simdHandle == m_simdHandleCache->Vector64ByteHandle);
16347	break;
16348	case TYP_UINT:
16349	assert(simdHandle == m_simdHandleCache->Vector64UIntHandle);
16350	break;
16351	#endif // defined(_TARGET_ARM64_) && defined(FEATURE_HW_INTRINSICS)
16352	default:
16353	break;
16354	}
16355	break;
16356
16357	case TYP_SIMD12:
16358	assert((baseType == TYP_FLOAT) && (simdHandle == m_simdHandleCache->SIMDVector3Handle));
16359	isHWSIMD = false;
16360	break;
16361
16362	case TYP_SIMD16:
16363	switch (baseType)
16364	{
16365	case TYP_FLOAT:
16366	if (simdHandle == m_simdHandleCache->SIMDVector4Handle)
16367	{
16368	isHWSIMD = false;
16369	}
16370	#if defined(FEATURE_HW_INTRINSICS)
16371	else
16372	{
16373	assert(simdHandle == m_simdHandleCache->Vector128FloatHandle);
16374	}
16375	break;
16376	case TYP_DOUBLE:
16377	assert(simdHandle == m_simdHandleCache->Vector128DoubleHandle);
16378	break;
16379	case TYP_INT:
16380	assert(simdHandle == m_simdHandleCache->Vector128IntHandle);
16381	break;
16382	case TYP_USHORT:
16383	assert(simdHandle == m_simdHandleCache->Vector128UShortHandle);
16384	break;
16385	case TYP_UBYTE:
16386	assert(simdHandle == m_simdHandleCache->Vector128UByteHandle);
16387	break;
16388	case TYP_SHORT:
16389	assert(simdHandle == m_simdHandleCache->Vector128ShortHandle);
16390	break;
16391	case TYP_BYTE:
16392	assert(simdHandle == m_simdHandleCache->Vector128ByteHandle);
16393	break;
16394	case TYP_LONG:
16395	assert(simdHandle == m_simdHandleCache->Vector128LongHandle);
16396	break;
16397	case TYP_UINT:
16398	assert(simdHandle == m_simdHandleCache->Vector128UIntHandle);
16399	break;
16400	case TYP_ULONG:
16401	assert(simdHandle == m_simdHandleCache->Vector128ULongHandle);
16402	break;
16403	#endif // defined(FEATURE_HW_INTRINSICS)
16404
16405	default:
16406	break;
16407	}
16408	break;
16409
16410	#if defined(_TARGET_XARCH4_) && defined(FEATURE_HW_INTRINSICS)
16411	case TYP_SIMD32:
16412	switch (baseType)
16413	{
16414	case TYP_FLOAT:
16415	assert(simdHandle == m_simdHandleCache->Vector256FloatHandle);
16416	break;
16417	case TYP_DOUBLE:
16418	assert(simdHandle == m_simdHandleCache->Vector256DoubleHandle);
16419	break;
16420	case TYP_INT:
16421	assert(simdHandle == m_simdHandleCache->Vector256IntHandle);
16422	break;
16423	case TYP_USHORT:
16424	assert(simdHandle == m_simdHandleCache->Vector256UShortHandle);
16425	break;
16426	case TYP_UBYTE:
16427	assert(simdHandle == m_simdHandleCache->Vector256UByteHandle);
16428	break;
16429	case TYP_SHORT:
16430	assert(simdHandle == m_simdHandleCache->Vector256ShortHandle);
16431	break;
16432	case TYP_BYTE:
16433	assert(simdHandle == m_simdHandleCache->Vector256ByteHandle);
16434	break;
16435	case TYP_LONG:
16436	assert(simdHandle == m_simdHandleCache->Vector256LongHandle);
16437	break;
16438	case TYP_UINT:
16439	assert(simdHandle == m_simdHandleCache->Vector256UIntHandle);
16440	break;
16441	case TYP_ULONG:
16442	assert(simdHandle == m_simdHandleCache->Vector256ULongHandle);
16443	break;
16444	default:
16445	break;
16446	}
16447	break;
16448	#endif // _TARGET_XARCH_ && FEATURE_HW_INTRINSICS
16449	default:
16450	break;
16451	}
16452	}
16453
16454	unsigned size = genTypeSize(simdType);
16455	if (isHWSIMD)
16456	{
16457	#if defined(_TARGET_XARCH_) && defined(FEATURE_HW_INTRINSICS)
16458	switch (simdType)
16459	{
16460	case TYP_SIMD16:
16461	if (compSupports(InstructionSet_SSE))
16462	{
16463	// We only return the HWIntrinsicNode if SSE is supported, since it is possible for
16464	// the user to disable the SSE HWIntrinsic support via the COMPlus configuration knobs
16465	// even though the hardware vector types are still available.
16466	return gtNewSimdHWIntrinsicNode(simdType, NI_Base_Vector128_Zero, baseType, size);
16467	}
16468	return nullptr;
16469	case TYP_SIMD32:
16470	if (compSupports(InstructionSet_AVX))
16471	{
16472	// We only return the HWIntrinsicNode if AVX is supported, since it is possible for
16473	// the user to disable the AVX HWIntrinsic support via the COMPlus configuration knobs
16474	// even though the hardware vector types are still available.
16475	return gtNewSimdHWIntrinsicNode(simdType, NI_Base_Vector256_Zero, baseType, size);
16476	}
16477	return nullptr;
16478	default:
16479	break;
16480	}
16481	#endif // _TARGET_XARCH_ && FEATURE_HW_INTRINSICS
16482	JITDUMP("Coudn't find the matching SIMD type for %s<%s> in gtGetSIMDZero\n", varTypeName(simdType),
16483	varTypeName(baseType));
16484	}
16485	else
16486	{
16487	return gtNewSIMDVectorZero(simdType, baseType, size);
16488	}
16489	return nullptr;
16490	}
16491	#endif // FEATURE_SIMD
16492
16493	CORINFO_CLASS_HANDLE Compiler::gtGetStructHandleIfPresent(GenTree* tree)
16494	{
16495	CORINFO_CLASS_HANDLE structHnd = NO_CLASS_HANDLE;
16496	tree = tree->gtEffectiveVal();
16497	if (varTypeIsStruct(tree->gtType))
16498	{
16499	switch (tree->gtOper)
16500	{
16501	default:
16502	break;
16503	case GT_MKREFANY:
16504	structHnd = impGetRefAnyClass();
16505	break;
16506	case GT_OBJ:
16507	structHnd = tree->gtObj.gtClass;
16508	break;
16509	case GT_CALL:
16510	structHnd = tree->gtCall.gtRetClsHnd;
16511	break;
16512	case GT_RET_EXPR:
16513	structHnd = tree->gtRetExpr.gtRetClsHnd;
16514	break;
16515	case GT_ARGPLACE:
16516	structHnd = tree->gtArgPlace.gtArgPlaceClsHnd;
16517	break;
16518	case GT_INDEX:
16519	structHnd = tree->gtIndex.gtStructElemClass;
16520	break;
16521	case GT_INDEX_ADDR:
16522	structHnd = tree->AsIndexAddr()->gtStructElemClass;
16523	break;
16524	case GT_FIELD:
16525	info.compCompHnd->getFieldType(tree->gtField.gtFldHnd, &structHnd);
16526	break;
16527	case GT_ASG:
16528	structHnd = gtGetStructHandleIfPresent(tree->gtGetOp1());
16529	break;
16530	case GT_LCL_FLD:
16531	#ifdef FEATURE_SIMD
16532	if (varTypeIsSIMD(tree))
16533	{
16534	structHnd = gtGetStructHandleForSIMD(tree->gtType, TYP_FLOAT);
16535	}
16536	#endif
16537	break;
16538	case GT_LCL_VAR:
16539	structHnd = lvaTable[tree->AsLclVarCommon()->gtLclNum].lvVerTypeInfo.GetClassHandle();
16540	break;
16541	case GT_RETURN:
16542	structHnd = gtGetStructHandleIfPresent(tree->gtOp.gtOp1);
16543	break;
16544	case GT_IND:
16545	#ifdef FEATURE_SIMD
16546	if (varTypeIsSIMD(tree))
16547	{
16548	structHnd = gtGetStructHandleForSIMD(tree->gtType, TYP_FLOAT);
16549	}
16550	else
16551	#endif
16552	{
16553	ArrayInfo arrInfo;
16554	if (TryGetArrayInfo(tree->AsIndir(), &arrInfo))
16555	{
16556	structHnd = EncodeElemType(arrInfo.m_elemType, arrInfo.m_elemStructType);
16557	}
16558	}
16559	break;
16560	#ifdef FEATURE_SIMD
16561	case GT_SIMD:
16562	structHnd = gtGetStructHandleForSIMD(tree->gtType, tree->AsSIMD()->gtSIMDBaseType);
16563	break;
16564	#endif // FEATURE_SIMD
16565	#ifdef FEATURE_HW_INTRINSICS
16566	case GT_HWIntrinsic:
16567	structHnd = gtGetStructHandleForHWSIMD(tree->gtType, tree->AsHWIntrinsic()->gtSIMDBaseType);
16568	break;
16569	#endif
16570	break;
16571	}
16572	}
16573	return structHnd;
16574	}
16575
16576	CORINFO_CLASS_HANDLE Compiler::gtGetStructHandle(GenTree* tree)
16577	{
16578	CORINFO_CLASS_HANDLE structHnd = gtGetStructHandleIfPresent(tree);
16579	assert(structHnd != NO_CLASS_HANDLE);
16580	return structHnd;
16581	}
16582
16583	//------------------------------------------------------------------------
16584	// gtGetClassHandle: find class handle for a ref type
16585	//
16586	// Arguments:
16587	// tree -- tree to find handle for
16588	// pIsExact [out] -- whether handle is exact type
16589	// pIsNonNull [out] -- whether tree value is known not to be null
16590	//
16591	// Return Value:
16592	// nullptr if class handle is unknown,
16593	// otherwise the class handle.
16594	// pIsExact set true if tree type is known to be exactly the handle type,*
16595	// otherwise actual type may be a subtype.
16596	// pIsNonNull set true if tree value is known not to be null,*
16597	// otherwise a null value is possible.
16598
16599	CORINFO_CLASS_HANDLE Compiler::gtGetClassHandle(GenTree* tree, bool* pIsExact, bool* pIsNonNull)
16600	{
16601	// Set default values for our out params.
16602	pIsNonNull = false*;
16603	pIsExact = false*;
16604	CORINFO_CLASS_HANDLE objClass = nullptr;
16605
16606	// Bail out if we're just importing and not generating code, since
16607	// the jit uses TYP_REF for CORINFO_TYPE_VAR locals and args, but
16608	// these may not be ref types.
16609	if (compIsForImportOnly())
16610	{
16611	return objClass;
16612	}
16613
16614	// Bail out if the tree is not a ref type.
16615	var_types treeType = tree->TypeGet();
16616	if (treeType != TYP_REF)
16617	{
16618	return objClass;
16619	}
16620
16621	// Tunnel through commas.
16622	GenTree* obj = tree->gtEffectiveVal(false);
16623	const genTreeOps objOp = obj->OperGet();
16624
16625	switch (objOp)
16626	{
16627	case GT_COMMA:
16628	{
16629	// gtEffectiveVal above means we shouldn't see commas here.
16630	assert(!"unexpected GT_COMMA");
16631	break;
16632	}
16633
16634	case GT_LCL_VAR:
16635	{
16636	// For locals, pick up type info from the local table.
16637	const unsigned objLcl = obj->AsLclVar()->GetLclNum();
16638
16639	objClass = lvaTable[objLcl].lvClassHnd;
16640	*pIsExact = lvaTable[objLcl].lvClassIsExact;
16641	break;
16642	}
16643
16644	case GT_FIELD:
16645	{
16646	// For fields, get the type from the field handle.
16647	CORINFO_FIELD_HANDLE fieldHnd = obj->gtField.gtFldHnd;
16648
16649	if (fieldHnd != nullptr)
16650	{
16651	objClass = gtGetFieldClassHandle(fieldHnd, pIsExact, pIsNonNull);
16652	}
16653
16654	break;
16655	}
16656
16657	case GT_RET_EXPR:
16658	{
16659	// If we see a RET_EXPR, recurse through to examine the
16660	// return value expression.
16661	GenTree* retExpr = tree->gtRetExpr.gtInlineCandidate;
16662	objClass = gtGetClassHandle(retExpr, pIsExact, pIsNonNull);
16663	break;
16664	}
16665
16666	case GT_CALL:
16667	{
16668	GenTreeCall* call = tree->AsCall();
16669	if (call->IsInlineCandidate())
16670	{
16671	// For inline candidates, we've already cached the return
16672	// type class handle in the inline info.
16673	InlineCandidateInfo* inlInfo = call->gtInlineCandidateInfo;
16674	assert(inlInfo != nullptr);
16675
16676	// Grab it as our first cut at a return type.
16677	assert(inlInfo->methInfo.args.retType == CORINFO_TYPE_CLASS);
16678	objClass = inlInfo->methInfo.args.retTypeClass;
16679
16680	// If the method is shared, the above may not capture
16681	// the most precise return type information (that is,
16682	// it may represent a shared return type and as such,
16683	// have instances of __Canon). See if we can use the
16684	// context to get at something more definite.
16685	//
16686	// For now, we do this here on demand rather than when
16687	// processing the call, but we could/should apply
16688	// similar sharpening to the argument and local types
16689	// of the inlinee.
16690	const unsigned retClassFlags = info.compCompHnd->getClassAttribs(objClass);
16691	if (retClassFlags & CORINFO_FLG_SHAREDINST)
16692	{
16693	CORINFO_CONTEXT_HANDLE context = inlInfo->exactContextHnd;
16694
16695	if (context != nullptr)
16696	{
16697	CORINFO_CLASS_HANDLE exactClass = nullptr;
16698
16699	if (((size_t)context & CORINFO_CONTEXTFLAGS_MASK) == CORINFO_CONTEXTFLAGS_CLASS)
16700	{
16701	exactClass = (CORINFO_CLASS_HANDLE)((size_t)context & ~CORINFO_CONTEXTFLAGS_MASK);
16702	}
16703	else
16704	{
16705	CORINFO_METHOD_HANDLE exactMethod =
16706	(CORINFO_METHOD_HANDLE)((size_t)context & ~CORINFO_CONTEXTFLAGS_MASK);
16707	exactClass = info.compCompHnd->getMethodClass(exactMethod);
16708	}
16709
16710	// Grab the signature in this context.
16711	CORINFO_SIG_INFO sig;
16712	eeGetMethodSig(call->gtCallMethHnd, &sig, exactClass);
16713	assert(sig.retType == CORINFO_TYPE_CLASS);
16714	objClass = sig.retTypeClass;
16715	}
16716	}
16717	}
16718	else if (call->gtCallType == CT_USER_FUNC)
16719	{
16720	// For user calls, we can fetch the approximate return
16721	// type info from the method handle. Unfortunately
16722	// we've lost the exact context, so this is the best
16723	// we can do for now.
16724	CORINFO_METHOD_HANDLE method = call->gtCallMethHnd;
16725	CORINFO_CLASS_HANDLE exactClass = nullptr;
16726	CORINFO_SIG_INFO sig;
16727	eeGetMethodSig(method, &sig, exactClass);
16728	if (sig.retType == CORINFO_TYPE_VOID)
16729	{
16730	// This is a constructor call.
16731	const unsigned methodFlags = info.compCompHnd->getMethodAttribs(method);
16732	assert((methodFlags & CORINFO_FLG_CONSTRUCTOR) != `0`);
16733	objClass = info.compCompHnd->getMethodClass(method);
16734	pIsExact = true*;
16735	pIsNonNull = true*;
16736	}
16737	else
16738	{
16739	assert(sig.retType == CORINFO_TYPE_CLASS);
16740	objClass = sig.retTypeClass;
16741	}
16742	}
16743	else if (call->gtCallType == CT_HELPER)
16744	{
16745	objClass = gtGetHelperCallClassHandle(call, pIsExact, pIsNonNull);
16746	}
16747
16748	break;
16749	}
16750
16751	case GT_INTRINSIC:
16752	{
16753	GenTreeIntrinsic* intrinsic = obj->AsIntrinsic();
16754
16755	if (intrinsic->gtIntrinsicId == CORINFO_INTRINSIC_Object_GetType)
16756	{
16757	CORINFO_CLASS_HANDLE runtimeType = info.compCompHnd->getBuiltinClass(CLASSID_RUNTIME_TYPE);
16758	assert(runtimeType != NO_CLASS_HANDLE);
16759
16760	objClass = runtimeType;
16761	pIsExact = false*;
16762	pIsNonNull = true*;
16763	}
16764
16765	break;
16766	}
16767
16768	case GT_CNS_STR:
16769	{
16770	// For literal strings, we know the class and that the
16771	// value is not null.
16772	objClass = impGetStringClass();
16773	pIsExact = true*;
16774	pIsNonNull = true*;
16775	break;
16776	}
16777
16778	case GT_IND:
16779	{
16780	GenTreeIndir* indir = obj->AsIndir();
16781
16782	if (indir->HasBase() && !indir->HasIndex())
16783	{
16784	// indir(addr(lcl)) --> lcl
16785	//
16786	// This comes up during constrained callvirt on ref types.
16787
16788	GenTree* base = indir->Base();
16789	GenTreeLclVarCommon* lcl = base->IsLocalAddrExpr();
16790
16791	if ((lcl != nullptr) && (base->OperGet() != GT_ADD))
16792	{
16793	const unsigned objLcl = lcl->GetLclNum();
16794	objClass = lvaTable[objLcl].lvClassHnd;
16795	*pIsExact = lvaTable[objLcl].lvClassIsExact;
16796	}
16797	else if (base->OperGet() == GT_ARR_ELEM)
16798	{
16799	// indir(arr_elem(...)) -> array element type
16800
16801	GenTree* array = base->AsArrElem()->gtArrObj;
16802
16803	objClass = gtGetArrayElementClassHandle(array);
16804	pIsExact = false*;
16805	pIsNonNull = false*;
16806	}
16807	else if (base->OperGet() == GT_ADD)
16808	{
16809	// This could be a static field access.
16810	//
16811	// See if op1 is a static field base helper call
16812	// and if so, op2 will have the field info.
16813	GenTree* op1 = base->gtOp.gtOp1;
16814	GenTree* op2 = base->gtOp.gtOp2;
16815
16816	const bool op1IsStaticFieldBase = gtIsStaticGCBaseHelperCall(op1);
16817
16818	if (op1IsStaticFieldBase && (op2->OperGet() == GT_CNS_INT))
16819	{
16820	FieldSeqNode* fieldSeq = op2->AsIntCon()->gtFieldSeq;
16821
16822	if (fieldSeq != nullptr)
16823	{
16824	while (fieldSeq->m_next != nullptr)
16825	{
16826	fieldSeq = fieldSeq->m_next;
16827	}
16828
16829	assert(!fieldSeq->IsPseudoField());
16830
16831	// No benefit to calling gtGetFieldClassHandle here, as
16832	// the exact field being accessed can vary.
16833	CORINFO_FIELD_HANDLE fieldHnd = fieldSeq->m_fieldHnd;
16834	CORINFO_CLASS_HANDLE fieldClass = nullptr;
16835	CorInfoType fieldCorType = info.compCompHnd->getFieldType(fieldHnd, &fieldClass);
16836
16837	assert(fieldCorType == CORINFO_TYPE_CLASS);
16838	objClass = fieldClass;
16839	}
16840	}
16841	}
16842	}
16843
16844	break;
16845	}
16846
16847	case GT_BOX:
16848	{
16849	// Box should just wrap a local var reference which has
16850	// the type we're looking for. Also box only represents a
16851	// non-nullable value type so result cannot be null.
16852	GenTreeBox* box = obj->AsBox();
16853	GenTree* boxTemp = box->BoxOp();
16854	assert(boxTemp->IsLocal());
16855	const unsigned boxTempLcl = boxTemp->AsLclVar()->GetLclNum();
16856	objClass = lvaTable[boxTempLcl].lvClassHnd;
16857	*pIsExact = lvaTable[boxTempLcl].lvClassIsExact;
16858	pIsNonNull = true*;
16859	break;
16860	}
16861
16862	case GT_INDEX:
16863	{
16864	GenTree* array = obj->AsIndex()->Arr();
16865
16866	objClass = gtGetArrayElementClassHandle(array);
16867	pIsExact = false*;
16868	pIsNonNull = false*;
16869	break;
16870	}
16871
16872	default:
16873	{
16874	break;
16875	}
16876	}
16877
16878	return objClass;
16879	}
16880
16881	//------------------------------------------------------------------------
16882	// gtGetHelperCallClassHandle: find class handle for return value of a
16883	// helper call
16884	//
16885	// Arguments:
16886	// call - helper call to examine
16887	// pIsExact - [OUT] true if type is known exactly
16888	// pIsNonNull - [OUT] true if return value is not null
16889	//
16890	// Return Value:
16891	// nullptr if helper call result is not a ref class, or the class handle
16892	// is unknown, otherwise the class handle.
16893
16894	CORINFO_CLASS_HANDLE Compiler::gtGetHelperCallClassHandle(GenTreeCall* call, bool* pIsExact, bool* pIsNonNull)
16895	{
16896	assert(call->gtCallType == CT_HELPER);
16897
16898	pIsNonNull = false*;
16899	pIsExact = false*;
16900	CORINFO_CLASS_HANDLE objClass = nullptr;
16901	const CorInfoHelpFunc helper = eeGetHelperNum(call->gtCallMethHnd);
16902
16903	switch (helper)
16904	{
16905	case CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE:
16906	case CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE_MAYBENULL:
16907	{
16908	// Note for some runtimes these helpers return exact types.
16909	//
16910	// But in those cases the types are also sealed, so there's no
16911	// need to claim exactness here.
16912	const bool helperResultNonNull = (helper == CORINFO_HELP_TYPEHANDLE_TO_RUNTIMETYPE);
16913	CORINFO_CLASS_HANDLE runtimeType = info.compCompHnd->getBuiltinClass(CLASSID_RUNTIME_TYPE);
16914
16915	assert(runtimeType != NO_CLASS_HANDLE);
16916
16917	objClass = runtimeType;
16918	*pIsNonNull = helperResultNonNull;
16919	break;
16920	}
16921
16922	case CORINFO_HELP_CHKCASTCLASS:
16923	case CORINFO_HELP_CHKCASTANY:
16924	case CORINFO_HELP_CHKCASTARRAY:
16925	case CORINFO_HELP_CHKCASTINTERFACE:
16926	case CORINFO_HELP_CHKCASTCLASS_SPECIAL:
16927	case CORINFO_HELP_ISINSTANCEOFINTERFACE:
16928	case CORINFO_HELP_ISINSTANCEOFARRAY:
16929	case CORINFO_HELP_ISINSTANCEOFCLASS:
16930	case CORINFO_HELP_ISINSTANCEOFANY:
16931	{
16932	// Fetch the class handle from the helper call arglist
16933	GenTreeArgList* args = call->gtCallArgs;
16934	GenTree* typeArg = args->Current();
16935	CORINFO_CLASS_HANDLE castHnd = gtGetHelperArgClassHandle(typeArg);
16936
16937	// We generally assume the type being cast to is the best type
16938	// for the result, unless it is an interface type.
16939	//
16940	// TODO-CQ: when we have default interface methods then
16941	// this might not be the best assumption. We could also
16942	// explore calling something like mergeClasses to identify
16943	// the more specific class. A similar issue arises when
16944	// typing the temp in impCastClassOrIsInstToTree, when we
16945	// expand the cast inline.
16946	if (castHnd != nullptr)
16947	{
16948	DWORD attrs = info.compCompHnd->getClassAttribs(castHnd);
16949
16950	if ((attrs & CORINFO_FLG_INTERFACE) != `0`)
16951	{
16952	castHnd = nullptr;
16953	}
16954	}
16955
16956	// If we don't have a good estimate for the type we can use the
16957	// type from the value being cast instead.
16958	if (castHnd == nullptr)
16959	{
16960	GenTree* valueArg = args->Rest()->Current();
16961	castHnd = gtGetClassHandle(valueArg, pIsExact, pIsNonNull);
16962	}
16963
16964	// We don't know at jit time if the cast will succeed or fail, but if it
16965	// fails at runtime then an exception is thrown for cast helpers, or the
16966	// result is set null for instance helpers.
16967	//
16968	// So it safe to claim the result has the cast type.
16969	// Note we don't know for sure that it is exactly this type.
16970	if (castHnd != nullptr)
16971	{
16972	objClass = castHnd;
16973	}
16974
16975	break;
16976	}
16977
16978	default:
16979	break;
16980	}
16981
16982	return objClass;
16983	}
16984
16985	//------------------------------------------------------------------------
16986	// gtGetArrayElementClassHandle: find class handle for elements of an array
16987	// of ref types
16988	//
16989	// Arguments:
16990	// array -- array to find handle for
16991	//
16992	// Return Value:
16993	// nullptr if element class handle is unknown, otherwise the class handle.
16994
16995	CORINFO_CLASS_HANDLE Compiler::gtGetArrayElementClassHandle(GenTree* array)
16996	{
16997	bool isArrayExact = false;
16998	bool isArrayNonNull = false;
16999	CORINFO_CLASS_HANDLE arrayClassHnd = gtGetClassHandle(array, &isArrayExact, &isArrayNonNull);
17000
17001	if (arrayClassHnd != nullptr)
17002	{
17003	// We know the class of the reference
17004	DWORD attribs = info.compCompHnd->getClassAttribs(arrayClassHnd);
17005
17006	if ((attribs & CORINFO_FLG_ARRAY) != `0`)
17007	{
17008	// We know for sure it is an array
17009	CORINFO_CLASS_HANDLE elemClassHnd = nullptr;
17010	CorInfoType arrayElemType = info.compCompHnd->getChildType(arrayClassHnd, &elemClassHnd);
17011
17012	if (arrayElemType == CORINFO_TYPE_CLASS)
17013	{
17014	// We know it is an array of ref types
17015	return elemClassHnd;
17016	}
17017	}
17018	}
17019
17020	return nullptr;
17021	}
17022
17023	//------------------------------------------------------------------------
17024	// gtGetFieldClassHandle: find class handle for a field
17025	//
17026	// Arguments:
17027	// fieldHnd - field handle for field in question
17028	// pIsExact - [OUT] true if type is known exactly
17029	// pIsNonNull - [OUT] true if field value is not null
17030	//
17031	// Return Value:
17032	// nullptr if helper call result is not a ref class, or the class handle
17033	// is unknown, otherwise the class handle.
17034	//
17035	// May examine runtime state of static field instances.
17036
17037	CORINFO_CLASS_HANDLE Compiler::gtGetFieldClassHandle(CORINFO_FIELD_HANDLE fieldHnd, bool* pIsExact, bool* pIsNonNull)
17038	{
17039	CORINFO_CLASS_HANDLE fieldClass = nullptr;
17040	CorInfoType fieldCorType = info.compCompHnd->getFieldType(fieldHnd, &fieldClass);
17041
17042	if (fieldCorType == CORINFO_TYPE_CLASS)
17043	{
17044	// Optionally, look at the actual type of the field's value
17045	bool queryForCurrentClass = true;
17046	INDEBUG(queryForCurrentClass = (JitConfig.JitQueryCurrentStaticFieldClass() > `0`););
17047
17048	if (queryForCurrentClass)
17049	{
17050
17051	#if DEBUG
17052	const char* fieldClassName = nullptr;
17053	const char* fieldName = eeGetFieldName(fieldHnd, &fieldClassName);
17054	JITDUMP("Querying runtime about current class of field %s.%s (declared as %s)\n", fieldClassName, fieldName,
17055	eeGetClassName(fieldClass));
17056	#endif // DEBUG
17057
17058	// Is this a fully initialized init-only static field?
17059	//
17060	// Note we're not asking for speculative results here, yet.
17061	CORINFO_CLASS_HANDLE currentClass = info.compCompHnd->getStaticFieldCurrentClass(fieldHnd);
17062
17063	if (currentClass != NO_CLASS_HANDLE)
17064	{
17065	// Yes! We know the class exactly and can rely on this to always be true.
17066	fieldClass = currentClass;
17067	pIsExact = true*;
17068	pIsNonNull = true*;
17069	JITDUMP("Runtime reports field is init-only and initialized and has class %s\n",
17070	eeGetClassName(fieldClass));
17071	}
17072	else
17073	{
17074	JITDUMP("Field's current class not available\n");
17075	}
17076	}
17077	}
17078
17079	return fieldClass;
17080	}
17081
17082	//------------------------------------------------------------------------
17083	// gtIsGCStaticBaseHelperCall: true if tree is fetching the gc static base
17084	// for a subsequent static field access
17085	//
17086	// Arguments:
17087	// tree - tree to consider
17088	//
17089	// Return Value:
17090	// true if the tree is a suitable helper call
17091	//
17092	// Notes:
17093	// Excludes R2R helpers as they specify the target field in a way
17094	// that is opaque to the jit.
17095
17096	bool Compiler::gtIsStaticGCBaseHelperCall(GenTree* tree)
17097	{
17098	if (tree->OperGet() != GT_CALL)
17099	{
17100	return false;
17101	}
17102
17103	GenTreeCall* call = tree->AsCall();
17104
17105	if (call->gtCallType != CT_HELPER)
17106	{
17107	return false;
17108	}
17109
17110	const CorInfoHelpFunc helper = eeGetHelperNum(call->gtCallMethHnd);
17111
17112	switch (helper)
17113	{
17114	// We are looking for a REF type so only need to check for the GC base helpers
17115	case CORINFO_HELP_GETGENERICS_GCSTATIC_BASE:
17116	case CORINFO_HELP_GETSHARED_GCSTATIC_BASE:
17117	case CORINFO_HELP_GETSHARED_GCSTATIC_BASE_NOCTOR:
17118	case CORINFO_HELP_GETSHARED_GCSTATIC_BASE_DYNAMICCLASS:
17119	case CORINFO_HELP_GETGENERICS_GCTHREADSTATIC_BASE:
17120	case CORINFO_HELP_GETSHARED_GCTHREADSTATIC_BASE:
17121	case CORINFO_HELP_GETSHARED_GCTHREADSTATIC_BASE_NOCTOR:
17122	case CORINFO_HELP_GETSHARED_GCTHREADSTATIC_BASE_DYNAMICCLASS:
17123	return true;
17124	default:
17125	break;
17126	}
17127
17128	return false;
17129	}
17130
17131	void GenTree::ParseArrayAddress(
17132	Compiler* comp, ArrayInfo* arrayInfo, GenTree** pArr, ValueNum* pInxVN, FieldSeqNode** pFldSeq)
17133	{
17134	pArr = nullptr*;
17135	ValueNum inxVN = ValueNumStore::NoVN;
17136	target_ssize_t offset = `0`;
17137	FieldSeqNode* fldSeq = nullptr;
17138
17139	ParseArrayAddressWork(comp, `1`, pArr, &inxVN, &offset, &fldSeq);
17140
17141	// If we didn't find an array reference (perhaps it is the constant null?) we will give up.
17142	if (pArr == nullptr*)
17143	{
17144	return;
17145	}
17146
17147	// OK, new we have to figure out if any part of the "offset" is a constant contribution to the index.
17148	// First, sum the offsets of any fields in fldSeq.
17149	unsigned fieldOffsets = `0`;
17150	FieldSeqNode* fldSeqIter = fldSeq;
17151	// Also, find the first non-pseudo field...
17152	assert(pFldSeq == nullptr*);
17153	while (fldSeqIter != nullptr)
17154	{
17155	if (fldSeqIter == FieldSeqStore::NotAField())
17156	{
17157	// TODO-Review: A NotAField here indicates a failure to properly maintain the field sequence
17158	// See test case self_host_tests_x86\jit\regression\CLR-x86-JIT\v1-m12-beta2\ b70992\ b70992.exe
17159	// Safest thing to do here is to drop back to MinOpts
17160	CLANG_FORMAT_COMMENT_ANCHOR;
17161
17162	#ifdef DEBUG
17163	if (comp->opts.optRepeat)
17164	{
17165	// We don't guarantee preserving these annotations through the entire optimizer, so
17166	// just conservatively return null if under optRepeat.
17167	pArr = nullptr*;
17168	return;
17169	}
17170	#endif // DEBUG
17171	noway_assert(!"fldSeqIter is NotAField() in ParseArrayAddress");
17172	}
17173
17174	if (!FieldSeqStore::IsPseudoField(fldSeqIter->m_fieldHnd))
17175	{
17176	if (pFldSeq == nullptr*)
17177	{
17178	*pFldSeq = fldSeqIter;
17179	}
17180	CORINFO_CLASS_HANDLE fldCls = nullptr;
17181	noway_assert(fldSeqIter->m_fieldHnd != nullptr);
17182	CorInfoType cit = comp->info.compCompHnd->getFieldType(fldSeqIter->m_fieldHnd, &fldCls);
17183	fieldOffsets += comp->compGetTypeSize(cit, fldCls);
17184	}
17185	fldSeqIter = fldSeqIter->m_next;
17186	}
17187
17188	// Is there some portion of the "offset" beyond the first-elem offset and the struct field suffix we just computed?
17189	if (!FitsIn<target_ssize_t>(fieldOffsets + arrayInfo->m_elemOffset) \|\|
17190	!FitsIn<target_ssize_t>(arrayInfo->m_elemSize))
17191	{
17192	// This seems unlikely, but no harm in being safe...
17193	pInxVN = comp->GetValueNumStore()->VNForExpr(nullptr*, TYP_INT);
17194	return;
17195	}
17196	// Otherwise...
17197	target_ssize_t offsetAccountedFor = static_cast<target_ssize_t>(fieldOffsets + arrayInfo->m_elemOffset);
17198	target_ssize_t elemSize = static_cast<target_ssize_t>(arrayInfo->m_elemSize);
17199
17200	target_ssize_t constIndOffset = offset - offsetAccountedFor;
17201	// This should be divisible by the element size...
17202	assert((constIndOffset % elemSize) == `0`);
17203	target_ssize_t constInd = constIndOffset / elemSize;
17204
17205	ValueNumStore* vnStore = comp->GetValueNumStore();
17206
17207	if (inxVN == ValueNumStore::NoVN)
17208	{
17209	// Must be a constant index.
17210	*pInxVN = vnStore->VNForPtrSizeIntCon(constInd);
17211	}
17212	else
17213	{
17214	//
17215	// Perform ((inxVN / elemSizeVN) + vnForConstInd)
17216	//
17217
17218	// The value associated with the index value number (inxVN) is the offset into the array,
17219	// which has been scaled by element size. We need to recover the array index from that offset
17220	if (vnStore->IsVNConstant(inxVN))
17221	{
17222	target_ssize_t index = vnStore->CoercedConstantValue<target_ssize_t>(inxVN);
17223	noway_assert(elemSize > `0` && ((index % elemSize) == `0`));
17224	*pInxVN = vnStore->VNForPtrSizeIntCon((index / elemSize) + constInd);
17225	}
17226	else
17227	{
17228	bool canFoldDiv = false;
17229
17230	// If the index VN is a MUL by elemSize, see if we can eliminate it instead of adding
17231	// the division by elemSize.
17232	VNFuncApp funcApp;
17233	if (vnStore->GetVNFunc(inxVN, &funcApp) && funcApp.m_func == (VNFunc)GT_MUL)
17234	{
17235	ValueNum vnForElemSize = vnStore->VNForLongCon(elemSize);
17236
17237	// One of the multiply operand is elemSize, so the resulting
17238	// index VN should simply be the other operand.
17239	if (funcApp.m_args[`1`] == vnForElemSize)
17240	{
17241	*pInxVN = funcApp.m_args[`0`];
17242	canFoldDiv = true;
17243	}
17244	else if (funcApp.m_args[`0`] == vnForElemSize)
17245	{
17246	*pInxVN = funcApp.m_args[`1`];
17247	canFoldDiv = true;
17248	}
17249	}
17250
17251	// Perform ((inxVN / elemSizeVN) + vnForConstInd)
17252	if (!canFoldDiv)
17253	{
17254	ValueNum vnForElemSize = vnStore->VNForPtrSizeIntCon(elemSize);
17255	ValueNum vnForScaledInx =
17256	vnStore->VNForFunc(TYP_I_IMPL, GetVNFuncForOper(GT_DIV, VOK_Default), inxVN, vnForElemSize);
17257	*pInxVN = vnForScaledInx;
17258	}
17259
17260	if (constInd != `0`)
17261	{
17262	ValueNum vnForConstInd = comp->GetValueNumStore()->VNForPtrSizeIntCon(constInd);
17263	VNFunc vnFunc = GetVNFuncForOper(GT_ADD, VOK_Default);
17264
17265	pInxVN = comp->GetValueNumStore()->VNForFunc(TYP_I_IMPL, vnFunc, pInxVN, vnForConstInd);
17266	}
17267	}
17268	}
17269	}
17270
17271	void GenTree::ParseArrayAddressWork(Compiler* comp,
17272	target_ssize_t inputMul,
17273	GenTree** pArr,
17274	ValueNum* pInxVN,
17275	target_ssize_t* pOffset,
17276	FieldSeqNode** pFldSeq)
17277	{
17278	if (TypeGet() == TYP_REF)
17279	{
17280	// This must be the array pointer.
17281	pArr = this*;
17282	assert(inputMul == `1`); // Can't multiply the array pointer by anything.
17283	}
17284	else
17285	{
17286	switch (OperGet())
17287	{
17288	case GT_CNS_INT:
17289	pFldSeq = comp->GetFieldSeqStore()->Append(pFldSeq, gtIntCon.gtFieldSeq);
17290	assert(!gtIntCon.ImmedValNeedsReloc(comp));
17291	// TODO-CrossBitness: we wouldn't need the cast below if GenTreeIntCon::gtIconVal had target_ssize_t
17292	// type.
17293	pOffset += (inputMul (target_ssize_t)(gtIntCon.gtIconVal));
17294	return;
17295
17296	case GT_ADD:
17297	case GT_SUB:
17298	gtOp.gtOp1->ParseArrayAddressWork(comp, inputMul, pArr, pInxVN, pOffset, pFldSeq);
17299	if (OperGet() == GT_SUB)
17300	{
17301	inputMul = -inputMul;
17302	}
17303	gtOp.gtOp2->ParseArrayAddressWork(comp, inputMul, pArr, pInxVN, pOffset, pFldSeq);
17304	return;
17305
17306	case GT_MUL:
17307	{
17308	// If one op is a constant, continue parsing down.
17309	target_ssize_t subMul = `0`;
17310	GenTree* nonConst = nullptr;
17311	if (gtOp.gtOp1->IsCnsIntOrI())
17312	{
17313	// If the other arg is an int constant, and is a "not-a-field", choose
17314	// that as the multiplier, thus preserving constant index offsets...
17315	if (gtOp.gtOp2->OperGet() == GT_CNS_INT &&
17316	gtOp.gtOp2->gtIntCon.gtFieldSeq == FieldSeqStore::NotAField())
17317	{
17318	assert(!gtOp.gtOp2->gtIntCon.ImmedValNeedsReloc(comp));
17319	// TODO-CrossBitness: we wouldn't need the cast below if GenTreeIntConCommon::gtIconVal had
17320	// target_ssize_t type.
17321	subMul = (target_ssize_t)gtOp.gtOp2->gtIntConCommon.IconValue();
17322	nonConst = gtOp.gtOp1;
17323	}
17324	else
17325	{
17326	assert(!gtOp.gtOp1->gtIntCon.ImmedValNeedsReloc(comp));
17327	// TODO-CrossBitness: we wouldn't need the cast below if GenTreeIntConCommon::gtIconVal had
17328	// target_ssize_t type.
17329	subMul = (target_ssize_t)gtOp.gtOp1->gtIntConCommon.IconValue();
17330	nonConst = gtOp.gtOp2;
17331	}
17332	}
17333	else if (gtOp.gtOp2->IsCnsIntOrI())
17334	{
17335	assert(!gtOp.gtOp2->gtIntCon.ImmedValNeedsReloc(comp));
17336	// TODO-CrossBitness: we wouldn't need the cast below if GenTreeIntConCommon::gtIconVal had
17337	// target_ssize_t type.
17338	subMul = (target_ssize_t)gtOp.gtOp2->gtIntConCommon.IconValue();
17339	nonConst = gtOp.gtOp1;
17340	}
17341	if (nonConst != nullptr)
17342	{
17343	nonConst->ParseArrayAddressWork(comp, inputMul * subMul, pArr, pInxVN, pOffset, pFldSeq);
17344	return;
17345	}
17346	// Otherwise, exit the switch, treat as a contribution to the index.
17347	}
17348	break;
17349
17350	case GT_LSH:
17351	// If one op is a constant, continue parsing down.
17352	if (gtOp.gtOp2->IsCnsIntOrI())
17353	{
17354	assert(!gtOp.gtOp2->gtIntCon.ImmedValNeedsReloc(comp));
17355	// TODO-CrossBitness: we wouldn't need the cast below if GenTreeIntCon::gtIconVal had target_ssize_t
17356	// type.
17357	target_ssize_t subMul = target_ssize_t{`1`} << (target_ssize_t)gtOp.gtOp2->gtIntConCommon.IconValue();
17358	gtOp.gtOp1->ParseArrayAddressWork(comp, inputMul * subMul, pArr, pInxVN, pOffset, pFldSeq);
17359	return;
17360	}
17361	// Otherwise, exit the switch, treat as a contribution to the index.
17362	break;
17363
17364	case GT_COMMA:
17365	// We don't care about exceptions for this purpose.
17366	if ((gtOp.gtOp1->OperGet() == GT_ARR_BOUNDS_CHECK) \|\| gtOp.gtOp1->IsNothingNode())
17367	{
17368	gtOp.gtOp2->ParseArrayAddressWork(comp, inputMul, pArr, pInxVN, pOffset, pFldSeq);
17369	return;
17370	}
17371	break;
17372
17373	default:
17374	break;
17375	}
17376	// If we didn't return above, must be a contribution to the non-constant part of the index VN.
17377	ValueNum vn = comp->GetValueNumStore()->VNLiberalNormalValue(gtVNPair);
17378	if (inputMul != `1`)
17379	{
17380	ValueNum mulVN = comp->GetValueNumStore()->VNForLongCon(inputMul);
17381	vn = comp->GetValueNumStore()->VNForFunc(TypeGet(), GetVNFuncForOper(GT_MUL, VOK_Default), mulVN, vn);
17382	}
17383	if (*pInxVN == ValueNumStore::NoVN)
17384	{
17385	*pInxVN = vn;
17386	}
17387	else
17388	{
17389	*pInxVN =
17390	comp->GetValueNumStore()->VNForFunc(TypeGet(), GetVNFuncForOper(GT_ADD, VOK_Default), *pInxVN, vn);
17391	}
17392	}
17393	}
17394
17395	bool GenTree::ParseArrayElemForm(Compiler* comp, ArrayInfo* arrayInfo, FieldSeqNode** pFldSeq)
17396	{
17397	if (OperIsIndir())
17398	{
17399	if (gtFlags & GTF_IND_ARR_INDEX)
17400	{
17401	bool b = comp->GetArrayInfoMap()->Lookup(this, arrayInfo);
17402	assert(b);
17403	return true;
17404	}
17405
17406	// Otherwise...
17407	GenTree* addr = AsIndir()->Addr();
17408	return addr->ParseArrayElemAddrForm(comp, arrayInfo, pFldSeq);
17409	}
17410	else
17411	{
17412	return false;
17413	}
17414	}
17415
17416	bool GenTree::ParseArrayElemAddrForm(Compiler* comp, ArrayInfo* arrayInfo, FieldSeqNode** pFldSeq)
17417	{
17418	switch (OperGet())
17419	{
17420	case GT_ADD:
17421	{
17422	GenTree* arrAddr = nullptr;
17423	GenTree* offset = nullptr;
17424	if (gtOp.gtOp1->TypeGet() == TYP_BYREF)
17425	{
17426	arrAddr = gtOp.gtOp1;
17427	offset = gtOp.gtOp2;
17428	}
17429	else if (gtOp.gtOp2->TypeGet() == TYP_BYREF)
17430	{
17431	arrAddr = gtOp.gtOp2;
17432	offset = gtOp.gtOp1;
17433	}
17434	else
17435	{
17436	return false;
17437	}
17438	if (!offset->ParseOffsetForm(comp, pFldSeq))
17439	{
17440	return false;
17441	}
17442	return arrAddr->ParseArrayElemAddrForm(comp, arrayInfo, pFldSeq);
17443	}
17444
17445	case GT_ADDR:
17446	{
17447	GenTree* addrArg = gtOp.gtOp1;
17448	if (addrArg->OperGet() != GT_IND)
17449	{
17450	return false;
17451	}
17452	else
17453	{
17454	// The "Addr" node might be annotated with a zero-offset field sequence.
17455	FieldSeqNode* zeroOffsetFldSeq = nullptr;
17456	if (comp->GetZeroOffsetFieldMap()->Lookup(this, &zeroOffsetFldSeq))
17457	{
17458	pFldSeq = comp->GetFieldSeqStore()->Append(pFldSeq, zeroOffsetFldSeq);
17459	}
17460	return addrArg->ParseArrayElemForm(comp, arrayInfo, pFldSeq);
17461	}
17462	}
17463
17464	default:
17465	return false;
17466	}
17467	}
17468
17469	bool GenTree::ParseOffsetForm(Compiler* comp, FieldSeqNode** pFldSeq)
17470	{
17471	switch (OperGet())
17472	{
17473	case GT_CNS_INT:
17474	{
17475	GenTreeIntCon* icon = AsIntCon();
17476	pFldSeq = comp->GetFieldSeqStore()->Append(pFldSeq, icon->gtFieldSeq);
17477	return true;
17478	}
17479
17480	case GT_ADD:
17481	if (!gtOp.gtOp1->ParseOffsetForm(comp, pFldSeq))
17482	{
17483	return false;
17484	}
17485	return gtOp.gtOp2->ParseOffsetForm(comp, pFldSeq);
17486
17487	default:
17488	return false;
17489	}
17490	}
17491
17492	void GenTree::LabelIndex(Compiler* comp, bool isConst)
17493	{
17494	switch (OperGet())
17495	{
17496	case GT_CNS_INT:
17497	// If we got here, this is a contribution to the constant part of the index.
17498	if (isConst)
17499	{
17500	gtIntCon.gtFieldSeq =
17501	comp->GetFieldSeqStore()->CreateSingleton(FieldSeqStore::ConstantIndexPseudoField);
17502	}
17503	return;
17504
17505	case GT_LCL_VAR:
17506	gtFlags \|= GTF_VAR_ARR_INDEX;
17507	return;
17508
17509	case GT_ADD:
17510	case GT_SUB:
17511	gtOp.gtOp1->LabelIndex(comp, isConst);
17512	gtOp.gtOp2->LabelIndex(comp, isConst);
17513	break;
17514
17515	case GT_CAST:
17516	gtOp.gtOp1->LabelIndex(comp, isConst);
17517	break;
17518
17519	case GT_ARR_LENGTH:
17520	gtFlags \|= GTF_ARRLEN_ARR_IDX;
17521	return;
17522
17523	default:
17524	// For all other operators, peel off one constant; and then label the other if it's also a constant.
17525	if (OperIsArithmetic() \|\| OperIsCompare())
17526	{
17527	if (gtOp.gtOp2->OperGet() == GT_CNS_INT)
17528	{
17529	gtOp.gtOp1->LabelIndex(comp, isConst);
17530	break;
17531	}
17532	else if (gtOp.gtOp1->OperGet() == GT_CNS_INT)
17533	{
17534	gtOp.gtOp2->LabelIndex(comp, isConst);
17535	break;
17536	}
17537	// Otherwise continue downward on both, labeling vars.
17538	gtOp.gtOp1->LabelIndex(comp, false);
17539	gtOp.gtOp2->LabelIndex(comp, false);
17540	}
17541	break;
17542	}
17543	}
17544
17545	// Note that the value of the below field doesn't matter; it exists only to provide a distinguished address.
17546	//
17547	// static
17548	FieldSeqNode FieldSeqStore::s_notAField(nullptr, nullptr);
17549
17550	// FieldSeqStore methods.
17551	FieldSeqStore::FieldSeqStore(CompAllocator alloc) : m_alloc (alloc), m_canonMap(new (alloc) FieldSeqNodeCanonMap (alloc))
17552	{
17553	}
17554
17555	FieldSeqNode* FieldSeqStore::CreateSingleton(CORINFO_FIELD_HANDLE fieldHnd)
17556	{
17557	FieldSeqNode fsn(fieldHnd, nullptr);
17558	FieldSeqNode* res = nullptr;
17559	if (m_canonMap->Lookup(fsn, &res))
17560	{
17561	return res;
17562	}
17563	else
17564	{
17565	res = m_alloc.allocate<FieldSeqNode>(`1`);
17566	*res = fsn;
17567	m_canonMap->Set(fsn, res);
17568	return res;
17569	}
17570	}
17571
17572	FieldSeqNode* FieldSeqStore::Append(FieldSeqNode* a, FieldSeqNode* b)
17573	{
17574	if (a == nullptr)
17575	{
17576	return b;
17577	}
17578	else if (a == NotAField())
17579	{
17580	return NotAField();
17581	}
17582	else if (b == nullptr)
17583	{
17584	return a;
17585	}
17586	else if (b == NotAField())
17587	{
17588	return NotAField();
17589	// Extremely special case for ConstantIndex pseudo-fields -- appending consecutive such
17590	// together collapse to one.
17591	}
17592	else if (a->m_next == nullptr && a->m_fieldHnd == ConstantIndexPseudoField &&
17593	b->m_fieldHnd == ConstantIndexPseudoField)
17594	{
17595	return b;
17596	}
17597	else
17598	{
17599	FieldSeqNode* tmp = Append(a->m_next, b);
17600	FieldSeqNode fsn(a->m_fieldHnd, tmp);
17601	FieldSeqNode* res = nullptr;
17602	if (m_canonMap->Lookup(fsn, &res))
17603	{
17604	return res;
17605	}
17606	else
17607	{
17608	res = m_alloc.allocate<FieldSeqNode>(`1`);
17609	*res = fsn;
17610	m_canonMap->Set(fsn, res);
17611	return res;
17612	}
17613	}
17614	}
17615
17616	// Static vars.
17617	int FieldSeqStore::FirstElemPseudoFieldStruct;
17618	int FieldSeqStore::ConstantIndexPseudoFieldStruct;
17619
17620	CORINFO_FIELD_HANDLE FieldSeqStore::FirstElemPseudoField =
17621	(CORINFO_FIELD_HANDLE)&FieldSeqStore::FirstElemPseudoFieldStruct;
17622	CORINFO_FIELD_HANDLE FieldSeqStore::ConstantIndexPseudoField =
17623	(CORINFO_FIELD_HANDLE)&FieldSeqStore::ConstantIndexPseudoFieldStruct;
17624
17625	bool FieldSeqNode::IsFirstElemFieldSeq()
17626	{
17627	// this must be non-null per ISO C++
17628	return m_fieldHnd == FieldSeqStore::FirstElemPseudoField;
17629	}
17630
17631	bool FieldSeqNode::IsConstantIndexFieldSeq()
17632	{
17633	// this must be non-null per ISO C++
17634	return m_fieldHnd == FieldSeqStore::ConstantIndexPseudoField;
17635	}
17636
17637	bool FieldSeqNode::IsPseudoField()
17638	{
17639	if (this == nullptr)
17640	{
17641	return false;
17642	}
17643	return m_fieldHnd == FieldSeqStore::FirstElemPseudoField \|\| m_fieldHnd == FieldSeqStore::ConstantIndexPseudoField;
17644	}
17645
17646	#ifdef FEATURE_SIMD
17647	GenTreeSIMD* Compiler::gtNewSIMDNode(
17648	var_types type, GenTree* op1, SIMDIntrinsicID simdIntrinsicID, var_types baseType, unsigned size)
17649	{
17650	assert(op1 != nullptr);
17651	SetOpLclRelatedToSIMDIntrinsic(op1);
17652
17653	return new (this, GT_SIMD) GenTreeSIMD (type, op1, simdIntrinsicID, baseType, size);
17654	}
17655
17656	GenTreeSIMD* Compiler::gtNewSIMDNode(
17657	var_types type, GenTree* op1, GenTree* op2, SIMDIntrinsicID simdIntrinsicID, var_types baseType, unsigned size)
17658	{
17659	assert(op1 != nullptr);
17660	SetOpLclRelatedToSIMDIntrinsic(op1);
17661	SetOpLclRelatedToSIMDIntrinsic(op2);
17662
17663	return new (this, GT_SIMD) GenTreeSIMD (type, op1, op2, simdIntrinsicID, baseType, size);
17664	}
17665
17666	//-------------------------------------------------------------------
17667	// SetOpLclRelatedToSIMDIntrinsic: Determine if the tree has a local var that needs to be set
17668	// as used by a SIMD intrinsic, and if so, set that local var appropriately.
17669	//
17670	// Arguments:
17671	// op - The tree, to be an operand of a new GT_SIMD node, to check.
17672	//
17673	void Compiler::SetOpLclRelatedToSIMDIntrinsic(GenTree* op)
17674	{
17675	if (op != nullptr)
17676	{
17677	if (op->OperIsLocal())
17678	{
17679	setLclRelatedToSIMDIntrinsic(op);
17680	}
17681	else if ((op->OperGet() == GT_OBJ) && (op->gtOp.gtOp1->OperGet() == GT_ADDR) &&
17682	op->gtOp.gtOp1->gtOp.gtOp1->OperIsLocal())
17683	{
17684	setLclRelatedToSIMDIntrinsic(op->gtOp.gtOp1->gtOp.gtOp1);
17685	}
17686	}
17687	}
17688
17689	bool GenTree::isCommutativeSIMDIntrinsic()
17690	{
17691	assert(gtOper == GT_SIMD);
17692	switch (AsSIMD()->gtSIMDIntrinsicID)
17693	{
17694	case SIMDIntrinsicAdd:
17695	case SIMDIntrinsicBitwiseAnd:
17696	case SIMDIntrinsicBitwiseOr:
17697	case SIMDIntrinsicBitwiseXor:
17698	case SIMDIntrinsicEqual:
17699	case SIMDIntrinsicMax:
17700	case SIMDIntrinsicMin:
17701	case SIMDIntrinsicMul:
17702	case SIMDIntrinsicOpEquality:
17703	case SIMDIntrinsicOpInEquality:
17704	return true;
17705	default:
17706	return false;
17707	}
17708	}
17709	#endif // FEATURE_SIMD
17710
17711	#ifdef FEATURE_HW_INTRINSICS
17712	bool GenTree::isCommutativeHWIntrinsic() const
17713	{
17714	assert(gtOper == GT_HWIntrinsic);
17715
17716	#ifdef _TARGET_XARCH_
17717	return HWIntrinsicInfo::IsCommutative(AsHWIntrinsic()->gtHWIntrinsicId);
17718	#else
17719	return false;
17720	#endif // _TARGET_XARCH_
17721	}
17722
17723	bool GenTree::isContainableHWIntrinsic() const
17724	{
17725	assert(gtOper == GT_HWIntrinsic);
17726
17727	#ifdef _TARGET_XARCH_
17728	switch (AsHWIntrinsic()->gtHWIntrinsicId)
17729	{
17730	case NI_SSE_LoadAlignedVector128:
17731	case NI_SSE_LoadScalarVector128:
17732	case NI_SSE_LoadVector128:
17733	case NI_SSE2_LoadAlignedVector128:
17734	case NI_SSE2_LoadScalarVector128:
17735	case NI_SSE2_LoadVector128:
17736	case NI_AVX_LoadAlignedVector256:
17737	case NI_AVX_LoadVector256:
17738	{
17739	return true;
17740	}
17741
17742	default:
17743	{
17744	return false;
17745	}
17746	}
17747	#else
17748	return false;
17749	#endif // _TARGET_XARCH_
17750	}
17751
17752	bool GenTree::isRMWHWIntrinsic(Compiler* comp)
17753	{
17754	assert(gtOper == GT_HWIntrinsic);
17755	assert(comp != nullptr);
17756
17757	#ifdef _TARGET_XARCH_
17758	if (!comp->canUseVexEncoding())
17759	{
17760	return HWIntrinsicInfo::HasRMWSemantics(AsHWIntrinsic()->gtHWIntrinsicId);
17761	}
17762
17763	switch (AsHWIntrinsic()->gtHWIntrinsicId)
17764	{
17765	// TODO-XArch-Cleanup: Move this switch block to be table driven.
17766
17767	case NI_SSE42_Crc32:
17768	case NI_SSE42_X64_Crc32:
17769	case NI_FMA_MultiplyAdd:
17770	case NI_FMA_MultiplyAddNegated:
17771	case NI_FMA_MultiplyAddNegatedScalar:
17772	case NI_FMA_MultiplyAddScalar:
17773	case NI_FMA_MultiplyAddSubtract:
17774	case NI_FMA_MultiplySubtract:
17775	case NI_FMA_MultiplySubtractAdd:
17776	case NI_FMA_MultiplySubtractNegated:
17777	case NI_FMA_MultiplySubtractNegatedScalar:
17778	case NI_FMA_MultiplySubtractScalar:
17779	{
17780	return true;
17781	}
17782
17783	default:
17784	{
17785	return false;
17786	}
17787	}
17788	#else
17789	return false;
17790	#endif // _TARGET_XARCH_
17791	}
17792
17793	GenTreeHWIntrinsic* Compiler::gtNewSimdHWIntrinsicNode(var_types type,
17794	NamedIntrinsic hwIntrinsicID,
17795	var_types baseType,
17796	unsigned size)
17797	{
17798	return new (this, GT_HWIntrinsic) GenTreeHWIntrinsic (type, hwIntrinsicID, baseType, size);
17799	}
17800
17801	GenTreeHWIntrinsic* Compiler::gtNewSimdHWIntrinsicNode(
17802	var_types type, GenTree* op1, NamedIntrinsic hwIntrinsicID, var_types baseType, unsigned simdSize)
17803	{
17804	SetOpLclRelatedToSIMDIntrinsic(op1);
17805
17806	return new (this, GT_HWIntrinsic) GenTreeHWIntrinsic (type, op1, hwIntrinsicID, baseType, simdSize);
17807	}
17808
17809	GenTreeHWIntrinsic* Compiler::gtNewSimdHWIntrinsicNode(
17810	var_types type, GenTree* op1, GenTree* op2, NamedIntrinsic hwIntrinsicID, var_types baseType, unsigned simdSize)
17811	{
17812	SetOpLclRelatedToSIMDIntrinsic(op1);
17813	SetOpLclRelatedToSIMDIntrinsic(op2);
17814
17815	return new (this, GT_HWIntrinsic) GenTreeHWIntrinsic (type, op1, op2, hwIntrinsicID, baseType, simdSize);
17816	}
17817
17818	GenTreeHWIntrinsic* Compiler::gtNewSimdHWIntrinsicNode(var_types type,
17819	GenTree* op1,
17820	GenTree* op2,
17821	GenTree* op3,
17822	NamedIntrinsic hwIntrinsicID,
17823	var_types baseType,
17824	unsigned size)
17825	{
17826	SetOpLclRelatedToSIMDIntrinsic(op1);
17827	SetOpLclRelatedToSIMDIntrinsic(op2);
17828	SetOpLclRelatedToSIMDIntrinsic(op3);
17829
17830	return new (this, GT_HWIntrinsic)
17831	GenTreeHWIntrinsic (type, gtNewArgList(op1, op2, op3), hwIntrinsicID, baseType, size);
17832	}
17833
17834	GenTreeHWIntrinsic* Compiler::gtNewSimdHWIntrinsicNode(var_types type,
17835	GenTree* op1,
17836	GenTree* op2,
17837	GenTree* op3,
17838	GenTree* op4,
17839	NamedIntrinsic hwIntrinsicID,
17840	var_types baseType,
17841	unsigned size)
17842	{
17843	SetOpLclRelatedToSIMDIntrinsic(op1);
17844	SetOpLclRelatedToSIMDIntrinsic(op2);
17845	SetOpLclRelatedToSIMDIntrinsic(op3);
17846	SetOpLclRelatedToSIMDIntrinsic(op4);
17847
17848	return new (this, GT_HWIntrinsic)
17849	GenTreeHWIntrinsic (type, gtNewArgList(op1, op2, op3, op4), hwIntrinsicID, baseType, size);
17850	}
17851
17852	GenTreeHWIntrinsic* Compiler::gtNewScalarHWIntrinsicNode(var_types type, GenTree* op1, NamedIntrinsic hwIntrinsicID)
17853	{
17854	SetOpLclRelatedToSIMDIntrinsic(op1);
17855
17856	return new (this, GT_HWIntrinsic) GenTreeHWIntrinsic (type, op1, hwIntrinsicID, TYP_UNKNOWN, `0`);
17857	}
17858
17859	GenTreeHWIntrinsic* Compiler::gtNewScalarHWIntrinsicNode(var_types type,
17860	GenTree* op1,
17861	GenTree* op2,
17862	NamedIntrinsic hwIntrinsicID)
17863	{
17864	SetOpLclRelatedToSIMDIntrinsic(op1);
17865	SetOpLclRelatedToSIMDIntrinsic(op2);
17866
17867	return new (this, GT_HWIntrinsic) GenTreeHWIntrinsic (type, op1, op2, hwIntrinsicID, TYP_UNKNOWN, `0`);
17868	}
17869
17870	GenTreeHWIntrinsic* Compiler::gtNewScalarHWIntrinsicNode(
17871	var_types type, GenTree* op1, GenTree* op2, GenTree* op3, NamedIntrinsic hwIntrinsicID)
17872	{
17873	SetOpLclRelatedToSIMDIntrinsic(op1);
17874	SetOpLclRelatedToSIMDIntrinsic(op2);
17875	SetOpLclRelatedToSIMDIntrinsic(op3);
17876
17877	return new (this, GT_HWIntrinsic)
17878	GenTreeHWIntrinsic (type, gtNewArgList(op1, op2, op3), hwIntrinsicID, TYP_UNKNOWN, `0`);
17879	}
17880
17881	//---------------------------------------------------------------------------------------
17882	// gtNewMustThrowException:
17883	// create a throw node (calling into JIT helper) that must be thrown.
17884	// The result would be a comma node: COMMA(jithelperthrow(void), x) where x's type should be specified.
17885	//
17886	// Arguments
17887	// helper - JIT helper ID
17888	// type - return type of the node
17889	//
17890	// Return Value
17891	// pointer to the throw node
17892	//
17893	GenTree* Compiler::gtNewMustThrowException(unsigned helper, var_types type, CORINFO_CLASS_HANDLE clsHnd)
17894	{
17895	GenTreeCall* node = gtNewHelperCallNode(helper, TYP_VOID);
17896	node->gtCallMoreFlags \|= GTF_CALL_M_DOES_NOT_RETURN;
17897	if (type != TYP_VOID)
17898	{
17899	unsigned dummyTemp = lvaGrabTemp(true DEBUGARG("dummy temp of must thrown exception"));
17900	if (type == TYP_STRUCT)
17901	{
17902	lvaSetStruct(dummyTemp, clsHnd, false);
17903	type = lvaTable[dummyTemp].lvType; // struct type is normalized
17904	}
17905	else
17906	{
17907	lvaTable[dummyTemp].lvType = type;
17908	}
17909	GenTree* dummyNode = gtNewLclvNode(dummyTemp, type);
17910	return gtNewOperNode(GT_COMMA, type, node, dummyNode);
17911	}
17912	return node;
17913	}
17914
17915	// Returns true for the HW Instrinsic instructions that have MemoryLoad semantics, false otherwise
17916	bool GenTreeHWIntrinsic::OperIsMemoryLoad()
17917	{
17918	#ifdef _TARGET_XARCH_
17919	// Some xarch instructions have MemoryLoad sematics
17920	HWIntrinsicCategory category = HWIntrinsicInfo::lookupCategory(gtHWIntrinsicId);
17921	if (category == HW_Category_MemoryLoad)
17922	{
17923	return true;
17924	}
17925	else if (HWIntrinsicInfo::MaybeMemoryLoad(gtHWIntrinsicId))
17926	{
17927	// Some AVX intrinsic (without HW_Category_MemoryLoad) also have MemoryLoad semantics
17928	if (category == HW_Category_SIMDScalar)
17929	{
17930	// Avx2.BroadcastScalarToVector128/256 have vector and pointer overloads both, e.g.,
17931	// Vector128<byte> BroadcastScalarToVector128(Vector128<byte> value)
17932	// Vector128<byte> BroadcastScalarToVector128(byte source)*
17933	// So, we need to check the argument's type is memory-reference (TYP_I_IMPL) or not
17934	assert(HWIntrinsicInfo::lookupNumArgs(this) == `1`);
17935	return (gtHWIntrinsicId == NI_AVX2_BroadcastScalarToVector128 \|\|
17936	gtHWIntrinsicId == NI_AVX2_BroadcastScalarToVector256) &&
17937	gtOp.gtOp1->TypeGet() == TYP_I_IMPL;
17938	}
17939	else if (category == HW_Category_IMM)
17940	{
17941	// Do we have less than 3 operands?
17942	if (HWIntrinsicInfo::lookupNumArgs(this) < `3`)
17943	{
17944	return false;
17945	}
17946	else // We have 3 or more operands/args
17947	{
17948	// All the Avx2.Gather are "load" instructions*
17949	if (HWIntrinsicInfo::isAVX2GatherIntrinsic(gtHWIntrinsicId))
17950	{
17951	return true;
17952	}
17953
17954	GenTreeArgList* argList = gtOp.gtOp1->AsArgList();
17955
17956	// Avx/Avx2.InsertVector128 have vector and pointer overloads both, e.g.,
17957	// Vector256<sbyte> InsertVector128(Vector256<sbyte> value, Vector128<sbyte> data, byte index)
17958	// Vector256<sbyte> InsertVector128(Vector256<sbyte> value, sbyte address, byte index)*
17959	// So, we need to check the second argument's type is memory-reference (TYP_I_IMPL) or not
17960	if ((gtHWIntrinsicId == NI_AVX_InsertVector128 \|\| gtHWIntrinsicId == NI_AVX2_InsertVector128) &&
17961	(argList->Rest()->Current()->TypeGet() == TYP_I_IMPL)) // Is the type of the second arg TYP_I_IMPL?
17962	{
17963	// This is Avx/Avx2.InsertVector128
17964	return true;
17965	}
17966	}
17967	}
17968	}
17969	#endif // _TARGET_XARCH_
17970	return false;
17971	}
17972
17973	// Returns true for the HW Instrinsic instructions that have MemoryStore semantics, false otherwise
17974	bool GenTreeHWIntrinsic::OperIsMemoryStore()
17975	{
17976	#ifdef _TARGET_XARCH_
17977	// Some xarch instructions have MemoryStore sematics
17978	HWIntrinsicCategory category = HWIntrinsicInfo::lookupCategory(gtHWIntrinsicId);
17979	if (category == HW_Category_MemoryStore)
17980	{
17981	return true;
17982	}
17983	else if (HWIntrinsicInfo::MaybeMemoryStore(gtHWIntrinsicId) &&
17984	(category == HW_Category_IMM \|\| category == HW_Category_Scalar))
17985	{
17986	// Some AVX intrinsic (without HW_Category_MemoryStore) also have MemoryStore semantics
17987
17988	// Avx/Avx2.InsertVector128 have vector and pointer overloads both, e.g.,
17989	// Vector128<sbyte> ExtractVector128(Vector256<sbyte> value, byte index)
17990	// void ExtractVector128(sbyte address, Vector256<sbyte> value, byte index)*
17991	// Bmi2/Bmi2.X64.MultiplyNoFlags may return the lower half result by a out argument
17992	// unsafe ulong MultiplyNoFlags(ulong left, ulong right, ulong low)*
17993	//
17994	// So, the 3-argument form is MemoryStore
17995	if (HWIntrinsicInfo::lookupNumArgs(this) == `3`)
17996	{
17997	switch (gtHWIntrinsicId)
17998	{
17999	case NI_AVX_ExtractVector128:
18000	case NI_AVX2_ExtractVector128:
18001	case NI_BMI2_MultiplyNoFlags:
18002	case NI_BMI2_X64_MultiplyNoFlags:
18003	return true;
18004	default:
18005	return false;
18006	}
18007	}
18008	}
18009	#endif // _TARGET_XARCH_
18010	return false;
18011	}
18012
18013	// Returns true for the HW Instrinsic instructions that have MemoryLoad semantics, false otherwise
18014	bool GenTreeHWIntrinsic::OperIsMemoryLoadOrStore()
18015	{
18016	#ifdef _TARGET_XARCH_
18017	return OperIsMemoryLoad() \|\| OperIsMemoryStore();
18018	#endif // _TARGET_XARCH_
18019	return false;
18020	}
18021
18022	#endif // FEATURE_HW_INTRINSICS
18023
18024	//---------------------------------------------------------------------------------------
18025	// InitializeStructReturnType:
18026	// Initialize the Return Type Descriptor for a method that returns a struct type
18027	//
18028	// Arguments
18029	// comp - Compiler Instance
18030	// retClsHnd - VM handle to the struct type returned by the method
18031	//
18032	// Return Value
18033	// None
18034	//
18035	void ReturnTypeDesc::InitializeStructReturnType(Compiler* comp, CORINFO_CLASS_HANDLE retClsHnd)
18036	{
18037	assert(!m_inited);
18038
18039	#if FEATURE_MULTIREG_RET
18040
18041	assert(retClsHnd != NO_CLASS_HANDLE);
18042	unsigned structSize = comp->info.compCompHnd->getClassSize(retClsHnd);
18043
18044	Compiler::structPassingKind howToReturnStruct;
18045	var_types returnType = comp->getReturnTypeForStruct(retClsHnd, &howToReturnStruct, structSize);
18046
18047	switch (howToReturnStruct)
18048	{
18049	case Compiler::SPK_EnclosingType:
18050	m_isEnclosingType = true;
18051	__fallthrough;
18052
18053	case Compiler::SPK_PrimitiveType:
18054	{
18055	assert(returnType != TYP_UNKNOWN);
18056	assert(!varTypeIsStruct(returnType));
18057	m_regType[`0`] = returnType;
18058	break;
18059	}
18060
18061	case Compiler::SPK_ByValueAsHfa:
18062	{
18063	assert(varTypeIsStruct(returnType));
18064	var_types hfaType = comp->GetHfaType(retClsHnd);
18065
18066	// We should have an hfa struct type
18067	assert(varTypeIsFloating(hfaType));
18068
18069	// Note that the retail build issues a warning about a potential divsion by zero without this Max function
18070	unsigned elemSize = Max((unsigned)`1`, EA_SIZE_IN_BYTES(emitActualTypeSize(hfaType)));
18071
18072	// The size of this struct should be evenly divisible by elemSize
18073	assert((structSize % elemSize) == `0`);
18074
18075	unsigned hfaCount = (structSize / elemSize);
18076	for (unsigned i = `0`; i < hfaCount; ++i)
18077	{
18078	m_regType[i] = hfaType;
18079	}
18080
18081	if (comp->compFloatingPointUsed == false)
18082	{
18083	comp->compFloatingPointUsed = true;
18084	}
18085	break;
18086	}
18087
18088	case Compiler::SPK_ByValue:
18089	{
18090	assert(varTypeIsStruct(returnType));
18091
18092	#ifdef UNIX_AMD64_ABI
18093
18094	SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR structDesc;
18095	comp->eeGetSystemVAmd64PassStructInRegisterDescriptor(retClsHnd, &structDesc);
18096
18097	assert(structDesc.passedInRegisters);
18098	for (int i = `0`; i < structDesc.eightByteCount; i++)
18099	{
18100	assert(i < MAX_RET_REG_COUNT);
18101	m_regType[i] = comp->GetEightByteType(structDesc, i);
18102	}
18103
18104	#elif defined(_TARGET_ARM64_)
18105
18106	// a non-HFA struct returned using two registers
18107	//
18108	assert((structSize > TARGET_POINTER_SIZE) && (structSize <= (`2` * TARGET_POINTER_SIZE)));
18109
18110	BYTE gcPtrs[`2`] = {TYPE_GC_NONE, TYPE_GC_NONE};
18111	comp->info.compCompHnd->getClassGClayout(retClsHnd, &gcPtrs[`0`]);
18112	for (unsigned i = `0`; i < `2`; ++i)
18113	{
18114	m_regType[i] = comp->getJitGCType(gcPtrs[i]);
18115	}
18116
18117	#else // _TARGET_XXX_
18118
18119	// This target needs support here!
18120	//
18121	NYI("Unsupported TARGET returning a TYP_STRUCT in InitializeStructReturnType");
18122
18123	#endif // UNIX_AMD64_ABI
18124
18125	break; // for case SPK_ByValue
18126	}
18127
18128	case Compiler::SPK_ByReference:
18129
18130	// We are returning using the return buffer argument
18131	// There are no return registers
18132	break;
18133
18134	default:
18135
18136	unreached(); // By the contract of getReturnTypeForStruct we should never get here.
18137
18138	} // end of switch (howToReturnStruct)
18139
18140	#endif // FEATURE_MULTIREG_RET
18141
18142	#ifdef DEBUG
18143	m_inited = true;
18144	#endif
18145	}
18146
18147	//---------------------------------------------------------------------------------------
18148	// InitializeLongReturnType:
18149	// Initialize the Return Type Descriptor for a method that returns a TYP_LONG
18150	//
18151	// Arguments
18152	// comp - Compiler Instance
18153	//
18154	// Return Value
18155	// None
18156	//
18157	void ReturnTypeDesc::InitializeLongReturnType(Compiler* comp)
18158	{
18159	#if defined(_TARGET_X86_) \|\| defined(_TARGET_ARM_)
18160
18161	// Setups up a ReturnTypeDesc for returning a long using two registers
18162	//
18163	assert(MAX_RET_REG_COUNT >= `2`);
18164	m_regType[`0`] = TYP_INT;
18165	m_regType[`1`] = TYP_INT;
18166
18167	#else // not (_TARGET_X86_ or _TARGET_ARM_)
18168
18169	m_regType[`0`] = TYP_LONG;
18170
18171	#endif // _TARGET_X86_ or _TARGET_ARM_
18172
18173	#ifdef DEBUG
18174	m_inited = true;
18175	#endif
18176	}
18177
18178	//-------------------------------------------------------------------
18179	// GetABIReturnReg: Return ith return register as per target ABI
18180	//
18181	// Arguments:
18182	// idx - Index of the return register.
18183	// The first return register has an index of 0 and so on.
18184	//
18185	// Return Value:
18186	// Returns ith return register as per target ABI.
18187	//
18188	// Notes:
18189	// x86 and ARM return long in multiple registers.
18190	// ARM and ARM64 return HFA struct in multiple registers.
18191	//
18192	regNumber ReturnTypeDesc::GetABIReturnReg(unsigned idx)
18193	{
18194	unsigned count = GetReturnRegCount();
18195	assert(idx < count);
18196
18197	regNumber resultReg = REG_NA;
18198
18199	#ifdef UNIX_AMD64_ABI
18200	var_types regType0 = GetReturnRegType(`0`);
18201
18202	if (idx == `0`)
18203	{
18204	if (varTypeIsIntegralOrI(regType0))
18205	{
18206	resultReg = REG_INTRET;
18207	}
18208	else
18209	{
18210	noway_assert(varTypeIsFloating(regType0));
18211	resultReg = REG_FLOATRET;
18212	}
18213	}
18214	else if (idx == `1`)
18215	{
18216	var_types regType1 = GetReturnRegType(`1`);
18217
18218	if (varTypeIsIntegralOrI(regType1))
18219	{
18220	if (varTypeIsIntegralOrI(regType0))
18221	{
18222	resultReg = REG_INTRET_1;
18223	}
18224	else
18225	{
18226	resultReg = REG_INTRET;
18227	}
18228	}
18229	else
18230	{
18231	noway_assert(varTypeIsFloating(regType1));
18232
18233	if (varTypeIsFloating(regType0))
18234	{
18235	resultReg = REG_FLOATRET_1;
18236	}
18237	else
18238	{
18239	resultReg = REG_FLOATRET;
18240	}
18241	}
18242	}
18243
18244	#elif defined(_TARGET_X86_)
18245
18246	if (idx == `0`)
18247	{
18248	resultReg = REG_LNGRET_LO;
18249	}
18250	else if (idx == `1`)
18251	{
18252	resultReg = REG_LNGRET_HI;
18253	}
18254
18255	#elif defined(_TARGET_ARM_)
18256
18257	var_types regType = GetReturnRegType(idx);
18258	if (varTypeIsIntegralOrI(regType))
18259	{
18260	// Ints are returned in one return register.
18261	// Longs are returned in two return registers.
18262	if (idx == `0`)
18263	{
18264	resultReg = REG_LNGRET_LO;
18265	}
18266	else if (idx == `1`)
18267	{
18268	resultReg = REG_LNGRET_HI;
18269	}
18270	}
18271	else
18272	{
18273	// Floats are returned in one return register (f0).
18274	// Doubles are returned in one return register (d0).
18275	// Structs are returned in four registers with HFAs.
18276	assert(idx < MAX_RET_REG_COUNT); // Up to 4 return registers for HFA's
18277	if (regType == TYP_DOUBLE)
18278	{
18279	resultReg = (regNumber)((unsigned)(REG_FLOATRET) + idx * `2`); // d0, d1, d2 or d3
18280	}
18281	else
18282	{
18283	resultReg = (regNumber)((unsigned)(REG_FLOATRET) + idx); // f0, f1, f2 or f3
18284	}
18285	}
18286
18287	#elif defined(_TARGET_ARM64_)
18288
18289	var_types regType = GetReturnRegType(idx);
18290	if (varTypeIsIntegralOrI(regType))
18291	{
18292	noway_assert(idx < `2`); // Up to 2 return registers for 16-byte structs
18293	resultReg = (idx == `0`) ? REG_INTRET : REG_INTRET_1; // X0 or X1
18294	}
18295	else
18296	{
18297	noway_assert(idx < `4`); // Up to 4 return registers for HFA's
18298	resultReg = (regNumber)((unsigned)(REG_FLOATRET) + idx); // V0, V1, V2 or V3
18299	}
18300
18301	#endif // TARGET_XXX
18302
18303	assert(resultReg != REG_NA);
18304	return resultReg;
18305	}
18306
18307	//--------------------------------------------------------------------------------
18308	// GetABIReturnRegs: get the mask of return registers as per target arch ABI.
18309	//
18310	// Arguments:
18311	// None
18312	//
18313	// Return Value:
18314	// reg mask of return registers in which the return type is returned.
18315	//
18316	// Note:
18317	// This routine can be used when the caller is not particular about the order
18318	// of return registers and wants to know the set of return registers.
18319	//
18320	// static
18321	regMaskTP ReturnTypeDesc::GetABIReturnRegs()
18322	{
18323	regMaskTP resultMask = RBM_NONE;
18324
18325	unsigned count = GetReturnRegCount();
18326	for (unsigned i = `0`; i < count; ++i)
18327	{
18328	resultMask \|= genRegMask(GetABIReturnReg(i));
18329	}
18330
18331	return resultMask;
18332	}
18333
18334	//------------------------------------------------------------------------
18335	// The following functions manage the gtRsvdRegs set of temporary registers
18336	// created by LSRA during code generation.
18337
18338	//------------------------------------------------------------------------
18339	// AvailableTempRegCount: return the number of available temporary registers in the (optional) given set
18340	// (typically, RBM_ALLINT or RBM_ALLFLOAT).
18341	//
18342	// Arguments:
18343	// mask - (optional) Check for available temporary registers only in this set.
18344	//
18345	// Return Value:
18346	// Count of available temporary registers in given set.
18347	//
18348	unsigned GenTree::AvailableTempRegCount(regMaskTP mask / = (regMaskTP)-1 /) const
18349	{
18350	return genCountBits(gtRsvdRegs & mask);
18351	}
18352
18353	//------------------------------------------------------------------------
18354	// GetSingleTempReg: There is expected to be exactly one available temporary register
18355	// in the given mask in the gtRsvdRegs set. Get that register. No future calls to get
18356	// a temporary register are expected. Removes the register from the set, but only in
18357	// DEBUG to avoid doing unnecessary work in non-DEBUG builds.
18358	//
18359	// Arguments:
18360	// mask - (optional) Get an available temporary register only in this set.
18361	//
18362	// Return Value:
18363	// Available temporary register in given mask.
18364	//
18365	regNumber GenTree::GetSingleTempReg(regMaskTP mask / = (regMaskTP)-1 /)
18366	{
18367	regMaskTP availableSet = gtRsvdRegs & mask;
18368	assert(genCountBits(availableSet) == `1`);
18369	regNumber tempReg = genRegNumFromMask(availableSet);
18370	INDEBUG(gtRsvdRegs &= ~availableSet;) // Remove the register from the set, so it can't be used again.
18371	return tempReg;
18372	}
18373
18374	//------------------------------------------------------------------------
18375	// ExtractTempReg: Find the lowest number temporary register from the gtRsvdRegs set
18376	// that is also in the optional given mask (typically, RBM_ALLINT or RBM_ALLFLOAT),
18377	// and return it. Remove this register from the temporary register set, so it won't
18378	// be returned again.
18379	//
18380	// Arguments:
18381	// mask - (optional) Extract an available temporary register only in this set.
18382	//
18383	// Return Value:
18384	// Available temporary register in given mask.
18385	//
18386	regNumber GenTree::ExtractTempReg(regMaskTP mask / = (regMaskTP)-1 /)
18387	{
18388	regMaskTP availableSet = gtRsvdRegs & mask;
18389	assert(genCountBits(availableSet) >= `1`);
18390	regMaskTP tempRegMask = genFindLowestBit(availableSet);
18391	gtRsvdRegs &= ~tempRegMask;
18392	return genRegNumFromMask(tempRegMask);
18393	}
18394

Browse the source code of CoreCLR/jit/gentree.cpp