src/jit/compiler.h

   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                           Compiler                                        XX
   9 XX                                                                           XX
  10 XX  Represents the method data we are currently JIT-compiling.               XX
  11 XX  An instance of this class is created for every method we JIT.            XX
  12 XX  This contains all the info needed for the method. So allocating a        XX
  13 XX  a new instance per method makes it thread-safe.                          XX
  14 XX  It should be used to do all the memory management for the compiler run.  XX
  15 XX                                                                           XX
  16 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  17 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  18 */
  19
  20 /*****************************************************************************/
  21 #ifndef _COMPILER_H_
  22 #define _COMPILER_H_
  23 /*****************************************************************************/
  24
  25 #include "jit.h"
  26 #include "opcode.h"
  27 #include "varset.h"
  28 #include "gentree.h"
  29 #include "lir.h"
  30 #include "block.h"
  31 #include "inline.h"
  32 #include "jiteh.h"
  33 #include "instr.h"
  34 #include "regalloc.h"
  35 #include "sm.h"
  36 #include "simplerhash.h"
  37 #include "cycletimer.h"
  38 #include "blockset.h"
  39 #include "jitstd.h"
  40 #include "arraystack.h"
  41 #include "hashbv.h"
  42 #include "fp.h"
  43 #include "expandarray.h"
  44 #include "tinyarray.h"
  45 #include "valuenum.h"
  46 #include "reglist.h"
  47 #include "jittelemetry.h"
  48 #ifdef LATE_DISASM
  49 #include "disasm.h"
  50 #endif
  51
  52 #include "codegeninterface.h"
  53 #include "regset.h"
  54 #include "jitgcinfo.h"
  55
  56 #if DUMP_GC_TABLES && defined(JIT32_GCENCODER)
  57 #include "gcdump.h"
  58 #endif
  59
  60 #include "emit.h"
  61
  62 #include "simd.h"
  63
  64 // This is only used locally in the JIT to indicate that
  65 // a verification block should be inserted
  66 #define SEH_VERIFICATION_EXCEPTION 0xe0564552 // VER
  67
  68 /*****************************************************************************
  69  *                  Forward declarations
  70  */
  71
  72 struct InfoHdr;            // defined in GCInfo.h
  73 struct escapeMapping_t;    // defined in flowgraph.cpp
  74 class emitter;             // defined in emit.h
  75 struct ShadowParamVarInfo; // defined in GSChecks.cpp
  76 struct InitVarDscInfo;     // defined in register_arg_convention.h
  77 class FgStack;             // defined in flowgraph.cpp
  78 #if FEATURE_STACK_FP_X87
  79 struct FlatFPStateX87; // defined in fp.h
  80 #endif
  81 #if FEATURE_ANYCSE
  82 class CSE_DataFlow; // defined in OptCSE.cpp
  83 #endif
  84 #ifdef DEBUG
  85 struct IndentStack;
  86 #endif
  87
  88 // The following are defined in this file, Compiler.h
  89
  90 class Compiler;
  91
  92 /*****************************************************************************
  93  *                  Unwind info
  94  */
  95
  96 #include "unwind.h"
  97
  98 /*****************************************************************************/
  99
 100 //
 101 // Declare global operator new overloads that use the Compiler::compGetMem() function for allocation.
 102 //
 103
 104 // Or the more-general IAllocator interface.
 105 void* __cdecl operator new(size_t n, IAllocator* alloc);
 106 void* __cdecl operator new[](size_t n, IAllocator* alloc);
 107
 108 // I wanted to make the second argument optional, with default = CMK_Unknown, but that
 109 // caused these to be ambiguous with the global placement new operators.
 110 void* __cdecl operator new(size_t n, Compiler* context, CompMemKind cmk);
 111 void* __cdecl operator new[](size_t n, Compiler* context, CompMemKind cmk);
 112 void* __cdecl operator new(size_t n, void* p, const jitstd::placement_t& syntax_difference);
 113
 114 // Requires the definitions of "operator new" so including "LoopCloning.h" after the definitions.
 115 #include "loopcloning.h"
 116
 117 /*****************************************************************************/
 118
 119 /* This is included here and not earlier as it needs the definition of "CSE"
 120  * which is defined in the section above */
 121
 122 /*****************************************************************************/
 123
 124 unsigned genLog2(unsigned value);
 125 unsigned genLog2(unsigned __int64 value);
 126
 127 var_types genActualType(var_types type);
 128 var_types genUnsignedType(var_types type);
 129 var_types genSignedType(var_types type);
 130
 131 unsigned ReinterpretHexAsDecimal(unsigned);
 132
 133 /*****************************************************************************/
 134
 135 #ifdef FEATURE_SIMD
 136 #ifdef FEATURE_AVX_SUPPORT
 137 const unsigned TEMP_MAX_SIZE = YMM_REGSIZE_BYTES;
 138 #else  // !FEATURE_AVX_SUPPORT
 139 const unsigned TEMP_MAX_SIZE = XMM_REGSIZE_BYTES;
 140 #endif // !FEATURE_AVX_SUPPORT
 141 #else  // !FEATURE_SIMD
 142 const unsigned TEMP_MAX_SIZE = sizeof(double);
 143 #endif // !FEATURE_SIMD
 144 const unsigned TEMP_SLOT_COUNT = (TEMP_MAX_SIZE / sizeof(int));
 145
 146 const unsigned FLG_CCTOR = (CORINFO_FLG_CONSTRUCTOR | CORINFO_FLG_STATIC);
 147
 148 #ifdef DEBUG
 149 const int BAD_STK_OFFS = 0xBAADF00D; // for LclVarDsc::lvStkOffs
 150 #endif
 151
 152 // The following holds the Local var info (scope information)
 153 typedef const char* VarName; // Actual ASCII string
 154 struct VarScopeDsc
 155 {
 156     IL_OFFSET vsdLifeBeg; // instr offset of beg of life
 157     IL_OFFSET vsdLifeEnd; // instr offset of end of life
 158     unsigned  vsdVarNum;  // (remapped) LclVarDsc number
 159
 160 #ifdef DEBUG
 161     VarName vsdName; // name of the var
 162 #endif
 163
 164     unsigned vsdLVnum; // 'which' in eeGetLVinfo().
 165                        // Also, it is the index of this entry in the info.compVarScopes array,
 166                        // which is useful since the array is also accessed via the
 167                        // compEnterScopeList and compExitScopeList sorted arrays.
 168 };
 169
 170 /*****************************************************************************
 171  *
 172  *  The following holds the local variable counts and the descriptor table.
 173  */
 174
 175 // This is the location of a definition.
 176 struct DefLoc
 177 {
 178     BasicBlock* m_blk;
 179     GenTreePtr  m_tree;
 180
 181     DefLoc() : m_blk(nullptr), m_tree(nullptr)
 182     {
 183     }
 184 };
 185
 186 // This class encapsulates all info about a local variable that may vary for different SSA names
 187 // in the family.
 188 class LclSsaVarDsc
 189 {
 190 public:
 191     ValueNumPair m_vnPair;
 192     DefLoc       m_defLoc;
 193
 194     LclSsaVarDsc()
 195     {
 196     }
 197 };
 198
 199 typedef ExpandArray<LclSsaVarDsc> PerSsaArray;
 200
 201 class LclVarDsc
 202 {
 203 public:
 204     // The constructor. Most things can just be zero'ed.
 205     LclVarDsc(Compiler* comp);
 206
 207     // note this only packs because var_types is a typedef of unsigned char
 208     var_types lvType : 5; // TYP_INT/LONG/FLOAT/DOUBLE/REF
 209
 210     unsigned char lvIsParam : 1;           // is this a parameter?
 211     unsigned char lvIsRegArg : 1;          // is this a register argument?
 212     unsigned char lvFramePointerBased : 1; // 0 = off of REG_SPBASE (e.g., ESP), 1 = off of REG_FPBASE (e.g., EBP)
 213
 214     unsigned char lvStructGcCount : 3; // if struct, how many GC pointer (stop counting at 7). The only use of values >1
 215                                        // is to help determine whether to use block init in the prolog.
 216     unsigned char lvOnFrame : 1;       // (part of) the variable lives on the frame
 217     unsigned char lvDependReg : 1;     // did the predictor depend upon this being enregistered
 218     unsigned char lvRegister : 1;      // assigned to live in a register? For RyuJIT backend, this is only set if the
 219                                        // variable is in the same register for the entire function.
 220     unsigned char lvTracked : 1;       // is this a tracked variable?
 221     bool          lvTrackedNonStruct()
 222     {
 223         return lvTracked && lvType != TYP_STRUCT;
 224     }
 225     unsigned char lvPinned : 1; // is this a pinned variable?
 226
 227     unsigned char lvMustInit : 1;    // must be initialized
 228     unsigned char lvAddrExposed : 1; // The address of this variable is "exposed" -- passed as an argument, stored in a
 229                                      // global location, etc.
 230                                      // We cannot reason reliably about the value of the variable.
 231     unsigned char lvDoNotEnregister : 1; // Do not enregister this variable.
 232     unsigned char lvFieldAccessed : 1;   // The var is a struct local, and a field of the variable is accessed.  Affects
 233                                          // struct promotion.
 234
 235 #ifdef DEBUG
 236     // These further document the reasons for setting "lvDoNotEnregister".  (Note that "lvAddrExposed" is one of the
 237     // reasons;
 238     // also, lvType == TYP_STRUCT prevents enregistration.  At least one of the reasons should be true.
 239     unsigned char lvVMNeedsStackAddr : 1; // The VM may have access to a stack-relative address of the variable, and
 240                                           // read/write its value.
 241     unsigned char lvLiveInOutOfHndlr : 1; // The variable was live in or out of an exception handler, and this required
 242                                           // the variable to be
 243                                           // in the stack (at least at those boundaries.)
 244     unsigned char lvLclFieldExpr : 1;     // The variable is not a struct, but was accessed like one (e.g., reading a
 245                                           // particular byte from an int).
 246     unsigned char lvLclBlockOpAddr : 1;   // The variable was written to via a block operation that took its address.
 247     unsigned char lvLiveAcrossUCall : 1;  // The variable is live across an unmanaged call.
 248 #endif
 249     unsigned char lvIsCSE : 1;       // Indicates if this LclVar is a CSE variable.
 250     unsigned char lvRefAssign : 1;   // involved in pointer assignment
 251     unsigned char lvHasLdAddrOp : 1; // has ldloca or ldarga opcode on this local.
 252     unsigned char lvStackByref : 1;  // This is a compiler temporary of TYP_BYREF that is known to point into our local
 253                                      // stack frame.
 254
 255     unsigned char lvArgWrite : 1; // variable is a parameter and STARG was used on it
 256     unsigned char lvIsTemp : 1;   // Short-lifetime compiler temp
 257 #if OPT_BOOL_OPS
 258     unsigned char lvIsBoolean : 1; // set if variable is boolean
 259 #endif
 260     unsigned char lvRngOptDone : 1; // considered for range check opt?
 261     unsigned char lvLoopInc : 1;    // incremented in the loop?
 262     unsigned char lvLoopAsg : 1;    // reassigned  in the loop (other than a monotonic inc/dec for the index var)?
 263     unsigned char lvArrIndx : 1;    // used as an array index?
 264     unsigned char lvArrIndxOff : 1; // used as an array index with an offset?
 265     unsigned char lvArrIndxDom : 1; // index dominates loop exit
 266 #if ASSERTION_PROP
 267     unsigned char lvSingleDef : 1;    // variable has a single def
 268     unsigned char lvDisqualify : 1;   // variable is no longer OK for add copy optimization
 269     unsigned char lvVolatileHint : 1; // hint for AssertionProp
 270 #endif
 271
 272     unsigned char lvSpilled : 1; // enregistered variable was spilled
 273 #ifndef _TARGET_64BIT_
 274     unsigned char lvStructDoubleAlign : 1; // Must we double align this struct?
 275 #endif                                     // !_TARGET_64BIT_
 276 #ifdef _TARGET_64BIT_
 277     unsigned char lvQuirkToLong : 1; // Quirk to allocate this LclVar as a 64-bit long
 278 #endif
 279 #ifdef DEBUG
 280     unsigned char lvKeepType : 1;       // Don't change the type of this variable
 281     unsigned char lvNoLclFldStress : 1; // Can't apply local field stress on this one
 282 #endif
 283     unsigned char lvIsPtr : 1; // Might this be used in an address computation? (used by buffer overflow security
 284                                // checks)
 285     unsigned char lvIsUnsafeBuffer : 1; // Does this contain an unsafe buffer requiring buffer overflow security checks?
 286     unsigned char lvPromoted : 1; // True when this local is a promoted struct, a normed struct, or a "split" long on a
 287                                   // 32-bit target.
 288     unsigned char lvIsStructField : 1;          // Is this local var a field of a promoted struct local?
 289     unsigned char lvContainsFloatingFields : 1; // Does this struct contains floating point fields?
 290     unsigned char lvOverlappingFields : 1;      // True when we have a struct with possibly overlapping fields
 291     unsigned char lvContainsHoles : 1;          // True when we have a promoted struct that contains holes
 292     unsigned char lvCustomLayout : 1;           // True when this struct has "CustomLayout"
 293
 294     unsigned char lvIsMultiRegArg : 1; // true if this is a multireg LclVar struct used in an argument context
 295     unsigned char lvIsMultiRegRet : 1; // true if this is a multireg LclVar struct assigned from a multireg call
 296
 297 #ifdef FEATURE_HFA
 298     unsigned char _lvIsHfa : 1;          // Is this a struct variable who's class handle is an HFA type
 299     unsigned char _lvIsHfaRegArg : 1;    // Is this a HFA argument variable?    // TODO-CLEANUP: Remove this and replace
 300                                          // with (lvIsRegArg && lvIsHfa())
 301     unsigned char _lvHfaTypeIsFloat : 1; // Is the HFA type float or double?
 302 #endif                                   // FEATURE_HFA
 303
 304 #ifdef DEBUG
 305     // TODO-Cleanup: See the note on lvSize() - this flag is only in use by asserts that are checking for struct
 306     // types, and is needed because of cases where TYP_STRUCT is bashed to an integral type.
 307     // Consider cleaning this up so this workaround is not required.
 308     unsigned char lvUnusedStruct : 1; // All references to this promoted struct are through its field locals.
 309                                       // I.e. there is no longer any reference to the struct directly.
 310                                       // In this case we can simply remove this struct local.
 311 #endif
 312 #ifndef LEGACY_BACKEND
 313     unsigned char lvLRACandidate : 1; // Tracked for linear scan register allocation purposes
 314 #endif                                // !LEGACY_BACKEND
 315
 316 #ifdef FEATURE_SIMD
 317     // Note that both SIMD vector args and locals are marked as lvSIMDType = true, but the
 318     // type of an arg node is TYP_BYREF and a local node is TYP_SIMD*.
 319     unsigned char lvSIMDType : 1;            // This is a SIMD struct
 320     unsigned char lvUsedInSIMDIntrinsic : 1; // This tells lclvar is used for simd intrinsic
 321     var_types     lvBaseType : 5;            // Note: this only packs because var_types is a typedef of unsigned char
 322 #endif                                       // FEATURE_SIMD
 323     unsigned char lvRegStruct : 1;           // This is a reg-sized non-field-addressed struct.
 324
 325     union {
 326         unsigned lvFieldLclStart; // The index of the local var representing the first field in the promoted struct
 327                                   // local.
 328         unsigned lvParentLcl; // The index of the local var representing the parent (i.e. the promoted struct local).
 329                               // Valid on promoted struct local fields.
 330     };
 331
 332     unsigned char lvFieldCnt; //  Number of fields in the promoted VarDsc.
 333     unsigned char lvFldOffset;
 334     unsigned char lvFldOrdinal;
 335
 336 #if FEATURE_MULTIREG_ARGS
 337     regNumber lvRegNumForSlot(unsigned slotNum)
 338     {
 339         if (slotNum == 0)
 340         {
 341             return lvArgReg;
 342         }
 343         else if (slotNum == 1)
 344         {
 345             return lvOtherArgReg;
 346         }
 347         else
 348         {
 349             assert(false && "Invalid slotNum!");
 350         }
 351
 352         unreached();
 353     }
 354 #endif // FEATURE_MULTIREG_ARGS
 355
 356     bool lvIsHfa() const
 357     {
 358 #ifdef FEATURE_HFA
 359         return _lvIsHfa;
 360 #else
 361         return false;
 362 #endif
 363     }
 364
 365     void lvSetIsHfa()
 366     {
 367 #ifdef FEATURE_HFA
 368         _lvIsHfa = true;
 369 #endif
 370     }
 371
 372     bool lvIsHfaRegArg() const
 373     {
 374 #ifdef FEATURE_HFA
 375         return _lvIsHfaRegArg;
 376 #else
 377         return false;
 378 #endif
 379     }
 380
 381     void lvSetIsHfaRegArg()
 382     {
 383 #ifdef FEATURE_HFA
 384         _lvIsHfaRegArg = true;
 385 #endif
 386     }
 387
 388     bool lvHfaTypeIsFloat() const
 389     {
 390 #ifdef FEATURE_HFA
 391         return _lvHfaTypeIsFloat;
 392 #else
 393         return false;
 394 #endif
 395     }
 396
 397     void lvSetHfaTypeIsFloat(bool value)
 398     {
 399 #ifdef FEATURE_HFA
 400         _lvHfaTypeIsFloat = value;
 401 #endif
 402     }
 403
 404     // on Arm64 - Returns 1-4 indicating the number of register slots used by the HFA
 405     // on Arm32 - Returns the total number of single FP register slots used by the HFA, max is 8
 406     //
 407     unsigned lvHfaSlots() const
 408     {
 409         assert(lvIsHfa());
 410         assert(lvType == TYP_STRUCT);
 411 #ifdef _TARGET_ARM_
 412         return lvExactSize / sizeof(float);
 413 #else  //  _TARGET_ARM64_
 414         if (lvHfaTypeIsFloat())
 415         {
 416             return lvExactSize / sizeof(float);
 417         }
 418         else
 419         {
 420             return lvExactSize / sizeof(double);
 421         }
 422 #endif //  _TARGET_ARM64_
 423     }
 424
 425     // lvIsMultiRegArgOrRet()
 426     //     returns true if this is a multireg LclVar struct used in an argument context
 427     //               or if this is a multireg LclVar struct assigned from a multireg call
 428     bool lvIsMultiRegArgOrRet()
 429     {
 430         return lvIsMultiRegArg || lvIsMultiRegRet;
 431     }
 432
 433 private:
 434     regNumberSmall _lvRegNum; // Used to store the register this variable is in (or, the low register of a
 435                               // register pair). For LEGACY_BACKEND, this is only set if lvRegister is
 436                               // non-zero. For non-LEGACY_BACKEND, it is set during codegen any time the
 437                               // variable is enregistered (in non-LEGACY_BACKEND, lvRegister is only set
 438                               // to non-zero if the variable gets the same register assignment for its entire
 439                               // lifetime).
 440 #if !defined(_TARGET_64BIT_)
 441     regNumberSmall _lvOtherReg; // Used for "upper half" of long var.
 442 #endif                          // !defined(_TARGET_64BIT_)
 443
 444     regNumberSmall _lvArgReg; // The register in which this argument is passed.
 445
 446 #if FEATURE_MULTIREG_ARGS
 447     regNumberSmall _lvOtherArgReg; // Used for the second part of the struct passed in a register.
 448                                    // Note this is defined but not used by ARM32
 449 #endif                             // FEATURE_MULTIREG_ARGS
 450
 451 #ifndef LEGACY_BACKEND
 452     union {
 453         regNumberSmall _lvArgInitReg;     // the register      into which the argument is moved at entry
 454         regPairNoSmall _lvArgInitRegPair; // the register pair into which the argument is moved at entry
 455     };
 456 #endif // !LEGACY_BACKEND
 457
 458 public:
 459     // The register number is stored in a small format (8 bits), but the getters return and the setters take
 460     // a full-size (unsigned) format, to localize the casts here.
 461
 462     /////////////////////
 463
 464     __declspec(property(get = GetRegNum, put = SetRegNum)) regNumber lvRegNum;
 465
 466     regNumber GetRegNum() const
 467     {
 468         return (regNumber)_lvRegNum;
 469     }
 470
 471     void SetRegNum(regNumber reg)
 472     {
 473         _lvRegNum = (regNumberSmall)reg;
 474         assert(_lvRegNum == reg);
 475     }
 476
 477 /////////////////////
 478
 479 #if defined(_TARGET_64BIT_)
 480     __declspec(property(get = GetOtherReg, put = SetOtherReg)) regNumber lvOtherReg;
 481
 482     regNumber GetOtherReg() const
 483     {
 484         assert(!"shouldn't get here"); // can't use "unreached();" because it's NORETURN, which causes C4072
 485                                        // "unreachable code" warnings
 486         return REG_NA;
 487     }
 488
 489     void SetOtherReg(regNumber reg)
 490     {
 491         assert(!"shouldn't get here"); // can't use "unreached();" because it's NORETURN, which causes C4072
 492                                        // "unreachable code" warnings
 493     }
 494 #else  // !_TARGET_64BIT_
 495     __declspec(property(get = GetOtherReg, put = SetOtherReg)) regNumber lvOtherReg;
 496
 497     regNumber GetOtherReg() const
 498     {
 499         return (regNumber)_lvOtherReg;
 500     }
 501
 502     void SetOtherReg(regNumber reg)
 503     {
 504         _lvOtherReg = (regNumberSmall)reg;
 505         assert(_lvOtherReg == reg);
 506     }
 507 #endif // !_TARGET_64BIT_
 508
 509     /////////////////////
 510
 511     __declspec(property(get = GetArgReg, put = SetArgReg)) regNumber lvArgReg;
 512
 513     regNumber GetArgReg() const
 514     {
 515         return (regNumber)_lvArgReg;
 516     }
 517
 518     void SetArgReg(regNumber reg)
 519     {
 520         _lvArgReg = (regNumberSmall)reg;
 521         assert(_lvArgReg == reg);
 522     }
 523
 524 #if FEATURE_MULTIREG_ARGS
 525     __declspec(property(get = GetOtherArgReg, put = SetOtherArgReg)) regNumber lvOtherArgReg;
 526
 527     regNumber GetOtherArgReg() const
 528     {
 529         return (regNumber)_lvOtherArgReg;
 530     }
 531
 532     void SetOtherArgReg(regNumber reg)
 533     {
 534         _lvOtherArgReg = (regNumberSmall)reg;
 535         assert(_lvOtherArgReg == reg);
 536     }
 537 #endif // FEATURE_MULTIREG_ARGS
 538
 539 #ifdef FEATURE_SIMD
 540     // Is this is a SIMD struct?
 541     bool lvIsSIMDType() const
 542     {
 543         return lvSIMDType;
 544     }
 545
 546     // Is this is a SIMD struct which is used for SIMD intrinsic?
 547     bool lvIsUsedInSIMDIntrinsic() const
 548     {
 549         return lvUsedInSIMDIntrinsic;
 550     }
 551 #else
 552     // If feature_simd not enabled, return false
 553     bool lvIsSIMDType() const
 554     {
 555         return false;
 556     }
 557     bool lvIsUsedInSIMDIntrinsic() const
 558     {
 559         return false;
 560     }
 561 #endif
 562
 563 /////////////////////
 564
 565 #ifndef LEGACY_BACKEND
 566     __declspec(property(get = GetArgInitReg, put = SetArgInitReg)) regNumber lvArgInitReg;
 567
 568     regNumber GetArgInitReg() const
 569     {
 570         return (regNumber)_lvArgInitReg;
 571     }
 572
 573     void SetArgInitReg(regNumber reg)
 574     {
 575         _lvArgInitReg = (regNumberSmall)reg;
 576         assert(_lvArgInitReg == reg);
 577     }
 578
 579     /////////////////////
 580
 581     __declspec(property(get = GetArgInitRegPair, put = SetArgInitRegPair)) regPairNo lvArgInitRegPair;
 582
 583     regPairNo GetArgInitRegPair() const
 584     {
 585         regPairNo regPair = (regPairNo)_lvArgInitRegPair;
 586         assert(regPair >= REG_PAIR_FIRST && regPair <= REG_PAIR_LAST);
 587         return regPair;
 588     }
 589
 590     void SetArgInitRegPair(regPairNo regPair)
 591     {
 592         assert(regPair >= REG_PAIR_FIRST && regPair <= REG_PAIR_LAST);
 593         _lvArgInitRegPair = (regPairNoSmall)regPair;
 594         assert(_lvArgInitRegPair == regPair);
 595     }
 596
 597     /////////////////////
 598
 599     bool lvIsRegCandidate() const
 600     {
 601         return lvLRACandidate != 0;
 602     }
 603
 604     bool lvIsInReg() const
 605     {
 606         return lvIsRegCandidate() && (lvRegNum != REG_STK);
 607     }
 608
 609 #else // LEGACY_BACKEND
 610
 611     bool lvIsRegCandidate() const
 612     {
 613         return lvTracked != 0;
 614     }
 615
 616     bool lvIsInReg() const
 617     {
 618         return lvRegister != 0;
 619     }
 620
 621 #endif // LEGACY_BACKEND
 622
 623     regMaskTP lvRegMask() const
 624     {
 625         regMaskTP regMask = RBM_NONE;
 626         if (varTypeIsFloating(TypeGet()))
 627         {
 628             if (lvRegNum != REG_STK)
 629             {
 630                 regMask = genRegMaskFloat(lvRegNum, TypeGet());
 631             }
 632         }
 633         else
 634         {
 635             if (lvRegNum != REG_STK)
 636             {
 637                 regMask = genRegMask(lvRegNum);
 638             }
 639
 640             // For longs we may have two regs
 641             if (isRegPairType(lvType) && lvOtherReg != REG_STK)
 642             {
 643                 regMask |= genRegMask(lvOtherReg);
 644             }
 645         }
 646         return regMask;
 647     }
 648
 649     regMaskSmall lvPrefReg; // set of regs it prefers to live in
 650
 651     unsigned short lvVarIndex;  // variable tracking index
 652     unsigned short lvRefCnt;    // unweighted (real) reference count
 653     unsigned       lvRefCntWtd; // weighted reference count
 654     int            lvStkOffs;   // stack offset of home
 655     unsigned       lvExactSize; // (exact) size of the type in bytes
 656
 657     // Is this a promoted struct?
 658     // This method returns true only for structs (including SIMD structs), not for
 659     // locals that are split on a 32-bit target.
 660     // It is only necessary to use this:
 661     //   1) if only structs are wanted, and
 662     //   2) if Lowering has already been done.
 663     // Otherwise lvPromoted is valid.
 664     bool lvPromotedStruct()
 665     {
 666 #if !defined(_TARGET_64BIT_)
 667         return (lvPromoted && !varTypeIsLong(lvType));
 668 #else  // defined(_TARGET_64BIT_)
 669         return lvPromoted;
 670 #endif // defined(_TARGET_64BIT_)
 671     }
 672
 673     unsigned lvSize() const // Size needed for storage representation. Only used for structs or TYP_BLK.
 674     {
 675         // TODO-Review: Sometimes we get called on ARM with HFA struct variables that have been promoted,
 676         // where the struct itself is no longer used because all access is via its member fields.
 677         // When that happens, the struct is marked as unused and its type has been changed to
 678         // TYP_INT (to keep the GC tracking code from looking at it).
 679         // See Compiler::raAssignVars() for details. For example:
 680         //      N002 (  4,  3) [00EA067C] -------------               return    struct $346
 681         //      N001 (  3,  2) [00EA0628] -------------                  lclVar    struct(U) V03 loc2
 682         //                                                                        float  V03.f1 (offs=0x00) -> V12 tmp7
 683         //                                                                        f8 (last use) (last use) $345
 684         // Here, the "struct(U)" shows that the "V03 loc2" variable is unused. Not shown is that V03
 685         // is now TYP_INT in the local variable table. It's not really unused, because it's in the tree.
 686
 687         assert(varTypeIsStruct(lvType) || (lvType == TYP_BLK) || (lvPromoted && lvUnusedStruct));
 688
 689 #if defined(FEATURE_SIMD) && !defined(_TARGET_64BIT_)
 690         // For 32-bit architectures, we make local variable SIMD12 types 16 bytes instead of just 12. We can't do
 691         // this for arguments, which must be passed according the defined ABI. We don't want to do this for
 692         // dependently promoted struct fields, but we don't know that here. See lvaMapSimd12ToSimd16().
 693         if ((lvType == TYP_SIMD12) && !lvIsParam)
 694         {
 695             assert(lvExactSize == 12);
 696             return 16;
 697         }
 698 #endif // defined(FEATURE_SIMD) && !defined(_TARGET_64BIT_)
 699
 700         return (unsigned)(roundUp(lvExactSize, TARGET_POINTER_SIZE));
 701     }
 702
 703     unsigned lvSlotNum; // original slot # (if remapped)
 704
 705     typeInfo lvVerTypeInfo; // type info needed for verification
 706
 707     BYTE* lvGcLayout; // GC layout info for structs
 708
 709 #if ASSERTION_PROP
 710     BlockSet   lvRefBlks;          // Set of blocks that contain refs
 711     GenTreePtr lvDefStmt;          // Pointer to the statement with the single definition
 712     void       lvaDisqualifyVar(); // Call to disqualify a local variable from use in optAddCopies
 713 #endif
 714     var_types TypeGet() const
 715     {
 716         return (var_types)lvType;
 717     }
 718     bool lvStackAligned() const
 719     {
 720         assert(lvIsStructField);
 721         return ((lvFldOffset % sizeof(void*)) == 0);
 722     }
 723     bool lvNormalizeOnLoad() const
 724     {
 725         return varTypeIsSmall(TypeGet()) &&
 726                // lvIsStructField is treated the same as the aliased local, see fgDoNormalizeOnStore.
 727                (lvIsParam || lvAddrExposed || lvIsStructField);
 728     }
 729
 730     bool lvNormalizeOnStore()
 731     {
 732         return varTypeIsSmall(TypeGet()) &&
 733                // lvIsStructField is treated the same as the aliased local, see fgDoNormalizeOnStore.
 734                !(lvIsParam || lvAddrExposed || lvIsStructField);
 735     }
 736
 737     void lvaResetSortAgainFlag(Compiler* pComp);
 738     void decRefCnts(BasicBlock::weight_t weight, Compiler* pComp, bool propagate = true);
 739     void incRefCnts(BasicBlock::weight_t weight, Compiler* pComp, bool propagate = true);
 740     void setPrefReg(regNumber regNum, Compiler* pComp);
 741     void addPrefReg(regMaskTP regMask, Compiler* pComp);
 742     bool IsFloatRegType() const
 743     {
 744         return isFloatRegType(lvType) || lvIsHfaRegArg();
 745     }
 746     var_types GetHfaType() const
 747     {
 748         return lvIsHfa() ? (lvHfaTypeIsFloat() ? TYP_FLOAT : TYP_DOUBLE) : TYP_UNDEF;
 749     }
 750     void SetHfaType(var_types type)
 751     {
 752         assert(varTypeIsFloating(type));
 753         lvSetHfaTypeIsFloat(type == TYP_FLOAT);
 754     }
 755
 756 #ifndef LEGACY_BACKEND
 757     var_types lvaArgType();
 758 #endif
 759
 760     PerSsaArray lvPerSsaData;
 761
 762 #ifdef DEBUG
 763     // Keep track of the # of SsaNames, for a bounds check.
 764     unsigned lvNumSsaNames;
 765 #endif
 766
 767     // Returns the address of the per-Ssa data for the given ssaNum (which is required
 768     // not to be the SsaConfig::RESERVED_SSA_NUM, which indicates that the variable is
 769     // not an SSA variable).
 770     LclSsaVarDsc* GetPerSsaData(unsigned ssaNum)
 771     {
 772         assert(ssaNum != SsaConfig::RESERVED_SSA_NUM);
 773         assert(SsaConfig::RESERVED_SSA_NUM == 0);
 774         unsigned zeroBased = ssaNum - SsaConfig::UNINIT_SSA_NUM;
 775         assert(zeroBased < lvNumSsaNames);
 776         return &lvPerSsaData.GetRef(zeroBased);
 777     }
 778
 779 #ifdef DEBUG
 780 public:
 781     void PrintVarReg() const
 782     {
 783         if (isRegPairType(TypeGet()))
 784         {
 785             printf("%s:%s", getRegName(lvOtherReg), // hi32
 786                    getRegName(lvRegNum));           // lo32
 787         }
 788         else
 789         {
 790             printf("%s", getRegName(lvRegNum));
 791         }
 792     }
 793 #endif // DEBUG
 794
 795 }; // class LclVarDsc
 796
 797 /*
 798 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 799 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 800 XX                                                                           XX
 801 XX                           TempsInfo                                       XX
 802 XX                                                                           XX
 803 XX  The temporary lclVars allocated by the compiler for code generation      XX
 804 XX                                                                           XX
 805 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 806 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
 807 */
 808
 809 /*****************************************************************************
 810  *
 811  *  The following keeps track of temporaries allocated in the stack frame
 812  *  during code-generation (after register allocation). These spill-temps are
 813  *  only used if we run out of registers while evaluating a tree.
 814  *
 815  *  These are different from the more common temps allocated by lvaGrabTemp().
 816  */
 817
 818 class TempDsc
 819 {
 820 public:
 821     TempDsc* tdNext;
 822
 823 private:
 824     int tdOffs;
 825 #ifdef DEBUG
 826     static const int BAD_TEMP_OFFSET = 0xDDDDDDDD; // used as a sentinel "bad value" for tdOffs in DEBUG
 827 #endif                                             // DEBUG
 828
 829     int       tdNum;
 830     BYTE      tdSize;
 831     var_types tdType;
 832
 833 public:
 834     TempDsc(int _tdNum, unsigned _tdSize, var_types _tdType) : tdNum(_tdNum), tdSize((BYTE)_tdSize), tdType(_tdType)
 835     {
 836 #ifdef DEBUG
 837         assert(tdNum <
 838                0); // temps must have a negative number (so they have a different number from all local variables)
 839         tdOffs = BAD_TEMP_OFFSET;
 840 #endif // DEBUG
 841         if (tdNum != _tdNum)
 842         {
 843             IMPL_LIMITATION("too many spill temps");
 844         }
 845     }
 846
 847 #ifdef DEBUG
 848     bool tdLegalOffset() const
 849     {
 850         return tdOffs != BAD_TEMP_OFFSET;
 851     }
 852 #endif // DEBUG
 853
 854     int tdTempOffs() const
 855     {
 856         assert(tdLegalOffset());
 857         return tdOffs;
 858     }
 859     void tdSetTempOffs(int offs)
 860     {
 861         tdOffs = offs;
 862         assert(tdLegalOffset());
 863     }
 864     void tdAdjustTempOffs(int offs)
 865     {
 866         tdOffs += offs;
 867         assert(tdLegalOffset());
 868     }
 869
 870     int tdTempNum() const
 871     {
 872         assert(tdNum < 0);
 873         return tdNum;
 874     }
 875     unsigned tdTempSize() const
 876     {
 877         return tdSize;
 878     }
 879     var_types tdTempType() const
 880     {
 881         return tdType;
 882     }
 883 };
 884
 885 // interface to hide linearscan implementation from rest of compiler
 886 class LinearScanInterface
 887 {
 888 public:
 889     virtual void doLinearScan()                                = 0;
 890     virtual void recordVarLocationsAtStartOfBB(BasicBlock* bb) = 0;
 891 };
 892
 893 LinearScanInterface* getLinearScanAllocator(Compiler* comp);
 894
 895 // Information about arrays: their element type and size, and the offset of the first element.
 896 // We label GT_IND's that are array indices with GTF_IND_ARR_INDEX, and, for such nodes,
 897 // associate an array info via the map retrieved by GetArrayInfoMap().  This information is used,
 898 // for example, in value numbering of array index expressions.
 899 struct ArrayInfo
 900 {
 901     var_types            m_elemType;
 902     CORINFO_CLASS_HANDLE m_elemStructType;
 903     unsigned             m_elemSize;
 904     unsigned             m_elemOffset;
 905
 906     ArrayInfo() : m_elemType(TYP_UNDEF), m_elemStructType(nullptr), m_elemSize(0), m_elemOffset(0)
 907     {
 908     }
 909
 910     ArrayInfo(var_types elemType, unsigned elemSize, unsigned elemOffset, CORINFO_CLASS_HANDLE elemStructType)
 911         : m_elemType(elemType), m_elemStructType(elemStructType), m_elemSize(elemSize), m_elemOffset(elemOffset)
 912     {
 913     }
 914 };
 915
 916 // This enumeration names the phases into which we divide compilation.  The phases should completely
 917 // partition a compilation.
 918 enum Phases
 919 {
 920 #define CompPhaseNameMacro(enum_nm, string_nm, short_nm, hasChildren, parent) enum_nm,
 921 #include "compphases.h"
 922     PHASE_NUMBER_OF
 923 };
 924
 925 extern const char*   PhaseNames[];
 926 extern const char*   PhaseEnums[];
 927 extern const LPCWSTR PhaseShortNames[];
 928
 929 // The following enum provides a simple 1:1 mapping to CLR API's
 930 enum API_ICorJitInfo_Names
 931 {
 932 #define DEF_CLR_API(name) API_##name,
 933 #include "ICorJitInfo_API_names.h"
 934     API_COUNT
 935 };
 936
 937 //---------------------------------------------------------------
 938 // Compilation time.
 939 //
 940
 941 // A "CompTimeInfo" is a structure for tracking the compilation time of one or more methods.
 942 // We divide a compilation into a sequence of contiguous phases, and track the total (per-thread) cycles
 943 // of the compilation, as well as the cycles for each phase.  We also track the number of bytecodes.
 944 // If there is a failure in reading a timer at any point, the "CompTimeInfo" becomes invalid, as indicated
 945 // by "m_timerFailure" being true.
 946 // If FEATURE_JIT_METHOD_PERF is not set, we define a minimal form of this, enough to let other code compile.
 947 struct CompTimeInfo
 948 {
 949 #ifdef FEATURE_JIT_METHOD_PERF
 950     // The string names of the phases.
 951     static const char* PhaseNames[];
 952
 953     static bool PhaseHasChildren[];
 954     static int  PhaseParent[];
 955
 956     unsigned         m_byteCodeBytes;
 957     unsigned __int64 m_totalCycles;
 958     unsigned __int64 m_invokesByPhase[PHASE_NUMBER_OF];
 959     unsigned __int64 m_cyclesByPhase[PHASE_NUMBER_OF];
 960 #if MEASURE_CLRAPI_CALLS
 961     unsigned __int64 m_CLRinvokesByPhase[PHASE_NUMBER_OF];
 962     unsigned __int64 m_CLRcyclesByPhase[PHASE_NUMBER_OF];
 963 #endif
 964     // For better documentation, we call EndPhase on
 965     // non-leaf phases.  We should also call EndPhase on the
 966     // last leaf subphase; obviously, the elapsed cycles between the EndPhase
 967     // for the last leaf subphase and the EndPhase for an ancestor should be very small.
 968     // We add all such "redundant end phase" intervals to this variable below; we print
 969     // it out in a report, so we can verify that it is, indeed, very small.  If it ever
 970     // isn't, this means that we're doing something significant between the end of the last
 971     // declared subphase and the end of its parent.
 972     unsigned __int64 m_parentPhaseEndSlop;
 973     bool             m_timerFailure;
 974
 975 #if MEASURE_CLRAPI_CALLS
 976     // The following measures the time spent inside each individual CLR API call.
 977     unsigned         m_allClrAPIcalls;
 978     unsigned         m_perClrAPIcalls[API_ICorJitInfo_Names::API_COUNT];
 979     unsigned __int64 m_allClrAPIcycles;
 980     unsigned __int64 m_perClrAPIcycles[API_ICorJitInfo_Names::API_COUNT];
 981     unsigned __int32 m_maxClrAPIcycles[API_ICorJitInfo_Names::API_COUNT];
 982 #endif // MEASURE_CLRAPI_CALLS
 983
 984     CompTimeInfo(unsigned byteCodeBytes);
 985 #endif
 986 };
 987
 988 #ifdef FEATURE_JIT_METHOD_PERF
 989
 990 #if MEASURE_CLRAPI_CALLS
 991 struct WrapICorJitInfo;
 992 #endif
 993
 994 // This class summarizes the JIT time information over the course of a run: the number of methods compiled,
 995 // and the total and maximum timings.  (These are instances of the "CompTimeInfo" type described above).
 996 // The operation of adding a single method's timing to the summary may be performed concurrently by several
 997 // threads, so it is protected by a lock.
 998 // This class is intended to be used as a singleton type, with only a single instance.
 999 class CompTimeSummaryInfo
1000 {
1001     // This lock protects the fields of all CompTimeSummaryInfo(s) (of which we expect there to be one).
1002     static CritSecObject s_compTimeSummaryLock;
1003
1004     int          m_numMethods;
1005     int          m_totMethods;
1006     CompTimeInfo m_total;
1007     CompTimeInfo m_maximum;
1008
1009     int          m_numFilteredMethods;
1010     CompTimeInfo m_filtered;
1011
1012     // This method computes the number of cycles/sec for the current machine.  The cycles are those counted
1013     // by GetThreadCycleTime; we assume that these are of equal duration, though that is not necessarily true.
1014     // If any OS interaction fails, returns 0.0.
1015     double CyclesPerSecond();
1016
1017     // This can use what ever data you want to determine if the value to be added
1018     // belongs in the filtered section (it's always included in the unfiltered section)
1019     bool IncludedInFilteredData(CompTimeInfo& info);
1020
1021 public:
1022     // This is the unique CompTimeSummaryInfo object for this instance of the runtime.
1023     static CompTimeSummaryInfo s_compTimeSummary;
1024
1025     CompTimeSummaryInfo()
1026         : m_numMethods(0), m_totMethods(0), m_total(0), m_maximum(0), m_numFilteredMethods(0), m_filtered(0)
1027     {
1028     }
1029
1030     // Assumes that "info" is a completed CompTimeInfo for a compilation; adds it to the summary.
1031     // This is thread safe.
1032     void AddInfo(CompTimeInfo& info, bool includePhases);
1033
1034     // Print the summary information to "f".
1035     // This is not thread-safe; assumed to be called by only one thread.
1036     void Print(FILE* f);
1037 };
1038
1039 // A JitTimer encapsulates a CompTimeInfo for a single compilation. It also tracks the start of compilation,
1040 // and when the current phase started.  This is intended to be part of a Compilation object.  This is
1041 // disabled (FEATURE_JIT_METHOD_PERF not defined) when FEATURE_CORECLR is set, or on non-windows platforms.
1042 //
1043 class JitTimer
1044 {
1045     unsigned __int64 m_start;         // Start of the compilation.
1046     unsigned __int64 m_curPhaseStart; // Start of the current phase.
1047 #if MEASURE_CLRAPI_CALLS
1048     unsigned __int64 m_CLRcallStart;   // Start of the current CLR API call (if any).
1049     unsigned __int64 m_CLRcallInvokes; // CLR API invokes under current outer so far
1050     unsigned __int64 m_CLRcallCycles;  // CLR API  cycles under current outer so far.
1051     int              m_CLRcallAPInum;  // The enum/index of the current CLR API call (or -1).
1052     static double    s_cyclesPerSec;   // Cached for speedier measurements
1053 #endif
1054 #ifdef DEBUG
1055     Phases m_lastPhase; // The last phase that was completed (or (Phases)-1 to start).
1056 #endif
1057     CompTimeInfo m_info; // The CompTimeInfo for this compilation.
1058
1059     static CritSecObject s_csvLock; // Lock to protect the time log file.
1060     void PrintCsvMethodStats(Compiler* comp);
1061
1062 private:
1063     void* operator new(size_t);
1064     void* operator new[](size_t);
1065     void operator delete(void*);
1066     void operator delete[](void*);
1067
1068 public:
1069     // Initialized the timer instance
1070     JitTimer(unsigned byteCodeSize);
1071
1072     static JitTimer* Create(Compiler* comp, unsigned byteCodeSize)
1073     {
1074         return ::new (comp, CMK_Unknown) JitTimer(byteCodeSize);
1075     }
1076
1077     static void PrintCsvHeader();
1078
1079     // Ends the current phase (argument is for a redundant check).
1080     void EndPhase(Phases phase);
1081
1082 #if MEASURE_CLRAPI_CALLS
1083     // Start and end a timed CLR API call.
1084     void CLRApiCallEnter(unsigned apix);
1085     void CLRApiCallLeave(unsigned apix);
1086 #endif // MEASURE_CLRAPI_CALLS
1087
1088     // Completes the timing of the current method, which is assumed to have "byteCodeBytes" bytes of bytecode,
1089     // and adds it to "sum".
1090     void Terminate(Compiler* comp, CompTimeSummaryInfo& sum, bool includePhases);
1091
1092     // Attempts to query the cycle counter of the current thread.  If successful, returns "true" and sets
1093     // *cycles to the cycle counter value.  Otherwise, returns false and sets the "m_timerFailure" flag of
1094     // "m_info" to true.
1095     bool GetThreadCycles(unsigned __int64* cycles)
1096     {
1097         bool res = CycleTimer::GetThreadCyclesS(cycles);
1098         if (!res)
1099         {
1100             m_info.m_timerFailure = true;
1101         }
1102         return res;
1103     }
1104 };
1105 #endif // FEATURE_JIT_METHOD_PERF
1106
1107 //------------------- Function/Funclet info -------------------------------
1108 DECLARE_TYPED_ENUM(FuncKind, BYTE)
1109 {
1110     FUNC_ROOT,        // The main/root function (always id==0)
1111         FUNC_HANDLER, // a funclet associated with an EH handler (finally, fault, catch, filter handler)
1112         FUNC_FILTER,  // a funclet associated with an EH filter
1113         FUNC_COUNT
1114 }
1115 END_DECLARE_TYPED_ENUM(FuncKind, BYTE)
1116
1117 class emitLocation;
1118
1119 struct FuncInfoDsc
1120 {
1121     FuncKind       funKind;
1122     BYTE           funFlags;   // Currently unused, just here for padding
1123     unsigned short funEHIndex; // index, into the ebd table, of innermost EH clause corresponding to this
1124                                // funclet. It is only valid if funKind field indicates this is a
1125                                // EH-related funclet: FUNC_HANDLER or FUNC_FILTER
1126
1127 #if defined(_TARGET_AMD64_)
1128
1129     // TODO-AMD64-Throughput: make the AMD64 info more like the ARM info to avoid having this large static array.
1130     emitLocation* startLoc;
1131     emitLocation* endLoc;
1132     emitLocation* coldStartLoc; // locations for the cold section, if there is one.
1133     emitLocation* coldEndLoc;
1134     UNWIND_INFO   unwindHeader;
1135     // Maximum of 255 UNWIND_CODE 'nodes' and then the unwind header. If there are an odd
1136     // number of codes, the VM or Zapper will 4-byte align the whole thing.
1137     BYTE     unwindCodes[offsetof(UNWIND_INFO, UnwindCode) + (0xFF * sizeof(UNWIND_CODE))];
1138     unsigned unwindCodeSlot;
1139
1140 #ifdef UNIX_AMD64_ABI
1141     jitstd::vector<CFI_CODE>* cfiCodes;
1142 #endif // UNIX_AMD64_ABI
1143
1144 #elif defined(_TARGET_ARMARCH_)
1145
1146     UnwindInfo  uwi;     // Unwind information for this function/funclet's hot  section
1147     UnwindInfo* uwiCold; // Unwind information for this function/funclet's cold section
1148                          //   Note: we only have a pointer here instead of the actual object,
1149                          //   to save memory in the JIT case (compared to the NGEN case),
1150                          //   where we don't have any cold section.
1151                          //   Note 2: we currently don't support hot/cold splitting in functions
1152                          //   with EH, so uwiCold will be NULL for all funclets.
1153
1154 #endif // _TARGET_ARMARCH_
1155
1156     // Eventually we may want to move rsModifiedRegsMask, lvaOutgoingArgSize, and anything else
1157     // that isn't shared between the main function body and funclets.
1158 };
1159
1160 struct fgArgTabEntry
1161 {
1162
1163 #if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
1164     fgArgTabEntry()
1165     {
1166         otherRegNum = REG_NA;
1167         isStruct    = false; // is this a struct arg
1168     }
1169 #endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
1170
1171     GenTreePtr node; // Initially points at the Op1 field of 'parent', but if the argument is replaced with an GT_ASG or
1172                      // placeholder
1173                      //  it will point at the actual argument in the gtCallLateArgs list.
1174     GenTreePtr parent; // Points at the GT_LIST node in the gtCallArgs for this argument
1175
1176     unsigned argNum; // The original argument number, also specifies the required argument evaluation order from the IL
1177
1178     regNumber regNum; // The (first) register to use when passing this argument, set to REG_STK for arguments passed on
1179                       // the stack
1180     unsigned numRegs; // Count of number of registers that this argument uses
1181
1182     // A slot is a pointer sized region in the OutArg area.
1183     unsigned slotNum;  // When an argument is passed in the OutArg area this is the slot number in the OutArg area
1184     unsigned numSlots; // Count of number of slots that this argument uses
1185
1186     unsigned alignment;  // 1 or 2 (slots/registers)
1187     unsigned lateArgInx; // index into gtCallLateArgs list
1188     unsigned tmpNum;     // the LclVar number if we had to force evaluation of this arg
1189
1190     bool isSplit : 1;       // True when this argument is split between the registers and OutArg area
1191     bool needTmp : 1;       // True when we force this argument's evaluation into a temp LclVar
1192     bool needPlace : 1;     // True when we must replace this argument with a placeholder node
1193     bool isTmp : 1;         // True when we setup a temp LclVar for this argument due to size issues with the struct
1194     bool processed : 1;     // True when we have decided the evaluation order for this argument in the gtCallLateArgs
1195     bool isHfaRegArg : 1;   // True when the argument is passed as a HFA in FP registers.
1196     bool isBackFilled : 1;  // True when the argument fills a register slot skipped due to alignment requirements of
1197                             // previous arguments.
1198     bool isNonStandard : 1; // True if it is an arg that is passed in a reg other than a standard arg reg, or is forced
1199                             // to be on the stack despite its arg list position.
1200
1201 #if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
1202     bool isStruct : 1; // True if this is a struct arg
1203
1204     regNumber otherRegNum; // The (second) register to use when passing this argument.
1205
1206     SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR structDesc;
1207 #elif defined(_TARGET_X86_)
1208     __declspec(property(get = getIsStruct)) bool isStruct;
1209     bool getIsStruct()
1210     {
1211         return varTypeIsStruct(node);
1212     }
1213 #endif // _TARGET_X86_
1214
1215 #ifdef _TARGET_ARM_
1216     void SetIsHfaRegArg(bool hfaRegArg)
1217     {
1218         isHfaRegArg = hfaRegArg;
1219     }
1220
1221     void SetIsBackFilled(bool backFilled)
1222     {
1223         isBackFilled = backFilled;
1224     }
1225
1226     bool IsBackFilled() const
1227     {
1228         return isBackFilled;
1229     }
1230 #else  // !_TARGET_ARM_
1231     // To make the callers easier, we allow these calls (and the isHfaRegArg and isBackFilled data members) for all
1232     // platforms.
1233     void SetIsHfaRegArg(bool hfaRegArg)
1234     {
1235     }
1236
1237     void SetIsBackFilled(bool backFilled)
1238     {
1239     }
1240
1241     bool IsBackFilled() const
1242     {
1243         return false;
1244     }
1245 #endif // !_TARGET_ARM_
1246
1247 #ifdef DEBUG
1248     void Dump();
1249 #endif
1250 };
1251 typedef struct fgArgTabEntry* fgArgTabEntryPtr;
1252
1253 //-------------------------------------------------------------------------
1254 //
1255 //  The class fgArgInfo is used to handle the arguments
1256 //  when morphing a GT_CALL node.
1257 //
1258
1259 class fgArgInfo
1260 {
1261     Compiler*  compiler;    // Back pointer to the compiler instance so that we can allocate memory
1262     GenTreePtr callTree;    // Back pointer to the GT_CALL node for this fgArgInfo
1263     unsigned   argCount;    // Updatable arg count value
1264     unsigned   nextSlotNum; // Updatable slot count value
1265     unsigned   stkLevel;    // Stack depth when we make this call (for x86)
1266
1267     unsigned          argTableSize; // size of argTable array (equal to the argCount when done with fgMorphArgs)
1268     bool              hasRegArgs;   // true if we have one or more register arguments
1269     bool              hasStackArgs; // true if we have one or more stack arguments
1270     bool              argsComplete; // marker for state
1271     bool              argsSorted;   // marker for state
1272     fgArgTabEntryPtr* argTable;     // variable sized array of per argument descrption: (i.e. argTable[argTableSize])
1273
1274 private:
1275     void AddArg(fgArgTabEntryPtr curArgTabEntry);
1276
1277 public:
1278     fgArgInfo(Compiler* comp, GenTreePtr call, unsigned argCount);
1279     fgArgInfo(GenTreePtr newCall, GenTreePtr oldCall);
1280
1281     fgArgTabEntryPtr AddRegArg(
1282         unsigned argNum, GenTreePtr node, GenTreePtr parent, regNumber regNum, unsigned numRegs, unsigned alignment);
1283
1284 #ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
1285     fgArgTabEntryPtr AddRegArg(
1286         unsigned                                                         argNum,
1287         GenTreePtr                                                       node,
1288         GenTreePtr                                                       parent,
1289         regNumber                                                        regNum,
1290         unsigned                                                         numRegs,
1291         unsigned                                                         alignment,
1292         const bool                                                       isStruct,
1293         const regNumber                                                  otherRegNum   = REG_NA,
1294         const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* const structDescPtr = nullptr);
1295 #endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
1296
1297     fgArgTabEntryPtr AddStkArg(unsigned   argNum,
1298                                GenTreePtr node,
1299                                GenTreePtr parent,
1300                                unsigned   numSlots,
1301                                unsigned alignment FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(const bool isStruct));
1302
1303     void             RemorphReset();
1304     fgArgTabEntryPtr RemorphRegArg(
1305         unsigned argNum, GenTreePtr node, GenTreePtr parent, regNumber regNum, unsigned numRegs, unsigned alignment);
1306
1307     void RemorphStkArg(unsigned argNum, GenTreePtr node, GenTreePtr parent, unsigned numSlots, unsigned alignment);
1308
1309     void SplitArg(unsigned argNum, unsigned numRegs, unsigned numSlots);
1310
1311     void EvalToTmp(unsigned argNum, unsigned tmpNum, GenTreePtr newNode);
1312
1313     void ArgsComplete();
1314
1315     void SortArgs();
1316
1317     void EvalArgsToTemps();
1318
1319     void RecordStkLevel(unsigned stkLvl);
1320     unsigned RetrieveStkLevel();
1321
1322     unsigned ArgCount()
1323     {
1324         return argCount;
1325     }
1326     fgArgTabEntryPtr* ArgTable()
1327     {
1328         return argTable;
1329     }
1330     unsigned GetNextSlotNum()
1331     {
1332         return nextSlotNum;
1333     }
1334     bool HasRegArgs()
1335     {
1336         return hasRegArgs;
1337     }
1338     bool HasStackArgs()
1339     {
1340         return hasStackArgs;
1341     }
1342     bool AreArgsComplete() const
1343     {
1344         return argsComplete;
1345     }
1346 };
1347
1348 #ifdef DEBUG
1349 // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1350 // We have the ability to mark source expressions with "Test Labels."
1351 // These drive assertions within the JIT, or internal JIT testing.  For example, we could label expressions
1352 // that should be CSE defs, and other expressions that should uses of those defs, with a shared label.
1353
1354 enum TestLabel // This must be kept identical to System.Runtime.CompilerServices.JitTestLabel.TestLabel.
1355 {
1356     TL_SsaName,
1357     TL_VN,        // Defines a "VN equivalence class".  (For full VN, including exceptions thrown).
1358     TL_VNNorm,    // Like above, but uses the non-exceptional value of the expression.
1359     TL_CSE_Def,   //  This must be identified in the JIT as a CSE def
1360     TL_CSE_Use,   //  This must be identified in the JIT as a CSE use
1361     TL_LoopHoist, // Expression must (or must not) be hoisted out of the loop.
1362 };
1363
1364 struct TestLabelAndNum
1365 {
1366     TestLabel m_tl;
1367     ssize_t   m_num;
1368
1369     TestLabelAndNum() : m_tl(TestLabel(0)), m_num(0)
1370     {
1371     }
1372 };
1373
1374 typedef SimplerHashTable<GenTreePtr, PtrKeyFuncs<GenTree>, TestLabelAndNum, JitSimplerHashBehavior> NodeToTestDataMap;
1375
1376 // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1377 #endif // DEBUG
1378
1379 // This class implements the "IAllocator" interface, so that we can use
1380 // utilcode collection classes in the JIT, and have them use the JIT's allocator.
1381
1382 class CompAllocator : public IAllocator
1383 {
1384     Compiler* m_comp;
1385 #if MEASURE_MEM_ALLOC
1386     CompMemKind m_cmk;
1387 #endif
1388 public:
1389     CompAllocator(Compiler* comp, CompMemKind cmk)
1390         : m_comp(comp)
1391 #if MEASURE_MEM_ALLOC
1392         , m_cmk(cmk)
1393 #endif
1394     {
1395     }
1396
1397     inline void* Alloc(size_t sz);
1398
1399     inline void* ArrayAlloc(size_t elems, size_t elemSize);
1400
1401     // For the compiler's no-release allocator, free operations are no-ops.
1402     void Free(void* p)
1403     {
1404     }
1405 };
1406
1407 /*
1408 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1409 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1410 XX                                                                           XX
1411 XX   The big guy. The sections are currently organized as :                  XX
1412 XX                                                                           XX
1413 XX    o  GenTree and BasicBlock                                              XX
1414 XX    o  LclVarsInfo                                                         XX
1415 XX    o  Importer                                                            XX
1416 XX    o  FlowGraph                                                           XX
1417 XX    o  Optimizer                                                           XX
1418 XX    o  RegAlloc                                                            XX
1419 XX    o  EEInterface                                                         XX
1420 XX    o  TempsInfo                                                           XX
1421 XX    o  RegSet                                                              XX
1422 XX    o  GCInfo                                                              XX
1423 XX    o  Instruction                                                         XX
1424 XX    o  ScopeInfo                                                           XX
1425 XX    o  PrologScopeInfo                                                     XX
1426 XX    o  CodeGenerator                                                       XX
1427 XX    o  UnwindInfo                                                          XX
1428 XX    o  Compiler                                                            XX
1429 XX    o  typeInfo                                                            XX
1430 XX                                                                           XX
1431 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1432 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1433 */
1434
1435 class Compiler
1436 {
1437     friend class emitter;
1438     friend class UnwindInfo;
1439     friend class UnwindFragmentInfo;
1440     friend class UnwindEpilogInfo;
1441     friend class JitTimer;
1442     friend class LinearScan;
1443     friend class fgArgInfo;
1444     friend class Rationalizer;
1445     friend class Phase;
1446     friend class Lowering;
1447     friend class CSE_DataFlow;
1448     friend class CSE_Heuristic;
1449     friend class CodeGenInterface;
1450     friend class CodeGen;
1451     friend class LclVarDsc;
1452     friend class TempDsc;
1453     friend class LIR;
1454     friend class ObjectAllocator;
1455
1456 #ifndef _TARGET_64BIT_
1457     friend class DecomposeLongs;
1458 #endif // !_TARGET_64BIT_
1459
1460     /*
1461     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1462     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1463     XX                                                                           XX
1464     XX  Misc structs definitions                                                 XX
1465     XX                                                                           XX
1466     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1467     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1468     */
1469
1470 public:
1471     hashBvGlobalData hbvGlobalData; // Used by the hashBv bitvector package.
1472
1473 #ifdef DEBUG
1474     bool    verbose;
1475     bool    dumpIR;
1476     bool    dumpIRNodes;
1477     bool    dumpIRTypes;
1478     bool    dumpIRKinds;
1479     bool    dumpIRLocals;
1480     bool    dumpIRRegs;
1481     bool    dumpIRSsa;
1482     bool    dumpIRValnums;
1483     bool    dumpIRCosts;
1484     bool    dumpIRFlags;
1485     bool    dumpIRNoLists;
1486     bool    dumpIRNoLeafs;
1487     bool    dumpIRNoStmts;
1488     bool    dumpIRTrees;
1489     bool    dumpIRLinear;
1490     bool    dumpIRDataflow;
1491     bool    dumpIRBlockHeaders;
1492     bool    dumpIRExit;
1493     LPCWSTR dumpIRPhase;
1494     LPCWSTR dumpIRFormat;
1495     bool    verboseTrees;
1496     bool    shouldUseVerboseTrees();
1497     bool    asciiTrees; // If true, dump trees using only ASCII characters
1498     bool    shouldDumpASCIITrees();
1499     bool    verboseSsa; // If true, produce especially verbose dump output in SSA construction.
1500     bool    shouldUseVerboseSsa();
1501     bool    treesBeforeAfterMorph; // If true, print trees before/after morphing (paired by an intra-compilation id:
1502     int     morphNum; // This counts the the trees that have been morphed, allowing us to label each uniquely.
1503
1504     const char* VarNameToStr(VarName name)
1505     {
1506         return name;
1507     }
1508
1509     DWORD expensiveDebugCheckLevel;
1510 #endif
1511
1512 #if FEATURE_MULTIREG_RET
1513     GenTreePtr impAssignMultiRegTypeToVar(GenTreePtr op, CORINFO_CLASS_HANDLE hClass);
1514 #endif // FEATURE_MULTIREG_RET
1515
1516 #ifdef ARM_SOFTFP
1517     bool isSingleFloat32Struct(CORINFO_CLASS_HANDLE hClass);
1518 #endif // ARM_SOFTFP
1519
1520     //-------------------------------------------------------------------------
1521     // Functions to handle homogeneous floating-point aggregates (HFAs) in ARM.
1522     // HFAs are one to four element structs where each element is the same
1523     // type, either all float or all double. They are treated specially
1524     // in the ARM Procedure Call Standard, specifically, they are passed in
1525     // floating-point registers instead of the general purpose registers.
1526     //
1527
1528     bool IsHfa(CORINFO_CLASS_HANDLE hClass);
1529     bool IsHfa(GenTreePtr tree);
1530
1531     var_types GetHfaType(GenTreePtr tree);
1532     unsigned GetHfaCount(GenTreePtr tree);
1533
1534     var_types GetHfaType(CORINFO_CLASS_HANDLE hClass);
1535     unsigned GetHfaCount(CORINFO_CLASS_HANDLE hClass);
1536
1537     bool IsMultiRegPassedType(CORINFO_CLASS_HANDLE hClass);
1538     bool IsMultiRegReturnedType(CORINFO_CLASS_HANDLE hClass);
1539
1540     //-------------------------------------------------------------------------
1541     // The following is used for validating format of EH table
1542     //
1543
1544     struct EHNodeDsc;
1545     typedef struct EHNodeDsc* pEHNodeDsc;
1546
1547     EHNodeDsc* ehnTree; // root of the tree comprising the EHnodes.
1548     EHNodeDsc* ehnNext; // root of the tree comprising the EHnodes.
1549
1550     struct EHNodeDsc
1551     {
1552         enum EHBlockType
1553         {
1554             TryNode,
1555             FilterNode,
1556             HandlerNode,
1557             FinallyNode,
1558             FaultNode
1559         };
1560
1561         EHBlockType ehnBlockType;   // kind of EH block
1562         IL_OFFSET   ehnStartOffset; // IL offset of start of the EH block
1563         IL_OFFSET ehnEndOffset; // IL offset past end of the EH block. (TODO: looks like verInsertEhNode() sets this to
1564                                 // the last IL offset, not "one past the last one", i.e., the range Start to End is
1565                                 // inclusive).
1566         pEHNodeDsc ehnNext;     // next (non-nested) block in sequential order
1567         pEHNodeDsc ehnChild;    // leftmost nested block
1568         union {
1569             pEHNodeDsc ehnTryNode;     // for filters and handlers, the corresponding try node
1570             pEHNodeDsc ehnHandlerNode; // for a try node, the corresponding handler node
1571         };
1572         pEHNodeDsc ehnFilterNode; // if this is a try node and has a filter, otherwise 0
1573         pEHNodeDsc ehnEquivalent; // if blockType=tryNode, start offset and end offset is same,
1574
1575         inline void ehnSetTryNodeType()
1576         {
1577             ehnBlockType = TryNode;
1578         }
1579         inline void ehnSetFilterNodeType()
1580         {
1581             ehnBlockType = FilterNode;
1582         }
1583         inline void ehnSetHandlerNodeType()
1584         {
1585             ehnBlockType = HandlerNode;
1586         }
1587         inline void ehnSetFinallyNodeType()
1588         {
1589             ehnBlockType = FinallyNode;
1590         }
1591         inline void ehnSetFaultNodeType()
1592         {
1593             ehnBlockType = FaultNode;
1594         }
1595
1596         inline BOOL ehnIsTryBlock()
1597         {
1598             return ehnBlockType == TryNode;
1599         }
1600         inline BOOL ehnIsFilterBlock()
1601         {
1602             return ehnBlockType == FilterNode;
1603         }
1604         inline BOOL ehnIsHandlerBlock()
1605         {
1606             return ehnBlockType == HandlerNode;
1607         }
1608         inline BOOL ehnIsFinallyBlock()
1609         {
1610             return ehnBlockType == FinallyNode;
1611         }
1612         inline BOOL ehnIsFaultBlock()
1613         {
1614             return ehnBlockType == FaultNode;
1615         }
1616
1617         // returns true if there is any overlap between the two nodes
1618         static inline BOOL ehnIsOverlap(pEHNodeDsc node1, pEHNodeDsc node2)
1619         {
1620             if (node1->ehnStartOffset < node2->ehnStartOffset)
1621             {
1622                 return (node1->ehnEndOffset >= node2->ehnStartOffset);
1623             }
1624             else
1625             {
1626                 return (node1->ehnStartOffset <= node2->ehnEndOffset);
1627             }
1628         }
1629
1630         // fails with BADCODE if inner is not completely nested inside outer
1631         static inline BOOL ehnIsNested(pEHNodeDsc inner, pEHNodeDsc outer)
1632         {
1633             return ((inner->ehnStartOffset >= outer->ehnStartOffset) && (inner->ehnEndOffset <= outer->ehnEndOffset));
1634         }
1635     };
1636
1637 //-------------------------------------------------------------------------
1638 // Exception handling functions
1639 //
1640
1641 #if !FEATURE_EH_FUNCLETS
1642
1643     bool ehNeedsShadowSPslots()
1644     {
1645         return (info.compXcptnsCount || opts.compDbgEnC);
1646     }
1647
1648     // 0 for methods with no EH
1649     // 1 for methods with non-nested EH, or where only the try blocks are nested
1650     // 2 for a method with a catch within a catch
1651     // etc.
1652     unsigned ehMaxHndNestingCount;
1653
1654 #endif // !FEATURE_EH_FUNCLETS
1655
1656     static bool jitIsBetween(unsigned value, unsigned start, unsigned end);
1657     static bool jitIsBetweenInclusive(unsigned value, unsigned start, unsigned end);
1658
1659     bool bbInCatchHandlerILRange(BasicBlock* blk);
1660     bool bbInFilterILRange(BasicBlock* blk);
1661     bool bbInTryRegions(unsigned regionIndex, BasicBlock* blk);
1662     bool bbInExnFlowRegions(unsigned regionIndex, BasicBlock* blk);
1663     bool bbInHandlerRegions(unsigned regionIndex, BasicBlock* blk);
1664     bool bbInCatchHandlerRegions(BasicBlock* tryBlk, BasicBlock* hndBlk);
1665     unsigned short bbFindInnermostCommonTryRegion(BasicBlock* bbOne, BasicBlock* bbTwo);
1666
1667     unsigned short bbFindInnermostTryRegionContainingHandlerRegion(unsigned handlerIndex);
1668     unsigned short bbFindInnermostHandlerRegionContainingTryRegion(unsigned tryIndex);
1669
1670     // Returns true if "block" is the start of a try region.
1671     bool bbIsTryBeg(BasicBlock* block);
1672
1673     // Returns true if "block" is the start of a handler or filter region.
1674     bool bbIsHandlerBeg(BasicBlock* block);
1675
1676     // Returns true iff "block" is where control flows if an exception is raised in the
1677     // try region, and sets "*regionIndex" to the index of the try for the handler.
1678     // Differs from "IsHandlerBeg" in the case of filters, where this is true for the first
1679     // block of the filter, but not for the filter's handler.
1680     bool bbIsExFlowBlock(BasicBlock* block, unsigned* regionIndex);
1681
1682     bool ehHasCallableHandlers();
1683
1684     // Return the EH descriptor for the given region index.
1685     EHblkDsc* ehGetDsc(unsigned regionIndex);
1686
1687     // Return the EH index given a region descriptor.
1688     unsigned ehGetIndex(EHblkDsc* ehDsc);
1689
1690     // Return the EH descriptor index of the enclosing try, for the given region index.
1691     unsigned ehGetEnclosingTryIndex(unsigned regionIndex);
1692
1693     // Return the EH descriptor index of the enclosing handler, for the given region index.
1694     unsigned ehGetEnclosingHndIndex(unsigned regionIndex);
1695
1696     // Return the EH descriptor for the most nested 'try' region this BasicBlock is a member of (or nullptr if this
1697     // block is not in a 'try' region).
1698     EHblkDsc* ehGetBlockTryDsc(BasicBlock* block);
1699
1700     // Return the EH descriptor for the most nested filter or handler region this BasicBlock is a member of (or nullptr
1701     // if this block is not in a filter or handler region).
1702     EHblkDsc* ehGetBlockHndDsc(BasicBlock* block);
1703
1704     // Return the EH descriptor for the most nested region that may handle exceptions raised in this BasicBlock (or
1705     // nullptr if this block's exceptions propagate to caller).
1706     EHblkDsc* ehGetBlockExnFlowDsc(BasicBlock* block);
1707
1708     EHblkDsc* ehIsBlockTryLast(BasicBlock* block);
1709     EHblkDsc* ehIsBlockHndLast(BasicBlock* block);
1710     bool ehIsBlockEHLast(BasicBlock* block);
1711
1712     bool ehBlockHasExnFlowDsc(BasicBlock* block);
1713
1714     // Return the region index of the most nested EH region this block is in.
1715     unsigned ehGetMostNestedRegionIndex(BasicBlock* block, bool* inTryRegion);
1716
1717     // Find the true enclosing try index, ignoring 'mutual protect' try. Uses IL ranges to check.
1718     unsigned ehTrueEnclosingTryIndexIL(unsigned regionIndex);
1719
1720     // Return the index of the most nested enclosing region for a particular EH region. Returns NO_ENCLOSING_INDEX
1721     // if there is no enclosing region. If the returned index is not NO_ENCLOSING_INDEX, then '*inTryRegion'
1722     // is set to 'true' if the enclosing region is a 'try', or 'false' if the enclosing region is a handler.
1723     // (It can never be a filter.)
1724     unsigned ehGetEnclosingRegionIndex(unsigned regionIndex, bool* inTryRegion);
1725
1726     // A block has been deleted. Update the EH table appropriately.
1727     void ehUpdateForDeletedBlock(BasicBlock* block);
1728
1729     // Determine whether a block can be deleted while preserving the EH normalization rules.
1730     bool ehCanDeleteEmptyBlock(BasicBlock* block);
1731
1732     // Update the 'last' pointers in the EH table to reflect new or deleted blocks in an EH region.
1733     void ehUpdateLastBlocks(BasicBlock* oldLast, BasicBlock* newLast);
1734
1735     // For a finally handler, find the region index that the BBJ_CALLFINALLY lives in that calls the handler,
1736     // or NO_ENCLOSING_INDEX if the BBJ_CALLFINALLY lives in the main function body. Normally, the index
1737     // is the same index as the handler (and the BBJ_CALLFINALLY lives in the 'try' region), but for AMD64 the
1738     // BBJ_CALLFINALLY lives in the enclosing try or handler region, whichever is more nested, or the main function
1739     // body. If the returned index is not NO_ENCLOSING_INDEX, then '*inTryRegion' is set to 'true' if the
1740     // BBJ_CALLFINALLY lives in the returned index's 'try' region, or 'false' if lives in the handler region. (It never
1741     // lives in a filter.)
1742     unsigned ehGetCallFinallyRegionIndex(unsigned finallyIndex, bool* inTryRegion);
1743
1744     // Find the range of basic blocks in which all BBJ_CALLFINALLY will be found that target the 'finallyIndex' region's
1745     // handler. Set begBlk to the first block, and endBlk to the block after the last block of the range
1746     // (nullptr if the last block is the last block in the program).
1747     // Precondition: 'finallyIndex' is the EH region of a try/finally clause.
1748     void ehGetCallFinallyBlockRange(unsigned finallyIndex, BasicBlock** begBlk, BasicBlock** endBlk);
1749
1750 #ifdef DEBUG
1751     // Given a BBJ_CALLFINALLY block and the EH region index of the finally it is calling, return
1752     // 'true' if the BBJ_CALLFINALLY is in the correct EH region.
1753     bool ehCallFinallyInCorrectRegion(BasicBlock* blockCallFinally, unsigned finallyIndex);
1754 #endif // DEBUG
1755
1756 #if FEATURE_EH_FUNCLETS
1757     // Do we need a PSPSym in the main function? For codegen purposes, we only need one
1758     // if there is a filter that protects a region with a nested EH clause (such as a
1759     // try/catch nested in the 'try' body of a try/filter/filter-handler). See
1760     // genFuncletProlog() for more details. However, the VM seems to use it for more
1761     // purposes, maybe including debugging. Until we are sure otherwise, always create
1762     // a PSPSym for functions with any EH.
1763     bool ehNeedsPSPSym() const
1764     {
1765 #ifdef _TARGET_X86_
1766         return false;
1767 #else  // _TARGET_X86_
1768         return compHndBBtabCount > 0;
1769 #endif // _TARGET_X86_
1770     }
1771
1772     bool     ehAnyFunclets();  // Are there any funclets in this function?
1773     unsigned ehFuncletCount(); // Return the count of funclets in the function
1774
1775     unsigned bbThrowIndex(BasicBlock* blk); // Get the index to use as the cache key for sharing throw blocks
1776 #else                                       // !FEATURE_EH_FUNCLETS
1777     bool ehAnyFunclets()
1778     {
1779         return false;
1780     }
1781     unsigned ehFuncletCount()
1782     {
1783         return 0;
1784     }
1785
1786     unsigned bbThrowIndex(BasicBlock* blk)
1787     {
1788         return blk->bbTryIndex;
1789     } // Get the index to use as the cache key for sharing throw blocks
1790 #endif                                      // !FEATURE_EH_FUNCLETS
1791
1792     // Returns a flowList representing the "EH predecessors" of "blk".  These are the normal predecessors of
1793     // "blk", plus one special case: if "blk" is the first block of a handler, considers the predecessor(s) of the first
1794     // first block of the corresponding try region to be "EH predecessors".  (If there is a single such predecessor,
1795     // for example, we want to consider that the immediate dominator of the catch clause start block, so it's
1796     // convenient to also consider it a predecessor.)
1797     flowList* BlockPredsWithEH(BasicBlock* blk);
1798
1799     // This table is useful for memoization of the method above.
1800     typedef SimplerHashTable<BasicBlock*, PtrKeyFuncs<BasicBlock>, flowList*, JitSimplerHashBehavior>
1801                         BlockToFlowListMap;
1802     BlockToFlowListMap* m_blockToEHPreds;
1803     BlockToFlowListMap* GetBlockToEHPreds()
1804     {
1805         if (m_blockToEHPreds == nullptr)
1806         {
1807             m_blockToEHPreds = new (getAllocator()) BlockToFlowListMap(getAllocator());
1808         }
1809         return m_blockToEHPreds;
1810     }
1811
1812     void* ehEmitCookie(BasicBlock* block);
1813     UNATIVE_OFFSET ehCodeOffset(BasicBlock* block);
1814
1815     EHblkDsc* ehInitHndRange(BasicBlock* src, IL_OFFSET* hndBeg, IL_OFFSET* hndEnd, bool* inFilter);
1816
1817     EHblkDsc* ehInitTryRange(BasicBlock* src, IL_OFFSET* tryBeg, IL_OFFSET* tryEnd);
1818
1819     EHblkDsc* ehInitHndBlockRange(BasicBlock* blk, BasicBlock** hndBeg, BasicBlock** hndLast, bool* inFilter);
1820
1821     EHblkDsc* ehInitTryBlockRange(BasicBlock* blk, BasicBlock** tryBeg, BasicBlock** tryLast);
1822
1823     void fgSetTryEnd(EHblkDsc* handlerTab, BasicBlock* newTryLast);
1824
1825     void fgSetHndEnd(EHblkDsc* handlerTab, BasicBlock* newHndLast);
1826
1827     void fgSkipRmvdBlocks(EHblkDsc* handlerTab);
1828
1829     void fgAllocEHTable();
1830
1831     void fgRemoveEHTableEntry(unsigned XTnum);
1832
1833 #if FEATURE_EH_FUNCLETS
1834
1835     EHblkDsc* fgAddEHTableEntry(unsigned XTnum);
1836
1837 #endif // FEATURE_EH_FUNCLETS
1838
1839 #if !FEATURE_EH
1840     void fgRemoveEH();
1841 #endif // !FEATURE_EH
1842
1843     void fgSortEHTable();
1844
1845     // Causes the EH table to obey some well-formedness conditions, by inserting
1846     // empty BB's when necessary:
1847     //   * No block is both the first block of a handler and the first block of a try.
1848     //   * No block is the first block of multiple 'try' regions.
1849     //   * No block is the last block of multiple EH regions.
1850     void fgNormalizeEH();
1851     bool fgNormalizeEHCase1();
1852     bool fgNormalizeEHCase2();
1853     bool fgNormalizeEHCase3();
1854
1855 #ifdef DEBUG
1856     void dispIncomingEHClause(unsigned num, const CORINFO_EH_CLAUSE& clause);
1857     void dispOutgoingEHClause(unsigned num, const CORINFO_EH_CLAUSE& clause);
1858     void fgVerifyHandlerTab();
1859     void fgDispHandlerTab();
1860 #endif // DEBUG
1861
1862     bool fgNeedToSortEHTable;
1863
1864     void verInitEHTree(unsigned numEHClauses);
1865     void verInsertEhNode(CORINFO_EH_CLAUSE* clause, EHblkDsc* handlerTab);
1866     void verInsertEhNodeInTree(EHNodeDsc** ppRoot, EHNodeDsc* node);
1867     void verInsertEhNodeParent(EHNodeDsc** ppRoot, EHNodeDsc* node);
1868     void verCheckNestingLevel(EHNodeDsc* initRoot);
1869
1870     /*
1871     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1872     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1873     XX                                                                           XX
1874     XX                        GenTree and BasicBlock                             XX
1875     XX                                                                           XX
1876     XX  Functions to allocate and display the GenTrees and BasicBlocks           XX
1877     XX                                                                           XX
1878     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1879     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
1880     */
1881
1882     // Functions to create nodes
1883     GenTreeStmt* gtNewStmt(GenTreePtr expr = nullptr, IL_OFFSETX offset = BAD_IL_OFFSET);
1884
1885     // For unary opers.
1886     GenTreePtr gtNewOperNode(genTreeOps oper, var_types type, GenTreePtr op1, bool doSimplifications = TRUE);
1887
1888     // For binary opers.
1889     GenTreePtr gtNewOperNode(genTreeOps oper, var_types type, GenTreePtr op1, GenTreePtr op2);
1890
1891     GenTreePtr gtNewQmarkNode(var_types type, GenTreePtr cond, GenTreePtr colon);
1892
1893     GenTreePtr gtNewLargeOperNode(genTreeOps oper,
1894                                   var_types  type = TYP_I_IMPL,
1895                                   GenTreePtr op1  = nullptr,
1896                                   GenTreePtr op2  = nullptr);
1897
1898     GenTreeIntCon* gtNewIconNode(ssize_t value, var_types type = TYP_INT);
1899
1900     GenTree* gtNewPhysRegNode(regNumber reg, var_types type);
1901
1902     GenTree* gtNewPhysRegNode(regNumber reg, GenTree* src);
1903
1904     GenTreePtr gtNewJmpTableNode();
1905     GenTreePtr gtNewIconHandleNode(
1906         size_t value, unsigned flags, FieldSeqNode* fields = nullptr, unsigned handle1 = 0, void* handle2 = nullptr);
1907
1908     unsigned gtTokenToIconFlags(unsigned token);
1909
1910     GenTreePtr gtNewIconEmbHndNode(void*    value,
1911                                    void*    pValue,
1912                                    unsigned flags,
1913                                    unsigned handle1           = 0,
1914                                    void*    handle2           = nullptr,
1915                                    void*    compileTimeHandle = nullptr);
1916
1917     GenTreePtr gtNewIconEmbScpHndNode(CORINFO_MODULE_HANDLE scpHnd, unsigned hnd1 = 0, void* hnd2 = nullptr);
1918     GenTreePtr gtNewIconEmbClsHndNode(CORINFO_CLASS_HANDLE clsHnd, unsigned hnd1 = 0, void* hnd2 = nullptr);
1919     GenTreePtr gtNewIconEmbMethHndNode(CORINFO_METHOD_HANDLE methHnd, unsigned hnd1 = 0, void* hnd2 = nullptr);
1920     GenTreePtr gtNewIconEmbFldHndNode(CORINFO_FIELD_HANDLE fldHnd, unsigned hnd1 = 0, void* hnd2 = nullptr);
1921
1922     GenTreePtr gtNewStringLiteralNode(InfoAccessType iat, void* pValue);
1923
1924     GenTreePtr gtNewLconNode(__int64 value);
1925
1926     GenTreePtr gtNewDconNode(double value);
1927
1928     GenTreePtr gtNewSconNode(int CPX, CORINFO_MODULE_HANDLE scpHandle);
1929
1930     GenTreePtr gtNewZeroConNode(var_types type);
1931
1932     GenTreePtr gtNewOneConNode(var_types type);
1933
1934 #ifdef FEATURE_SIMD
1935     GenTreePtr gtNewSIMDVectorZero(var_types simdType, var_types baseType, unsigned size);
1936     GenTreePtr gtNewSIMDVectorOne(var_types simdType, var_types baseType, unsigned size);
1937 #endif
1938
1939     GenTreeBlk* gtNewBlkOpNode(
1940         genTreeOps oper, GenTreePtr dst, GenTreePtr srcOrFillVal, GenTreePtr sizeOrClsTok, bool isVolatile);
1941
1942     GenTree* gtNewBlkOpNode(GenTreePtr dst, GenTreePtr srcOrFillVal, unsigned size, bool isVolatile, bool isCopyBlock);
1943
1944 protected:
1945     void gtBlockOpInit(GenTreePtr result, GenTreePtr dst, GenTreePtr srcOrFillVal, bool isVolatile);
1946
1947 public:
1948     GenTree* gtNewObjNode(CORINFO_CLASS_HANDLE structHnd, GenTreePtr addr);
1949     void gtSetObjGcInfo(GenTreeObj* objNode);
1950     GenTree* gtNewStructVal(CORINFO_CLASS_HANDLE structHnd, GenTreePtr addr);
1951     GenTree* gtNewBlockVal(GenTreePtr addr, unsigned size);
1952
1953     GenTree* gtNewCpObjNode(GenTreePtr dst, GenTreePtr src, CORINFO_CLASS_HANDLE structHnd, bool isVolatile);
1954
1955     GenTreeArgList* gtNewListNode(GenTreePtr op1, GenTreeArgList* op2);
1956
1957     GenTreeCall* gtNewCallNode(gtCallTypes           callType,
1958                                CORINFO_METHOD_HANDLE handle,
1959                                var_types             type,
1960                                GenTreeArgList*       args,
1961                                IL_OFFSETX            ilOffset = BAD_IL_OFFSET);
1962
1963     GenTreeCall* gtNewIndCallNode(GenTreePtr      addr,
1964                                   var_types       type,
1965                                   GenTreeArgList* args,
1966                                   IL_OFFSETX      ilOffset = BAD_IL_OFFSET);
1967
1968     GenTreeCall* gtNewHelperCallNode(unsigned        helper,
1969                                      var_types       type,
1970                                      unsigned        flags = 0,
1971                                      GenTreeArgList* args  = nullptr);
1972
1973     GenTreePtr gtNewLclvNode(unsigned lnum, var_types type, IL_OFFSETX ILoffs = BAD_IL_OFFSET);
1974
1975 #ifdef FEATURE_SIMD
1976     GenTreeSIMD* gtNewSIMDNode(
1977         var_types type, GenTreePtr op1, SIMDIntrinsicID simdIntrinsicID, var_types baseType, unsigned size);
1978     GenTreeSIMD* gtNewSIMDNode(var_types       type,
1979                                GenTreePtr      op1,
1980                                GenTreePtr      op2,
1981                                SIMDIntrinsicID simdIntrinsicID,
1982                                var_types       baseType,
1983                                unsigned        size);
1984     void SetOpLclRelatedToSIMDIntrinsic(GenTreePtr op);
1985 #endif
1986
1987     GenTreePtr gtNewLclLNode(unsigned lnum, var_types type, IL_OFFSETX ILoffs = BAD_IL_OFFSET);
1988     GenTreeLclFld* gtNewLclFldNode(unsigned lnum, var_types type, unsigned offset);
1989     GenTreePtr gtNewInlineCandidateReturnExpr(GenTreePtr inlineCandidate, var_types type);
1990
1991     GenTreePtr gtNewCodeRef(BasicBlock* block);
1992
1993     GenTreePtr gtNewFieldRef(
1994         var_types typ, CORINFO_FIELD_HANDLE fldHnd, GenTreePtr obj = nullptr, DWORD offset = 0, bool nullcheck = false);
1995
1996     GenTreePtr gtNewIndexRef(var_types typ, GenTreePtr arrayOp, GenTreePtr indexOp);
1997
1998     GenTreeArgList* gtNewArgList(GenTreePtr op);
1999     GenTreeArgList* gtNewArgList(GenTreePtr op1, GenTreePtr op2);
2000     GenTreeArgList* gtNewArgList(GenTreePtr op1, GenTreePtr op2, GenTreePtr op3);
2001
2002     static fgArgTabEntryPtr gtArgEntryByArgNum(GenTreePtr call, unsigned argNum);
2003     static fgArgTabEntryPtr gtArgEntryByNode(GenTreePtr call, GenTreePtr node);
2004     fgArgTabEntryPtr gtArgEntryByLateArgIndex(GenTreePtr call, unsigned lateArgInx);
2005     bool gtArgIsThisPtr(fgArgTabEntryPtr argEntry);
2006
2007     GenTreePtr gtNewAssignNode(GenTreePtr dst, GenTreePtr src);
2008
2009     GenTreePtr gtNewTempAssign(unsigned tmp, GenTreePtr val);
2010
2011     GenTreePtr gtNewRefCOMfield(GenTreePtr              objPtr,
2012                                 CORINFO_RESOLVED_TOKEN* pResolvedToken,
2013                                 CORINFO_ACCESS_FLAGS    access,
2014                                 CORINFO_FIELD_INFO*     pFieldInfo,
2015                                 var_types               lclTyp,
2016                                 CORINFO_CLASS_HANDLE    structType,
2017                                 GenTreePtr              assg);
2018
2019     GenTreePtr gtNewNothingNode();
2020
2021     GenTreePtr gtNewArgPlaceHolderNode(var_types type, CORINFO_CLASS_HANDLE clsHnd);
2022
2023     GenTreePtr gtUnusedValNode(GenTreePtr expr);
2024
2025     GenTreePtr gtNewCastNode(var_types typ, GenTreePtr op1, var_types castType);
2026
2027     GenTreePtr gtNewCastNodeL(var_types typ, GenTreePtr op1, var_types castType);
2028
2029     GenTreePtr gtNewAllocObjNode(unsigned int helper, CORINFO_CLASS_HANDLE clsHnd, var_types type, GenTreePtr op1);
2030
2031     //------------------------------------------------------------------------
2032     // Other GenTree functions
2033
2034     GenTreePtr gtClone(GenTree* tree, bool complexOK = false);
2035
2036     // If `tree` is a lclVar with lclNum `varNum`, return an IntCns with value `varVal`; otherwise,
2037     // create a copy of `tree`, adding specified flags, replacing uses of lclVar `deepVarNum` with
2038     // IntCnses with value `deepVarVal`.
2039     GenTreePtr gtCloneExpr(
2040         GenTree* tree, unsigned addFlags, unsigned varNum, int varVal, unsigned deepVarNum, int deepVarVal);
2041
2042     // Create a copy of `tree`, optionally adding specifed flags, and optionally mapping uses of local
2043     // `varNum` to int constants with value `varVal`.
2044     GenTreePtr gtCloneExpr(GenTree* tree, unsigned addFlags = 0, unsigned varNum = (unsigned)-1, int varVal = 0)
2045     {
2046         return gtCloneExpr(tree, addFlags, varNum, varVal, varNum, varVal);
2047     }
2048
2049     GenTreePtr gtReplaceTree(GenTreePtr stmt, GenTreePtr tree, GenTreePtr replacementTree);
2050
2051     void gtUpdateSideEffects(GenTreePtr tree, unsigned oldGtFlags, unsigned newGtFlags);
2052
2053     // Returns "true" iff the complexity (not formally defined, but first interpretation
2054     // is #of nodes in subtree) of "tree" is greater than "limit".
2055     // (This is somewhat redundant with the "gtCostEx/gtCostSz" fields, but can be used
2056     // before they have been set.)
2057     bool gtComplexityExceeds(GenTreePtr* tree, unsigned limit);
2058
2059     bool gtCompareTree(GenTree* op1, GenTree* op2);
2060
2061     GenTreePtr gtReverseCond(GenTree* tree);
2062
2063     bool gtHasRef(GenTree* tree, ssize_t lclNum, bool defOnly);
2064
2065     bool gtHasLocalsWithAddrOp(GenTreePtr tree);
2066
2067     unsigned gtSetListOrder(GenTree* list, bool regs, bool isListCallArgs);
2068
2069     void gtWalkOp(GenTree** op1, GenTree** op2, GenTree* adr, bool constOnly);
2070
2071 #ifdef DEBUG
2072     unsigned gtHashValue(GenTree* tree);
2073
2074     GenTreePtr gtWalkOpEffectiveVal(GenTreePtr op);
2075 #endif
2076
2077     void gtPrepareCost(GenTree* tree);
2078     bool gtIsLikelyRegVar(GenTree* tree);
2079
2080     unsigned gtSetEvalOrderAndRestoreFPstkLevel(GenTree* tree);
2081
2082     // Returns true iff the secondNode can be swapped with firstNode.
2083     bool gtCanSwapOrder(GenTree* firstNode, GenTree* secondNode);
2084
2085     unsigned gtSetEvalOrder(GenTree* tree);
2086
2087 #if FEATURE_STACK_FP_X87
2088     bool gtFPstLvlRedo;
2089     void gtComputeFPlvls(GenTreePtr tree);
2090 #endif // FEATURE_STACK_FP_X87
2091
2092     void gtSetStmtInfo(GenTree* stmt);
2093
2094     // Returns "true" iff "node" has any of the side effects in "flags".
2095     bool gtNodeHasSideEffects(GenTreePtr node, unsigned flags);
2096
2097     // Returns "true" iff "tree" or its (transitive) children have any of the side effects in "flags".
2098     bool gtTreeHasSideEffects(GenTreePtr tree, unsigned flags);
2099
2100     // Appends 'expr' in front of 'list'
2101     //    'list' will typically start off as 'nullptr'
2102     //    when 'list' is non-null a GT_COMMA node is used to insert 'expr'
2103     GenTreePtr gtBuildCommaList(GenTreePtr list, GenTreePtr expr);
2104
2105     void gtExtractSideEffList(GenTreePtr  expr,
2106                               GenTreePtr* pList,
2107                               unsigned    flags      = GTF_SIDE_EFFECT,
2108                               bool        ignoreRoot = false);
2109
2110     GenTreePtr gtGetThisArg(GenTreePtr call);
2111
2112     // Static fields of struct types (and sometimes the types that those are reduced to) are represented by having the
2113     // static field contain an object pointer to the boxed struct.  This simplifies the GC implementation...but
2114     // complicates the JIT somewhat.  This predicate returns "true" iff a node with type "fieldNodeType", representing
2115     // the given "fldHnd", is such an object pointer.
2116     bool gtIsStaticFieldPtrToBoxedStruct(var_types fieldNodeType, CORINFO_FIELD_HANDLE fldHnd);
2117
2118     // Return true if call is a recursive call; return false otherwise.
2119     bool gtIsRecursiveCall(GenTreeCall* call)
2120     {
2121         return (call->gtCallMethHnd == info.compMethodHnd);
2122     }
2123
2124     //-------------------------------------------------------------------------
2125
2126     GenTreePtr gtFoldExpr(GenTreePtr tree);
2127     GenTreePtr
2128 #ifdef __clang__
2129         // TODO-Amd64-Unix: Remove this when the clang optimizer is fixed and/or the method implementation is
2130         // refactored in a simpler code. This is a workaround for a bug in the clang-3.5 optimizer. The issue is that in
2131         // release build the optimizer is mistyping (or just wrongly decides to use 32 bit operation for a corner case
2132         // of MIN_LONG) the args of the (ltemp / lval2) to int (it does a 32 bit div operation instead of 64 bit) - see
2133         // the implementation of the method in gentree.cpp. For the case of lval1 and lval2 equal to MIN_LONG
2134         // (0x8000000000000000) this results in raising a SIGFPE. The method implementation is rather complex. Disable
2135         // optimizations for now.
2136         __attribute__((optnone))
2137 #endif // __clang__
2138         gtFoldExprConst(GenTreePtr tree);
2139     GenTreePtr gtFoldExprSpecial(GenTreePtr tree);
2140     GenTreePtr gtFoldExprCompare(GenTreePtr tree);
2141
2142     //-------------------------------------------------------------------------
2143     // Get the handle, if any.
2144     CORINFO_CLASS_HANDLE gtGetStructHandleIfPresent(GenTreePtr tree);
2145     // Get the handle, and assert if not found.
2146     CORINFO_CLASS_HANDLE gtGetStructHandle(GenTreePtr tree);
2147
2148 //-------------------------------------------------------------------------
2149 // Functions to display the trees
2150
2151 #ifdef DEBUG
2152     void gtDispNode(GenTreePtr tree, IndentStack* indentStack, __in_z const char* msg, bool isLIR);
2153
2154     void gtDispVN(GenTreePtr tree);
2155     void gtDispConst(GenTreePtr tree);
2156     void gtDispLeaf(GenTreePtr tree, IndentStack* indentStack);
2157     void gtDispNodeName(GenTreePtr tree);
2158     void gtDispRegVal(GenTreePtr tree);
2159
2160     enum IndentInfo
2161     {
2162         IINone,
2163         IIArc,
2164         IIArcTop,
2165         IIArcBottom,
2166         IIEmbedded,
2167         IIError,
2168         IndentInfoCount
2169     };
2170     void gtDispChild(GenTreePtr           child,
2171                      IndentStack*         indentStack,
2172                      IndentInfo           arcType,
2173                      __in_opt const char* msg     = nullptr,
2174                      bool                 topOnly = false);
2175     void gtDispTree(GenTreePtr           tree,
2176                     IndentStack*         indentStack = nullptr,
2177                     __in_opt const char* msg         = nullptr,
2178                     bool                 topOnly     = false,
2179                     bool                 isLIR       = false);
2180     void gtGetLclVarNameInfo(unsigned lclNum, const char** ilKindOut, const char** ilNameOut, unsigned* ilNumOut);
2181     int gtGetLclVarName(unsigned lclNum, char* buf, unsigned buf_remaining);
2182     char* gtGetLclVarName(unsigned lclNum);
2183     void gtDispLclVar(unsigned varNum, bool padForBiggestDisp = true);
2184     void gtDispTreeList(GenTreePtr tree, IndentStack* indentStack = nullptr);
2185     void gtGetArgMsg(GenTreePtr call, GenTreePtr arg, unsigned argNum, int listCount, char* bufp, unsigned bufLength);
2186     void gtGetLateArgMsg(GenTreePtr call, GenTreePtr arg, int argNum, int listCount, char* bufp, unsigned bufLength);
2187     void gtDispArgList(GenTreePtr tree, IndentStack* indentStack);
2188     void gtDispFieldSeq(FieldSeqNode* pfsn);
2189
2190     void gtDispRange(LIR::ReadOnlyRange const& range);
2191
2192     void gtDispTreeRange(LIR::Range& containingRange, GenTree* tree);
2193
2194     void gtDispLIRNode(GenTree* node);
2195 #endif
2196
2197     // For tree walks
2198
2199     enum fgWalkResult
2200     {
2201         WALK_CONTINUE,
2202         WALK_SKIP_SUBTREES,
2203         WALK_ABORT
2204     };
2205     struct fgWalkData;
2206     typedef fgWalkResult(fgWalkPreFn)(GenTreePtr* pTree, fgWalkData* data);
2207     typedef fgWalkResult(fgWalkPostFn)(GenTreePtr* pTree, fgWalkData* data);
2208
2209 #ifdef DEBUG
2210     static fgWalkPreFn gtAssertColonCond;
2211 #endif
2212     static fgWalkPreFn gtMarkColonCond;
2213     static fgWalkPreFn gtClearColonCond;
2214
2215     GenTreePtr* gtFindLink(GenTreePtr stmt, GenTreePtr node);
2216     bool gtHasCatchArg(GenTreePtr tree);
2217     bool gtHasUnmanagedCall(GenTreePtr tree);
2218
2219     typedef ArrayStack<GenTree*> GenTreeStack;
2220
2221     static bool gtHasCallOnStack(GenTreeStack* parentStack);
2222     void gtCheckQuirkAddrExposedLclVar(GenTreePtr argTree, GenTreeStack* parentStack);
2223
2224 //=========================================================================
2225 // BasicBlock functions
2226 #ifdef DEBUG
2227     // This is a debug flag we will use to assert when creating block during codegen
2228     // as this interferes with procedure splitting. If you know what you're doing, set
2229     // it to true before creating the block. (DEBUG only)
2230     bool fgSafeBasicBlockCreation;
2231 #endif
2232
2233     BasicBlock* bbNewBasicBlock(BBjumpKinds jumpKind);
2234
2235     /*
2236     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2237     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2238     XX                                                                           XX
2239     XX                           LclVarsInfo                                     XX
2240     XX                                                                           XX
2241     XX   The variables to be used by the code generator.                         XX
2242     XX                                                                           XX
2243     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2244     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2245     */
2246
2247     //
2248     // For both PROMOTION_TYPE_NONE and PROMOTION_TYPE_DEPENDENT the struct will
2249     // be placed in the stack frame and it's fields must be laid out sequentially.
2250     //
2251     // For PROMOTION_TYPE_INDEPENDENT each of the struct's fields is replaced by
2252     //  a local variable that can be enregistered or placed in the stack frame.
2253     //  The fields do not need to be laid out sequentially
2254     //
2255     enum lvaPromotionType
2256     {
2257         PROMOTION_TYPE_NONE,        // The struct local is not promoted
2258         PROMOTION_TYPE_INDEPENDENT, // The struct local is promoted,
2259                                     //   and its field locals are independent of its parent struct local.
2260         PROMOTION_TYPE_DEPENDENT    // The struct local is promoted,
2261                                     //   but its field locals depend on its parent struct local.
2262     };
2263
2264     static int __cdecl RefCntCmp(const void* op1, const void* op2);
2265     static int __cdecl WtdRefCntCmp(const void* op1, const void* op2);
2266
2267     /*****************************************************************************/
2268
2269     enum FrameLayoutState
2270     {
2271         NO_FRAME_LAYOUT,
2272         INITIAL_FRAME_LAYOUT,
2273         PRE_REGALLOC_FRAME_LAYOUT,
2274         REGALLOC_FRAME_LAYOUT,
2275         TENTATIVE_FRAME_LAYOUT,
2276         FINAL_FRAME_LAYOUT
2277     };
2278
2279 public:
2280     bool     lvaRefCountingStarted; // Set to true when we have started counting the local vars
2281     bool     lvaLocalVarRefCounted; // Set to true after we have called lvaMarkLocalVars()
2282     bool     lvaSortAgain;          // true: We need to sort the lvaTable
2283     bool     lvaTrackedFixed;       // true: We cannot add new 'tracked' variable
2284     unsigned lvaCount;              // total number of locals
2285
2286     unsigned   lvaRefCount; // total number of references to locals
2287     LclVarDsc* lvaTable;    // variable descriptor table
2288     unsigned   lvaTableCnt; // lvaTable size (>= lvaCount)
2289
2290     LclVarDsc** lvaRefSorted; // table sorted by refcount
2291
2292     unsigned short lvaTrackedCount;       // actual # of locals being tracked
2293     unsigned lvaTrackedCountInSizeTUnits; // min # of size_t's sufficient to hold a bit for all the locals being tracked
2294
2295 #ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
2296     // Only for AMD64 System V cache the first caller stack homed argument.
2297     unsigned lvaFirstStackIncomingArgNum; // First argument with stack slot in the caller.
2298 #endif                                    // !FEATURE_UNIX_AMD64_STRUCT_PASSING
2299
2300 #ifdef DEBUG
2301     VARSET_TP lvaTrackedVars; // set of tracked variables
2302 #endif
2303 #ifndef _TARGET_64BIT_
2304     VARSET_TP lvaLongVars; // set of long (64-bit) variables
2305 #endif
2306     VARSET_TP lvaFloatVars; // set of floating-point (32-bit and 64-bit) variables
2307
2308     unsigned lvaCurEpoch; // VarSets are relative to a specific set of tracked var indices.
2309                           // It that changes, this changes.  VarSets from different epochs
2310                           // cannot be meaningfully combined.
2311
2312     unsigned GetCurLVEpoch()
2313     {
2314         return lvaCurEpoch;
2315     }
2316
2317     // reverse map of tracked number to var number
2318     unsigned lvaTrackedToVarNum[lclMAX_TRACKED];
2319
2320 #ifdef LEGACY_BACKEND
2321     // variable interference graph
2322     VARSET_TP lvaVarIntf[lclMAX_TRACKED];
2323 #endif
2324
2325     // variable preference graph
2326     VARSET_TP lvaVarPref[lclMAX_TRACKED];
2327
2328 #if DOUBLE_ALIGN
2329 #ifdef DEBUG
2330     // # of procs compiled a with double-aligned stack
2331     static unsigned s_lvaDoubleAlignedProcsCount;
2332 #endif
2333 #endif
2334
2335     // Getters and setters for address-exposed and do-not-enregister local var properties.
2336     bool lvaVarAddrExposed(unsigned varNum);
2337     void lvaSetVarAddrExposed(unsigned varNum);
2338     bool lvaVarDoNotEnregister(unsigned varNum);
2339 #ifdef DEBUG
2340     // Reasons why we can't enregister.  Some of these correspond to debug properties of local vars.
2341     enum DoNotEnregisterReason
2342     {
2343         DNER_AddrExposed,
2344         DNER_IsStruct,
2345         DNER_LocalField,
2346         DNER_VMNeedsStackAddr,
2347         DNER_LiveInOutOfHandler,
2348         DNER_LiveAcrossUnmanagedCall,
2349         DNER_BlockOp,     // Is read or written via a block operation that explicitly takes the address.
2350         DNER_IsStructArg, // Is a struct passed as an argument in a way that requires a stack location.
2351 #ifdef JIT32_GCENCODER
2352         DNER_PinningRef,
2353 #endif
2354     };
2355 #endif
2356     void lvaSetVarDoNotEnregister(unsigned varNum DEBUGARG(DoNotEnregisterReason reason));
2357
2358     unsigned lvaVarargsHandleArg;
2359 #ifdef _TARGET_X86_
2360     unsigned lvaVarargsBaseOfStkArgs; // Pointer (computed based on incoming varargs handle) to the start of the stack
2361                                       // arguments
2362 #endif                                // _TARGET_X86_
2363
2364     unsigned lvaInlinedPInvokeFrameVar; // variable representing the InlinedCallFrame
2365     unsigned lvaReversePInvokeFrameVar; // variable representing the reverse PInvoke frame
2366 #if FEATURE_FIXED_OUT_ARGS
2367     unsigned lvaPInvokeFrameRegSaveVar; // variable representing the RegSave for PInvoke inlining.
2368 #endif
2369     unsigned lvaMonAcquired; // boolean variable introduced into in synchronized methods
2370                              // that tracks whether the lock has been taken
2371
2372     unsigned lvaArg0Var; // The lclNum of arg0. Normally this will be info.compThisArg.
2373                          // However, if there is a "ldarga 0" or "starg 0" in the IL,
2374                          // we will redirect all "ldarg(a) 0" and "starg 0" to this temp.
2375
2376     unsigned lvaInlineeReturnSpillTemp; // The temp to spill the non-VOID return expression
2377                                         // in case there are multiple BBJ_RETURN blocks in the inlinee.
2378
2379 #if FEATURE_FIXED_OUT_ARGS
2380     unsigned lvaOutgoingArgSpaceVar;  // dummy TYP_LCLBLK var for fixed outgoing argument space
2381     unsigned lvaOutgoingArgSpaceSize; // size of fixed outgoing argument space
2382 #endif                                // FEATURE_FIXED_OUT_ARGS
2383
2384 #ifdef _TARGET_ARM_
2385     // On architectures whose ABIs allow structs to be passed in registers, struct promotion will sometimes
2386     // require us to "rematerialize" a struct from it's separate constituent field variables.  Packing several sub-word
2387     // field variables into an argument register is a hard problem.  It's easier to reserve a word of memory into which
2388     // such field can be copied, after which the assembled memory word can be read into the register.  We will allocate
2389     // this variable to be this scratch word whenever struct promotion occurs.
2390     unsigned lvaPromotedStructAssemblyScratchVar;
2391 #endif // _TARGET_ARM_
2392
2393 #ifdef DEBUG
2394     unsigned lvaReturnEspCheck; // confirms ESP not corrupted on return
2395     unsigned lvaCallEspCheck;   // confirms ESP not corrupted after a call
2396 #endif
2397
2398     bool lvaGenericsContextUsed;
2399
2400     bool lvaKeepAliveAndReportThis(); // Synchronized instance method of a reference type, or
2401                                       // CORINFO_GENERICS_CTXT_FROM_THIS?
2402     bool lvaReportParamTypeArg();     // Exceptions and CORINFO_GENERICS_CTXT_FROM_PARAMTYPEARG?
2403
2404 //-------------------------------------------------------------------------
2405 // All these frame offsets are inter-related and must be kept in sync
2406
2407 #if !FEATURE_EH_FUNCLETS
2408     // This is used for the callable handlers
2409     unsigned lvaShadowSPslotsVar; // TYP_BLK variable for all the shadow SP slots
2410 #endif                            // FEATURE_EH_FUNCLETS
2411
2412     unsigned lvaCachedGenericContextArgOffs;
2413     unsigned lvaCachedGenericContextArgOffset(); // For CORINFO_CALLCONV_PARAMTYPE and if generic context is passed as
2414                                                  // THIS pointer
2415
2416     unsigned lvaLocAllocSPvar; // variable which has the result of the last alloca/localloc
2417
2418     unsigned lvaNewObjArrayArgs; // variable with arguments for new MD array helper
2419
2420     // TODO-Review: Prior to reg predict we reserve 24 bytes for Spill temps.
2421     //              after the reg predict we will use a computed maxTmpSize
2422     //              which is based upon the number of spill temps predicted by reg predict
2423     //              All this is necessary because if we under-estimate the size of the spill
2424     //              temps we could fail when encoding instructions that reference stack offsets for ARM.
2425     //
2426     // Pre codegen max spill temp size.
2427     static const unsigned MAX_SPILL_TEMP_SIZE = 24;
2428
2429     //-------------------------------------------------------------------------
2430
2431     unsigned lvaGetMaxSpillTempSize();
2432 #ifdef _TARGET_ARM_
2433     bool lvaIsPreSpilled(unsigned lclNum, regMaskTP preSpillMask);
2434 #endif // _TARGET_ARM_
2435     void lvaAssignFrameOffsets(FrameLayoutState curState);
2436     void lvaFixVirtualFrameOffsets();
2437
2438 #ifndef LEGACY_BACKEND
2439     void lvaUpdateArgsWithInitialReg();
2440 #endif // !LEGACY_BACKEND
2441
2442     void lvaAssignVirtualFrameOffsetsToArgs();
2443 #ifdef UNIX_AMD64_ABI
2444     int lvaAssignVirtualFrameOffsetToArg(unsigned lclNum, unsigned argSize, int argOffs, int* callerArgOffset);
2445 #else  // !UNIX_AMD64_ABI
2446     int lvaAssignVirtualFrameOffsetToArg(unsigned lclNum, unsigned argSize, int argOffs);
2447 #endif // !UNIX_AMD64_ABI
2448     void lvaAssignVirtualFrameOffsetsToLocals();
2449     int lvaAllocLocalAndSetVirtualOffset(unsigned lclNum, unsigned size, int stkOffs);
2450 #ifdef _TARGET_AMD64_
2451     // Returns true if compCalleeRegsPushed (including RBP if used as frame pointer) is even.
2452     bool lvaIsCalleeSavedIntRegCountEven();
2453 #endif
2454     void lvaAlignFrame();
2455     void lvaAssignFrameOffsetsToPromotedStructs();
2456     int lvaAllocateTemps(int stkOffs, bool mustDoubleAlign);
2457
2458 #ifdef DEBUG
2459     void lvaDumpRegLocation(unsigned lclNum);
2460     void lvaDumpFrameLocation(unsigned lclNum);
2461     void lvaDumpEntry(unsigned lclNum, FrameLayoutState curState, size_t refCntWtdWidth = 6);
2462     void lvaTableDump(FrameLayoutState curState = NO_FRAME_LAYOUT); // NO_FRAME_LAYOUT means use the current frame
2463                                                                     // layout state defined by lvaDoneFrameLayout
2464 #endif
2465
2466 // Limit frames size to 1GB. The maximum is 2GB in theory - make it intentionally smaller
2467 // to avoid bugs from borderline cases.
2468 #define MAX_FrameSize 0x3FFFFFFF
2469     void lvaIncrementFrameSize(unsigned size);
2470
2471     unsigned lvaFrameSize(FrameLayoutState curState);
2472
2473     // Returns the caller-SP-relative offset for the SP/FP relative offset determined by FP based.
2474     int lvaToCallerSPRelativeOffset(int offs, bool isFpBased);
2475
2476     // Returns the caller-SP-relative offset for the local variable "varNum."
2477     int lvaGetCallerSPRelativeOffset(unsigned varNum);
2478
2479     // Returns the SP-relative offset for the local variable "varNum". Illegal to ask this for functions with localloc.
2480     int lvaGetSPRelativeOffset(unsigned varNum);
2481
2482     int lvaToInitialSPRelativeOffset(unsigned offset, bool isFpBased);
2483     int lvaGetInitialSPRelativeOffset(unsigned varNum);
2484
2485     //------------------------ For splitting types ----------------------------
2486
2487     void lvaInitTypeRef();
2488
2489     void lvaInitArgs(InitVarDscInfo* varDscInfo);
2490     void lvaInitThisPtr(InitVarDscInfo* varDscInfo);
2491     void lvaInitRetBuffArg(InitVarDscInfo* varDscInfo);
2492     void lvaInitUserArgs(InitVarDscInfo* varDscInfo);
2493     void lvaInitGenericsCtxt(InitVarDscInfo* varDscInfo);
2494     void lvaInitVarArgsHandle(InitVarDscInfo* varDscInfo);
2495
2496     void lvaInitVarDsc(LclVarDsc*              varDsc,
2497                        unsigned                varNum,
2498                        CorInfoType             corInfoType,
2499                        CORINFO_CLASS_HANDLE    typeHnd,
2500                        CORINFO_ARG_LIST_HANDLE varList,
2501                        CORINFO_SIG_INFO*       varSig);
2502
2503     static unsigned lvaTypeRefMask(var_types type);
2504
2505     var_types lvaGetActualType(unsigned lclNum);
2506     var_types lvaGetRealType(unsigned lclNum);
2507
2508     //-------------------------------------------------------------------------
2509
2510     void lvaInit();
2511
2512     unsigned lvaLclSize(unsigned varNum);
2513     unsigned lvaLclExactSize(unsigned varNum);
2514
2515     bool lvaLclVarRefs(GenTreePtr tree, GenTreePtr* findPtr, varRefKinds* refsPtr, void* result);
2516
2517     // Call lvaLclVarRefs on "true"; accumulate "*result" into whichever of
2518     // "allVars" and "trkdVars" is indiated by the nullness of "findPtr"; return
2519     // the return result.
2520     bool lvaLclVarRefsAccum(
2521         GenTreePtr tree, GenTreePtr* findPtr, varRefKinds* refsPtr, ALLVARSET_TP* allVars, VARSET_TP* trkdVars);
2522
2523     // If "findPtr" is non-NULL, assumes "result" is an "ALLVARSET_TP*", and
2524     // (destructively) unions "allVars" into "*result".  Otherwise, assumes "result" is a "VARSET_TP*",
2525     // and (destructively) unions "trkedVars" into "*result".
2526     void lvaLclVarRefsAccumIntoRes(GenTreePtr*         findPtr,
2527                                    void*               result,
2528                                    ALLVARSET_VALARG_TP allVars,
2529                                    VARSET_VALARG_TP    trkdVars);
2530
2531     bool lvaHaveManyLocals() const;
2532
2533     unsigned lvaGrabTemp(bool shortLifetime DEBUGARG(const char* reason));
2534     unsigned lvaGrabTemps(unsigned cnt DEBUGARG(const char* reason));
2535     unsigned lvaGrabTempWithImplicitUse(bool shortLifetime DEBUGARG(const char* reason));
2536
2537     void lvaSortOnly();
2538     void lvaSortByRefCount();
2539     void lvaDumpRefCounts();
2540
2541     void lvaMarkLocalVars(BasicBlock* block);
2542
2543     void lvaMarkLocalVars(); // Local variable ref-counting
2544
2545     void lvaAllocOutgoingArgSpace(); // 'Commit' lvaOutgoingArgSpaceSize and lvaOutgoingArgSpaceVar
2546
2547     VARSET_VALRET_TP lvaStmtLclMask(GenTreePtr stmt);
2548
2549     static fgWalkPreFn lvaIncRefCntsCB;
2550     void lvaIncRefCnts(GenTreePtr tree);
2551
2552     static fgWalkPreFn lvaDecRefCntsCB;
2553     void lvaDecRefCnts(GenTreePtr tree);
2554     void lvaDecRefCnts(BasicBlock* basicBlock, GenTreePtr tree);
2555     void lvaRecursiveDecRefCounts(GenTreePtr tree);
2556     void lvaRecursiveIncRefCounts(GenTreePtr tree);
2557
2558 #ifdef DEBUG
2559     struct lvaStressLclFldArgs
2560     {
2561         Compiler* m_pCompiler;
2562         bool      m_bFirstPass;
2563     };
2564
2565     static fgWalkPreFn lvaStressLclFldCB;
2566     void               lvaStressLclFld();
2567
2568     void lvaDispVarSet(VARSET_VALARG_TP set, VARSET_VALARG_TP allVars);
2569     void lvaDispVarSet(VARSET_VALARG_TP set);
2570
2571 #endif
2572
2573 #ifdef _TARGET_ARM_
2574     int lvaFrameAddress(int varNum, bool mustBeFPBased, regNumber* pBaseReg, int addrModeOffset);
2575 #else
2576     int lvaFrameAddress(int varNum, bool* pFPbased);
2577 #endif
2578
2579     bool lvaIsParameter(unsigned varNum);
2580     bool lvaIsRegArgument(unsigned varNum);
2581     BOOL lvaIsOriginalThisArg(unsigned varNum); // Is this varNum the original this argument?
2582     BOOL lvaIsOriginalThisReadOnly();           // return TRUE if there is no place in the code
2583                                                 // that writes to arg0
2584
2585     // Struct parameters that are passed by reference are marked as both lvIsParam and lvIsTemp
2586     // (this is an overload of lvIsTemp because there are no temp parameters).
2587     // For x64 this is 3, 5, 6, 7, >8 byte structs that are passed by reference.
2588     // For ARM64, this is structs larger than 16 bytes that are passed by reference.
2589     bool lvaIsImplicitByRefLocal(unsigned varNum)
2590     {
2591 #if defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
2592         LclVarDsc* varDsc = &(lvaTable[varNum]);
2593         if (varDsc->lvIsParam && varDsc->lvIsTemp)
2594         {
2595             assert((varDsc->lvType == TYP_STRUCT) || (varDsc->lvType == TYP_BYREF));
2596             return true;
2597         }
2598 #endif // defined(_TARGET_AMD64_) || defined(_TARGET_ARM64_)
2599         return false;
2600     }
2601
2602     // Returns true if this local var is a multireg struct
2603     bool lvaIsMultiregStruct(LclVarDsc* varDsc);
2604
2605     // If the class is a TYP_STRUCT, get/set a class handle describing it
2606
2607     CORINFO_CLASS_HANDLE lvaGetStruct(unsigned varNum);
2608     void lvaSetStruct(unsigned varNum, CORINFO_CLASS_HANDLE typeHnd, bool unsafeValueClsCheck, bool setTypeInfo = true);
2609
2610 #define MAX_NumOfFieldsInPromotableStruct 4 // Maximum number of fields in promotable struct
2611
2612     // Info about struct fields
2613     struct lvaStructFieldInfo
2614     {
2615         CORINFO_FIELD_HANDLE fldHnd;
2616         unsigned char        fldOffset;
2617         unsigned char        fldOrdinal;
2618         var_types            fldType;
2619         unsigned             fldSize;
2620         CORINFO_CLASS_HANDLE fldTypeHnd;
2621     };
2622
2623     // Info about struct to be promoted.
2624     struct lvaStructPromotionInfo
2625     {
2626         CORINFO_CLASS_HANDLE typeHnd;
2627         bool                 canPromote;
2628         bool                 requiresScratchVar;
2629         bool                 containsHoles;
2630         bool                 customLayout;
2631         unsigned char        fieldCnt;
2632         lvaStructFieldInfo   fields[MAX_NumOfFieldsInPromotableStruct];
2633
2634         lvaStructPromotionInfo()
2635             : typeHnd(nullptr), canPromote(false), requiresScratchVar(false), containsHoles(false), customLayout(false)
2636         {
2637         }
2638     };
2639
2640     static int __cdecl lvaFieldOffsetCmp(const void* field1, const void* field2);
2641     void lvaCanPromoteStructType(CORINFO_CLASS_HANDLE    typeHnd,
2642                                  lvaStructPromotionInfo* StructPromotionInfo,
2643                                  bool                    sortFields);
2644     void lvaCanPromoteStructVar(unsigned lclNum, lvaStructPromotionInfo* StructPromotionInfo);
2645     void lvaPromoteStructVar(unsigned lclNum, lvaStructPromotionInfo* StructPromotionInfo);
2646 #if !defined(_TARGET_64BIT_)
2647     void lvaPromoteLongVars();
2648 #endif // !defined(_TARGET_64BIT_)
2649     unsigned lvaGetFieldLocal(LclVarDsc* varDsc, unsigned int fldOffset);
2650     lvaPromotionType lvaGetPromotionType(const LclVarDsc* varDsc);
2651     lvaPromotionType lvaGetPromotionType(unsigned varNum);
2652     lvaPromotionType lvaGetParentPromotionType(const LclVarDsc* varDsc);
2653     lvaPromotionType lvaGetParentPromotionType(unsigned varNum);
2654     bool lvaIsFieldOfDependentlyPromotedStruct(const LclVarDsc* varDsc);
2655     bool lvaIsGCTracked(const LclVarDsc* varDsc);
2656
2657 #if defined(FEATURE_SIMD)
2658     bool lvaMapSimd12ToSimd16(const LclVarDsc* varDsc)
2659     {
2660         assert(varDsc->lvType == TYP_SIMD12);
2661         assert(varDsc->lvExactSize == 12);
2662
2663 #if defined(_TARGET_64BIT_)
2664         assert(varDsc->lvSize() == 16);
2665         return true;
2666 #else // !defined(_TARGET_64BIT_)
2667
2668         // For 32-bit architectures, we make local variable SIMD12 types 16 bytes instead of just 12. lvSize()
2669         // already does this calculation. However, we also need to prevent mapping types if the var is a
2670         // depenendently promoted struct field, which must remain its exact size within its parent struct.
2671         // However, we don't know this until late, so we may have already pretended the field is bigger
2672         // before that.
2673         if ((varDsc->lvSize() == 16) && !lvaIsFieldOfDependentlyPromotedStruct(varDsc))
2674         {
2675             return true;
2676         }
2677         else
2678         {
2679             return false;
2680         }
2681
2682 #endif // !defined(_TARGET_64BIT_)
2683     }
2684 #endif // defined(FEATURE_SIMD)
2685
2686     BYTE* lvaGetGcLayout(unsigned varNum);
2687     bool lvaTypeIsGC(unsigned varNum);
2688     unsigned lvaGSSecurityCookie; // LclVar number
2689     bool     lvaTempsHaveLargerOffsetThanVars();
2690
2691     unsigned lvaSecurityObject;  // variable representing the security object on the stack
2692     unsigned lvaStubArgumentVar; // variable representing the secret stub argument coming in EAX
2693
2694 #if FEATURE_EH_FUNCLETS
2695     unsigned lvaPSPSym; // variable representing the PSPSym
2696 #endif
2697
2698     InlineInfo*     impInlineInfo;
2699     InlineStrategy* m_inlineStrategy;
2700
2701     // The Compiler* that is the root of the inlining tree of which "this" is a member.
2702     Compiler* impInlineRoot();
2703
2704 #if defined(DEBUG) || defined(INLINE_DATA)
2705     unsigned __int64 getInlineCycleCount()
2706     {
2707         return m_compCycles;
2708     }
2709 #endif // defined(DEBUG) || defined(INLINE_DATA)
2710
2711     bool fgNoStructPromotion;      // Set to TRUE to turn off struct promotion for this method.
2712     bool fgNoStructParamPromotion; // Set to TRUE to turn off struct promotion for parameters this method.
2713
2714     //=========================================================================
2715     //                          PROTECTED
2716     //=========================================================================
2717
2718 protected:
2719 //---------------- Local variable ref-counting ----------------------------
2720
2721 #if ASSERTION_PROP
2722     BasicBlock* lvaMarkRefsCurBlock;
2723     GenTreePtr  lvaMarkRefsCurStmt;
2724 #endif
2725     BasicBlock::weight_t lvaMarkRefsWeight;
2726
2727     static fgWalkPreFn lvaMarkLclRefsCallback;
2728     void lvaMarkLclRefs(GenTreePtr tree);
2729
2730     // Keeps the mapping from SSA #'s to VN's for the implicit "Heap" variable.
2731     PerSsaArray lvHeapPerSsaData;
2732     unsigned    lvHeapNumSsaNames;
2733
2734 public:
2735     // Returns the address of the per-Ssa data for "Heap" at the given ssaNum (which is required
2736     // not to be the SsaConfig::RESERVED_SSA_NUM, which indicates that the variable is
2737     // not an SSA variable).
2738     LclSsaVarDsc* GetHeapPerSsaData(unsigned ssaNum)
2739     {
2740         assert(ssaNum != SsaConfig::RESERVED_SSA_NUM);
2741         assert(SsaConfig::RESERVED_SSA_NUM == 0);
2742         ssaNum--;
2743         assert(ssaNum < lvHeapNumSsaNames);
2744         return &lvHeapPerSsaData.GetRef(ssaNum);
2745     }
2746
2747     /*
2748     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2749     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2750     XX                                                                           XX
2751     XX                           Importer                                        XX
2752     XX                                                                           XX
2753     XX   Imports the given method and converts it to semantic trees              XX
2754     XX                                                                           XX
2755     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2756     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
2757     */
2758
2759 public:
2760     void impInit();
2761
2762     void impImport(BasicBlock* method);
2763
2764     CORINFO_CLASS_HANDLE impGetRefAnyClass();
2765     CORINFO_CLASS_HANDLE impGetRuntimeArgumentHandle();
2766     CORINFO_CLASS_HANDLE impGetTypeHandleClass();
2767     CORINFO_CLASS_HANDLE impGetStringClass();
2768     CORINFO_CLASS_HANDLE impGetObjectClass();
2769
2770     //=========================================================================
2771     //                          PROTECTED
2772     //=========================================================================
2773
2774 protected:
2775     //-------------------- Stack manipulation ---------------------------------
2776
2777     unsigned impStkSize; // Size of the full stack
2778
2779 #define SMALL_STACK_SIZE 16 // number of elements in impSmallStack
2780
2781     StackEntry impSmallStack[SMALL_STACK_SIZE]; // Use this array if possible
2782
2783     struct SavedStack // used to save/restore stack contents.
2784     {
2785         unsigned    ssDepth; // number of values on stack
2786         StackEntry* ssTrees; // saved tree values
2787     };
2788
2789     bool impIsPrimitive(CorInfoType type);
2790     bool impILConsumesAddr(const BYTE* codeAddr, CORINFO_METHOD_HANDLE fncHandle, CORINFO_MODULE_HANDLE scpHandle);
2791
2792     void impResolveToken(const BYTE* addr, CORINFO_RESOLVED_TOKEN* pResolvedToken, CorInfoTokenKind kind);
2793     void impPushOnStackNoType(GenTreePtr tree);
2794
2795     void impPushOnStack(GenTreePtr tree, typeInfo ti);
2796     void       impPushNullObjRefOnStack();
2797     StackEntry impPopStack();
2798     StackEntry impPopStack(CORINFO_CLASS_HANDLE& structTypeRet);
2799     GenTreePtr impPopStack(typeInfo& ti);
2800     StackEntry& impStackTop(unsigned n = 0);
2801
2802     void impSaveStackState(SavedStack* savePtr, bool copy);
2803     void impRestoreStackState(SavedStack* savePtr);
2804
2805     GenTreePtr impImportLdvirtftn(GenTreePtr              thisPtr,
2806                                   CORINFO_RESOLVED_TOKEN* pResolvedToken,
2807                                   CORINFO_CALL_INFO*      pCallInfo);
2808
2809     void impImportAndPushBox(CORINFO_RESOLVED_TOKEN* pResolvedToken);
2810
2811     void impImportNewObjArray(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_CALL_INFO* pCallInfo);
2812
2813     bool impCanPInvokeInline();
2814     bool impCanPInvokeInlineCallSite(BasicBlock* block);
2815     void impCheckForPInvokeCall(
2816         GenTreePtr call, CORINFO_METHOD_HANDLE methHnd, CORINFO_SIG_INFO* sig, unsigned mflags, BasicBlock* block);
2817     GenTreePtr impImportIndirectCall(CORINFO_SIG_INFO* sig, IL_OFFSETX ilOffset = BAD_IL_OFFSET);
2818     void impPopArgsForUnmanagedCall(GenTreePtr call, CORINFO_SIG_INFO* sig);
2819
2820     void impInsertHelperCall(CORINFO_HELPER_DESC* helperCall);
2821     void impHandleAccessAllowed(CorInfoIsAccessAllowedResult result, CORINFO_HELPER_DESC* helperCall);
2822     void impHandleAccessAllowedInternal(CorInfoIsAccessAllowedResult result, CORINFO_HELPER_DESC* helperCall);
2823
2824     void impInsertCalloutForDelegate(CORINFO_METHOD_HANDLE callerMethodHnd,
2825                                      CORINFO_METHOD_HANDLE calleeMethodHnd,
2826                                      CORINFO_CLASS_HANDLE  delegateTypeHnd);
2827
2828     var_types impImportCall(OPCODE                  opcode,
2829                             CORINFO_RESOLVED_TOKEN* pResolvedToken,
2830                             CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken, // Is this a "constrained." call on a
2831                                                                                // type parameter?
2832                             GenTreePtr         newobjThis,
2833                             int                prefixFlags,
2834                             CORINFO_CALL_INFO* callInfo,
2835                             IL_OFFSET          rawILOffset);
2836
2837     bool impMethodInfo_hasRetBuffArg(CORINFO_METHOD_INFO* methInfo);
2838
2839     GenTreePtr impFixupCallStructReturn(GenTreePtr call, CORINFO_CLASS_HANDLE retClsHnd);
2840
2841     GenTreePtr impFixupStructReturnType(GenTreePtr op, CORINFO_CLASS_HANDLE retClsHnd);
2842
2843 #ifdef DEBUG
2844     var_types impImportJitTestLabelMark(int numArgs);
2845 #endif // DEBUG
2846
2847     GenTreePtr impInitClass(CORINFO_RESOLVED_TOKEN* pResolvedToken);
2848
2849     GenTreePtr impImportStaticReadOnlyField(void* fldAddr, var_types lclTyp);
2850
2851     GenTreePtr impImportStaticFieldAccess(CORINFO_RESOLVED_TOKEN* pResolvedToken,
2852                                           CORINFO_ACCESS_FLAGS    access,
2853                                           CORINFO_FIELD_INFO*     pFieldInfo,
2854                                           var_types               lclTyp);
2855
2856     static void impBashVarAddrsToI(GenTreePtr tree1, GenTreePtr tree2 = nullptr);
2857
2858     GenTreePtr impImplicitIorI4Cast(GenTreePtr tree, var_types dstTyp);
2859
2860     GenTreePtr impImplicitR4orR8Cast(GenTreePtr tree, var_types dstTyp);
2861
2862     void impImportLeave(BasicBlock* block);
2863     void impResetLeaveBlock(BasicBlock* block, unsigned jmpAddr);
2864     GenTreePtr impIntrinsic(GenTreePtr            newobjThis,
2865                             CORINFO_CLASS_HANDLE  clsHnd,
2866                             CORINFO_METHOD_HANDLE method,
2867                             CORINFO_SIG_INFO*     sig,
2868                             int                   memberRef,
2869                             bool                  readonlyCall,
2870                             bool                  tailCall,
2871                             CorInfoIntrinsics*    pIntrinsicID);
2872     GenTreePtr impArrayAccessIntrinsic(CORINFO_CLASS_HANDLE clsHnd,
2873                                        CORINFO_SIG_INFO*    sig,
2874                                        int                  memberRef,
2875                                        bool                 readonlyCall,
2876                                        CorInfoIntrinsics    intrinsicID);
2877     GenTreePtr impInitializeArrayIntrinsic(CORINFO_SIG_INFO* sig);
2878
2879     GenTreePtr impMethodPointer(CORINFO_RESOLVED_TOKEN* pResolvedToken, CORINFO_CALL_INFO* pCallInfo);
2880
2881     GenTreePtr impTransformThis(GenTreePtr              thisPtr,
2882                                 CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken,
2883                                 CORINFO_THIS_TRANSFORM  transform);
2884
2885     //----------------- Manipulating the trees and stmts ----------------------
2886
2887     GenTreePtr impTreeList; // Trees for the BB being imported
2888     GenTreePtr impTreeLast; // The last tree for the current BB
2889
2890     enum
2891     {
2892         CHECK_SPILL_ALL  = -1,
2893         CHECK_SPILL_NONE = -2
2894     };
2895
2896 public:
2897     void impBeginTreeList();
2898     void impEndTreeList(BasicBlock* block, GenTreePtr firstStmt, GenTreePtr lastStmt);
2899     void impEndTreeList(BasicBlock* block);
2900     void impAppendStmtCheck(GenTreePtr stmt, unsigned chkLevel);
2901     void impAppendStmt(GenTreePtr stmt, unsigned chkLevel);
2902     void impInsertStmtBefore(GenTreePtr stmt, GenTreePtr stmtBefore);
2903     GenTreePtr impAppendTree(GenTreePtr tree, unsigned chkLevel, IL_OFFSETX offset);
2904     void impInsertTreeBefore(GenTreePtr tree, IL_OFFSETX offset, GenTreePtr stmtBefore);
2905     void impAssignTempGen(unsigned    tmp,
2906                           GenTreePtr  val,
2907                           unsigned    curLevel,
2908                           GenTreePtr* pAfterStmt = nullptr,
2909                           IL_OFFSETX  ilOffset   = BAD_IL_OFFSET,
2910                           BasicBlock* block      = nullptr);
2911     void impAssignTempGen(unsigned             tmpNum,
2912                           GenTreePtr           val,
2913                           CORINFO_CLASS_HANDLE structHnd,
2914                           unsigned             curLevel,
2915                           GenTreePtr*          pAfterStmt = nullptr,
2916                           IL_OFFSETX           ilOffset   = BAD_IL_OFFSET,
2917                           BasicBlock*          block      = nullptr);
2918     GenTreePtr impCloneExpr(GenTreePtr           tree,
2919                             GenTreePtr*          clone,
2920                             CORINFO_CLASS_HANDLE structHnd,
2921                             unsigned             curLevel,
2922                             GenTreePtr* pAfterStmt DEBUGARG(const char* reason));
2923     GenTreePtr impAssignStruct(GenTreePtr           dest,
2924                                GenTreePtr           src,
2925                                CORINFO_CLASS_HANDLE structHnd,
2926                                unsigned             curLevel,
2927                                GenTreePtr*          pAfterStmt = nullptr,
2928                                BasicBlock*          block      = nullptr);
2929     GenTreePtr impAssignStructPtr(GenTreePtr           dest,
2930                                   GenTreePtr           src,
2931                                   CORINFO_CLASS_HANDLE structHnd,
2932                                   unsigned             curLevel,
2933                                   GenTreePtr*          pAfterStmt = nullptr,
2934                                   BasicBlock*          block      = nullptr);
2935
2936     GenTreePtr impGetStructAddr(GenTreePtr           structVal,
2937                                 CORINFO_CLASS_HANDLE structHnd,
2938                                 unsigned             curLevel,
2939                                 bool                 willDeref);
2940
2941     var_types impNormStructType(CORINFO_CLASS_HANDLE structHnd,
2942                                 BYTE*                gcLayout     = nullptr,
2943                                 unsigned*            numGCVars    = nullptr,
2944                                 var_types*           simdBaseType = nullptr);
2945
2946     GenTreePtr impNormStructVal(GenTreePtr           structVal,
2947                                 CORINFO_CLASS_HANDLE structHnd,
2948                                 unsigned             curLevel,
2949                                 bool                 forceNormalization = false);
2950
2951     GenTreePtr impTokenToHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken,
2952                                 BOOL*                   pRuntimeLookup    = nullptr,
2953                                 BOOL                    mustRestoreHandle = FALSE,
2954                                 BOOL                    importParent      = FALSE);
2955
2956     GenTreePtr impParentClassTokenToHandle(CORINFO_RESOLVED_TOKEN* pResolvedToken,
2957                                            BOOL*                   pRuntimeLookup    = nullptr,
2958                                            BOOL                    mustRestoreHandle = FALSE)
2959     {
2960         return impTokenToHandle(pResolvedToken, pRuntimeLookup, mustRestoreHandle, TRUE);
2961     }
2962
2963     GenTreePtr impLookupToTree(CORINFO_RESOLVED_TOKEN* pResolvedToken,
2964                                CORINFO_LOOKUP*         pLookup,
2965                                unsigned                flags,
2966                                void*                   compileTimeHandle);
2967
2968     GenTreePtr getRuntimeContextTree(CORINFO_RUNTIME_LOOKUP_KIND kind);
2969
2970     GenTreePtr impRuntimeLookupToTree(CORINFO_RESOLVED_TOKEN* pResolvedToken,
2971                                       CORINFO_LOOKUP*         pLookup,
2972                                       void*                   compileTimeHandle);
2973
2974     GenTreePtr impReadyToRunLookupToTree(CORINFO_CONST_LOOKUP* pLookup, unsigned flags, void* compileTimeHandle);
2975
2976     GenTreePtr impReadyToRunHelperToTree(CORINFO_RESOLVED_TOKEN* pResolvedToken,
2977                                          CorInfoHelpFunc         helper,
2978                                          var_types               type,
2979                                          GenTreeArgList*         arg                = nullptr,
2980                                          CORINFO_LOOKUP_KIND*    pGenericLookupKind = nullptr);
2981
2982     GenTreePtr impCastClassOrIsInstToTree(GenTreePtr              op1,
2983                                           GenTreePtr              op2,
2984                                           CORINFO_RESOLVED_TOKEN* pResolvedToken,
2985                                           bool                    isCastClass);
2986
2987     bool VarTypeIsMultiByteAndCanEnreg(var_types            type,
2988                                        CORINFO_CLASS_HANDLE typeClass,
2989                                        unsigned*            typeSize,
2990                                        bool                 forReturn);
2991
2992     static bool IsIntrinsicImplementedByUserCall(CorInfoIntrinsics intrinsicId);
2993     static bool IsTargetIntrinsic(CorInfoIntrinsics intrinsicId);
2994     static bool IsMathIntrinsic(CorInfoIntrinsics intrinsicId);
2995     static bool IsMathIntrinsic(GenTreePtr tree);
2996
2997 private:
2998     //----------------- Importing the method ----------------------------------
2999
3000     CORINFO_CONTEXT_HANDLE impTokenLookupContextHandle; // The context used for looking up tokens.
3001
3002 #ifdef DEBUG
3003     unsigned    impCurOpcOffs;
3004     const char* impCurOpcName;
3005     bool        impNestedStackSpill;
3006
3007     // For displaying instrs with generated native code (-n:B)
3008     GenTreePtr impLastILoffsStmt; // oldest stmt added for which we did not gtStmtLastILoffs
3009     void       impNoteLastILoffs();
3010 #endif
3011
3012     /* IL offset of the stmt currently being imported. It gets set to
3013        BAD_IL_OFFSET after it has been set in the appended trees. Then it gets
3014        updated at IL offsets for which we have to report mapping info.
3015        It also includes flag bits, so use jitGetILoffs()
3016        to get the actual IL offset value.
3017     */
3018
3019     IL_OFFSETX impCurStmtOffs;
3020     void impCurStmtOffsSet(IL_OFFSET offs);
3021
3022     void impNoteBranchOffs();
3023
3024     unsigned impInitBlockLineInfo();
3025
3026     GenTreePtr impCheckForNullPointer(GenTreePtr obj);
3027     bool impIsThis(GenTreePtr obj);
3028     bool impIsLDFTN_TOKEN(const BYTE* delegateCreateStart, const BYTE* newobjCodeAddr);
3029     bool impIsDUP_LDVIRTFTN_TOKEN(const BYTE* delegateCreateStart, const BYTE* newobjCodeAddr);
3030     bool impIsAnySTLOC(OPCODE opcode)
3031     {
3032         return ((opcode == CEE_STLOC) || (opcode == CEE_STLOC_S) ||
3033                 ((opcode >= CEE_STLOC_0) && (opcode <= CEE_STLOC_3)));
3034     }
3035
3036     GenTreeArgList* impPopList(unsigned          count,
3037                                unsigned*         flagsPtr,
3038                                CORINFO_SIG_INFO* sig,
3039                                GenTreeArgList*   prefixTree = nullptr);
3040
3041     GenTreeArgList* impPopRevList(unsigned          count,
3042                                   unsigned*         flagsPtr,
3043                                   CORINFO_SIG_INFO* sig,
3044                                   unsigned          skipReverseCount = 0);
3045
3046     /*
3047      * Get current IL offset with stack-empty info incoporated
3048      */
3049     IL_OFFSETX impCurILOffset(IL_OFFSET offs, bool callInstruction = false);
3050
3051     //---------------- Spilling the importer stack ----------------------------
3052
3053     struct PendingDsc
3054     {
3055         PendingDsc*   pdNext;
3056         BasicBlock*   pdBB;
3057         SavedStack    pdSavedStack;
3058         ThisInitState pdThisPtrInit;
3059     };
3060
3061     PendingDsc* impPendingList; // list of BBs currently waiting to be imported.
3062     PendingDsc* impPendingFree; // Freed up dscs that can be reused
3063
3064     // We keep a byte-per-block map (dynamically extended) in the top-level Compiler object of a compilation.
3065     ExpandArray<BYTE> impPendingBlockMembers;
3066
3067     // Return the byte for "b" (allocating/extending impPendingBlockMembers if necessary.)
3068     // Operates on the map in the top-level ancestor.
3069     BYTE impGetPendingBlockMember(BasicBlock* blk)
3070     {
3071         return impInlineRoot()->impPendingBlockMembers.Get(blk->bbInd());
3072     }
3073
3074     // Set the byte for "b" to "val" (allocating/extending impPendingBlockMembers if necessary.)
3075     // Operates on the map in the top-level ancestor.
3076     void impSetPendingBlockMember(BasicBlock* blk, BYTE val)
3077     {
3078         impInlineRoot()->impPendingBlockMembers.Set(blk->bbInd(), val);
3079     }
3080
3081     bool impCanReimport;
3082
3083     bool impSpillStackEntry(unsigned level,
3084                             unsigned varNum
3085 #ifdef DEBUG
3086                             ,
3087                             bool        bAssertOnRecursion,
3088                             const char* reason
3089 #endif
3090                             );
3091
3092     void impSpillStackEnsure(bool spillLeaves = false);
3093     void impEvalSideEffects();
3094     void impSpillSpecialSideEff();
3095     void impSpillSideEffects(bool spillGlobEffects, unsigned chkLevel DEBUGARG(const char* reason));
3096     void               impSpillValueClasses();
3097     void               impSpillEvalStack();
3098     static fgWalkPreFn impFindValueClasses;
3099     void impSpillLclRefs(ssize_t lclNum);
3100
3101     BasicBlock* impPushCatchArgOnStack(BasicBlock* hndBlk, CORINFO_CLASS_HANDLE clsHnd);
3102
3103     void impImportBlockCode(BasicBlock* block);
3104
3105     void impReimportMarkBlock(BasicBlock* block);
3106     void impReimportMarkSuccessors(BasicBlock* block);
3107
3108     void impVerifyEHBlock(BasicBlock* block, bool isTryStart);
3109
3110     void impImportBlockPending(BasicBlock* block);
3111
3112     // Similar to impImportBlockPending, but assumes that block has already been imported once and is being
3113     // reimported for some reason.  It specifically does *not* look at verCurrentState to set the EntryState
3114     // for the block, but instead, just re-uses the block's existing EntryState.
3115     void impReimportBlockPending(BasicBlock* block);
3116
3117     var_types impGetByRefResultType(genTreeOps oper, bool fUnsigned, GenTreePtr* pOp1, GenTreePtr* pOp2);
3118
3119     void impImportBlock(BasicBlock* block);
3120
3121     // Assumes that "block" is a basic block that completes with a non-empty stack. We will assign the values
3122     // on the stack to local variables (the "spill temp" variables). The successor blocks will assume that
3123     // its incoming stack contents are in those locals. This requires "block" and its successors to agree on
3124     // the variables that will be used -- and for all the predecessors of those successors, and the
3125     // successors of those predecessors, etc. Call such a set of blocks closed under alternating
3126     // successor/predecessor edges a "spill clique." A block is a "predecessor" or "successor" member of the
3127     // clique (or, conceivably, both). Each block has a specified sequence of incoming and outgoing spill
3128     // temps. If "block" already has its outgoing spill temps assigned (they are always a contiguous series
3129     // of local variable numbers, so we represent them with the base local variable number), returns that.
3130     // Otherwise, picks a set of spill temps, and propagates this choice to all blocks in the spill clique of
3131     // which "block" is a member (asserting, in debug mode, that no block in this clique had its spill temps
3132     // chosen already. More precisely, that the incoming or outgoing spill temps are not chosen, depending
3133     // on which kind of member of the clique the block is).
3134     unsigned impGetSpillTmpBase(BasicBlock* block);
3135
3136     // Assumes that "block" is a basic block that completes with a non-empty stack. We have previously
3137     // assigned the values on the stack to local variables (the "spill temp" variables). The successor blocks
3138     // will assume that its incoming stack contents are in those locals. This requires "block" and its
3139     // successors to agree on the variables and their types that will be used.  The CLI spec allows implicit
3140     // conversions between 'int' and 'native int' or 'float' and 'double' stack types. So one predecessor can
3141     // push an int and another can push a native int.  For 64-bit we have chosen to implement this by typing
3142     // the "spill temp" as native int, and then importing (or re-importing as needed) so that all the
3143     // predecessors in the "spill clique" push a native int (sign-extending if needed), and all the
3144     // successors receive a native int. Similarly float and double are unified to double.
3145     // This routine is called after a type-mismatch is detected, and it will walk the spill clique to mark
3146     // blocks for re-importation as appropriate (both successors, so they get the right incoming type, and
3147     // predecessors, so they insert an upcast if needed).
3148     void impReimportSpillClique(BasicBlock* block);
3149
3150     // When we compute a "spill clique" (see above) these byte-maps are allocated to have a byte per basic
3151     // block, and represent the predecessor and successor members of the clique currently being computed.
3152     // *** Access to these will need to be locked in a parallel compiler.
3153     ExpandArray<BYTE> impSpillCliquePredMembers;
3154     ExpandArray<BYTE> impSpillCliqueSuccMembers;
3155
3156     enum SpillCliqueDir
3157     {
3158         SpillCliquePred,
3159         SpillCliqueSucc
3160     };
3161
3162     // Abstract class for receiving a callback while walking a spill clique
3163     class SpillCliqueWalker
3164     {
3165     public:
3166         virtual void Visit(SpillCliqueDir predOrSucc, BasicBlock* blk) = 0;
3167     };
3168
3169     // This class is used for setting the bbStkTempsIn and bbStkTempsOut on the blocks within a spill clique
3170     class SetSpillTempsBase : public SpillCliqueWalker
3171     {
3172         unsigned m_baseTmp;
3173
3174     public:
3175         SetSpillTempsBase(unsigned baseTmp) : m_baseTmp(baseTmp)
3176         {
3177         }
3178         virtual void Visit(SpillCliqueDir predOrSucc, BasicBlock* blk);
3179     };
3180
3181     // This class is used for implementing impReimportSpillClique part on each block within the spill clique
3182     class ReimportSpillClique : public SpillCliqueWalker
3183     {
3184         Compiler* m_pComp;
3185
3186     public:
3187         ReimportSpillClique(Compiler* pComp) : m_pComp(pComp)
3188         {
3189         }
3190         virtual void Visit(SpillCliqueDir predOrSucc, BasicBlock* blk);
3191     };
3192
3193     // This is the heart of the algorithm for walking spill cliques. It invokes callback->Visit for each
3194     // predecessor or successor within the spill clique
3195     void impWalkSpillCliqueFromPred(BasicBlock* pred, SpillCliqueWalker* callback);
3196
3197     // For a BasicBlock that has already been imported, the EntryState has an array of GenTrees for the
3198     // incoming locals. This walks that list an resets the types of the GenTrees to match the types of
3199     // the VarDscs. They get out of sync when we have int/native int issues (see impReimportSpillClique).
3200     void impRetypeEntryStateTemps(BasicBlock* blk);
3201
3202     BYTE impSpillCliqueGetMember(SpillCliqueDir predOrSucc, BasicBlock* blk);
3203     void impSpillCliqueSetMember(SpillCliqueDir predOrSucc, BasicBlock* blk, BYTE val);
3204
3205     void impPushVar(GenTree* op, typeInfo tiRetVal);
3206     void impLoadVar(unsigned lclNum, IL_OFFSET offset, typeInfo tiRetVal);
3207     void impLoadVar(unsigned lclNum, IL_OFFSET offset)
3208     {
3209         impLoadVar(lclNum, offset, lvaTable[lclNum].lvVerTypeInfo);
3210     }
3211     void impLoadArg(unsigned ilArgNum, IL_OFFSET offset);
3212     void impLoadLoc(unsigned ilLclNum, IL_OFFSET offset);
3213     bool impReturnInstruction(BasicBlock* block, int prefixFlags, OPCODE& opcode);
3214
3215 #ifdef _TARGET_ARM_
3216     void impMarkLclDstNotPromotable(unsigned tmpNum, GenTreePtr op, CORINFO_CLASS_HANDLE hClass);
3217 #endif
3218
3219     // A free list of linked list nodes used to represent to-do stacks of basic blocks.
3220     struct BlockListNode
3221     {
3222         BasicBlock*    m_blk;
3223         BlockListNode* m_next;
3224         BlockListNode(BasicBlock* blk, BlockListNode* next = nullptr) : m_blk(blk), m_next(next)
3225         {
3226         }
3227         void* operator new(size_t sz, Compiler* comp);
3228     };
3229     BlockListNode* impBlockListNodeFreeList;
3230
3231     BlockListNode* AllocBlockListNode();
3232     void FreeBlockListNode(BlockListNode* node);
3233
3234     bool impIsValueType(typeInfo* pTypeInfo);
3235     var_types mangleVarArgsType(var_types type);
3236
3237 #if FEATURE_VARARG
3238     regNumber getCallArgIntRegister(regNumber floatReg);
3239     regNumber getCallArgFloatRegister(regNumber intReg);
3240 #endif // FEATURE_VARARG
3241
3242 #if defined(DEBUG)
3243     static unsigned jitTotalMethodCompiled;
3244 #endif
3245
3246 #ifdef DEBUG
3247     static LONG jitNestingLevel;
3248 #endif // DEBUG
3249
3250     static BOOL impIsAddressInLocal(GenTreePtr tree, GenTreePtr* lclVarTreeOut);
3251
3252     void impMakeDiscretionaryInlineObservations(InlineInfo* pInlineInfo, InlineResult* inlineResult);
3253
3254     // STATIC inlining decision based on the IL code.
3255     void impCanInlineIL(CORINFO_METHOD_HANDLE fncHandle,
3256                         CORINFO_METHOD_INFO*  methInfo,
3257                         bool                  forceInline,
3258                         InlineResult*         inlineResult);
3259
3260     void impCheckCanInline(GenTreePtr             call,
3261                            CORINFO_METHOD_HANDLE  fncHandle,
3262                            unsigned               methAttr,
3263                            CORINFO_CONTEXT_HANDLE exactContextHnd,
3264                            InlineCandidateInfo**  ppInlineCandidateInfo,
3265                            InlineResult*          inlineResult);
3266
3267     void impInlineRecordArgInfo(InlineInfo*   pInlineInfo,
3268                                 GenTreePtr    curArgVal,
3269                                 unsigned      argNum,
3270                                 InlineResult* inlineResult);
3271
3272     void impInlineInitVars(InlineInfo* pInlineInfo);
3273
3274     unsigned impInlineFetchLocal(unsigned lclNum DEBUGARG(const char* reason));
3275
3276     GenTreePtr impInlineFetchArg(unsigned lclNum, InlArgInfo* inlArgInfo, InlLclVarInfo* lclTypeInfo);
3277
3278     BOOL impInlineIsThis(GenTreePtr tree, InlArgInfo* inlArgInfo);
3279
3280     BOOL impInlineIsGuaranteedThisDerefBeforeAnySideEffects(GenTreePtr  additionalTreesToBeEvaluatedBefore,
3281                                                             GenTreePtr  variableBeingDereferenced,
3282                                                             InlArgInfo* inlArgInfo);
3283
3284     void impMarkInlineCandidate(GenTreePtr call, CORINFO_CONTEXT_HANDLE exactContextHnd, CORINFO_CALL_INFO* callInfo);
3285
3286     bool impTailCallRetTypeCompatible(var_types            callerRetType,
3287                                       CORINFO_CLASS_HANDLE callerRetTypeClass,
3288                                       var_types            calleeRetType,
3289                                       CORINFO_CLASS_HANDLE calleeRetTypeClass);
3290
3291     bool impIsTailCallILPattern(bool        tailPrefixed,
3292                                 OPCODE      curOpcode,
3293                                 const BYTE* codeAddrOfNextOpcode,
3294                                 const BYTE* codeEnd,
3295                                 bool        isRecursive,
3296                                 bool*       IsCallPopRet = nullptr);
3297
3298     bool impIsImplicitTailCallCandidate(
3299         OPCODE curOpcode, const BYTE* codeAddrOfNextOpcode, const BYTE* codeEnd, int prefixFlags, bool isRecursive);
3300
3301     /*
3302     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
3303     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
3304     XX                                                                           XX
3305     XX                           FlowGraph                                       XX
3306     XX                                                                           XX
3307     XX   Info about the basic-blocks, their contents and the flow analysis       XX
3308     XX                                                                           XX
3309     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
3310     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
3311     */
3312
3313 public:
3314     BasicBlock* fgFirstBB;        // Beginning of the basic block list
3315     BasicBlock* fgLastBB;         // End of the basic block list
3316     BasicBlock* fgFirstColdBlock; // First block to be placed in the cold section
3317 #if FEATURE_EH_FUNCLETS
3318     BasicBlock* fgFirstFuncletBB; // First block of outlined funclets (to allow block insertion before the funclets)
3319 #endif
3320     BasicBlock* fgFirstBBScratch;   // Block inserted for initialization stuff. Is nullptr if no such block has been
3321                                     // created.
3322     BasicBlockList* fgReturnBlocks; // list of BBJ_RETURN blocks
3323     unsigned        fgEdgeCount;    // # of control flow edges between the BBs
3324     unsigned        fgBBcount;      // # of BBs in the method
3325 #ifdef DEBUG
3326     unsigned fgBBcountAtCodegen; // # of BBs in the method at the start of codegen
3327 #endif
3328     unsigned     fgBBNumMax;       // The max bbNum that has been assigned to basic blocks
3329     unsigned     fgDomBBcount;     // # of BBs for which we have dominator and reachability information
3330     BasicBlock** fgBBInvPostOrder; // The flow graph stored in an array sorted in topological order, needed to compute
3331                                    // dominance. Indexed by block number. Size: fgBBNumMax + 1.
3332
3333     // After the dominance tree is computed, we cache a DFS preorder number and DFS postorder number to compute
3334     // dominance queries in O(1). fgDomTreePreOrder and fgDomTreePostOrder are arrays giving the block's preorder and
3335     // postorder number, respectively. The arrays are indexed by basic block number. (Note that blocks are numbered
3336     // starting from one. Thus, we always waste element zero. This makes debugging easier and makes the code less likely
3337     // to suffer from bugs stemming from forgetting to add or subtract one from the block number to form an array
3338     // index). The arrays are of size fgBBNumMax + 1.
3339     unsigned* fgDomTreePreOrder;
3340     unsigned* fgDomTreePostOrder;
3341
3342     bool fgBBVarSetsInited;
3343
3344     // Allocate array like T* a = new T[fgBBNumMax + 1];
3345     // Using helper so we don't keep forgetting +1.
3346     template <typename T>
3347     T* fgAllocateTypeForEachBlk(CompMemKind cmk = CMK_Unknown)
3348     {
3349         return (T*)compGetMem((fgBBNumMax + 1) * sizeof(T), cmk);
3350     }
3351
3352     // BlockSets are relative to a specific set of BasicBlock numbers. If that changes
3353     // (if the blocks are renumbered), this changes. BlockSets from different epochs
3354     // cannot be meaningfully combined. Note that new blocks can be created with higher
3355     // block numbers without changing the basic block epoch. These blocks *cannot*
3356     // participate in a block set until the blocks are all renumbered, causing the epoch
3357     // to change. This is useful if continuing to use previous block sets is valuable.
3358     // If the epoch is zero, then it is uninitialized, and block sets can't be used.
3359     unsigned fgCurBBEpoch;
3360
3361     unsigned GetCurBasicBlockEpoch()
3362     {
3363         return fgCurBBEpoch;
3364     }
3365
3366     // The number of basic blocks in the current epoch. When the blocks are renumbered,
3367     // this is fgBBcount. As blocks are added, fgBBcount increases, fgCurBBEpochSize remains
3368     // the same, until a new BasicBlock epoch is created, such as when the blocks are all renumbered.
3369     unsigned fgCurBBEpochSize;
3370
3371     // The number of "size_t" elements required to hold a bitset large enough for fgCurBBEpochSize
3372     // bits. This is precomputed to avoid doing math every time BasicBlockBitSetTraits::GetArrSize() is called.
3373     unsigned fgBBSetCountInSizeTUnits;
3374
3375     void NewBasicBlockEpoch()
3376     {
3377         INDEBUG(unsigned oldEpochArrSize = fgBBSetCountInSizeTUnits);
3378
3379         // We have a new epoch. Compute and cache the size needed for new BlockSets.
3380         fgCurBBEpoch++;
3381         fgCurBBEpochSize = fgBBNumMax + 1;
3382         fgBBSetCountInSizeTUnits =
3383             unsigned(roundUp(fgCurBBEpochSize, sizeof(size_t) * 8)) / unsigned(sizeof(size_t) * 8);
3384
3385 #ifdef DEBUG
3386         // All BlockSet objects are now invalid!
3387         fgReachabilitySetsValid = false; // the bbReach sets are now invalid!
3388         fgEnterBlksSetValid     = false; // the fgEnterBlks set is now invalid!
3389
3390         if (verbose)
3391         {
3392             unsigned epochArrSize = BasicBlockBitSetTraits::GetArrSize(this, sizeof(size_t));
3393             printf("\nNew BlockSet epoch %d, # of blocks (including unused BB00): %u, bitset array size: %u (%s)",
3394                    fgCurBBEpoch, fgCurBBEpochSize, epochArrSize, (epochArrSize <= 1) ? "short" : "long");
3395             if ((fgCurBBEpoch != 1) && ((oldEpochArrSize <= 1) != (epochArrSize <= 1)))
3396             {
3397                 // If we're not just establishing the first epoch, and the epoch array size has changed such that we're
3398                 // going to change our bitset representation from short (just a size_t bitset) to long (a pointer to an
3399                 // array of size_t bitsets), then print that out.
3400                 printf("; NOTE: BlockSet size was previously %s!", (oldEpochArrSize <= 1) ? "short" : "long");
3401             }
3402             printf("\n");
3403         }
3404 #endif // DEBUG
3405     }
3406
3407     void EnsureBasicBlockEpoch()
3408     {
3409         if (fgCurBBEpochSize != fgBBNumMax + 1)
3410         {
3411             NewBasicBlockEpoch();
3412         }
3413     }
3414
3415     BasicBlock* fgNewBasicBlock(BBjumpKinds jumpKind);
3416     void fgEnsureFirstBBisScratch();
3417     bool fgFirstBBisScratch();
3418     bool fgBBisScratch(BasicBlock* block);
3419
3420     void fgExtendEHRegionBefore(BasicBlock* block);
3421     void fgExtendEHRegionAfter(BasicBlock* block);
3422
3423     BasicBlock* fgNewBBbefore(BBjumpKinds jumpKind, BasicBlock* block, bool extendRegion);
3424
3425     BasicBlock* fgNewBBafter(BBjumpKinds jumpKind, BasicBlock* block, bool extendRegion);
3426
3427     BasicBlock* fgNewBBinRegion(BBjumpKinds jumpKind,
3428                                 unsigned    tryIndex,
3429                                 unsigned    hndIndex,
3430                                 BasicBlock* nearBlk,
3431                                 bool        putInFilter = false,
3432                                 bool        runRarely   = false,
3433                                 bool        insertAtEnd = false);
3434
3435     BasicBlock* fgNewBBinRegion(BBjumpKinds jumpKind,
3436                                 BasicBlock* srcBlk,
3437                                 bool        runRarely   = false,
3438                                 bool        insertAtEnd = false);
3439
3440     BasicBlock* fgNewBBinRegion(BBjumpKinds jumpKind);
3441
3442     BasicBlock* fgNewBBinRegionWorker(BBjumpKinds jumpKind,
3443                                       BasicBlock* afterBlk,
3444                                       unsigned    xcptnIndex,
3445                                       bool        putInTryRegion);
3446
3447     void fgInsertBBbefore(BasicBlock* insertBeforeBlk, BasicBlock* newBlk);
3448     void fgInsertBBafter(BasicBlock* insertAfterBlk, BasicBlock* newBlk);
3449     void fgUnlinkBlock(BasicBlock* block);
3450
3451 #if OPT_BOOL_OPS // Used to detect multiple logical "not" assignments.
3452     bool fgMultipleNots;
3453 #endif
3454
3455     bool fgModified;         // True if the flow graph has been modified recently
3456     bool fgComputePredsDone; // Have we computed the bbPreds list
3457     bool fgCheapPredsValid;  // Is the bbCheapPreds list valid?
3458     bool fgDomsComputed;     // Have we computed the dominator sets?
3459     bool fgOptimizedFinally; // Did we optimize any try-finallys?
3460
3461     bool     fgHasSwitch;  // any BBJ_SWITCH jumps?
3462     bool     fgHasPostfix; // any postfix ++/-- found?
3463     unsigned fgIncrCount;  // number of increment nodes found
3464
3465     BlockSet fgEnterBlks; // Set of blocks which have a special transfer of control; the "entry" blocks plus EH handler
3466                           // begin blocks.
3467
3468 #ifdef DEBUG
3469     bool fgReachabilitySetsValid; // Are the bbReach sets valid?
3470     bool fgEnterBlksSetValid;     // Is the fgEnterBlks set valid?
3471 #endif                            // DEBUG
3472
3473     bool fgRemoveRestOfBlock; // true if we know that we will throw
3474     bool fgStmtRemoved;       // true if we remove statements -> need new DFA
3475
3476     // There are two modes for ordering of the trees.
3477     //  - In FGOrderTree, the dominant ordering is the tree order, and the nodes contained in
3478     //    each tree and sub-tree are contiguous, and can be traversed (in gtNext/gtPrev order)
3479     //    by traversing the tree according to the order of the operands.
3480     //  - In FGOrderLinear, the dominant ordering is the linear order.
3481
3482     enum FlowGraphOrder
3483     {
3484         FGOrderTree,
3485         FGOrderLinear
3486     };
3487     FlowGraphOrder fgOrder;
3488
3489     // The following are boolean flags that keep track of the state of internal data structures
3490
3491     bool                 fgStmtListThreaded;
3492     bool                 fgCanRelocateEHRegions;   // true if we are allowed to relocate the EH regions
3493     bool                 fgEdgeWeightsComputed;    // true after we have called fgComputeEdgeWeights
3494     bool                 fgHaveValidEdgeWeights;   // true if we were successful in computing all of the edge weights
3495     bool                 fgSlopUsedInEdgeWeights;  // true if their was some slop used when computing the edge weights
3496     bool                 fgRangeUsedInEdgeWeights; // true if some of the edgeWeight are expressed in Min..Max form
3497     bool                 fgNeedsUpdateFlowGraph;   // true if we need to run fgUpdateFlowGraph
3498     BasicBlock::weight_t fgCalledWeight;           // count of the number of times this method was called
3499                                                    // This is derived from the profile data
3500                                                    // or is BB_UNITY_WEIGHT when we don't have profile data
3501
3502 #if FEATURE_EH_FUNCLETS
3503     bool fgFuncletsCreated; // true if the funclet creation phase has been run
3504 #endif                      // FEATURE_EH_FUNCLETS
3505
3506     bool fgGlobalMorph;  // indicates if we are during the global morphing phase
3507                          // since fgMorphTree can be called from several places
3508     bool fgExpandInline; // indicates that we are creating tree for the inliner
3509
3510     bool     impBoxTempInUse; // the temp below is valid and available
3511     unsigned impBoxTemp;      // a temporary that is used for boxing
3512
3513 #ifdef DEBUG
3514     bool jitFallbackCompile; // Are we doing a fallback compile? That is, have we executed a NO_WAY assert,
3515                              //   and we are trying to compile again in a "safer", minopts mode?
3516 #endif
3517
3518 #if defined(DEBUG)
3519     unsigned impInlinedCodeSize;
3520 #endif
3521
3522     //-------------------------------------------------------------------------
3523
3524     void fgInit();
3525
3526     void fgImport();
3527
3528     void fgInline();
3529
3530     void fgRemoveEmptyTry();
3531
3532     void fgRemoveEmptyFinally();
3533
3534     void fgCloneFinally();
3535
3536     void fgCleanupContinuation(BasicBlock* continuation);
3537
3538     void fgUpdateFinallyTargetFlags();
3539
3540     GenTreePtr fgGetCritSectOfStaticMethod();
3541
3542 #if !defined(_TARGET_X86_)
3543
3544     void fgAddSyncMethodEnterExit();
3545
3546     GenTree* fgCreateMonitorTree(unsigned lvaMonitorBool, unsigned lvaThisVar, BasicBlock* block, bool enter);
3547
3548     void fgConvertSyncReturnToLeave(BasicBlock* block);
3549
3550 #endif // !_TARGET_X86_
3551
3552     void fgAddReversePInvokeEnterExit();
3553
3554     bool fgMoreThanOneReturnBlock();
3555
3556     // The number of separate return points in the method.
3557     unsigned fgReturnCount;
3558
3559     void fgAddInternal();
3560
3561     bool fgFoldConditional(BasicBlock* block);
3562
3563     void fgMorphStmts(BasicBlock* block, bool* mult, bool* lnot, bool* loadw);
3564     void fgMorphBlocks();
3565
3566     bool fgMorphBlockStmt(BasicBlock* block, GenTreeStmt* stmt DEBUGARG(const char* msg));
3567
3568     void fgCheckArgCnt();
3569     void fgSetOptions();
3570
3571 #ifdef DEBUG
3572     static fgWalkPreFn fgAssertNoQmark;
3573     void fgPreExpandQmarkChecks(GenTreePtr expr);
3574     void        fgPostExpandQmarkChecks();
3575     static void fgCheckQmarkAllowedForm(GenTreePtr tree);
3576 #endif
3577
3578     IL_OFFSET fgFindBlockILOffset(BasicBlock* block);
3579
3580     BasicBlock* fgSplitBlockAtBeginning(BasicBlock* curr);
3581     BasicBlock* fgSplitBlockAtEnd(BasicBlock* curr);
3582     BasicBlock* fgSplitBlockAfterStatement(BasicBlock* curr, GenTree* stmt);
3583     BasicBlock* fgSplitBlockAfterNode(BasicBlock* curr, GenTree* node); // for LIR
3584     BasicBlock* fgSplitEdge(BasicBlock* curr, BasicBlock* succ);
3585
3586     GenTreeStmt* fgNewStmtFromTree(GenTreePtr tree, BasicBlock* block, IL_OFFSETX offs);
3587     GenTreeStmt* fgNewStmtFromTree(GenTreePtr tree);
3588     GenTreeStmt* fgNewStmtFromTree(GenTreePtr tree, BasicBlock* block);
3589     GenTreeStmt* fgNewStmtFromTree(GenTreePtr tree, IL_OFFSETX offs);
3590
3591     GenTreePtr fgGetTopLevelQmark(GenTreePtr expr, GenTreePtr* ppDst = nullptr);
3592     void fgExpandQmarkForCastInstOf(BasicBlock* block, GenTreePtr stmt);
3593     void fgExpandQmarkStmt(BasicBlock* block, GenTreePtr expr);
3594     void fgExpandQmarkNodes();
3595
3596     void fgMorph();
3597
3598     // Do "simple lowering."  This functionality is (conceptually) part of "general"
3599     // lowering that is distributed between fgMorph and the lowering phase of LSRA.
3600     void fgSimpleLowering();
3601
3602     bool fgShouldCreateAssignOp(GenTreePtr tree, bool* bReverse);
3603
3604     GenTreePtr fgInitThisClass();
3605
3606     GenTreePtr fgGetStaticsCCtorHelper(CORINFO_CLASS_HANDLE cls, CorInfoHelpFunc helper);
3607
3608     GenTreePtr fgGetSharedCCtor(CORINFO_CLASS_HANDLE cls);
3609
3610     void fgLocalVarLiveness();
3611
3612     void fgLocalVarLivenessInit();
3613
3614 #ifdef LEGACY_BACKEND
3615     GenTreePtr fgLegacyPerStatementLocalVarLiveness(GenTreePtr startNode, GenTreePtr relopNode);
3616 #else
3617     void fgPerNodeLocalVarLiveness(GenTree* node);
3618 #endif
3619     void fgPerBlockLocalVarLiveness();
3620
3621     VARSET_VALRET_TP fgGetHandlerLiveVars(BasicBlock* block);
3622
3623     void fgLiveVarAnalysis(bool updateInternalOnly = false);
3624
3625     // This is used in the liveness computation, as a temporary.  When we use the
3626     // arbitrary-length VarSet representation, it is better not to allocate a new one
3627     // at each call.
3628     VARSET_TP fgMarkIntfUnionVS;
3629
3630     bool fgMarkIntf(VARSET_VALARG_TP varSet);
3631
3632     bool fgMarkIntf(VARSET_VALARG_TP varSet1, VARSET_VALARG_TP varSet2);
3633
3634     void fgUpdateRefCntForClone(BasicBlock* addedToBlock, GenTreePtr clonedTree);
3635
3636     void fgUpdateRefCntForExtract(GenTreePtr wholeTree, GenTreePtr keptTree);
3637
3638     void fgComputeLifeCall(VARSET_TP& life, GenTreeCall* call);
3639
3640     bool fgComputeLifeLocal(VARSET_TP& life, VARSET_TP& keepAliveVars, GenTree* lclVarNode, GenTree* node);
3641
3642     VARSET_VALRET_TP fgComputeLife(VARSET_VALARG_TP life,
3643                                    GenTreePtr       startNode,
3644                                    GenTreePtr       endNode,
3645                                    VARSET_VALARG_TP volatileVars,
3646                                    bool* pStmtInfoDirty DEBUGARG(bool* treeModf));
3647
3648     VARSET_VALRET_TP fgComputeLifeLIR(VARSET_VALARG_TP life, BasicBlock* block, VARSET_VALARG_TP volatileVars);
3649
3650     bool fgRemoveDeadStore(GenTree**  pTree,
3651                            LclVarDsc* varDsc,
3652                            VARSET_TP  life,
3653                            bool*      doAgain,
3654                            bool* pStmtInfoDirty DEBUGARG(bool* treeModf));
3655
3656     bool fgTryRemoveDeadLIRStore(LIR::Range& blockRange, GenTree* node, GenTree** next);
3657
3658     // For updating liveset during traversal AFTER fgComputeLife has completed
3659     VARSET_VALRET_TP fgGetVarBits(GenTreePtr tree);
3660     VARSET_VALRET_TP fgUpdateLiveSet(VARSET_VALARG_TP liveSet, GenTreePtr tree);
3661
3662     // Returns the set of live variables after endTree,
3663     // assuming that liveSet is the set of live variables BEFORE tree.
3664     // Requires that fgComputeLife has completed, and that tree is in the same
3665     // statement as endTree, and that it comes before endTree in execution order
3666
3667     VARSET_VALRET_TP fgUpdateLiveSet(VARSET_VALARG_TP liveSet, GenTreePtr tree, GenTreePtr endTree)
3668     {
3669         VARSET_TP VARSET_INIT(this, newLiveSet, liveSet);
3670         while (tree != nullptr && tree != endTree->gtNext)
3671         {
3672             VarSetOps::AssignNoCopy(this, newLiveSet, fgUpdateLiveSet(newLiveSet, tree));
3673             tree = tree->gtNext;
3674         }
3675         assert(tree == endTree->gtNext);
3676         return newLiveSet;
3677     }
3678
3679     void fgInterBlockLocalVarLiveness();
3680
3681     // The presence of "x op= y" operations presents some difficulties for SSA: this is both a use of some SSA name of
3682     // "x", and a def of a new SSA name for "x".  The tree only has one local variable for "x", so it has to choose
3683     // whether to treat that as the use or def.  It chooses the "use", and thus the old SSA name.  This map allows us
3684     // to record/recover the "def" SSA number, given the lcl var node for "x" in such a tree.
3685     typedef SimplerHashTable<GenTreePtr, PtrKeyFuncs<GenTree>, unsigned, JitSimplerHashBehavior> NodeToUnsignedMap;
3686     NodeToUnsignedMap* m_opAsgnVarDefSsaNums;
3687     NodeToUnsignedMap* GetOpAsgnVarDefSsaNums()
3688     {
3689         if (m_opAsgnVarDefSsaNums == nullptr)
3690         {
3691             m_opAsgnVarDefSsaNums = new (getAllocator()) NodeToUnsignedMap(getAllocator());
3692         }
3693         return m_opAsgnVarDefSsaNums;
3694     }
3695
3696     // Requires value numbering phase to have completed. Returns the value number ("gtVN") of the
3697     // "tree," EXCEPT in the case of GTF_VAR_USEASG, because the tree node's gtVN member is the
3698     // "use" VN. Performs a lookup into the map of (use asg tree -> def VN.) to return the "def's"
3699     // VN.
3700     inline ValueNum GetUseAsgDefVNOrTreeVN(GenTreePtr tree);
3701
3702     // Requires that "lcl" has the GTF_VAR_DEF flag set.  Returns the SSA number of "lcl".
3703     // Except: assumes that lcl is a def, and if it is
3704     // a def appearing in "lcl op= rhs" (GTF_VAR_USEASG), looks up and returns the SSA number for the "def",
3705     // rather than the "use" SSA number recorded in the tree "lcl".
3706     inline unsigned GetSsaNumForLocalVarDef(GenTreePtr lcl);
3707
3708     // Some assignments assign to a local "indirectly": they are part of a comma expression that takes the address
3709     // of the local (or a field thereof), assigns this address to a temp, and uses an indirection of this temp as
3710     // the LHS of the assignment.  This actually arises in exactly one situation.  At the source level we assign one
3711     // struct local to another: "s1 = s2".  This becomes a copyblk.  If "s2" is promoted into  field variables "s2f0",
3712     // ..."s2fn", then the copyblk will morph to a comma expression that takes the address of "s1" and does field-wise
3713     // assignments:
3714     //   (byref addrS1 = &s1,
3715     //    *(addrS1 * offsetof(f0)) = s2f0,
3716     //    ...
3717     //    *(addrS1 * offsetof(fn)) = s2fn)
3718     //
3719     // It would be a shame, given the simple form at the source level, to be unable to track the values in the
3720     // fields of "s1" after this.  But "s1" does not appear in the assignments that modify it.  How, then, to
3721     // give it SSA names and value numbers?
3722     //
3723     // The solution is to use the side table described below to annotate each of the field-wise assignments at the
3724     // end with an instance of the structure below, whose fields are described in the declaration.
3725     struct IndirectAssignmentAnnotation
3726     {
3727         unsigned      m_lclNum;   // The local num that is being indirectly assigned.
3728         FieldSeqNode* m_fieldSeq; // If the LHS of the struct assignment is itself a struct field dereference,
3729                                   // as in "s0.g = s2", then "m_lclNum" would be "s0", and "m_fieldSeq" would
3730                                   // be the singleton field sequence "g".  The individual assignments would
3731                                   // further append the fields of "s.g" to that.
3732         bool m_isEntire;          // True iff this assignment writes all of m_lclNum.  (This can occur if the
3733                                   // structure has a single field).
3734         unsigned m_defSsaNum;     // The new SSA number of "m_lclNum" after the assignment.
3735         unsigned m_useSsaNum;     // Only valid if "m_isEntire" is false; if so, the SSA number of "m_lclNum" before the
3736                                   // assignment.
3737
3738         IndirectAssignmentAnnotation(unsigned      lclNum,
3739                                      FieldSeqNode* fldSeq,
3740                                      bool          isEntire,
3741                                      unsigned      defSsaNum = SsaConfig::RESERVED_SSA_NUM,
3742                                      unsigned      useSsaNum = SsaConfig::RESERVED_SSA_NUM)
3743             : m_lclNum(lclNum), m_fieldSeq(fldSeq), m_isEntire(isEntire), m_defSsaNum(defSsaNum), m_useSsaNum(useSsaNum)
3744         {
3745         }
3746     };
3747     typedef SimplerHashTable<GenTreePtr, PtrKeyFuncs<GenTree>, IndirectAssignmentAnnotation*, JitSimplerHashBehavior>
3748                           NodeToIndirAssignMap;
3749     NodeToIndirAssignMap* m_indirAssignMap;
3750     NodeToIndirAssignMap* GetIndirAssignMap()
3751     {
3752         if (m_indirAssignMap == nullptr)
3753         {
3754             // Create a CompAllocator that labels sub-structure with CMK_IndirAssignMap, and use that for allocation.
3755             IAllocator* ialloc = new (this, CMK_IndirAssignMap) CompAllocator(this, CMK_IndirAssignMap);
3756             m_indirAssignMap   = new (ialloc) NodeToIndirAssignMap(ialloc);
3757         }
3758         return m_indirAssignMap;
3759     }
3760
3761     // Performs SSA conversion.
3762     void fgSsaBuild();
3763
3764     // Reset any data structures to the state expected by "fgSsaBuild", so it can be run again.
3765     void fgResetForSsa();
3766
3767     unsigned fgSsaPassesCompleted; // Number of times fgSsaBuild has been run.
3768
3769     // Returns "true" iff lcl "lclNum" should be excluded from SSA.
3770     inline bool fgExcludeFromSsa(unsigned lclNum);
3771
3772     // The value numbers for this compilation.
3773     ValueNumStore* vnStore;
3774
3775 public:
3776     ValueNumStore* GetValueNumStore()
3777     {
3778         return vnStore;
3779     }
3780
3781     // Do value numbering (assign a value number to each
3782     // tree node).
3783     void fgValueNumber();
3784
3785     // Updates "fgCurHeap" via the assignment H[elemTypeEq][arrVN][inx][fldSeq] = rhsVN.
3786     // Assumes that "elemTypeEq" is the (equivalence class rep) of the array element type.
3787     // The 'indType' is the indirection type of the lhs of the assignment and will typically
3788     // match the element type of the array or fldSeq.  When this type doesn't match
3789     // or if the fldSeq is 'NotAField' we invalidate the array contents H[elemTypeEq][arrVN]
3790     //
3791     void fgValueNumberArrIndexAssign(CORINFO_CLASS_HANDLE elemTypeEq,
3792                                      ValueNum             arrVN,
3793                                      ValueNum             inxVN,
3794                                      FieldSeqNode*        fldSeq,
3795                                      ValueNum             rhsVN,
3796                                      var_types            indType);
3797
3798     // Requires that "tree" is a GT_IND marked as an array index, and that its address argument
3799     // has been parsed to yield the other input arguments.  If evaluation of the address
3800     // can raise exceptions, those should be captured in the exception set "excVN."
3801     // Assumes that "elemTypeEq" is the (equivalence class rep) of the array element type.
3802     // Marks "tree" with the VN for H[elemTypeEq][arrVN][inx][fldSeq] (for the liberal VN; a new unique
3803     // VN for the conservative VN.)  Also marks the tree's argument as the address of an array element.
3804     // The type tree->TypeGet() will typically match the element type of the array or fldSeq.
3805     // When this type doesn't match or if the fldSeq is 'NotAField' we return a new unique VN
3806     //
3807     ValueNum fgValueNumberArrIndexVal(GenTreePtr           tree,
3808                                       CORINFO_CLASS_HANDLE elemTypeEq,
3809                                       ValueNum             arrVN,
3810                                       ValueNum             inxVN,
3811                                       ValueNum             excVN,
3812                                       FieldSeqNode*        fldSeq);
3813
3814     // Requires "funcApp" to be a VNF_PtrToArrElem, and "addrXvn" to represent the exception set thrown
3815     // by evaluating the array index expression "tree".  Returns the value number resulting from
3816     // dereferencing the array in the current heap state.  If "tree" is non-null, it must be the
3817     // "GT_IND" that does the dereference, and it is given the returned value number.
3818     ValueNum fgValueNumberArrIndexVal(GenTreePtr tree, struct VNFuncApp* funcApp, ValueNum addrXvn);
3819
3820     unsigned fgVNPassesCompleted; // Number of times fgValueNumber has been run.
3821
3822     // Utility functions for fgValueNumber.
3823
3824     // Perform value-numbering for the trees in "blk".
3825     void fgValueNumberBlock(BasicBlock* blk);
3826
3827     // Requires that "entryBlock" is the entry block of loop "loopNum", and that "loopNum" is the
3828     // innermost loop of which "entryBlock" is the entry.  Returns the value number that should be
3829     // assumed for the heap at the start "entryBlk".
3830     ValueNum fgHeapVNForLoopSideEffects(BasicBlock* entryBlock, unsigned loopNum);
3831
3832     // Called when an operation (performed by "tree", described by "msg") may cause the global Heap to be mutated.
3833     void fgMutateHeap(GenTreePtr tree DEBUGARG(const char* msg));
3834
3835     // Tree caused an update in the current heap VN.  If "tree" has an associated heap SSA #, record that
3836     // value in that SSA #.
3837     void fgValueNumberRecordHeapSsa(GenTreePtr tree);
3838
3839     // The input 'tree' is a leaf node that is a constant
3840     // Assign the proper value number to the tree
3841     void fgValueNumberTreeConst(GenTreePtr tree);
3842
3843     // Assumes that all inputs to "tree" have had value numbers assigned; assigns a VN to tree.
3844     // (With some exceptions: the VN of the lhs of an assignment is assigned as part of the
3845     // assignment.)
3846     // If "evalAsgLhsInd" is true, evaluate a GT_IND node, even if it's labeled as the LHS of
3847     // an assignment.
3848     void fgValueNumberTree(GenTreePtr tree, bool evalAsgLhsInd = false);
3849
3850     // Does value-numbering for a block assignment.
3851     void fgValueNumberBlockAssignment(GenTreePtr tree, bool evalAsgLhsInd);
3852
3853     // Does value-numbering for a cast tree.
3854     void fgValueNumberCastTree(GenTreePtr tree);
3855
3856     // Does value-numbering for an intrinsic tree.
3857     void fgValueNumberIntrinsic(GenTreePtr tree);
3858
3859     // Does value-numbering for a call.  We interpret some helper calls.
3860     void fgValueNumberCall(GenTreeCall* call);
3861
3862     // The VN of some nodes in "args" may have changed -- reassign VNs to the arg list nodes.
3863     void fgUpdateArgListVNs(GenTreeArgList* args);
3864
3865     // Does value-numbering for a helper "call" that has a VN function symbol "vnf".
3866     void fgValueNumberHelperCallFunc(GenTreeCall* call, VNFunc vnf, ValueNumPair vnpExc);
3867
3868     // Requires "helpCall" to be a helper call.  Assigns it a value number;
3869     // we understand the semantics of some of the calls.  Returns "true" if
3870     // the call may modify the heap (we assume arbitrary memory side effects if so).
3871     bool fgValueNumberHelperCall(GenTreeCall* helpCall);
3872
3873     // Requires "helpFunc" to be pure.  Returns the corresponding VNFunc.
3874     VNFunc fgValueNumberHelperMethVNFunc(CorInfoHelpFunc helpFunc);
3875
3876     // This is the current value number for the "Heap" implicit variable while
3877     // doing value numbering.  This is the value number under the "liberal" interpretation
3878     // of heap values; the "conservative" interpretation needs no VN, since every access of
3879     // the heap yields an unknown value.
3880     ValueNum fgCurHeapVN;
3881
3882     // Return a "pseudo"-class handle for an array element type.  If "elemType" is TYP_STRUCT,
3883     // requires "elemStructType" to be non-null (and to have a low-order zero).  Otherwise, low order bit
3884     // is 1, and the rest is an encoding of "elemTyp".
3885     static CORINFO_CLASS_HANDLE EncodeElemType(var_types elemTyp, CORINFO_CLASS_HANDLE elemStructType)
3886     {
3887         if (elemStructType != nullptr)
3888         {
3889             assert(varTypeIsStruct(elemTyp) || elemTyp == TYP_REF || elemTyp == TYP_BYREF ||
3890                    varTypeIsIntegral(elemTyp));
3891             assert((size_t(elemStructType) & 0x1) == 0x0); // Make sure the encoding below is valid.
3892             return elemStructType;
3893         }
3894         else
3895         {
3896             elemTyp = varTypeUnsignedToSigned(elemTyp);
3897             return CORINFO_CLASS_HANDLE(size_t(elemTyp) << 1 | 0x1);
3898         }
3899     }
3900     // If "clsHnd" is the result of an "EncodePrim" call, returns true and sets "*pPrimType" to the
3901     // var_types it represents.  Otherwise, returns TYP_STRUCT (on the assumption that "clsHnd" is
3902     // the struct type of the element).
3903     static var_types DecodeElemType(CORINFO_CLASS_HANDLE clsHnd)
3904     {
3905         size_t clsHndVal = size_t(clsHnd);
3906         if (clsHndVal & 0x1)
3907         {
3908             return var_types(clsHndVal >> 1);
3909         }
3910         else
3911         {
3912             return TYP_STRUCT;
3913         }
3914     }
3915
3916     // Convert a BYTE which represents the VM's CorInfoGCtype to the JIT's var_types
3917     var_types getJitGCType(BYTE gcType);
3918
3919     enum structPassingKind
3920     {
3921         SPK_Unknown,       // Invalid value, never returned
3922         SPK_PrimitiveType, // The struct is passed/returned using a primitive type.
3923         SPK_ByValue,       // The struct is passed/returned by value (using the ABI rules)
3924                            //  for ARM64 and UNIX_X64 in multiple registers. (when all of the
3925                            //   parameters registers are used, then the stack will be used)
3926                            //  for X86 passed on the stack, for ARM32 passed in registers
3927                            //   or the stack or split between registers and the stack.
3928         SPK_ByValueAsHfa,  // The struct is passed/returned as an HFA in multiple registers.
3929         SPK_ByReference
3930     }; // The struct is passed/returned by reference to a copy/buffer.
3931
3932     // Get the "primitive" type that is is used when we are given a struct of size 'structSize'.
3933     // For pointer sized structs the 'clsHnd' is used to determine if the struct contains GC ref.
3934     // A "primitive" type is one of the scalar types: byte, short, int, long, ref, float, double
3935     // If we can't or shouldn't use a "primitive" type then TYP_UNKNOWN is returned.
3936     //
3937     var_types getPrimitiveTypeForStruct(unsigned structSize, CORINFO_CLASS_HANDLE clsHnd);
3938
3939     // Get the type that is used to pass values of the given struct type.
3940     // If you have already retrieved the struct size then pass it as the optional third argument
3941     //
3942     var_types getArgTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
3943                                   structPassingKind*   wbPassStruct,
3944                                   unsigned             structSize = 0);
3945
3946     // Get the type that is used to return values of the given struct type.
3947     // If you have already retrieved the struct size then pass it as the optional third argument
3948     //
3949     var_types getReturnTypeForStruct(CORINFO_CLASS_HANDLE clsHnd,
3950                                      structPassingKind*   wbPassStruct = nullptr,
3951                                      unsigned             structSize   = 0);
3952
3953 #ifdef DEBUG
3954     // Print a representation of "vnp" or "vn" on standard output.
3955     // If "level" is non-zero, we also print out a partial expansion of the value.
3956     void vnpPrint(ValueNumPair vnp, unsigned level);
3957     void vnPrint(ValueNum vn, unsigned level);
3958 #endif
3959
3960     // Dominator computation member functions
3961     // Not exposed outside Compiler
3962 protected:
3963     bool fgDominate(BasicBlock* b1, BasicBlock* b2); // Return true if b1 dominates b2
3964
3965     bool fgReachable(BasicBlock* b1, BasicBlock* b2); // Returns true if block b1 can reach block b2
3966
3967     void fgComputeDoms(); // Computes the immediate dominators for each basic block in the
3968                           // flow graph.  We first assume the fields bbIDom on each
3969                           // basic block are invalid. This computation is needed later
3970                           // by fgBuildDomTree to build the dominance tree structure.
3971                           // Based on: A Simple, Fast Dominance Algorithm
3972                           // by Keith D. Cooper, Timothy J. Harvey, and Ken Kennedy
3973
3974     BlockSet_ValRet_T fgGetDominatorSet(BasicBlock* block); // Returns a set of blocks that dominate the given block.
3975     // Note: this is relatively slow compared to calling fgDominate(),
3976     // especially if dealing with a single block versus block check.
3977
3978     void fgComputeReachabilitySets(); // Compute bbReach sets. (Also sets BBF_GC_SAFE_POINT flag on blocks.)
3979
3980     void fgComputeEnterBlocksSet(); // Compute the set of entry blocks, 'fgEnterBlks'.
3981
3982     bool fgRemoveUnreachableBlocks(); // Remove blocks determined to be unreachable by the bbReach sets.
3983
3984     void fgComputeReachability(); // Perform flow graph node reachability analysis.
3985
3986     BasicBlock* fgIntersectDom(BasicBlock* a, BasicBlock* b); // Intersect two immediate dominator sets.
3987
3988     void fgDfsInvPostOrder(); // In order to compute dominance using fgIntersectDom, the flow graph nodes must be
3989                               // processed in topological sort, this function takes care of that.
3990
3991     void fgDfsInvPostOrderHelper(BasicBlock* block, BlockSet& visited, unsigned* count);
3992
3993     BlockSet_ValRet_T fgDomFindStartNodes(); // Computes which basic blocks don't have incoming edges in the flow graph.
3994                                              // Returns this as a set.
3995
3996     BlockSet_ValRet_T fgDomTreeEntryNodes(BasicBlockList** domTree); // Computes which nodes in the dominance forest are
3997                                                                      // root nodes. Returns this as a set.
3998
3999 #ifdef DEBUG
4000     void fgDispDomTree(BasicBlockList** domTree); // Helper that prints out the Dominator Tree in debug builds.
4001 #endif                                            // DEBUG
4002
4003     void fgBuildDomTree(); // Once we compute all the immediate dominator sets for each node in the flow graph
4004                            // (performed by fgComputeDoms), this procedure builds the dominance tree represented
4005                            // adjacency lists.
4006
4007     // In order to speed up the queries of the form 'Does A dominates B', we can perform a DFS preorder and postorder
4008     // traversal of the dominance tree and the dominance query will become A dominates B iif preOrder(A) <= preOrder(B)
4009     // && postOrder(A) >= postOrder(B) making the computation O(1).
4010     void fgTraverseDomTree(unsigned bbNum, BasicBlockList** domTree, unsigned* preNum, unsigned* postNum);
4011
4012     // When the flow graph changes, we need to update the block numbers, predecessor lists, reachability sets, and
4013     // dominators.
4014     void fgUpdateChangedFlowGraph();
4015
4016 public:
4017     // Compute the predecessors of the blocks in the control flow graph.
4018     void fgComputePreds();
4019
4020     // Remove all predecessor information.
4021     void fgRemovePreds();
4022
4023     // Compute the cheap flow graph predecessors lists. This is used in some early phases
4024     // before the full predecessors lists are computed.
4025     void fgComputeCheapPreds();
4026
4027 private:
4028     void fgAddCheapPred(BasicBlock* block, BasicBlock* blockPred);
4029
4030     void fgRemoveCheapPred(BasicBlock* block, BasicBlock* blockPred);
4031
4032 public:
4033     enum GCPollType
4034     {
4035         GCPOLL_NONE,
4036         GCPOLL_CALL,
4037         GCPOLL_INLINE
4038     };
4039
4040     // Initialize the per-block variable sets (used for liveness analysis).
4041     void fgInitBlockVarSets();
4042
4043     // true if we've gone through and created GC Poll calls.
4044     bool fgGCPollsCreated;
4045     void fgMarkGCPollBlocks();
4046     void fgCreateGCPolls();
4047     bool fgCreateGCPoll(GCPollType pollType, BasicBlock* block);
4048
4049     // Requires that "block" is a block that returns from
4050     // a finally.  Returns the number of successors (jump targets of
4051     // of blocks in the covered "try" that did a "LEAVE".)
4052     unsigned fgNSuccsOfFinallyRet(BasicBlock* block);
4053
4054     // Requires that "block" is a block that returns (in the sense of BBJ_EHFINALLYRET) from
4055     // a finally.  Returns its "i"th successor (jump targets of
4056     // of blocks in the covered "try" that did a "LEAVE".)
4057     // Requires that "i" < fgNSuccsOfFinallyRet(block).
4058     BasicBlock* fgSuccOfFinallyRet(BasicBlock* block, unsigned i);
4059
4060 private:
4061     // Factor out common portions of the impls of the methods above.
4062     void fgSuccOfFinallyRetWork(BasicBlock* block, unsigned i, BasicBlock** bres, unsigned* nres);
4063
4064 public:
4065     // For many purposes, it is desirable to be able to enumerate the *distinct* targets of a switch statement,
4066     // skipping duplicate targets.  (E.g., in flow analyses that are only interested in the set of possible targets.)
4067     // SwitchUniqueSuccSet contains the non-duplicated switch targets.
4068     // (Code that modifies the jump table of a switch has an obligation to call Compiler::UpdateSwitchTableTarget,
4069     // which in turn will call the "UpdateTarget" method of this type if a SwitchUniqueSuccSet has already
4070     // been computed for the switch block.  If a switch block is deleted or is transformed into a non-switch,
4071     // we leave the entry associated with the block, but it will no longer be accessed.)
4072     struct SwitchUniqueSuccSet
4073     {
4074         unsigned     numDistinctSuccs; // Number of distinct targets of the switch.
4075         BasicBlock** nonDuplicates;    // Array of "numDistinctSuccs", containing all the distinct switch target
4076                                        // successors.
4077
4078         // The switch block "switchBlk" just had an entry with value "from" modified to the value "to".
4079         // Update "this" as necessary: if "from" is no longer an element of the jump table of "switchBlk",
4080         // remove it from "this", and ensure that "to" is a member.  Use "alloc" to do any required allocation.
4081         void UpdateTarget(IAllocator* alloc, BasicBlock* switchBlk, BasicBlock* from, BasicBlock* to);
4082     };
4083
4084     typedef SimplerHashTable<BasicBlock*, PtrKeyFuncs<BasicBlock>, SwitchUniqueSuccSet, JitSimplerHashBehavior>
4085         BlockToSwitchDescMap;
4086
4087 private:
4088     // Maps BasicBlock*'s that end in switch statements to SwitchUniqueSuccSets that allow
4089     // iteration over only the distinct successors.
4090     BlockToSwitchDescMap* m_switchDescMap;
4091
4092 public:
4093     BlockToSwitchDescMap* GetSwitchDescMap()
4094     {
4095         if (m_switchDescMap == nullptr)
4096         {
4097             m_switchDescMap = new (getAllocator()) BlockToSwitchDescMap(getAllocator());
4098         }
4099         return m_switchDescMap;
4100     }
4101
4102     // Invalidate the map of unique switch block successors. For example, since the hash key of the map
4103     // depends on block numbers, we must invalidate the map when the blocks are renumbered, to ensure that
4104     // we don't accidentally look up and return the wrong switch data.
4105     void InvalidateUniqueSwitchSuccMap()
4106     {
4107         m_switchDescMap = nullptr;
4108     }
4109
4110     // Requires "switchBlock" to be a block that ends in a switch.  Returns
4111     // the corresponding SwitchUniqueSuccSet.
4112     SwitchUniqueSuccSet GetDescriptorForSwitch(BasicBlock* switchBlk);
4113
4114     // The switch block "switchBlk" just had an entry with value "from" modified to the value "to".
4115     // Update "this" as necessary: if "from" is no longer an element of the jump table of "switchBlk",
4116     // remove it from "this", and ensure that "to" is a member.
4117     void UpdateSwitchTableTarget(BasicBlock* switchBlk, BasicBlock* from, BasicBlock* to);
4118
4119     // Remove the "SwitchUniqueSuccSet" of "switchBlk" in the BlockToSwitchDescMap.
4120     void fgInvalidateSwitchDescMapEntry(BasicBlock* switchBlk);
4121
4122     BasicBlock* fgFirstBlockOfHandler(BasicBlock* block);
4123
4124     flowList* fgGetPredForBlock(BasicBlock* block, BasicBlock* blockPred);
4125
4126     flowList* fgGetPredForBlock(BasicBlock* block, BasicBlock* blockPred, flowList*** ptrToPred);
4127
4128     flowList* fgSpliceOutPred(BasicBlock* block, BasicBlock* blockPred);
4129
4130     flowList* fgRemoveRefPred(BasicBlock* block, BasicBlock* blockPred);
4131
4132     flowList* fgRemoveAllRefPreds(BasicBlock* block, BasicBlock* blockPred);
4133
4134     flowList* fgRemoveAllRefPreds(BasicBlock* block, flowList** ptrToPred);
4135
4136     void fgRemoveBlockAsPred(BasicBlock* block);
4137
4138     void fgChangeSwitchBlock(BasicBlock* oldSwitchBlock, BasicBlock* newSwitchBlock);
4139
4140     void fgReplaceSwitchJumpTarget(BasicBlock* blockSwitch, BasicBlock* newTarget, BasicBlock* oldTarget);
4141
4142     void fgReplaceJumpTarget(BasicBlock* block, BasicBlock* newTarget, BasicBlock* oldTarget);
4143
4144     void fgReplacePred(BasicBlock* block, BasicBlock* oldPred, BasicBlock* newPred);
4145
4146     flowList* fgAddRefPred(BasicBlock* block,
4147                            BasicBlock* blockPred,
4148                            flowList*   oldEdge           = nullptr,
4149                            bool        initializingPreds = false); // Only set to 'true' when we are computing preds in
4150                                                                    // fgComputePreds()
4151
4152     void fgFindBasicBlocks();
4153
4154     bool fgIsBetterFallThrough(BasicBlock* bCur, BasicBlock* bAlt);
4155
4156     bool fgCheckEHCanInsertAfterBlock(BasicBlock* blk, unsigned regionIndex, bool putInTryRegion);
4157
4158     BasicBlock* fgFindInsertPoint(unsigned    regionIndex,
4159                                   bool        putInTryRegion,
4160                                   BasicBlock* startBlk,
4161                                   BasicBlock* endBlk,
4162                                   BasicBlock* nearBlk,
4163                                   BasicBlock* jumpBlk,
4164                                   bool        runRarely);
4165
4166     unsigned fgGetNestingLevel(BasicBlock* block, unsigned* pFinallyNesting = nullptr);
4167
4168     void fgRemoveEmptyBlocks();
4169
4170     void fgRemoveStmt(BasicBlock* block, GenTreePtr stmt, bool updateRefCnt = true);
4171
4172     bool fgCheckRemoveStmt(BasicBlock* block, GenTreePtr stmt);
4173
4174     void fgCreateLoopPreHeader(unsigned lnum);
4175
4176     void fgUnreachableBlock(BasicBlock* block);
4177
4178     void fgRemoveConditionalJump(BasicBlock* block);
4179
4180     BasicBlock* fgLastBBInMainFunction();
4181
4182     BasicBlock* fgEndBBAfterMainFunction();
4183
4184     void fgUnlinkRange(BasicBlock* bBeg, BasicBlock* bEnd);
4185
4186     void fgRemoveBlock(BasicBlock* block, bool unreachable);
4187
4188     bool fgCanCompactBlocks(BasicBlock* block, BasicBlock* bNext);
4189
4190     void fgCompactBlocks(BasicBlock* block, BasicBlock* bNext);
4191
4192     void fgUpdateLoopsAfterCompacting(BasicBlock* block, BasicBlock* bNext);
4193
4194     BasicBlock* fgConnectFallThrough(BasicBlock* bSrc, BasicBlock* bDst);
4195
4196     bool fgRenumberBlocks();
4197
4198     bool fgExpandRarelyRunBlocks();
4199
4200     bool fgEhAllowsMoveBlock(BasicBlock* bBefore, BasicBlock* bAfter);
4201
4202     void fgMoveBlocksAfter(BasicBlock* bStart, BasicBlock* bEnd, BasicBlock* insertAfterBlk);
4203
4204     enum FG_RELOCATE_TYPE
4205     {
4206         FG_RELOCATE_TRY,    // relocate the 'try' region
4207         FG_RELOCATE_HANDLER // relocate the handler region (including the filter if necessary)
4208     };
4209     BasicBlock* fgRelocateEHRange(unsigned regionIndex, FG_RELOCATE_TYPE relocateType);
4210
4211 #if FEATURE_EH_FUNCLETS
4212 #if defined(_TARGET_ARM_)
4213     void fgClearFinallyTargetBit(BasicBlock* block);
4214 #endif // defined(_TARGET_ARM_)
4215     bool fgIsIntraHandlerPred(BasicBlock* predBlock, BasicBlock* block);
4216     bool fgAnyIntraHandlerPreds(BasicBlock* block);
4217     void fgInsertFuncletPrologBlock(BasicBlock* block);
4218     void fgCreateFuncletPrologBlocks();
4219     void fgCreateFunclets();
4220 #else  // !FEATURE_EH_FUNCLETS
4221     bool fgRelocateEHRegions();
4222 #endif // !FEATURE_EH_FUNCLETS
4223
4224     bool fgOptimizeUncondBranchToSimpleCond(BasicBlock* block, BasicBlock* target);
4225
4226     bool fgBlockEndFavorsTailDuplication(BasicBlock* block);
4227
4228     bool fgBlockIsGoodTailDuplicationCandidate(BasicBlock* block);
4229
4230     bool fgOptimizeFallthroughTailDup(BasicBlock* block, BasicBlock* target);
4231
4232     bool fgOptimizeEmptyBlock(BasicBlock* block);
4233
4234     bool fgOptimizeBranchToEmptyUnconditional(BasicBlock* block, BasicBlock* bDest);
4235
4236     bool fgOptimizeBranch(BasicBlock* bJump);
4237
4238     bool fgOptimizeSwitchBranches(BasicBlock* block);
4239
4240     bool fgOptimizeBranchToNext(BasicBlock* block, BasicBlock* bNext, BasicBlock* bPrev);
4241
4242     bool fgOptimizeSwitchJumps();
4243 #ifdef DEBUG
4244     void fgPrintEdgeWeights();
4245 #endif
4246     void fgComputeEdgeWeights();
4247
4248     void fgReorderBlocks();
4249
4250     void fgDetermineFirstColdBlock();
4251
4252     bool fgIsForwardBranch(BasicBlock* bJump, BasicBlock* bSrc = nullptr);
4253
4254     bool fgUpdateFlowGraph(bool doTailDup = false);
4255
4256     void fgFindOperOrder();
4257
4258     // method that returns if you should split here
4259     typedef bool(fgSplitPredicate)(GenTree* tree, GenTree* parent, fgWalkData* data);
4260
4261     void fgSetBlockOrder();
4262
4263     void fgRemoveReturnBlock(BasicBlock* block);
4264
4265     /* Helper code that has been factored out */
4266     inline void fgConvertBBToThrowBB(BasicBlock* block);
4267
4268     bool fgCastNeeded(GenTreePtr tree, var_types toType);
4269     GenTreePtr fgDoNormalizeOnStore(GenTreePtr tree);
4270     GenTreePtr fgMakeTmpArgNode(
4271         unsigned tmpVarNum FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(const bool passedInRegisters));
4272
4273     // The following check for loops that don't execute calls
4274     bool fgLoopCallMarked;
4275
4276     void fgLoopCallTest(BasicBlock* srcBB, BasicBlock* dstBB);
4277     void fgLoopCallMark();
4278
4279     void fgMarkLoopHead(BasicBlock* block);
4280
4281     unsigned fgGetCodeEstimate(BasicBlock* block);
4282
4283 #if DUMP_FLOWGRAPHS
4284     const char* fgProcessEscapes(const char* nameIn, escapeMapping_t* map);
4285     FILE* fgOpenFlowGraphFile(bool* wbDontClose, Phases phase, LPCWSTR type);
4286     bool fgDumpFlowGraph(Phases phase);
4287
4288 #endif // DUMP_FLOWGRAPHS
4289
4290 #ifdef DEBUG
4291     void fgDispDoms();
4292     void fgDispReach();
4293     void fgDispBBLiveness(BasicBlock* block);
4294     void fgDispBBLiveness();
4295     void fgTableDispBasicBlock(BasicBlock* block, int ibcColWidth = 0);
4296     void fgDispBasicBlocks(BasicBlock* firstBlock, BasicBlock* lastBlock, bool dumpTrees);
4297     void fgDispBasicBlocks(bool dumpTrees = false);
4298     void fgDumpStmtTree(GenTreePtr stmt, unsigned blkNum);
4299     void fgDumpBlock(BasicBlock* block);
4300     void fgDumpTrees(BasicBlock* firstBlock, BasicBlock* lastBlock);
4301
4302     static fgWalkPreFn fgStress64RsltMulCB;
4303     void               fgStress64RsltMul();
4304     void               fgDebugCheckUpdate();
4305     void fgDebugCheckBBlist(bool checkBBNum = false, bool checkBBRefs = true);
4306     void fgDebugCheckBlockLinks();
4307     void fgDebugCheckLinks(bool morphTrees = false);
4308     void fgDebugCheckNodeLinks(BasicBlock* block, GenTreePtr stmt);
4309     void fgDebugCheckFlags(GenTreePtr tree);
4310     void fgDebugCheckFlagsHelper(GenTreePtr tree, unsigned treeFlags, unsigned chkFlags);
4311     void fgDebugCheckTryFinallyExits();
4312 #endif
4313
4314 #ifdef LEGACY_BACKEND
4315     static void fgOrderBlockOps(GenTreePtr  tree,
4316                                 regMaskTP   reg0,
4317                                 regMaskTP   reg1,
4318                                 regMaskTP   reg2,
4319                                 GenTreePtr* opsPtr,   // OUT
4320                                 regMaskTP*  regsPtr); // OUT
4321 #endif                                                // LEGACY_BACKEND
4322
4323     static GenTreePtr fgGetFirstNode(GenTreePtr tree);
4324     static bool fgTreeIsInStmt(GenTree* tree, GenTreeStmt* stmt);
4325
4326     inline bool fgIsInlining()
4327     {
4328         return fgExpandInline;
4329     }
4330
4331     void fgTraverseRPO();
4332
4333     //--------------------- Walking the trees in the IR -----------------------
4334
4335     struct fgWalkData
4336     {
4337         Compiler*     compiler;
4338         fgWalkPreFn*  wtprVisitorFn;
4339         fgWalkPostFn* wtpoVisitorFn;
4340         void*         pCallbackData; // user-provided data
4341         bool          wtprLclsOnly;  // whether to only visit lclvar nodes
4342         GenTreePtr    parent;        // parent of current node, provided to callback
4343         GenTreeStack* parentStack;   // stack of parent nodes, if asked for
4344 #ifdef DEBUG
4345         bool printModified; // callback can use this
4346 #endif
4347     };
4348
4349     template <bool      computeStack>
4350     static fgWalkResult fgWalkTreePreRec(GenTreePtr* pTree, fgWalkData* fgWalkPre);
4351
4352     // general purpose tree-walker that is capable of doing pre- and post- order
4353     // callbacks at the same time
4354     template <bool doPreOrder, bool doPostOrder>
4355     static fgWalkResult fgWalkTreeRec(GenTreePtr* pTree, fgWalkData* fgWalkPre);
4356
4357     fgWalkResult fgWalkTreePre(GenTreePtr*  pTree,
4358                                fgWalkPreFn* visitor,
4359                                void*        pCallBackData = nullptr,
4360                                bool         lclVarsOnly   = false,
4361                                bool         computeStack  = false);
4362
4363     fgWalkResult fgWalkTree(GenTreePtr*   pTree,
4364                             fgWalkPreFn*  preVisitor,
4365                             fgWalkPostFn* postVisitor,
4366                             void*         pCallBackData = nullptr);
4367
4368     void fgWalkAllTreesPre(fgWalkPreFn* visitor, void* pCallBackData);
4369
4370     //----- Postorder
4371
4372     template <bool      computeStack>
4373     static fgWalkResult fgWalkTreePostRec(GenTreePtr* pTree, fgWalkData* fgWalkPre);
4374
4375     fgWalkResult fgWalkTreePost(GenTreePtr*   pTree,
4376                                 fgWalkPostFn* visitor,
4377                                 void*         pCallBackData = nullptr,
4378                                 bool          computeStack  = false);
4379
4380     // An fgWalkPreFn that looks for expressions that have inline throws in
4381     // minopts mode. Basically it looks for tress with gtOverflowEx() or
4382     // GTF_IND_RNGCHK.  It returns WALK_ABORT if one is found.  It
4383     // returns WALK_SKIP_SUBTREES if GTF_EXCEPT is not set (assumes flags
4384     // properly propagated to parent trees).  It returns WALK_CONTINUE
4385     // otherwise.
4386     static fgWalkResult fgChkThrowCB(GenTreePtr* pTree, Compiler::fgWalkData* data);
4387     static fgWalkResult fgChkLocAllocCB(GenTreePtr* pTree, Compiler::fgWalkData* data);
4388     static fgWalkResult fgChkQmarkCB(GenTreePtr* pTree, Compiler::fgWalkData* data);
4389
4390     /**************************************************************************
4391      *                          PROTECTED
4392      *************************************************************************/
4393
4394 protected:
4395     friend class SsaBuilder;
4396     friend struct ValueNumberState;
4397
4398     //--------------------- Detect the basic blocks ---------------------------
4399
4400     BasicBlock** fgBBs; // Table of pointers to the BBs
4401
4402     void        fgInitBBLookup();
4403     BasicBlock* fgLookupBB(unsigned addr);
4404
4405     void fgMarkJumpTarget(BYTE* jumpTarget, IL_OFFSET offs);
4406
4407     void fgFindJumpTargets(const BYTE* codeAddr, IL_OFFSET codeSize, BYTE* jumpTarget);
4408
4409     void fgMarkBackwardJump(BasicBlock* startBlock, BasicBlock* endBlock);
4410
4411     void fgLinkBasicBlocks();
4412
4413     unsigned fgMakeBasicBlocks(const BYTE* codeAddr, IL_OFFSET codeSize, BYTE* jumpTarget);
4414
4415     void fgCheckBasicBlockControlFlow();
4416
4417     void fgControlFlowPermitted(BasicBlock* blkSrc,
4418                                 BasicBlock* blkDest,
4419                                 BOOL        IsLeave = false /* is the src a leave block */);
4420
4421     bool fgFlowToFirstBlockOfInnerTry(BasicBlock* blkSrc, BasicBlock* blkDest, bool sibling);
4422
4423     void fgObserveInlineConstants(OPCODE opcode, const FgStack& stack, bool isInlining);
4424
4425     void fgAdjustForAddressExposedOrWrittenThis();
4426
4427     bool                        fgProfileData_ILSizeMismatch;
4428     ICorJitInfo::ProfileBuffer* fgProfileBuffer;
4429     ULONG                       fgProfileBufferCount;
4430     ULONG                       fgNumProfileRuns;
4431
4432     unsigned fgStressBBProf()
4433     {
4434 #ifdef DEBUG
4435         unsigned result = JitConfig.JitStressBBProf();
4436         if (result == 0)
4437         {
4438             if (compStressCompile(STRESS_BB_PROFILE, 15))
4439             {
4440                 result = 1;
4441             }
4442         }
4443         return result;
4444 #else
4445         return 0;
4446 #endif
4447     }
4448
4449     bool fgHaveProfileData();
4450     bool fgGetProfileWeightForBasicBlock(IL_OFFSET offset, unsigned* weight);
4451
4452     bool fgIsUsingProfileWeights()
4453     {
4454         return (fgHaveProfileData() || fgStressBBProf());
4455     }
4456     void fgInstrumentMethod();
4457
4458 //-------- Insert a statement at the start or end of a basic block --------
4459
4460 #ifdef DEBUG
4461 public:
4462     static bool fgBlockContainsStatementBounded(BasicBlock* block, GenTree* stmt, bool answerOnBoundExceeded = true);
4463 #endif
4464
4465 public:
4466     GenTreeStmt* fgInsertStmtAtEnd(BasicBlock* block, GenTreePtr node);
4467
4468 public: // Used by linear scan register allocation
4469     GenTreeStmt* fgInsertStmtNearEnd(BasicBlock* block, GenTreePtr node);
4470
4471 private:
4472     GenTreePtr fgInsertStmtAtBeg(BasicBlock* block, GenTreePtr stmt);
4473     GenTreePtr fgInsertStmtAfter(BasicBlock* block, GenTreePtr insertionPoint, GenTreePtr stmt);
4474
4475 public: // Used by linear scan register allocation
4476     GenTreePtr fgInsertStmtBefore(BasicBlock* block, GenTreePtr insertionPoint, GenTreePtr stmt);
4477
4478 private:
4479     GenTreePtr fgInsertStmtListAfter(BasicBlock* block, GenTreePtr stmtAfter, GenTreePtr stmtList);
4480
4481     GenTreePtr fgMorphSplitTree(GenTree** splitPoint, GenTree* stmt, BasicBlock* blk);
4482
4483     //                  Create a new temporary variable to hold the result of *ppTree,
4484     //                  and transform the graph accordingly.
4485     GenTree* fgInsertCommaFormTemp(GenTree** ppTree, CORINFO_CLASS_HANDLE structType = nullptr);
4486     GenTree* fgMakeMultiUse(GenTree** ppTree);
4487
4488 private:
4489     //                  Recognize a bitwise rotation pattern and convert into a GT_ROL or a GT_ROR node.
4490     GenTreePtr fgRecognizeAndMorphBitwiseRotation(GenTreePtr tree);
4491     bool fgOperIsBitwiseRotationRoot(genTreeOps oper);
4492
4493     //-------- Determine the order in which the trees will be evaluated -------
4494
4495     unsigned fgTreeSeqNum;
4496     GenTree* fgTreeSeqLst;
4497     GenTree* fgTreeSeqBeg;
4498
4499     GenTree* fgSetTreeSeq(GenTree* tree, GenTree* prev = nullptr, bool isLIR = false);
4500     void fgSetTreeSeqHelper(GenTree* tree, bool isLIR);
4501     void fgSetTreeSeqFinish(GenTreePtr tree, bool isLIR);
4502     void fgSetStmtSeq(GenTree* tree);
4503     void fgSetBlockOrder(BasicBlock* block);
4504
4505     //------------------------- Morphing --------------------------------------
4506
4507     unsigned fgPtrArgCntCur;
4508     unsigned fgPtrArgCntMax;
4509     hashBv*  fgOutgoingArgTemps;
4510     hashBv*  fgCurrentlyInUseArgTemps;
4511
4512     bool compCanEncodePtrArgCntMax();
4513
4514     void fgSetRngChkTarget(GenTreePtr tree, bool delay = true);
4515
4516 #if REARRANGE_ADDS
4517     void fgMoveOpsLeft(GenTreePtr tree);
4518 #endif
4519
4520     bool fgIsCommaThrow(GenTreePtr tree, bool forFolding = false);
4521
4522     bool fgIsThrow(GenTreePtr tree);
4523
4524     bool fgInDifferentRegions(BasicBlock* blk1, BasicBlock* blk2);
4525     bool fgIsBlockCold(BasicBlock* block);
4526
4527     GenTreePtr fgMorphCastIntoHelper(GenTreePtr tree, int helper, GenTreePtr oper);
4528
4529     GenTreePtr fgMorphIntoHelperCall(GenTreePtr tree, int helper, GenTreeArgList* args);
4530
4531     GenTreePtr fgMorphStackArgForVarArgs(unsigned lclNum, var_types varType, unsigned lclOffs);
4532
4533     bool fgMorphRelopToQmark(GenTreePtr tree);
4534
4535     // A "MorphAddrContext" carries information from the surrounding context.  If we are evaluating a byref address,
4536     // it is useful to know whether the address will be immediately dereferenced, or whether the address value will
4537     // be used, perhaps by passing it as an argument to a called method.  This affects how null checking is done:
4538     // for sufficiently small offsets, we can rely on OS page protection to implicitly null-check addresses that we
4539     // know will be dereferenced.  To know that reliance on implicit null checking is sound, we must further know that
4540     // all offsets between the top-level indirection and the bottom are constant, and that their sum is sufficiently
4541     // small; hence the other fields of MorphAddrContext.
4542     enum MorphAddrContextKind
4543     {
4544         MACK_Ind,
4545         MACK_Addr,
4546     };
4547     struct MorphAddrContext
4548     {
4549         MorphAddrContextKind m_kind;
4550         bool                 m_allConstantOffsets; // Valid only for "m_kind == MACK_Ind".  True iff all offsets between
4551                                                    // top-level indirection and here have been constants.
4552         size_t m_totalOffset; // Valid only for "m_kind == MACK_Ind", and if "m_allConstantOffsets" is true.
4553                               // In that case, is the sum of those constant offsets.
4554
4555         MorphAddrContext(MorphAddrContextKind kind) : m_kind(kind), m_allConstantOffsets(true), m_totalOffset(0)
4556         {
4557         }
4558     };
4559
4560     // A MACK_CopyBlock context is immutable, so we can just make one of these and share it.
4561     static MorphAddrContext s_CopyBlockMAC;
4562
4563 #ifdef FEATURE_SIMD
4564     GenTreePtr getSIMDStructFromField(GenTreePtr tree,
4565                                       var_types* baseTypeOut,
4566                                       unsigned*  indexOut,
4567                                       unsigned*  simdSizeOut,
4568                                       bool       ignoreUsedInSIMDIntrinsic = false);
4569     GenTreePtr fgMorphFieldAssignToSIMDIntrinsicSet(GenTreePtr tree);
4570     GenTreePtr fgMorphFieldToSIMDIntrinsicGet(GenTreePtr tree);
4571     bool fgMorphCombineSIMDFieldAssignments(BasicBlock* block, GenTreePtr stmt);
4572     void impMarkContiguousSIMDFieldAssignments(GenTreePtr stmt);
4573
4574     // fgPreviousCandidateSIMDFieldAsgStmt is only used for tracking previous simd field assignment
4575     // in function: Complier::impMarkContiguousSIMDFieldAssignments.
4576     GenTreePtr fgPreviousCandidateSIMDFieldAsgStmt;
4577
4578 #endif // FEATURE_SIMD
4579     GenTreePtr fgMorphArrayIndex(GenTreePtr tree);
4580     GenTreePtr fgMorphCast(GenTreePtr tree);
4581     GenTreePtr fgUnwrapProxy(GenTreePtr objRef);
4582     GenTreeCall* fgMorphArgs(GenTreeCall* call);
4583
4584     void fgMakeOutgoingStructArgCopy(GenTreeCall*         call,
4585                                      GenTree*             args,
4586                                      unsigned             argIndex,
4587                                      CORINFO_CLASS_HANDLE copyBlkClass FEATURE_UNIX_AMD64_STRUCT_PASSING_ONLY_ARG(
4588                                          const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structDescPtr));
4589
4590     void fgFixupStructReturn(GenTreePtr call);
4591     GenTreePtr fgMorphLocalVar(GenTreePtr tree);
4592     bool fgAddrCouldBeNull(GenTreePtr addr);
4593     GenTreePtr fgMorphField(GenTreePtr tree, MorphAddrContext* mac);
4594     bool fgCanFastTailCall(GenTreeCall* call);
4595     void fgMorphTailCall(GenTreeCall* call);
4596     void fgMorphRecursiveFastTailCallIntoLoop(BasicBlock* block, GenTreeCall* recursiveTailCall);
4597     GenTreePtr fgAssignRecursiveCallArgToCallerParam(GenTreePtr       arg,
4598                                                      fgArgTabEntryPtr argTabEntry,
4599                                                      BasicBlock*      block,
4600                                                      IL_OFFSETX       callILOffset,
4601                                                      GenTreePtr       tmpAssignmentInsertionPoint,
4602                                                      GenTreePtr       paramAssignmentInsertionPoint);
4603     static int fgEstimateCallStackSize(GenTreeCall* call);
4604     GenTreePtr fgMorphCall(GenTreeCall* call);
4605     void fgMorphCallInline(GenTreeCall* call, InlineResult* result);
4606     void fgMorphCallInlineHelper(GenTreeCall* call, InlineResult* result);
4607 #if DEBUG
4608     void fgNoteNonInlineCandidate(GenTreeStmt* stmt, GenTreeCall* call);
4609     static fgWalkPreFn fgFindNonInlineCandidate;
4610 #endif
4611     GenTreePtr fgOptimizeDelegateConstructor(GenTreePtr call, CORINFO_CONTEXT_HANDLE* ExactContextHnd);
4612     GenTreePtr fgMorphLeaf(GenTreePtr tree);
4613     void fgAssignSetVarDef(GenTreePtr tree);
4614     GenTreePtr fgMorphOneAsgBlockOp(GenTreePtr tree);
4615     GenTreePtr fgMorphInitBlock(GenTreePtr tree);
4616     GenTreePtr fgMorphBlkToInd(GenTreeBlk* tree, var_types type);
4617     GenTreePtr fgMorphGetStructAddr(GenTreePtr* pTree, CORINFO_CLASS_HANDLE clsHnd, bool isRValue = false);
4618     GenTreePtr fgMorphBlkNode(GenTreePtr tree, bool isDest);
4619     GenTreePtr fgMorphBlockOperand(GenTreePtr tree, var_types asgType, unsigned blockWidth, bool isDest);
4620     void fgMorphUnsafeBlk(GenTreeObj* obj);
4621     GenTreePtr fgMorphCopyBlock(GenTreePtr tree);
4622     GenTreePtr fgMorphForRegisterFP(GenTreePtr tree);
4623     GenTreePtr fgMorphSmpOp(GenTreePtr tree, MorphAddrContext* mac = nullptr);
4624     GenTreePtr fgMorphSmpOpPre(GenTreePtr tree);
4625     GenTreePtr fgMorphModToSubMulDiv(GenTreeOp* tree);
4626     GenTreePtr fgMorphSmpOpOptional(GenTreeOp* tree);
4627     GenTreePtr fgMorphRecognizeBoxNullable(GenTree* compare);
4628
4629     GenTreePtr fgMorphToEmulatedFP(GenTreePtr tree);
4630     GenTreePtr fgMorphConst(GenTreePtr tree);
4631
4632 public:
4633     GenTreePtr fgMorphTree(GenTreePtr tree, MorphAddrContext* mac = nullptr);
4634
4635 private:
4636 #if LOCAL_ASSERTION_PROP
4637     void fgKillDependentAssertionsSingle(unsigned lclNum DEBUGARG(GenTreePtr tree));
4638     void fgKillDependentAssertions(unsigned lclNum DEBUGARG(GenTreePtr tree));
4639 #endif
4640     void fgMorphTreeDone(GenTreePtr tree, GenTreePtr oldTree = nullptr DEBUGARG(int morphNum = 0));
4641
4642     GenTreeStmt* fgMorphStmt;
4643
4644     unsigned fgGetBigOffsetMorphingTemp(var_types type); // We cache one temp per type to be
4645                                                          // used when morphing big offset.
4646
4647     //----------------------- Liveness analysis -------------------------------
4648
4649     VARSET_TP fgCurUseSet; // vars used     by block (before an assignment)
4650     VARSET_TP fgCurDefSet; // vars assigned by block (before a use)
4651
4652     bool fgCurHeapUse;   // True iff the current basic block uses the heap before defining it.
4653     bool fgCurHeapDef;   // True iff the current basic block defines the heap.
4654     bool fgCurHeapHavoc; // True if  the current basic block is known to set the heap to a "havoc" value.
4655
4656     void fgMarkUseDef(GenTreeLclVarCommon* tree);
4657
4658     void fgBeginScopeLife(VARSET_TP* inScope, VarScopeDsc* var);
4659     void fgEndScopeLife(VARSET_TP* inScope, VarScopeDsc* var);
4660
4661     void fgMarkInScope(BasicBlock* block, VARSET_VALARG_TP inScope);
4662     void fgUnmarkInScope(BasicBlock* block, VARSET_VALARG_TP unmarkScope);
4663
4664     void fgExtendDbgScopes();
4665     void fgExtendDbgLifetimes();
4666
4667 #ifdef DEBUG
4668     void fgDispDebugScopes();
4669 #endif // DEBUG
4670
4671     //-------------------------------------------------------------------------
4672     //
4673     //  The following keeps track of any code we've added for things like array
4674     //  range checking or explicit calls to enable GC, and so on.
4675     //
4676 public:
4677     struct AddCodeDsc
4678     {
4679         AddCodeDsc*     acdNext;
4680         BasicBlock*     acdDstBlk; // block  to  which we jump
4681         unsigned        acdData;
4682         SpecialCodeKind acdKind; // what kind of a special block is this?
4683         unsigned short  acdStkLvl;
4684     };
4685
4686 private:
4687     static unsigned acdHelper(SpecialCodeKind codeKind);
4688
4689     AddCodeDsc* fgAddCodeList;
4690     bool        fgAddCodeModf;
4691     bool        fgRngChkThrowAdded;
4692     AddCodeDsc* fgExcptnTargetCache[SCK_COUNT];
4693
4694     BasicBlock* fgRngChkTarget(BasicBlock* block, unsigned stkDepth, SpecialCodeKind kind);
4695
4696     BasicBlock* fgAddCodeRef(BasicBlock* srcBlk, unsigned refData, SpecialCodeKind kind, unsigned stkDepth = 0);
4697
4698 public:
4699     AddCodeDsc* fgFindExcptnTarget(SpecialCodeKind kind, unsigned refData);
4700
4701 private:
4702     bool fgIsCodeAdded();
4703
4704     bool fgIsThrowHlpBlk(BasicBlock* block);
4705     unsigned fgThrowHlpBlkStkLevel(BasicBlock* block);
4706
4707     unsigned fgBigOffsetMorphingTemps[TYP_COUNT];
4708
4709     unsigned fgCheckInlineDepthAndRecursion(InlineInfo* inlineInfo);
4710     void fgInvokeInlineeCompiler(GenTreeCall* call, InlineResult* result);
4711     void fgInsertInlineeBlocks(InlineInfo* pInlineInfo);
4712     GenTreePtr fgInlinePrependStatements(InlineInfo* inlineInfo);
4713     void fgInlineAppendStatements(InlineInfo* inlineInfo, BasicBlock* block, GenTreePtr stmt);
4714
4715 #if FEATURE_MULTIREG_RET
4716     GenTreePtr fgGetStructAsStructPtr(GenTreePtr tree);
4717     GenTreePtr fgAssignStructInlineeToVar(GenTreePtr child, CORINFO_CLASS_HANDLE retClsHnd);
4718     void fgAttachStructInlineeToAsg(GenTreePtr tree, GenTreePtr child, CORINFO_CLASS_HANDLE retClsHnd);
4719 #endif // FEATURE_MULTIREG_RET
4720
4721     static fgWalkPreFn fgUpdateInlineReturnExpressionPlaceHolder;
4722
4723 #ifdef DEBUG
4724     static fgWalkPreFn fgDebugCheckInlineCandidates;
4725 #endif
4726
4727     void         fgPromoteStructs();
4728     fgWalkResult fgMorphStructField(GenTreePtr tree, fgWalkData* fgWalkPre);
4729     fgWalkResult fgMorphLocalField(GenTreePtr tree, fgWalkData* fgWalkPre);
4730     void fgMarkImplicitByRefArgs();
4731     bool fgMorphImplicitByRefArgs(GenTree** pTree, fgWalkData* fgWalkPre);
4732     static fgWalkPreFn  fgMarkAddrTakenLocalsPreCB;
4733     static fgWalkPostFn fgMarkAddrTakenLocalsPostCB;
4734     void                fgMarkAddressExposedLocals();
4735     bool fgNodesMayInterfere(GenTree* store, GenTree* load);
4736
4737     // Returns true if the type of tree is of size at least "width", or if "tree" is not a
4738     // local variable.
4739     bool fgFitsInOrNotLoc(GenTreePtr tree, unsigned width);
4740
4741     // The given local variable, required to be a struct variable, is being assigned via
4742     // a "lclField", to make it masquerade as an integral type in the ABI.  Make sure that
4743     // the variable is not enregistered, and is therefore not promoted independently.
4744     void fgLclFldAssign(unsigned lclNum);
4745
4746     static fgWalkPreFn gtHasLocalsWithAddrOpCB;
4747     bool gtCanOptimizeTypeEquality(GenTreePtr tree);
4748     bool gtIsTypeHandleToRuntimeTypeHelper(GenTreePtr tree);
4749     bool gtIsActiveCSE_Candidate(GenTreePtr tree);
4750
4751 #ifdef DEBUG
4752     bool fgPrintInlinedMethods;
4753 #endif
4754
4755     bool fgIsBigOffset(size_t offset);
4756
4757     // The following are used when morphing special cases of integer div/mod operations and also by codegen
4758     bool fgIsSignedDivOptimizable(GenTreePtr divisor);
4759     bool fgIsUnsignedDivOptimizable(GenTreePtr divisor);
4760     bool fgIsSignedModOptimizable(GenTreePtr divisor);
4761     bool fgIsUnsignedModOptimizable(GenTreePtr divisor);
4762
4763     /*
4764     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
4765     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
4766     XX                                                                           XX
4767     XX                           Optimizer                                       XX
4768     XX                                                                           XX
4769     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
4770     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
4771     */
4772
4773 public:
4774     void optInit();
4775
4776 protected:
4777     LclVarDsc* optIsTrackedLocal(GenTreePtr tree);
4778
4779 public:
4780     void optRemoveRangeCheck(
4781         GenTreePtr tree, GenTreePtr stmt, bool updateCSEcounts, unsigned sideEffFlags = 0, bool forceRemove = false);
4782     bool optIsRangeCheckRemovable(GenTreePtr tree);
4783
4784 protected:
4785     static fgWalkPreFn optValidRangeCheckIndex;
4786     static fgWalkPreFn optRemoveTreeVisitor; // Helper passed to Compiler::fgWalkAllTreesPre() to decrement the LclVar
4787                                              // usage counts
4788
4789     void optRemoveTree(GenTreePtr deadTree, GenTreePtr keepList);
4790
4791     /**************************************************************************
4792      *
4793      *************************************************************************/
4794
4795 protected:
4796     // Do hoisting for all loops.
4797     void optHoistLoopCode();
4798
4799     // To represent sets of VN's that have already been hoisted in outer loops.
4800     typedef SimplerHashTable<ValueNum, SmallPrimitiveKeyFuncs<ValueNum>, bool, JitSimplerHashBehavior> VNToBoolMap;
4801     typedef VNToBoolMap VNSet;
4802
4803     struct LoopHoistContext
4804     {
4805     private:
4806         // The set of variables hoisted in the current loop (or nullptr if there are none).
4807         VNSet* m_pHoistedInCurLoop;
4808
4809     public:
4810         // Value numbers of expressions that have been hoisted in parent loops in the loop nest.
4811         VNSet m_hoistedInParentLoops;
4812         // Value numbers of expressions that have been hoisted in the current (or most recent) loop in the nest.
4813         // Previous decisions on loop-invariance of value numbers in the current loop.
4814         VNToBoolMap m_curLoopVnInvariantCache;
4815
4816         VNSet* GetHoistedInCurLoop(Compiler* comp)
4817         {
4818             if (m_pHoistedInCurLoop == nullptr)
4819             {
4820                 m_pHoistedInCurLoop = new (comp->getAllocatorLoopHoist()) VNSet(comp->getAllocatorLoopHoist());
4821             }
4822             return m_pHoistedInCurLoop;
4823         }
4824
4825         VNSet* ExtractHoistedInCurLoop()
4826         {
4827             VNSet* res          = m_pHoistedInCurLoop;
4828             m_pHoistedInCurLoop = nullptr;
4829             return res;
4830         }
4831
4832         LoopHoistContext(Compiler* comp)
4833             : m_pHoistedInCurLoop(nullptr)
4834             , m_hoistedInParentLoops(comp->getAllocatorLoopHoist())
4835             , m_curLoopVnInvariantCache(comp->getAllocatorLoopHoist())
4836         {
4837         }
4838     };
4839
4840     // Do hoisting for loop "lnum" (an index into the optLoopTable), and all loops nested within it.
4841     // Tracks the expressions that have been hoisted by containing loops by temporary recording their
4842     // value numbers in "m_hoistedInParentLoops".  This set is not modified by the call.
4843     void optHoistLoopNest(unsigned lnum, LoopHoistContext* hoistCtxt);
4844
4845     // Do hoisting for a particular loop ("lnum" is an index into the optLoopTable.)
4846     // Assumes that expressions have been hoisted in containing loops if their value numbers are in
4847     // "m_hoistedInParentLoops".
4848     //
4849     void optHoistThisLoop(unsigned lnum, LoopHoistContext* hoistCtxt);
4850
4851     // Hoist all expressions in "blk" that are invariant in loop "lnum" (an index into the optLoopTable)
4852     // outside of that loop.  Exempt expressions whose value number is in "m_hoistedInParentLoops"; add VN's of hoisted
4853     // expressions to "hoistInLoop".
4854     void optHoistLoopExprsForBlock(BasicBlock* blk, unsigned lnum, LoopHoistContext* hoistCtxt);
4855
4856     // Return true if the tree looks profitable to hoist out of loop 'lnum'.
4857     bool optIsProfitableToHoistableTree(GenTreePtr tree, unsigned lnum);
4858
4859     // Hoist all proper sub-expressions of "tree" (which occurs in "stmt", which occurs in "blk")
4860     // that are invariant in loop "lnum" (an index into the optLoopTable)
4861     // outside of that loop.  Exempt expressions whose value number is in "hoistedInParents"; add VN's of hoisted
4862     // expressions to "hoistInLoop".
4863     // Returns "true" iff "tree" is loop-invariant (wrt "lnum").
4864     // Assumes that the value of "*firstBlockAndBeforeSideEffect" indicates that we're in the first block, and before
4865     // any possible globally visible side effects.  Assume is called in evaluation order, and updates this.
4866     bool optHoistLoopExprsForTree(GenTreePtr        tree,
4867                                   unsigned          lnum,
4868                                   LoopHoistContext* hoistCtxt,
4869                                   bool*             firstBlockAndBeforeSideEffect,
4870                                   bool*             pHoistable);
4871
4872     // Performs the hoisting 'tree' into the PreHeader for loop 'lnum'
4873     void optHoistCandidate(GenTreePtr tree, unsigned lnum, LoopHoistContext* hoistCtxt);
4874
4875     // Returns true iff the ValueNum "vn" represents a value that is loop-invariant in "lnum".
4876     //   Constants and init values are always loop invariant.
4877     //   VNPhi's connect VN's to the SSA definition, so we can know if the SSA def occurs in the loop.
4878     bool optVNIsLoopInvariant(ValueNum vn, unsigned lnum, VNToBoolMap* recordedVNs);
4879
4880     // Returns "true" iff "tree" is valid at the head of loop "lnum", in the context of the hoist substitution
4881     // "subst".  If "tree" is a local SSA var, it is valid if its SSA definition occurs outside of the loop, or
4882     // if it is in the domain of "subst" (meaning that it's definition has been previously hoisted, with a "standin"
4883     // local.)  If tree is a constant, it is valid.  Otherwise, if it is an operator, it is valid iff its children are.
4884     bool optTreeIsValidAtLoopHead(GenTreePtr tree, unsigned lnum);
4885
4886     // If "blk" is the entry block of a natural loop, returns true and sets "*pLnum" to the index of the loop
4887     // in the loop table.
4888     bool optBlockIsLoopEntry(BasicBlock* blk, unsigned* pLnum);
4889
4890     // Records the set of "side effects" of all loops: fields (object instance and static)
4891     // written to, and SZ-array element type equivalence classes updated.
4892     void optComputeLoopSideEffects();
4893
4894 private:
4895     // Requires "lnum" to be the index of an outermost loop in the loop table.  Traverses the body of that loop,
4896     // including all nested loops, and records the set of "side effects" of the loop: fields (object instance and
4897     // static) written to, and SZ-array element type equivalence classes updated.
4898     void optComputeLoopNestSideEffects(unsigned lnum);
4899
4900     // Add the side effects of "blk" (which is required to be within a loop) to all loops of which it is a part.
4901     void optComputeLoopSideEffectsOfBlock(BasicBlock* blk);
4902
4903     // Hoist the expression "expr" out of loop "lnum".
4904     void optPerformHoistExpr(GenTreePtr expr, unsigned lnum);
4905
4906 public:
4907     void optOptimizeBools();
4908
4909 private:
4910     GenTree* optIsBoolCond(GenTree* condBranch, GenTree** compPtr, bool* boolPtr);
4911 #ifdef DEBUG
4912     void optOptimizeBoolsGcStress(BasicBlock* condBlock);
4913 #endif
4914 public:
4915     void optOptimizeLayout(); // Optimize the BasicBlock layout of the method
4916
4917     void optOptimizeLoops(); // for "while-do" loops duplicates simple loop conditions and transforms
4918                              // the loop into a "do-while" loop
4919                              // Also finds all natural loops and records them in the loop table
4920
4921     // Optionally clone loops in the loop table.
4922     void optCloneLoops();
4923
4924     // Clone loop "loopInd" in the loop table.
4925     void optCloneLoop(unsigned loopInd, LoopCloneContext* context);
4926
4927     // Ensure that loop "loopInd" has a unique head block.  (If the existing entry has
4928     // non-loop predecessors other than the head entry, create a new, empty block that goes (only) to the entry,
4929     // and redirects the preds of the entry to this new block.)  Sets the weight of the newly created block to
4930     // "ambientWeight".
4931     void optEnsureUniqueHead(unsigned loopInd, unsigned ambientWeight);
4932
4933     void optUnrollLoops(); // Unrolls loops (needs to have cost info)
4934
4935 protected:
4936     // This enumeration describes what is killed by a call.
4937
4938     enum callInterf
4939     {
4940         CALLINT_NONE,       // no interference                               (most helpers)
4941         CALLINT_REF_INDIRS, // kills GC ref indirections                     (SETFIELD OBJ)
4942         CALLINT_SCL_INDIRS, // kills non GC ref indirections                 (SETFIELD non-OBJ)
4943         CALLINT_ALL_INDIRS, // kills both GC ref and non GC ref indirections (SETFIELD STRUCT)
4944         CALLINT_ALL,        // kills everything                              (normal method call)
4945     };
4946
4947 public:
4948     // A "LoopDsc" describes a ("natural") loop.  We (currently) require the body of a loop to be a contiguous (in
4949     // bbNext order) sequence of basic blocks.  (At times, we may require the blocks in a loop to be "properly numbered"
4950     // in bbNext order; we use comparisons on the bbNum to decide order.)
4951     // The blocks that define the body are
4952     //   first <= top <= entry <= bottom   .
4953     // The "head" of the loop is a block outside the loop that has "entry" as a successor. We only support loops with a
4954     // single 'head' block. The meanings of these blocks are given in the definitions below. Also see the picture at
4955     // Compiler::optFindNaturalLoops().
4956     struct LoopDsc
4957     {
4958         BasicBlock* lpHead;  // HEAD of the loop (not part of the looping of the loop) -- has ENTRY as a successor.
4959         BasicBlock* lpFirst; // FIRST block (in bbNext order) reachable within this loop.  (May be part of a nested
4960                              // loop, but not the outer loop.)
4961         BasicBlock* lpTop;   // loop TOP (the back edge from lpBottom reaches here) (in most cases FIRST and TOP are the
4962                              // same)
4963         BasicBlock* lpEntry; // the ENTRY in the loop (in most cases TOP or BOTTOM)
4964         BasicBlock* lpBottom; // loop BOTTOM (from here we have a back edge to the TOP)
4965         BasicBlock* lpExit;   // if a single exit loop this is the EXIT (in most cases BOTTOM)
4966
4967         callInterf   lpAsgCall;     // "callInterf" for calls in the loop
4968         ALLVARSET_TP lpAsgVars;     // set of vars assigned within the loop (all vars, not just tracked)
4969         varRefKinds  lpAsgInds : 8; // set of inds modified within the loop
4970
4971         unsigned short lpFlags; // Mask of the LPFLG_* constants
4972
4973         unsigned char lpExitCnt; // number of exits from the loop
4974
4975         unsigned char lpParent;  // The index of the most-nested loop that completely contains this one,
4976                                  // or else BasicBlock::NOT_IN_LOOP if no such loop exists.
4977         unsigned char lpChild;   // The index of a nested loop, or else BasicBlock::NOT_IN_LOOP if no child exists.
4978                                  // (Actually, an "immediately" nested loop --
4979                                  // no other child of this loop is a parent of lpChild.)
4980         unsigned char lpSibling; // The index of another loop that is an immediate child of lpParent,
4981                                  // or else BasicBlock::NOT_IN_LOOP.  One can enumerate all the children of a loop
4982                                  // by following "lpChild" then "lpSibling" links.
4983
4984 #define LPFLG_DO_WHILE 0x0001 // it's a do-while loop (i.e ENTRY is at the TOP)
4985 #define LPFLG_ONE_EXIT 0x0002 // the loop has only one exit
4986
4987 #define LPFLG_ITER 0x0004      // for (i = icon or lclVar; test_condition(); i++)
4988 #define LPFLG_HOISTABLE 0x0008 // the loop is in a form that is suitable for hoisting expressions
4989 #define LPFLG_CONST 0x0010     // for (i=icon;i<icon;i++){ ... } - constant loop
4990
4991 #define LPFLG_VAR_INIT 0x0020   // iterator is initialized with a local var (var # found in lpVarInit)
4992 #define LPFLG_CONST_INIT 0x0040 // iterator is initialized with a constant (found in lpConstInit)
4993
4994 #define LPFLG_VAR_LIMIT 0x0100    // iterator is compared with a local var (var # found in lpVarLimit)
4995 #define LPFLG_CONST_LIMIT 0x0200  // iterator is compared with a constant (found in lpConstLimit)
4996 #define LPFLG_ARRLEN_LIMIT 0x0400 // iterator is compared with a.len or a[i].len (found in lpArrLenLimit)
4997 #define LPFLG_SIMD_LIMIT 0x0080   // iterator is compared with Vector<T>.Count (found in lpConstLimit)
4998
4999 #define LPFLG_HAS_PREHEAD 0x0800 // lpHead is known to be a preHead for this loop
5000 #define LPFLG_REMOVED 0x1000     // has been removed from the loop table (unrolled or optimized away)
5001 #define LPFLG_DONT_UNROLL 0x2000 // do not unroll this loop
5002
5003 #define LPFLG_ASGVARS_YES 0x4000 // "lpAsgVars" has been  computed
5004 #define LPFLG_ASGVARS_INC 0x8000 // "lpAsgVars" is incomplete -- vars beyond those representable in an AllVarSet
5005                                  // type are assigned to.
5006
5007         bool lpLoopHasHeapHavoc; // The loop contains an operation that we assume has arbitrary heap side effects.
5008                                  // If this is set, the fields below may not be accurate (since they become irrelevant.)
5009         bool lpContainsCall;     // True if executing the loop body *may* execute a call
5010
5011         VARSET_TP lpVarInOut;  // The set of variables that are IN or OUT during the execution of this loop
5012         VARSET_TP lpVarUseDef; // The set of variables that are USE or DEF during the execution of this loop
5013
5014         int lpHoistedExprCount; // The register count for the non-FP expressions from inside this loop that have been
5015                                 // hoisted
5016         int lpLoopVarCount;     // The register count for the non-FP LclVars that are read/written inside this loop
5017         int lpVarInOutCount;    // The register count for the non-FP LclVars that are alive inside or accross this loop
5018
5019         int lpHoistedFPExprCount; // The register count for the FP expressions from inside this loop that have been
5020                                   // hoisted
5021         int lpLoopVarFPCount;     // The register count for the FP LclVars that are read/written inside this loop
5022         int lpVarInOutFPCount;    // The register count for the FP LclVars that are alive inside or accross this loop
5023
5024         typedef SimplerHashTable<CORINFO_FIELD_HANDLE,
5025                                  PtrKeyFuncs<struct CORINFO_FIELD_STRUCT_>,
5026                                  bool,
5027                                  JitSimplerHashBehavior>
5028                         FieldHandleSet;
5029         FieldHandleSet* lpFieldsModified; // This has entries (mappings to "true") for all static field and object
5030                                           // instance fields modified
5031                                           // in the loop.
5032
5033         typedef SimplerHashTable<CORINFO_CLASS_HANDLE,
5034                                  PtrKeyFuncs<struct CORINFO_CLASS_STRUCT_>,
5035                                  bool,
5036                                  JitSimplerHashBehavior>
5037                         ClassHandleSet;
5038         ClassHandleSet* lpArrayElemTypesModified; // Bits set indicate the set of sz array element types such that
5039                                                   // arrays of that type are modified
5040                                                   // in the loop.
5041
5042         // Adds the variable liveness information for 'blk' to 'this' LoopDsc
5043         void AddVariableLiveness(Compiler* comp, BasicBlock* blk);
5044
5045         inline void AddModifiedField(Compiler* comp, CORINFO_FIELD_HANDLE fldHnd);
5046         // This doesn't *always* take a class handle -- it can also take primitive types, encoded as class handles
5047         // (shifted left, with a low-order bit set to distinguish.)
5048         // Use the {Encode/Decode}ElemType methods to construct/destruct these.
5049         inline void AddModifiedElemType(Compiler* comp, CORINFO_CLASS_HANDLE structHnd);
5050
5051         /* The following values are set only for iterator loops, i.e. has the flag LPFLG_ITER set */
5052
5053         GenTreePtr lpIterTree;    // The "i <op>= const" tree
5054         unsigned   lpIterVar();   // iterator variable #
5055         int        lpIterConst(); // the constant with which the iterator is incremented
5056         genTreeOps lpIterOper();  // the type of the operation on the iterator (ASG_ADD, ASG_SUB, etc.)
5057         void       VERIFY_lpIterTree();
5058
5059         var_types lpIterOperType(); // For overflow instructions
5060
5061         union {
5062             int lpConstInit; // initial constant value of iterator                           : Valid if LPFLG_CONST_INIT
5063             unsigned lpVarInit; // initial local var number to which we initialize the iterator : Valid if
5064                                 // LPFLG_VAR_INIT
5065         };
5066
5067         /* The following is for LPFLG_ITER loops only (i.e. the loop condition is "i RELOP const or var" */
5068
5069         GenTreePtr lpTestTree;   // pointer to the node containing the loop test
5070         genTreeOps lpTestOper(); // the type of the comparison between the iterator and the limit (GT_LE, GT_GE, etc.)
5071         void       VERIFY_lpTestTree();
5072
5073         bool       lpIsReversed(); // true if the iterator node is the second operand in the loop condition
5074         GenTreePtr lpIterator();   // the iterator node in the loop test
5075         GenTreePtr lpLimit();      // the limit node in the loop test
5076
5077         int lpConstLimit();    // limit   constant value of iterator - loop condition is "i RELOP const" : Valid if
5078                                // LPFLG_CONST_LIMIT
5079         unsigned lpVarLimit(); // the lclVar # in the loop condition ( "i RELOP lclVar" )                : Valid if
5080                                // LPFLG_VAR_LIMIT
5081         bool lpArrLenLimit(Compiler* comp, ArrIndex* index); // The array length in the loop condition ( "i RELOP
5082                                                              // arr.len" or "i RELOP arr[i][j].len" )  : Valid if
5083                                                              // LPFLG_ARRLEN_LIMIT
5084
5085         // Returns "true" iff "*this" contains the blk.
5086         bool lpContains(BasicBlock* blk)
5087         {
5088             return lpFirst->bbNum <= blk->bbNum && blk->bbNum <= lpBottom->bbNum;
5089         }
5090         // Returns "true" iff "*this" (properly) contains the range [first, bottom] (allowing firsts
5091         // to be equal, but requiring bottoms to be different.)
5092         bool lpContains(BasicBlock* first, BasicBlock* bottom)
5093         {
5094             return lpFirst->bbNum <= first->bbNum && bottom->bbNum < lpBottom->bbNum;
5095         }
5096
5097         // Returns "true" iff "*this" (properly) contains "lp2" (allowing firsts to be equal, but requiring
5098         // bottoms to be different.)
5099         bool lpContains(const LoopDsc& lp2)
5100         {
5101             return lpContains(lp2.lpFirst, lp2.lpBottom);
5102         }
5103
5104         // Returns "true" iff "*this" is (properly) contained by the range [first, bottom]
5105         // (allowing firsts to be equal, but requiring bottoms to be different.)
5106         bool lpContainedBy(BasicBlock* first, BasicBlock* bottom)
5107         {
5108             return first->bbNum <= lpFirst->bbNum && lpBottom->bbNum < bottom->bbNum;
5109         }
5110
5111         // Returns "true" iff "*this" is (properly) contained by "lp2"
5112         // (allowing firsts to be equal, but requiring bottoms to be different.)
5113         bool lpContainedBy(const LoopDsc& lp2)
5114         {
5115             return lpContains(lp2.lpFirst, lp2.lpBottom);
5116         }
5117
5118         // Returns "true" iff "*this" is disjoint from the range [top, bottom].
5119         bool lpDisjoint(BasicBlock* first, BasicBlock* bottom)
5120         {
5121             return bottom->bbNum < lpFirst->bbNum || lpBottom->bbNum < first->bbNum;
5122         }
5123         // Returns "true" iff "*this" is disjoint from "lp2".
5124         bool lpDisjoint(const LoopDsc& lp2)
5125         {
5126             return lpDisjoint(lp2.lpFirst, lp2.lpBottom);
5127         }
5128         // Returns "true" iff the loop is well-formed (see code for defn).
5129         bool lpWellFormed()
5130         {
5131             return lpFirst->bbNum <= lpTop->bbNum && lpTop->bbNum <= lpEntry->bbNum &&
5132                    lpEntry->bbNum <= lpBottom->bbNum &&
5133                    (lpHead->bbNum < lpTop->bbNum || lpHead->bbNum > lpBottom->bbNum);
5134         }
5135     };
5136
5137 protected:
5138     bool fgMightHaveLoop(); // returns true if there are any backedges
5139     bool fgHasLoops;        // True if this method has any loops, set in fgComputeReachability
5140
5141 public:
5142     LoopDsc       optLoopTable[MAX_LOOP_NUM]; // loop descriptor table
5143     unsigned char optLoopCount;               // number of tracked loops
5144
5145 protected:
5146     unsigned optCallCount;         // number of calls made in the method
5147     unsigned optIndirectCallCount; // number of virtual, interface and indirect calls made in the method
5148     unsigned optNativeCallCount;   // number of Pinvoke/Native calls made in the method
5149     unsigned optLoopsCloned;       // number of loops cloned in the current method.
5150
5151 #ifdef DEBUG
5152     unsigned optFindLoopNumberFromBeginBlock(BasicBlock* begBlk);
5153     void optPrintLoopInfo(unsigned      loopNum,
5154                           BasicBlock*   lpHead,
5155                           BasicBlock*   lpFirst,
5156                           BasicBlock*   lpTop,
5157                           BasicBlock*   lpEntry,
5158                           BasicBlock*   lpBottom,
5159                           unsigned char lpExitCnt,
5160                           BasicBlock*   lpExit,
5161                           unsigned      parentLoop = BasicBlock::NOT_IN_LOOP);
5162     void optPrintLoopInfo(unsigned lnum);
5163     void optPrintLoopRecording(unsigned lnum);
5164
5165     void optCheckPreds();
5166 #endif
5167
5168     void optSetBlockWeights();
5169
5170     void optMarkLoopBlocks(BasicBlock* begBlk, BasicBlock* endBlk, bool excludeEndBlk);
5171
5172     void optUnmarkLoopBlocks(BasicBlock* begBlk, BasicBlock* endBlk);
5173
5174     void optUpdateLoopsBeforeRemoveBlock(BasicBlock* block, bool skipUnmarkLoop = false);
5175
5176     bool optIsLoopTestEvalIntoTemp(GenTreePtr test, GenTreePtr* newTest);
5177     unsigned optIsLoopIncrTree(GenTreePtr incr);
5178     bool optCheckIterInLoopTest(unsigned loopInd, GenTreePtr test, BasicBlock* from, BasicBlock* to, unsigned iterVar);
5179     bool optComputeIterInfo(GenTreePtr incr, BasicBlock* from, BasicBlock* to, unsigned* pIterVar);
5180     bool optPopulateInitInfo(unsigned loopInd, GenTreePtr init, unsigned iterVar);
5181     bool optExtractInitTestIncr(BasicBlock* head,
5182                                 BasicBlock* bottom,
5183                                 BasicBlock* exit,
5184                                 GenTreePtr* ppInit,
5185                                 GenTreePtr* ppTest,
5186                                 GenTreePtr* ppIncr);
5187
5188     void optRecordLoop(BasicBlock*   head,
5189                        BasicBlock*   first,
5190                        BasicBlock*   top,
5191                        BasicBlock*   entry,
5192                        BasicBlock*   bottom,
5193                        BasicBlock*   exit,
5194                        unsigned char exitCnt);
5195
5196     void optFindNaturalLoops();
5197
5198     // Ensures that all the loops in the loop nest rooted at "loopInd" (an index into the loop table) are 'canonical' --
5199     // each loop has a unique "top."  Returns "true" iff the flowgraph has been modified.
5200     bool optCanonicalizeLoopNest(unsigned char loopInd);
5201
5202     // Ensures that the loop "loopInd" (an index into the loop table) is 'canonical' -- it has a unique "top,"
5203     // unshared with any other loop.  Returns "true" iff the flowgraph has been modified
5204     bool optCanonicalizeLoop(unsigned char loopInd);
5205
5206     // Requires "l1" to be a valid loop table index, and not "BasicBlock::NOT_IN_LOOP".  Requires "l2" to be
5207     // a valid loop table index, or else "BasicBlock::NOT_IN_LOOP".  Returns true
5208     // iff "l2" is not NOT_IN_LOOP, and "l1" contains "l2".
5209     bool optLoopContains(unsigned l1, unsigned l2);
5210
5211     // Requires "loopInd" to be a valid index into the loop table.
5212     // Updates the loop table by changing loop "loopInd", whose head is required
5213     // to be "from", to be "to".  Also performs this transformation for any
5214     // loop nested in "loopInd" that shares the same head as "loopInd".
5215     void optUpdateLoopHead(unsigned loopInd, BasicBlock* from, BasicBlock* to);
5216
5217     // Updates the successors of "blk": if "blk2" is a successor of "blk", and there is a mapping for "blk2->blk3" in
5218     // "redirectMap", change "blk" so that "blk3" is this successor. Note that the predecessor lists are not updated.
5219     void optRedirectBlock(BasicBlock* blk, BlockToBlockMap* redirectMap);
5220
5221     // Marks the containsCall information to "lnum" and any parent loops.
5222     void AddContainsCallAllContainingLoops(unsigned lnum);
5223     // Adds the variable liveness information from 'blk' to "lnum" and any parent loops.
5224     void AddVariableLivenessAllContainingLoops(unsigned lnum, BasicBlock* blk);
5225     // Adds "fldHnd" to the set of modified fields of "lnum" and any parent loops.
5226     void AddModifiedFieldAllContainingLoops(unsigned lnum, CORINFO_FIELD_HANDLE fldHnd);
5227     // Adds "elemType" to the set of modified array element types of "lnum" and any parent loops.
5228     void AddModifiedElemTypeAllContainingLoops(unsigned lnum, CORINFO_CLASS_HANDLE elemType);
5229
5230     // Requires that "from" and "to" have the same "bbJumpKind" (perhaps because "to" is a clone
5231     // of "from".)  Copies the jump destination from "from" to "to".
5232     void optCopyBlkDest(BasicBlock* from, BasicBlock* to);
5233
5234     // The depth of the loop described by "lnum" (an index into the loop table.) (0 == top level)
5235     unsigned optLoopDepth(unsigned lnum)
5236     {
5237         unsigned par = optLoopTable[lnum].lpParent;
5238         if (par == BasicBlock::NOT_IN_LOOP)
5239         {
5240             return 0;
5241         }
5242         else
5243         {
5244             return 1 + optLoopDepth(par);
5245         }
5246     }
5247
5248     void fgOptWhileLoop(BasicBlock* block);
5249
5250     bool optComputeLoopRep(int        constInit,
5251                            int        constLimit,
5252                            int        iterInc,
5253                            genTreeOps iterOper,
5254                            var_types  iterType,
5255                            genTreeOps testOper,
5256                            bool       unsignedTest,
5257                            bool       dupCond,
5258                            unsigned*  iterCount);
5259 #if FEATURE_STACK_FP_X87
5260
5261 public:
5262     VARSET_TP optAllFloatVars; // mask of all tracked      FP variables
5263     VARSET_TP optAllFPregVars; // mask of all enregistered FP variables
5264     VARSET_TP optAllNonFPvars; // mask of all tracked  non-FP variables
5265 #endif                         // FEATURE_STACK_FP_X87
5266
5267 private:
5268     static fgWalkPreFn optIsVarAssgCB;
5269
5270 protected:
5271     bool optIsVarAssigned(BasicBlock* beg, BasicBlock* end, GenTreePtr skip, unsigned var);
5272
5273     bool optIsVarAssgLoop(unsigned lnum, unsigned var);
5274
5275     int optIsSetAssgLoop(unsigned lnum, ALLVARSET_VALARG_TP vars, varRefKinds inds = VR_NONE);
5276
5277     bool optNarrowTree(GenTreePtr tree, var_types srct, var_types dstt, ValueNumPair vnpNarrow, bool doit);
5278
5279     /**************************************************************************
5280      *                       Optimization conditions
5281      *************************************************************************/
5282
5283     bool optFastCodeOrBlendedLoop(BasicBlock::weight_t bbWeight);
5284     bool optPentium4(void);
5285     bool optAvoidIncDec(BasicBlock::weight_t bbWeight);
5286     bool optAvoidIntMult(void);
5287
5288 #if FEATURE_ANYCSE
5289
5290 protected:
5291     //  The following is the upper limit on how many expressions we'll keep track
5292     //  of for the CSE analysis.
5293     //
5294     static const unsigned MAX_CSE_CNT = EXPSET_SZ;
5295
5296     static const int MIN_CSE_COST = 2;
5297
5298     // Keeps tracked cse indices
5299     BitVecTraits* cseTraits;
5300     EXPSET_TP     cseFull;
5301     EXPSET_TP     cseEmpty;
5302
5303     /* Generic list of nodes - used by the CSE logic */
5304
5305     struct treeLst
5306     {
5307         treeLst*   tlNext;
5308         GenTreePtr tlTree;
5309     };
5310
5311     typedef struct treeLst* treeLstPtr;
5312
5313     struct treeStmtLst
5314     {
5315         treeStmtLst* tslNext;
5316         GenTreePtr   tslTree;  // tree node
5317         GenTreePtr   tslStmt;  // statement containing the tree
5318         BasicBlock*  tslBlock; // block containing the statement
5319     };
5320
5321     typedef struct treeStmtLst* treeStmtLstPtr;
5322
5323     // The following logic keeps track of expressions via a simple hash table.
5324
5325     struct CSEdsc
5326     {
5327         CSEdsc* csdNextInBucket; // used by the hash table
5328
5329         unsigned csdHashValue; // the orginal hashkey
5330
5331         unsigned csdIndex;          // 1..optCSECandidateCount
5332         char     csdLiveAcrossCall; // 0 or 1
5333
5334         unsigned short csdDefCount; // definition   count
5335         unsigned short csdUseCount; // use          count  (excluding the implicit uses at defs)
5336
5337         unsigned csdDefWtCnt; // weighted def count
5338         unsigned csdUseWtCnt; // weighted use count  (excluding the implicit uses at defs)
5339
5340         GenTreePtr  csdTree;  // treenode containing the 1st occurance
5341         GenTreePtr  csdStmt;  // stmt containing the 1st occurance
5342         BasicBlock* csdBlock; // block containing the 1st occurance
5343
5344         treeStmtLstPtr csdTreeList; // list of matching tree nodes: head
5345         treeStmtLstPtr csdTreeLast; // list of matching tree nodes: tail
5346     };
5347
5348     static const size_t s_optCSEhashSize;
5349     CSEdsc**            optCSEhash;
5350     CSEdsc**            optCSEtab;
5351
5352     void optCSEstop();
5353
5354     CSEdsc* optCSEfindDsc(unsigned index);
5355     void optUnmarkCSE(GenTreePtr tree);
5356
5357     // user defined callback data for the tree walk function optCSE_MaskHelper()
5358     struct optCSE_MaskData
5359     {
5360         EXPSET_TP CSE_defMask;
5361         EXPSET_TP CSE_useMask;
5362     };
5363
5364     // Treewalk helper for optCSE_DefMask and optCSE_UseMask
5365     static fgWalkPreFn optCSE_MaskHelper;
5366
5367     // This function walks all the node for an given tree
5368     // and return the mask of CSE definitions and uses for the tree
5369     //
5370     void optCSE_GetMaskData(GenTreePtr tree, optCSE_MaskData* pMaskData);
5371
5372     // Given a binary tree node return true if it is safe to swap the order of evaluation for op1 and op2.
5373     bool optCSE_canSwap(GenTree* firstNode, GenTree* secondNode);
5374     bool optCSE_canSwap(GenTree* tree);
5375
5376     static fgWalkPostFn optPropagateNonCSE;
5377     static fgWalkPreFn  optHasNonCSEChild;
5378
5379     static fgWalkPreFn optUnmarkCSEs;
5380
5381     static int __cdecl optCSEcostCmpEx(const void* op1, const void* op2);
5382     static int __cdecl optCSEcostCmpSz(const void* op1, const void* op2);
5383
5384     void optCleanupCSEs();
5385
5386 #ifdef DEBUG
5387     void optEnsureClearCSEInfo();
5388 #endif // DEBUG
5389
5390 #endif // FEATURE_ANYCSE
5391
5392 #if FEATURE_VALNUM_CSE
5393     /**************************************************************************
5394      *                   Value Number based CSEs
5395      *************************************************************************/
5396
5397 public:
5398     void optOptimizeValnumCSEs();
5399
5400 protected:
5401     void     optValnumCSE_Init();
5402     unsigned optValnumCSE_Index(GenTreePtr tree, GenTreePtr stmt);
5403     unsigned optValnumCSE_Locate();
5404     void     optValnumCSE_InitDataFlow();
5405     void     optValnumCSE_DataFlow();
5406     void     optValnumCSE_Availablity();
5407     void     optValnumCSE_Heuristic();
5408     void optValnumCSE_UnmarkCSEs(GenTreePtr deadTree, GenTreePtr keepList);
5409
5410 #endif // FEATURE_VALNUM_CSE
5411
5412 #if FEATURE_ANYCSE
5413     bool     optDoCSE;             // True when we have found a duplicate CSE tree
5414     bool     optValnumCSE_phase;   // True when we are executing the optValnumCSE_phase
5415     unsigned optCSECandidateTotal; // Grand total of CSE candidates for both Lexical and ValNum
5416     unsigned optCSECandidateCount; // Count of CSE's candidates, reset for Lexical and ValNum CSE's
5417     unsigned optCSEstart;          // The first local variable number that is a CSE
5418     unsigned optCSEcount;          // The total count of CSE's introduced.
5419     unsigned optCSEweight;         // The weight of the current block when we are
5420                                    // scanning for CSE expressions
5421
5422     bool optIsCSEcandidate(GenTreePtr tree);
5423
5424     // lclNumIsTrueCSE returns true if the LclVar was introduced by the CSE phase of the compiler
5425     //
5426     bool lclNumIsTrueCSE(unsigned lclNum) const
5427     {
5428         return ((optCSEcount > 0) && (lclNum >= optCSEstart) && (lclNum < optCSEstart + optCSEcount));
5429     }
5430
5431     //  lclNumIsCSE returns true if the LclVar should be treated like a CSE with regards to constant prop.
5432     //
5433     bool lclNumIsCSE(unsigned lclNum) const
5434     {
5435         return lvaTable[lclNum].lvIsCSE;
5436     }
5437
5438 #ifdef DEBUG
5439     bool optConfigDisableCSE();
5440     bool optConfigDisableCSE2();
5441 #endif
5442     void optOptimizeCSEs();
5443
5444 #endif // FEATURE_ANYCSE
5445
5446     struct isVarAssgDsc
5447     {
5448         GenTreePtr ivaSkip;
5449 #ifdef DEBUG
5450         void* ivaSelf;
5451 #endif
5452         unsigned     ivaVar;            // Variable we are interested in, or -1
5453         ALLVARSET_TP ivaMaskVal;        // Set of variables assigned to.  This is a set of all vars, not tracked vars.
5454         bool         ivaMaskIncomplete; // Variables not representable in ivaMaskVal were assigned to.
5455         varRefKinds  ivaMaskInd;        // What kind of indirect assignments are there?
5456         callInterf   ivaMaskCall;       // What kind of calls are there?
5457     };
5458
5459     static callInterf optCallInterf(GenTreePtr call);
5460
5461 public:
5462     // VN based copy propagation.
5463     typedef ArrayStack<GenTreePtr> GenTreePtrStack;
5464     typedef SimplerHashTable<unsigned, SmallPrimitiveKeyFuncs<unsigned>, GenTreePtrStack*, JitSimplerHashBehavior>
5465         LclNumToGenTreePtrStack;
5466
5467     // Kill set to track variables with intervening definitions.
5468     VARSET_TP optCopyPropKillSet;
5469
5470     // Copy propagation functions.
5471     void optCopyProp(BasicBlock* block, GenTreePtr stmt, GenTreePtr tree, LclNumToGenTreePtrStack* curSsaName);
5472     void optBlockCopyPropPopStacks(BasicBlock* block, LclNumToGenTreePtrStack* curSsaName);
5473     void optBlockCopyProp(BasicBlock* block, LclNumToGenTreePtrStack* curSsaName);
5474     bool optIsSsaLocal(GenTreePtr tree);
5475     int optCopyProp_LclVarScore(LclVarDsc* lclVarDsc, LclVarDsc* copyVarDsc, bool preferOp2);
5476     void optVnCopyProp();
5477
5478     /**************************************************************************
5479     *               Early value propagation
5480     *************************************************************************/
5481     struct SSAName
5482     {
5483         unsigned m_lvNum;
5484         unsigned m_ssaNum;
5485
5486         SSAName(unsigned lvNum, unsigned ssaNum) : m_lvNum(lvNum), m_ssaNum(ssaNum)
5487         {
5488         }
5489
5490         static unsigned GetHashCode(SSAName ssaNm)
5491         {
5492             return (ssaNm.m_lvNum << 16) | (ssaNm.m_ssaNum);
5493         }
5494
5495         static bool Equals(SSAName ssaNm1, SSAName ssaNm2)
5496         {
5497             return (ssaNm1.m_lvNum == ssaNm2.m_lvNum) && (ssaNm1.m_ssaNum == ssaNm2.m_ssaNum);
5498         }
5499     };
5500
5501 #define OMF_HAS_NEWARRAY 0x00000001  // Method contains 'new' of an array
5502 #define OMF_HAS_NEWOBJ 0x00000002    // Method contains 'new' of an object type.
5503 #define OMF_HAS_ARRAYREF 0x00000004  // Method contains array element loads or stores.
5504 #define OMF_HAS_VTABLEREF 0x00000008 // Method contains method table reference.
5505 #define OMF_HAS_NULLCHECK 0x00000010 // Method contains null check.
5506
5507     unsigned optMethodFlags;
5508
5509     // Recursion bound controls how far we can go backwards tracking for a SSA value.
5510     // No throughput diff was found with backward walk bound between 3-8.
5511     static const int optEarlyPropRecurBound = 5;
5512
5513     enum class optPropKind
5514     {
5515         OPK_INVALID,
5516         OPK_ARRAYLEN,
5517         OPK_OBJ_GETTYPE,
5518         OPK_NULLCHECK
5519     };
5520
5521     bool gtIsVtableRef(GenTreePtr tree);
5522     GenTreePtr getArrayLengthFromAllocation(GenTreePtr tree);
5523     GenTreePtr getObjectHandleNodeFromAllocation(GenTreePtr tree);
5524     GenTreePtr optPropGetValueRec(unsigned lclNum, unsigned ssaNum, optPropKind valueKind, int walkDepth);
5525     GenTreePtr optPropGetValue(unsigned lclNum, unsigned ssaNum, optPropKind valueKind);
5526     bool optEarlyPropRewriteTree(GenTreePtr tree);
5527     bool optDoEarlyPropForBlock(BasicBlock* block);
5528     bool optDoEarlyPropForFunc();
5529     void optEarlyProp();
5530     void optFoldNullCheck(GenTreePtr tree);
5531     bool optCanMoveNullCheckPastTree(GenTreePtr tree, bool isInsideTry);
5532
5533 #if ASSERTION_PROP
5534     /**************************************************************************
5535      *               Value/Assertion propagation
5536      *************************************************************************/
5537 public:
5538     // Data structures for assertion prop
5539     BitVecTraits* apTraits;
5540     ASSERT_TP     apFull;
5541     ASSERT_TP     apEmpty;
5542
5543     enum optAssertionKind
5544     {
5545         OAK_INVALID,
5546         OAK_EQUAL,
5547         OAK_NOT_EQUAL,
5548         OAK_SUBRANGE,
5549         OAK_NO_THROW,
5550         OAK_COUNT
5551     };
5552
5553     enum optOp1Kind
5554     {
5555         O1K_INVALID,
5556         O1K_LCLVAR,
5557         O1K_ARR_BND,
5558         O1K_ARRLEN_OPER_BND,
5559         O1K_ARRLEN_LOOP_BND,
5560         O1K_CONSTANT_LOOP_BND,
5561         O1K_EXACT_TYPE,
5562         O1K_SUBTYPE,
5563         O1K_VALUE_NUMBER,
5564         O1K_COUNT
5565     };
5566
5567     enum optOp2Kind
5568     {
5569         O2K_INVALID,
5570         O2K_LCLVAR_COPY,
5571         O2K_IND_CNS_INT,
5572         O2K_CONST_INT,
5573         O2K_CONST_LONG,
5574         O2K_CONST_DOUBLE,
5575         O2K_ARR_LEN,
5576         O2K_SUBRANGE,
5577         O2K_COUNT
5578     };
5579     struct AssertionDsc
5580     {
5581         optAssertionKind assertionKind;
5582         struct SsaVar
5583         {
5584             unsigned lclNum; // assigned to or property of this local var number
5585             unsigned ssaNum;
5586         };
5587         struct ArrBnd
5588         {
5589             ValueNum vnIdx;
5590             ValueNum vnLen;
5591         };
5592         struct AssertionDscOp1
5593         {
5594             optOp1Kind kind; // a normal LclVar, or Exact-type or Subtype
5595             ValueNum   vn;
5596             union {
5597                 SsaVar lcl;
5598                 ArrBnd bnd;
5599             };
5600         } op1;
5601         struct AssertionDscOp2
5602         {
5603             optOp2Kind kind; // a const or copy assignment
5604             ValueNum   vn;
5605             struct IntVal
5606             {
5607                 ssize_t  iconVal;   // integer
5608                 unsigned iconFlags; // gtFlags
5609             };
5610             struct Range // integer subrange
5611             {
5612                 ssize_t loBound;
5613                 ssize_t hiBound;
5614             };
5615             union {
5616                 SsaVar  lcl;
5617                 IntVal  u1;
5618                 __int64 lconVal;
5619                 double  dconVal;
5620                 Range   u2;
5621             };
5622         } op2;
5623
5624         bool IsArrLenArithBound()
5625         {
5626             return ((assertionKind == OAK_EQUAL || assertionKind == OAK_NOT_EQUAL) && op1.kind == O1K_ARRLEN_OPER_BND);
5627         }
5628         bool IsArrLenBound()
5629         {
5630             return ((assertionKind == OAK_EQUAL || assertionKind == OAK_NOT_EQUAL) && op1.kind == O1K_ARRLEN_LOOP_BND);
5631         }
5632         bool IsConstantBound()
5633         {
5634             return ((assertionKind == OAK_EQUAL || assertionKind == OAK_NOT_EQUAL) &&
5635                     op1.kind == O1K_CONSTANT_LOOP_BND);
5636         }
5637         bool IsBoundsCheckNoThrow()
5638         {
5639             return ((assertionKind == OAK_NO_THROW) && (op1.kind == O1K_ARR_BND));
5640         }
5641
5642         bool IsCopyAssertion()
5643         {
5644             return ((assertionKind == OAK_EQUAL) && (op1.kind == O1K_LCLVAR) && (op2.kind == O2K_LCLVAR_COPY));
5645         }
5646
5647         static bool SameKind(AssertionDsc* a1, AssertionDsc* a2)
5648         {
5649             return a1->assertionKind == a2->assertionKind && a1->op1.kind == a2->op1.kind &&
5650                    a1->op2.kind == a2->op2.kind;
5651         }
5652
5653         static bool ComplementaryKind(optAssertionKind kind, optAssertionKind kind2)
5654         {
5655             if (kind == OAK_EQUAL)
5656             {
5657                 return kind2 == OAK_NOT_EQUAL;
5658             }
5659             else if (kind == OAK_NOT_EQUAL)
5660             {
5661                 return kind2 == OAK_EQUAL;
5662             }
5663             return false;
5664         }
5665
5666         static ssize_t GetLowerBoundForIntegralType(var_types type)
5667         {
5668             switch (type)
5669             {
5670                 case TYP_BYTE:
5671                     return SCHAR_MIN;
5672                 case TYP_SHORT:
5673                     return SHRT_MIN;
5674                 case TYP_INT:
5675                     return INT_MIN;
5676                 case TYP_BOOL:
5677                 case TYP_UBYTE:
5678                 case TYP_CHAR:
5679                 case TYP_USHORT:
5680                 case TYP_UINT:
5681                     return 0;
5682                 default:
5683                     unreached();
5684             }
5685         }
5686         static ssize_t GetUpperBoundForIntegralType(var_types type)
5687         {
5688             switch (type)
5689             {
5690                 case TYP_BOOL:
5691                     return 1;
5692                 case TYP_BYTE:
5693                     return SCHAR_MAX;
5694                 case TYP_SHORT:
5695                     return SHRT_MAX;
5696                 case TYP_INT:
5697                     return INT_MAX;
5698                 case TYP_UBYTE:
5699                     return UCHAR_MAX;
5700                 case TYP_CHAR:
5701                 case TYP_USHORT:
5702                     return USHRT_MAX;
5703                 case TYP_UINT:
5704                     return UINT_MAX;
5705                 default:
5706                     unreached();
5707             }
5708         }
5709
5710         bool HasSameOp1(AssertionDsc* that, bool vnBased)
5711         {
5712             return (op1.kind == that->op1.kind) &&
5713                    ((vnBased && (op1.vn == that->op1.vn)) || (!vnBased && (op1.lcl.lclNum == that->op1.lcl.lclNum)));
5714         }
5715
5716         bool HasSameOp2(AssertionDsc* that, bool vnBased)
5717         {
5718             if (op2.kind != that->op2.kind)
5719             {
5720                 return false;
5721             }
5722             switch (op2.kind)
5723             {
5724                 case O2K_IND_CNS_INT:
5725                 case O2K_CONST_INT:
5726                     return ((op2.u1.iconVal == that->op2.u1.iconVal) && (op2.u1.iconFlags == that->op2.u1.iconFlags));
5727
5728                 case O2K_CONST_LONG:
5729                     return (op2.lconVal == that->op2.lconVal);
5730
5731                 case O2K_CONST_DOUBLE:
5732                     // exact match because of positive and negative zero.
5733                     return (memcmp(&op2.dconVal, &that->op2.dconVal, sizeof(double)) == 0);
5734
5735                 case O2K_LCLVAR_COPY:
5736                 case O2K_ARR_LEN:
5737                     return (op2.lcl.lclNum == that->op2.lcl.lclNum) &&
5738                            (!vnBased || op2.lcl.ssaNum == that->op2.lcl.ssaNum);
5739
5740                 case O2K_SUBRANGE:
5741                     return ((op2.u2.loBound == that->op2.u2.loBound) && (op2.u2.hiBound == that->op2.u2.hiBound));
5742
5743                 case O2K_INVALID:
5744                     // we will return false
5745                     break;
5746
5747                 default:
5748                     assert(!"Unexpected value for op2.kind in AssertionDsc.");
5749                     break;
5750             }
5751             return false;
5752         }
5753
5754         bool Complementary(AssertionDsc* that, bool vnBased)
5755         {
5756             return ComplementaryKind(assertionKind, that->assertionKind) && HasSameOp1(that, vnBased) &&
5757                    HasSameOp2(that, vnBased);
5758         }
5759
5760         bool Equals(AssertionDsc* that, bool vnBased)
5761         {
5762             return (assertionKind == that->assertionKind) && HasSameOp1(that, vnBased) && HasSameOp2(that, vnBased);
5763         }
5764     };
5765
5766     typedef unsigned short AssertionIndex;
5767
5768 protected:
5769     static fgWalkPreFn optAddCopiesCallback;
5770     static fgWalkPreFn optVNAssertionPropCurStmtVisitor;
5771     unsigned           optAddCopyLclNum;
5772     GenTreePtr         optAddCopyAsgnNode;
5773
5774     bool optLocalAssertionProp;  // indicates that we are performing local assertion prop
5775     bool optAssertionPropagated; // set to true if we modified the trees
5776     bool optAssertionPropagatedCurrentStmt;
5777 #ifdef DEBUG
5778     GenTreePtr optAssertionPropCurrentTree;
5779 #endif
5780     AssertionIndex*         optComplementaryAssertionMap;
5781     ExpandArray<ASSERT_TP>* optAssertionDep; // table that holds dependent assertions (assertions
5782                                              // using the value of a local var) for each local var
5783     AssertionDsc*  optAssertionTabPrivate;   // table that holds info about value assignments
5784     AssertionIndex optAssertionCount;        // total number of assertions in the assertion table
5785     AssertionIndex optMaxAssertionCount;
5786
5787 public:
5788     void optVnNonNullPropCurStmt(BasicBlock* block, GenTreePtr stmt, GenTreePtr tree);
5789     fgWalkResult optVNConstantPropCurStmt(BasicBlock* block, GenTreePtr stmt, GenTreePtr tree);
5790     GenTreePtr optVNConstantPropOnRelOp(GenTreePtr tree);
5791     GenTreePtr optVNConstantPropOnJTrue(BasicBlock* block, GenTreePtr stmt, GenTreePtr test);
5792     GenTreePtr optVNConstantPropOnTree(BasicBlock* block, GenTreePtr stmt, GenTreePtr tree);
5793     GenTreePtr optPrepareTreeForReplacement(GenTreePtr extractTree, GenTreePtr replaceTree);
5794
5795     AssertionIndex GetAssertionCount()
5796     {
5797         return optAssertionCount;
5798     }
5799     ASSERT_TP* bbJtrueAssertionOut;
5800     typedef SimplerHashTable<ValueNum, SmallPrimitiveKeyFuncs<ValueNum>, ASSERT_TP, JitSimplerHashBehavior>
5801                           ValueNumToAssertsMap;
5802     ValueNumToAssertsMap* optValueNumToAsserts;
5803
5804     static const AssertionIndex NO_ASSERTION_INDEX = 0;
5805
5806     // Assertion prop helpers.
5807     ASSERT_TP& GetAssertionDep(unsigned lclNum);
5808     AssertionDsc* optGetAssertion(AssertionIndex assertIndex);
5809     void optAssertionInit(bool isLocalProp);
5810     void optAssertionTraitsInit(AssertionIndex assertionCount);
5811 #if LOCAL_ASSERTION_PROP
5812     void optAssertionReset(AssertionIndex limit);
5813     void optAssertionRemove(AssertionIndex index);
5814 #endif
5815
5816     // Assertion prop data flow functions.
5817     void       optAssertionPropMain();
5818     GenTreePtr optVNAssertionPropCurStmt(BasicBlock* block, GenTreePtr stmt);
5819     bool optIsTreeKnownIntValue(bool vnBased, GenTreePtr tree, ssize_t* pConstant, unsigned* pIconFlags);
5820     ASSERT_TP* optInitAssertionDataflowFlags();
5821     ASSERT_TP* optComputeAssertionGen();
5822
5823     // Assertion Gen functions.
5824     void optAssertionGen(GenTreePtr tree);
5825     AssertionIndex optAssertionGenPhiDefn(GenTreePtr tree);
5826     AssertionIndex optCreateJTrueBoundsAssertion(GenTreePtr tree);
5827     AssertionIndex optAssertionGenJtrue(GenTreePtr tree);
5828     AssertionIndex optCreateJtrueAssertions(GenTreePtr op1, GenTreePtr op2, Compiler::optAssertionKind assertionKind);
5829     AssertionIndex optFindComplementary(AssertionIndex assertionIndex);
5830     void optMapComplementary(AssertionIndex assertionIndex, AssertionIndex index);
5831
5832     // Assertion creation functions.
5833     AssertionIndex optCreateAssertion(GenTreePtr op1, GenTreePtr op2, optAssertionKind assertionKind);
5834     AssertionIndex optCreateAssertion(GenTreePtr       op1,
5835                                       GenTreePtr       op2,
5836                                       optAssertionKind assertionKind,
5837                                       AssertionDsc*    assertion);
5838     void optCreateComplementaryAssertion(AssertionIndex assertionIndex, GenTreePtr op1, GenTreePtr op2);
5839
5840     bool optAssertionVnInvolvesNan(AssertionDsc* assertion);
5841     AssertionIndex optAddAssertion(AssertionDsc* assertion);
5842     void optAddVnAssertionMapping(ValueNum vn, AssertionIndex index);
5843 #ifdef DEBUG
5844     void optPrintVnAssertionMapping();
5845 #endif
5846     ASSERT_TP optGetVnMappedAssertions(ValueNum vn);
5847
5848     // Used for respective assertion propagations.
5849     AssertionIndex optAssertionIsSubrange(GenTreePtr tree, var_types toType, ASSERT_VALARG_TP assertions);
5850     AssertionIndex optAssertionIsSubtype(GenTreePtr tree, GenTreePtr methodTableArg, ASSERT_VALARG_TP assertions);
5851     AssertionIndex optAssertionIsNonNullInternal(GenTreePtr op, ASSERT_VALARG_TP assertions);
5852     bool optAssertionIsNonNull(GenTreePtr       op,
5853                                ASSERT_VALARG_TP assertions DEBUGARG(bool* pVnBased) DEBUGARG(AssertionIndex* pIndex));
5854
5855     // Used for Relop propagation.
5856     AssertionIndex optGlobalAssertionIsEqualOrNotEqual(ASSERT_VALARG_TP assertions, GenTreePtr op1, GenTreePtr op2);
5857     AssertionIndex optLocalAssertionIsEqualOrNotEqual(
5858         optOp1Kind op1Kind, unsigned lclNum, optOp2Kind op2Kind, ssize_t cnsVal, ASSERT_VALARG_TP assertions);
5859
5860     // Assertion prop for lcl var functions.
5861     bool optAssertionProp_LclVarTypeCheck(GenTreePtr tree, LclVarDsc* lclVarDsc, LclVarDsc* copyVarDsc);
5862     GenTreePtr optCopyAssertionProp(AssertionDsc* curAssertion,
5863                                     GenTreePtr    tree,
5864                                     GenTreePtr stmt DEBUGARG(AssertionIndex index));
5865     GenTreePtr optConstantAssertionProp(AssertionDsc*    curAssertion,
5866                                         const GenTreePtr tree,
5867                                         const GenTreePtr stmt DEBUGARG(AssertionIndex index));
5868     GenTreePtr optVnConstantAssertionProp(const GenTreePtr tree, const GenTreePtr stmt);
5869
5870     // Assertion propagation functions.
5871     GenTreePtr optAssertionProp(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5872     GenTreePtr optAssertionProp_LclVar(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5873     GenTreePtr optAssertionProp_Ind(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5874     GenTreePtr optAssertionProp_Cast(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5875     GenTreePtr optAssertionProp_Call(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5876     GenTreePtr optAssertionProp_RelOp(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5877     GenTreePtr optAssertionProp_Comma(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5878     GenTreePtr optAssertionProp_BndsChk(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5879     GenTreePtr optAssertionPropGlobal_RelOp(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5880     GenTreePtr optAssertionPropLocal_RelOp(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5881     GenTreePtr optAssertionProp_Update(const GenTreePtr newTree, const GenTreePtr tree, const GenTreePtr stmt);
5882     GenTreePtr optNonNullAssertionProp_Call(ASSERT_VALARG_TP assertions, const GenTreePtr tree, const GenTreePtr stmt);
5883
5884     // Implied assertion functions.
5885     void optImpliedAssertions(AssertionIndex assertionIndex, ASSERT_TP& activeAssertions);
5886     void optImpliedByTypeOfAssertions(ASSERT_TP& activeAssertions);
5887     void optImpliedByCopyAssertion(AssertionDsc* copyAssertion, AssertionDsc* depAssertion, ASSERT_TP& result);
5888     void optImpliedByConstAssertion(AssertionDsc* curAssertion, ASSERT_TP& result);
5889
5890     ASSERT_VALRET_TP optNewFullAssertSet();
5891     ASSERT_VALRET_TP optNewEmptyAssertSet();
5892
5893 #ifdef DEBUG
5894     void optPrintAssertion(AssertionDsc* newAssertion, AssertionIndex assertionIndex = 0);
5895     void optDebugCheckAssertion(AssertionDsc* assertion);
5896     void optDebugCheckAssertions(AssertionIndex AssertionIndex);
5897 #endif
5898     void optAddCopies();
5899 #endif // ASSERTION_PROP
5900
5901     /**************************************************************************
5902      *                          Range checks
5903      *************************************************************************/
5904
5905 public:
5906     struct LoopCloneVisitorInfo
5907     {
5908         LoopCloneContext* context;
5909         unsigned          loopNum;
5910         GenTreePtr        stmt;
5911         LoopCloneVisitorInfo(LoopCloneContext* context, unsigned loopNum, GenTreePtr stmt)
5912             : context(context), loopNum(loopNum), stmt(nullptr)
5913         {
5914         }
5915     };
5916
5917     bool optIsStackLocalInvariant(unsigned loopNum, unsigned lclNum);
5918     bool optExtractArrIndex(GenTreePtr tree, ArrIndex* result, unsigned lhsNum);
5919     bool optReconstructArrIndex(GenTreePtr tree, ArrIndex* result, unsigned lhsNum);
5920     bool optIdentifyLoopOptInfo(unsigned loopNum, LoopCloneContext* context);
5921     static fgWalkPreFn optCanOptimizeByLoopCloningVisitor;
5922     fgWalkResult optCanOptimizeByLoopCloning(GenTreePtr tree, LoopCloneVisitorInfo* info);
5923     void optObtainLoopCloningOpts(LoopCloneContext* context);
5924     bool optIsLoopClonable(unsigned loopInd);
5925
5926     bool optCanCloneLoops();
5927
5928 #ifdef DEBUG
5929     void optDebugLogLoopCloning(BasicBlock* block, GenTreePtr insertBefore);
5930 #endif
5931     void optPerformStaticOptimizations(unsigned loopNum, LoopCloneContext* context DEBUGARG(bool fastPath));
5932     bool optComputeDerefConditions(unsigned loopNum, LoopCloneContext* context);
5933     bool optDeriveLoopCloningConditions(unsigned loopNum, LoopCloneContext* context);
5934     BasicBlock* optInsertLoopChoiceConditions(LoopCloneContext* context,
5935                                               unsigned          loopNum,
5936                                               BasicBlock*       head,
5937                                               BasicBlock*       slow);
5938     void optInsertLoopCloningStress(BasicBlock* head);
5939
5940 #if COUNT_RANGECHECKS
5941     static unsigned optRangeChkRmv;
5942     static unsigned optRangeChkAll;
5943 #endif
5944
5945 protected:
5946     struct arraySizes
5947     {
5948         unsigned arrayVar;
5949         int      arrayDim;
5950
5951 #define MAX_ARRAYS 4 // a magic max number of arrays tracked for bounds check elimination
5952     };
5953
5954     struct RngChkDsc
5955     {
5956         RngChkDsc* rcdNextInBucket; // used by the hash table
5957
5958         unsigned short rcdHashValue; // to make matching faster
5959         unsigned short rcdIndex;     // 0..optRngChkCount-1
5960
5961         GenTreePtr rcdTree; // the array index tree
5962     };
5963
5964     unsigned            optRngChkCount;
5965     static const size_t optRngChkHashSize;
5966
5967     ssize_t optGetArrayRefScaleAndIndex(GenTreePtr mul, GenTreePtr* pIndex DEBUGARG(bool bRngChk));
5968     GenTreePtr optFindLocalInit(BasicBlock* block, GenTreePtr local, VARSET_TP* pKilledInOut, bool* isKilledAfterInit);
5969
5970     bool optReachWithoutCall(BasicBlock* srcBB, BasicBlock* dstBB);
5971
5972 protected:
5973     bool optLoopsMarked;
5974
5975     /*
5976     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
5977     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
5978     XX                                                                           XX
5979     XX                           RegAlloc                                        XX
5980     XX                                                                           XX
5981     XX  Does the register allocation and puts the remaining lclVars on the stack XX
5982     XX                                                                           XX
5983     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
5984     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
5985     */
5986
5987 public:
5988 #ifndef LEGACY_BACKEND
5989     bool doLSRA() const
5990     {
5991         return true;
5992     }
5993 #else  // LEGACY_BACKEND
5994     bool doLSRA() const
5995     {
5996         return false;
5997     }
5998 #endif // LEGACY_BACKEND
5999
6000 #ifdef LEGACY_BACKEND
6001     void raInit();
6002     void raAssignVars(); // register allocation
6003 #endif                   // LEGACY_BACKEND
6004
6005     VARSET_TP raRegVarsMask; // Set of all enregistered variables (not including FEATURE_STACK_FP_X87 enregistered
6006                              // variables)
6007     regNumber raUpdateRegStateForArg(RegState* regState, LclVarDsc* argDsc);
6008
6009     void raMarkStkVars();
6010
6011 protected:
6012     // Some things are used by both LSRA and regpredict allocators.
6013
6014     FrameType rpFrameType;
6015     bool      rpMustCreateEBPCalled; // Set to true after we have called rpMustCreateEBPFrame once
6016
6017 #ifdef LEGACY_BACKEND
6018     regMaskTP rpMaskPInvokeEpilogIntf; // pinvoke epilog trashes esi/edi holding stack args needed to setup tail call's
6019                                        // args
6020 #endif                                 // LEGACY_BACKEND
6021
6022     bool rpMustCreateEBPFrame(INDEBUG(const char** wbReason));
6023
6024 #if FEATURE_FP_REGALLOC
6025     enum enumConfigRegisterFP
6026     {
6027         CONFIG_REGISTER_FP_NONE         = 0x0,
6028         CONFIG_REGISTER_FP_CALLEE_TRASH = 0x1,
6029         CONFIG_REGISTER_FP_CALLEE_SAVED = 0x2,
6030         CONFIG_REGISTER_FP_FULL         = 0x3,
6031     };
6032     enumConfigRegisterFP raConfigRegisterFP();
6033 #endif // FEATURE_FP_REGALLOC
6034
6035 public:
6036     regMaskTP raConfigRestrictMaskFP();
6037
6038 private:
6039 #ifndef LEGACY_BACKEND
6040     LinearScanInterface* m_pLinearScan; // Linear Scan allocator
6041 #else                                   // LEGACY_BACKEND
6042     unsigned  raAvoidArgRegMask;       // Mask of incoming argument registers that we may need to avoid
6043     VARSET_TP raLclRegIntf[REG_COUNT]; // variable to register interference graph
6044     bool      raNewBlocks;             // True is we added killing blocks for FPU registers
6045     unsigned  rpPasses;                // Number of passes made by the register predicter
6046     unsigned  rpPassesMax;             // Maximum number of passes made by the register predicter
6047     unsigned  rpPassesPessimize;       // Number of passes non-pessimizing made by the register predicter
6048     unsigned rpStkPredict; // Weighted count of variables were predicted STK (lower means register allocation is better)
6049     unsigned rpPredictSpillCnt;     // Predicted number of integer spill tmps for the current tree
6050     regMaskTP rpPredictAssignMask;  // Mask of registers to consider in rpPredictAssignRegVars()
6051     VARSET_TP rpLastUseVars;        // Set of last use variables in rpPredictTreeRegUse
6052     VARSET_TP rpUseInPlace;         // Set of variables that we used in place
6053     int       rpAsgVarNum;          // VarNum for the target of GT_ASG node
6054     bool      rpPredictAssignAgain; // Must rerun the rpPredictAssignRegVars()
6055     bool      rpAddedVarIntf;       // Set to true if we need to add a new var intf
6056     bool      rpLostEnreg;          // Set to true if we lost an enregister var that had lvDependReg set
6057     bool      rpReverseEBPenreg;    // Decided to reverse the enregistration of EBP
6058 public:
6059     bool rpRegAllocDone; // Set to true after we have completed register allocation
6060 private:
6061     regMaskTP rpPredictMap[PREDICT_COUNT]; // Holds the regMaskTP for each of the enum values
6062
6063     void raSetupArgMasks(RegState* r);
6064
6065     const regNumber* raGetRegVarOrder(var_types regType, unsigned* wbVarOrderSize);
6066 #ifdef DEBUG
6067     void raDumpVarIntf(); // Dump the variable to variable interference graph
6068     void raDumpRegIntf(); // Dump the variable to register interference graph
6069 #endif
6070     void raAdjustVarIntf();
6071
6072     regMaskTP rpPredictRegMask(rpPredictReg predictReg, var_types type);
6073
6074     bool rpRecordRegIntf(regMaskTP regMask, VARSET_VALARG_TP life DEBUGARG(const char* msg));
6075
6076     bool rpRecordVarIntf(unsigned varNum, VARSET_VALARG_TP intfVar DEBUGARG(const char* msg));
6077     regMaskTP rpPredictRegPick(var_types type, rpPredictReg predictReg, regMaskTP lockedRegs);
6078
6079     regMaskTP rpPredictGrabReg(var_types type, rpPredictReg predictReg, regMaskTP lockedRegs);
6080
6081     static fgWalkPreFn rpMarkRegIntf;
6082
6083     regMaskTP rpPredictAddressMode(
6084         GenTreePtr tree, var_types type, regMaskTP lockedRegs, regMaskTP rsvdRegs, GenTreePtr lenCSE);
6085
6086     void rpPredictRefAssign(unsigned lclNum);
6087
6088     regMaskTP rpPredictBlkAsgRegUse(GenTreePtr tree, rpPredictReg predictReg, regMaskTP lockedRegs, regMaskTP rsvdRegs);
6089
6090     regMaskTP rpPredictTreeRegUse(GenTreePtr tree, rpPredictReg predictReg, regMaskTP lockedRegs, regMaskTP rsvdRegs);
6091
6092     regMaskTP rpPredictAssignRegVars(regMaskTP regAvail);
6093
6094     void rpPredictRegUse(); // Entry point
6095
6096     unsigned raPredictTreeRegUse(GenTreePtr tree);
6097     unsigned raPredictListRegUse(GenTreePtr list);
6098
6099     void raSetRegVarOrder(var_types  regType,
6100                           regNumber* customVarOrder,
6101                           unsigned*  customVarOrderSize,
6102                           regMaskTP  prefReg,
6103                           regMaskTP  avoidReg);
6104
6105     // We use (unsigned)-1 as an uninitialized sentinel for rpStkPredict and
6106     // also as the maximum value of lvRefCntWtd. Don't allow overflow, and
6107     // saturate at UINT_MAX - 1, to avoid using the sentinel.
6108     void raAddToStkPredict(unsigned val)
6109     {
6110         unsigned newStkPredict = rpStkPredict + val;
6111         if ((newStkPredict < rpStkPredict) || (newStkPredict == UINT_MAX))
6112             rpStkPredict = UINT_MAX - 1;
6113         else
6114             rpStkPredict = newStkPredict;
6115     }
6116
6117 #ifdef DEBUG
6118 #if !FEATURE_FP_REGALLOC
6119     void raDispFPlifeInfo();
6120 #endif
6121 #endif
6122
6123     regMaskTP genReturnRegForTree(GenTreePtr tree);
6124 #endif // LEGACY_BACKEND
6125
6126     /* raIsVarargsStackArg is called by raMaskStkVars and by
6127        lvaSortByRefCount.  It identifies the special case
6128        where a varargs function has a parameter passed on the
6129        stack, other than the special varargs handle.  Such parameters
6130        require special treatment, because they cannot be tracked
6131        by the GC (their offsets in the stack are not known
6132        at compile time).
6133     */
6134
6135     bool raIsVarargsStackArg(unsigned lclNum)
6136     {
6137 #ifdef _TARGET_X86_
6138
6139         LclVarDsc* varDsc = &lvaTable[lclNum];
6140
6141         assert(varDsc->lvIsParam);
6142
6143         return (info.compIsVarArgs && !varDsc->lvIsRegArg && (lclNum != lvaVarargsHandleArg));
6144
6145 #else // _TARGET_X86_
6146
6147         return false;
6148
6149 #endif // _TARGET_X86_
6150     }
6151
6152 #ifdef LEGACY_BACKEND
6153     // Records the current prediction, if it's better than any previous recorded prediction.
6154     void rpRecordPrediction();
6155     // Applies the best recorded prediction, if one exists and is better than the current prediction.
6156     void rpUseRecordedPredictionIfBetter();
6157
6158     // Data members used in the methods above.
6159     unsigned rpBestRecordedStkPredict;
6160     struct VarRegPrediction
6161     {
6162         bool           m_isEnregistered;
6163         regNumberSmall m_regNum;
6164         regNumberSmall m_otherReg;
6165     };
6166     VarRegPrediction* rpBestRecordedPrediction;
6167 #endif // LEGACY_BACKEND
6168
6169     /*
6170     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6171     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6172     XX                                                                           XX
6173     XX                           EEInterface                                     XX
6174     XX                                                                           XX
6175     XX   Get to the class and method info from the Execution Engine given        XX
6176     XX   tokens for the class and method                                         XX
6177     XX                                                                           XX
6178     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6179     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6180     */
6181
6182 public:
6183     /* These are the different addressing modes used to access a local var.
6184      * The JIT has to report the location of the locals back to the EE
6185      * for debugging purposes.
6186      */
6187
6188     enum siVarLocType
6189     {
6190         VLT_REG,
6191         VLT_REG_BYREF, // this type is currently only used for value types on X64
6192         VLT_REG_FP,
6193         VLT_STK,
6194         VLT_STK_BYREF, // this type is currently only used for value types on X64
6195         VLT_REG_REG,
6196         VLT_REG_STK,
6197         VLT_STK_REG,
6198         VLT_STK2,
6199         VLT_FPSTK,
6200         VLT_FIXED_VA,
6201
6202         VLT_COUNT,
6203         VLT_INVALID
6204     };
6205
6206     struct siVarLoc
6207     {
6208         siVarLocType vlType;
6209
6210         union {
6211             // VLT_REG/VLT_REG_FP -- Any pointer-sized enregistered value (TYP_INT, TYP_REF, etc)
6212             // eg. EAX
6213             // VLT_REG_BYREF -- the specified register contains the address of the variable
6214             // eg. [EAX]
6215
6216             struct
6217             {
6218                 regNumber vlrReg;
6219             } vlReg;
6220
6221             // VLT_STK       -- Any 32 bit value which is on the stack
6222             // eg. [ESP+0x20], or [EBP-0x28]
6223             // VLT_STK_BYREF -- the specified stack location contains the address of the variable
6224             // eg. mov EAX, [ESP+0x20]; [EAX]
6225
6226             struct
6227             {
6228                 regNumber     vlsBaseReg;
6229                 NATIVE_OFFSET vlsOffset;
6230             } vlStk;
6231
6232             // VLT_REG_REG -- TYP_LONG/TYP_DOUBLE with both DWords enregistered
6233             // eg. RBM_EAXEDX
6234
6235             struct
6236             {
6237                 regNumber vlrrReg1;
6238                 regNumber vlrrReg2;
6239             } vlRegReg;
6240
6241             // VLT_REG_STK -- Partly enregistered TYP_LONG/TYP_DOUBLE
6242             // eg { LowerDWord=EAX UpperDWord=[ESP+0x8] }
6243
6244             struct
6245             {
6246                 regNumber vlrsReg;
6247
6248                 struct
6249                 {
6250                     regNumber     vlrssBaseReg;
6251                     NATIVE_OFFSET vlrssOffset;
6252                 } vlrsStk;
6253             } vlRegStk;
6254
6255             // VLT_STK_REG -- Partly enregistered TYP_LONG/TYP_DOUBLE
6256             // eg { LowerDWord=[ESP+0x8] UpperDWord=EAX }
6257
6258             struct
6259             {
6260                 struct
6261                 {
6262                     regNumber     vlsrsBaseReg;
6263                     NATIVE_OFFSET vlsrsOffset;
6264                 } vlsrStk;
6265
6266                 regNumber vlsrReg;
6267             } vlStkReg;
6268
6269             // VLT_STK2 -- Any 64 bit value which is on the stack, in 2 successsive DWords
6270             // eg 2 DWords at [ESP+0x10]
6271
6272             struct
6273             {
6274                 regNumber     vls2BaseReg;
6275                 NATIVE_OFFSET vls2Offset;
6276             } vlStk2;
6277
6278             // VLT_FPSTK -- enregisterd TYP_DOUBLE (on the FP stack)
6279             // eg. ST(3). Actually it is ST("FPstkHeight - vpFpStk")
6280
6281             struct
6282             {
6283                 unsigned vlfReg;
6284             } vlFPstk;
6285
6286             // VLT_FIXED_VA -- fixed argument of a varargs function.
6287             // The argument location depends on the size of the variable
6288             // arguments (...). Inspecting the VARARGS_HANDLE indicates the
6289             // location of the first arg. This argument can then be accessed
6290             // relative to the position of the first arg
6291
6292             struct
6293             {
6294                 unsigned vlfvOffset;
6295             } vlFixedVarArg;
6296
6297             // VLT_MEMORY
6298
6299             struct
6300             {
6301                 void* rpValue; // pointer to the in-process
6302                                // location of the value.
6303             } vlMemory;
6304         };
6305
6306         // Helper functions
6307
6308         bool vlIsInReg(regNumber reg);
6309         bool vlIsOnStk(regNumber reg, signed offset);
6310     };
6311
6312     /*************************************************************************/
6313
6314 public:
6315     // Get handles
6316
6317     void eeGetCallInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
6318                        CORINFO_RESOLVED_TOKEN* pConstrainedToken,
6319                        CORINFO_CALLINFO_FLAGS  flags,
6320                        CORINFO_CALL_INFO*      pResult);
6321     inline CORINFO_CALLINFO_FLAGS addVerifyFlag(CORINFO_CALLINFO_FLAGS flags);
6322
6323     void eeGetFieldInfo(CORINFO_RESOLVED_TOKEN* pResolvedToken,
6324                         CORINFO_ACCESS_FLAGS    flags,
6325                         CORINFO_FIELD_INFO*     pResult);
6326
6327     // Get the flags
6328
6329     BOOL eeIsValueClass(CORINFO_CLASS_HANDLE clsHnd);
6330
6331 #if defined(DEBUG) || defined(FEATURE_JIT_METHOD_PERF) || defined(FEATURE_SIMD) || defined(TRACK_LSRA_STATS)
6332
6333     bool IsSuperPMIException(unsigned code)
6334     {
6335         // Copied from NDP\clr\src\ToolBox\SuperPMI\SuperPMI-Shared\ErrorHandling.h
6336
6337         const unsigned EXCEPTIONCODE_DebugBreakorAV = 0xe0421000;
6338         const unsigned EXCEPTIONCODE_MC             = 0xe0422000;
6339         const unsigned EXCEPTIONCODE_LWM            = 0xe0423000;
6340         const unsigned EXCEPTIONCODE_SASM           = 0xe0424000;
6341         const unsigned EXCEPTIONCODE_SSYM           = 0xe0425000;
6342         const unsigned EXCEPTIONCODE_CALLUTILS      = 0xe0426000;
6343         const unsigned EXCEPTIONCODE_TYPEUTILS      = 0xe0427000;
6344         const unsigned EXCEPTIONCODE_ASSERT         = 0xe0440000;
6345
6346         switch (code)
6347         {
6348             case EXCEPTIONCODE_DebugBreakorAV:
6349             case EXCEPTIONCODE_MC:
6350             case EXCEPTIONCODE_LWM:
6351             case EXCEPTIONCODE_SASM:
6352             case EXCEPTIONCODE_SSYM:
6353             case EXCEPTIONCODE_CALLUTILS:
6354             case EXCEPTIONCODE_TYPEUTILS:
6355             case EXCEPTIONCODE_ASSERT:
6356                 return true;
6357             default:
6358                 return false;
6359         }
6360     }
6361
6362     const char* eeGetMethodName(CORINFO_METHOD_HANDLE hnd, const char** className);
6363     const char* eeGetMethodFullName(CORINFO_METHOD_HANDLE hnd);
6364
6365     bool eeIsNativeMethod(CORINFO_METHOD_HANDLE method);
6366     CORINFO_METHOD_HANDLE eeGetMethodHandleForNative(CORINFO_METHOD_HANDLE method);
6367 #endif
6368
6369     var_types eeGetArgType(CORINFO_ARG_LIST_HANDLE list, CORINFO_SIG_INFO* sig);
6370     var_types eeGetArgType(CORINFO_ARG_LIST_HANDLE list, CORINFO_SIG_INFO* sig, bool* isPinned);
6371     unsigned eeGetArgSize(CORINFO_ARG_LIST_HANDLE list, CORINFO_SIG_INFO* sig);
6372
6373     // VOM info, method sigs
6374
6375     void eeGetSig(unsigned               sigTok,
6376                   CORINFO_MODULE_HANDLE  scope,
6377                   CORINFO_CONTEXT_HANDLE context,
6378                   CORINFO_SIG_INFO*      retSig);
6379
6380     void eeGetCallSiteSig(unsigned               sigTok,
6381                           CORINFO_MODULE_HANDLE  scope,
6382                           CORINFO_CONTEXT_HANDLE context,
6383                           CORINFO_SIG_INFO*      retSig);
6384
6385     void eeGetMethodSig(CORINFO_METHOD_HANDLE methHnd, CORINFO_SIG_INFO* retSig, CORINFO_CLASS_HANDLE owner = nullptr);
6386
6387     // Method entry-points, instrs
6388
6389     void* eeGetFieldAddress(CORINFO_FIELD_HANDLE handle, void*** ppIndir);
6390
6391     CORINFO_METHOD_HANDLE eeMarkNativeTarget(CORINFO_METHOD_HANDLE method);
6392
6393     CORINFO_EE_INFO eeInfo;
6394     bool            eeInfoInitialized;
6395
6396     CORINFO_EE_INFO* eeGetEEInfo();
6397
6398     // Gets the offset of a SDArray's first element
6399     unsigned eeGetArrayDataOffset(var_types type);
6400     // Gets the offset of a MDArray's first element
6401     unsigned eeGetMDArrayDataOffset(var_types type, unsigned rank);
6402
6403     GenTreePtr eeGetPInvokeCookie(CORINFO_SIG_INFO* szMetaSig);
6404
6405     // Returns the page size for the target machine as reported by the EE.
6406     inline size_t eeGetPageSize()
6407     {
6408 #if COR_JIT_EE_VERSION > 460
6409         return eeGetEEInfo()->osPageSize;
6410 #else  // COR_JIT_EE_VERSION <= 460
6411         return CORINFO_PAGE_SIZE;
6412 #endif // COR_JIT_EE_VERSION > 460
6413     }
6414
6415     // Returns the frame size at which we will generate a loop to probe the stack.
6416     inline size_t getVeryLargeFrameSize()
6417     {
6418 #ifdef _TARGET_ARM_
6419         // The looping probe code is 40 bytes, whereas the straight-line probing for
6420         // the (0x2000..0x3000) case is 44, so use looping for anything 0x2000 bytes
6421         // or greater, to generate smaller code.
6422         return 2 * eeGetPageSize();
6423 #else
6424         return 3 * eeGetPageSize();
6425 #endif
6426     }
6427
6428     inline bool IsTargetAbi(CORINFO_RUNTIME_ABI abi)
6429     {
6430 #if COR_JIT_EE_VERSION > 460
6431         return eeGetEEInfo()->targetAbi == abi;
6432 #else
6433         return CORINFO_DESKTOP_ABI == abi;
6434 #endif
6435     }
6436
6437     inline bool generateCFIUnwindCodes()
6438     {
6439 #ifdef UNIX_AMD64_ABI
6440         return IsTargetAbi(CORINFO_CORERT_ABI);
6441 #else
6442         return false;
6443 #endif
6444     }
6445
6446     // Exceptions
6447
6448     unsigned eeGetEHcount(CORINFO_METHOD_HANDLE handle);
6449
6450     // Debugging support - Line number info
6451
6452     void eeGetStmtOffsets();
6453
6454     unsigned eeBoundariesCount;
6455
6456     struct boundariesDsc
6457     {
6458         UNATIVE_OFFSET nativeIP;
6459         IL_OFFSET      ilOffset;
6460         unsigned       sourceReason;
6461     } * eeBoundaries; // Boundaries to report to EE
6462     void eeSetLIcount(unsigned count);
6463     void eeSetLIinfo(unsigned which, UNATIVE_OFFSET offs, unsigned srcIP, bool stkEmpty, bool callInstruction);
6464     void eeSetLIdone();
6465
6466 #ifdef DEBUG
6467     static void eeDispILOffs(IL_OFFSET offs);
6468     static void eeDispLineInfo(const boundariesDsc* line);
6469     void eeDispLineInfos();
6470 #endif // DEBUG
6471
6472     // Debugging support - Local var info
6473
6474     void eeGetVars();
6475
6476     unsigned eeVarsCount;
6477
6478     struct VarResultInfo
6479     {
6480         UNATIVE_OFFSET startOffset;
6481         UNATIVE_OFFSET endOffset;
6482         DWORD          varNumber;
6483         siVarLoc       loc;
6484     } * eeVars;
6485     void eeSetLVcount(unsigned count);
6486     void eeSetLVinfo(unsigned        which,
6487                      UNATIVE_OFFSET  startOffs,
6488                      UNATIVE_OFFSET  length,
6489                      unsigned        varNum,
6490                      unsigned        LVnum,
6491                      VarName         namex,
6492                      bool            avail,
6493                      const siVarLoc& loc);
6494     void eeSetLVdone();
6495
6496 #ifdef DEBUG
6497     void eeDispVar(ICorDebugInfo::NativeVarInfo* var);
6498     void eeDispVars(CORINFO_METHOD_HANDLE ftn, ULONG32 cVars, ICorDebugInfo::NativeVarInfo* vars);
6499 #endif // DEBUG
6500
6501     // ICorJitInfo wrappers
6502
6503     void eeReserveUnwindInfo(BOOL isFunclet, BOOL isColdCode, ULONG unwindSize);
6504
6505     void eeAllocUnwindInfo(BYTE*          pHotCode,
6506                            BYTE*          pColdCode,
6507                            ULONG          startOffset,
6508                            ULONG          endOffset,
6509                            ULONG          unwindSize,
6510                            BYTE*          pUnwindBlock,
6511                            CorJitFuncKind funcKind);
6512
6513     void eeSetEHcount(unsigned cEH);
6514
6515     void eeSetEHinfo(unsigned EHnumber, const CORINFO_EH_CLAUSE* clause);
6516
6517     WORD eeGetRelocTypeHint(void* target);
6518
6519     // ICorStaticInfo wrapper functions
6520
6521     bool eeTryResolveToken(CORINFO_RESOLVED_TOKEN* resolvedToken);
6522
6523 #if defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
6524 #ifdef DEBUG
6525     static void dumpSystemVClassificationType(SystemVClassificationType ct);
6526 #endif // DEBUG
6527
6528     void eeGetSystemVAmd64PassStructInRegisterDescriptor(
6529         /*IN*/ CORINFO_CLASS_HANDLE                                  structHnd,
6530         /*OUT*/ SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR* structPassInRegDescPtr);
6531 #endif // FEATURE_UNIX_AMD64_STRUCT_PASSING
6532
6533     template <typename ParamType>
6534     bool eeRunWithErrorTrap(void (*function)(ParamType*), ParamType* param)
6535     {
6536         return eeRunWithErrorTrapImp(reinterpret_cast<void (*)(void*)>(function), reinterpret_cast<void*>(param));
6537     }
6538
6539     bool eeRunWithErrorTrapImp(void (*function)(void*), void* param);
6540
6541     // Utility functions
6542
6543     const char* eeGetFieldName(CORINFO_FIELD_HANDLE fieldHnd, const char** classNamePtr = nullptr);
6544
6545 #if defined(DEBUG)
6546     const wchar_t* eeGetCPString(size_t stringHandle);
6547 #endif
6548
6549     const char* eeGetClassName(CORINFO_CLASS_HANDLE clsHnd);
6550
6551     static CORINFO_METHOD_HANDLE eeFindHelper(unsigned helper);
6552     static CorInfoHelpFunc eeGetHelperNum(CORINFO_METHOD_HANDLE method);
6553
6554     static fgWalkPreFn CountSharedStaticHelper;
6555     static bool IsSharedStaticHelper(GenTreePtr tree);
6556     static bool IsTreeAlwaysHoistable(GenTreePtr tree);
6557
6558     static CORINFO_FIELD_HANDLE eeFindJitDataOffs(unsigned jitDataOffs);
6559     // returns true/false if 'field' is a Jit Data offset
6560     static bool eeIsJitDataOffs(CORINFO_FIELD_HANDLE field);
6561     // returns a number < 0 if 'field' is not a Jit Data offset, otherwise the data offset (limited to 2GB)
6562     static int eeGetJitDataOffs(CORINFO_FIELD_HANDLE field);
6563
6564     /*****************************************************************************/
6565
6566 public:
6567     void tmpInit();
6568
6569     enum TEMP_USAGE_TYPE
6570     {
6571         TEMP_USAGE_FREE,
6572         TEMP_USAGE_USED
6573     };
6574
6575     static var_types tmpNormalizeType(var_types type);
6576     TempDsc* tmpGetTemp(var_types type); // get temp for the given type
6577     void tmpRlsTemp(TempDsc* temp);
6578     TempDsc* tmpFindNum(int temp, TEMP_USAGE_TYPE usageType = TEMP_USAGE_FREE) const;
6579
6580     void     tmpEnd();
6581     TempDsc* tmpListBeg(TEMP_USAGE_TYPE usageType = TEMP_USAGE_FREE) const;
6582     TempDsc* tmpListNxt(TempDsc* curTemp, TEMP_USAGE_TYPE usageType = TEMP_USAGE_FREE) const;
6583     void tmpDone();
6584
6585 #ifdef DEBUG
6586     bool tmpAllFree() const;
6587 #endif // DEBUG
6588
6589 #ifndef LEGACY_BACKEND
6590     void tmpPreAllocateTemps(var_types type, unsigned count);
6591 #endif // !LEGACY_BACKEND
6592
6593 protected:
6594 #ifdef LEGACY_BACKEND
6595     unsigned tmpIntSpillMax;    // number of int-sized spill temps
6596     unsigned tmpDoubleSpillMax; // number of double-sized spill temps
6597 #endif                          // LEGACY_BACKEND
6598
6599     unsigned tmpCount; // Number of temps
6600     unsigned tmpSize;  // Size of all the temps
6601 #ifdef DEBUG
6602 public:
6603     // Used by RegSet::rsSpillChk()
6604     unsigned tmpGetCount; // Temps which haven't been released yet
6605 #endif
6606 private:
6607     static unsigned tmpSlot(unsigned size); // which slot in tmpFree[] or tmpUsed[] to use
6608
6609     TempDsc* tmpFree[TEMP_MAX_SIZE / sizeof(int)];
6610     TempDsc* tmpUsed[TEMP_MAX_SIZE / sizeof(int)];
6611
6612     /*
6613     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6614     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6615     XX                                                                           XX
6616     XX                           CodeGenerator                                   XX
6617     XX                                                                           XX
6618     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6619     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6620     */
6621
6622 public:
6623     CodeGenInterface* codeGen;
6624
6625     //  The following holds information about instr offsets in terms of generated code.
6626
6627     struct IPmappingDsc
6628     {
6629         IPmappingDsc* ipmdNext;      // next line# record
6630         IL_OFFSETX    ipmdILoffsx;   // the instr offset
6631         emitLocation  ipmdNativeLoc; // the emitter location of the native code corresponding to the IL offset
6632         bool          ipmdIsLabel;   // Can this code be a branch label?
6633     };
6634
6635     // Record the instr offset mapping to the generated code
6636
6637     IPmappingDsc* genIPmappingList;
6638     IPmappingDsc* genIPmappingLast;
6639
6640     // Managed RetVal - A side hash table meant to record the mapping from a
6641     // GT_CALL node to its IL offset.  This info is used to emit sequence points
6642     // that can be used by debugger to determine the native offset at which the
6643     // managed RetVal will be available.
6644     //
6645     // In fact we can store IL offset in a GT_CALL node.  This was ruled out in
6646     // favor of a side table for two reasons: 1) We need IL offset for only those
6647     // GT_CALL nodes (created during importation) that correspond to an IL call and
6648     // whose return type is other than TYP_VOID. 2) GT_CALL node is a frequently used
6649     // structure and IL offset is needed only when generating debuggable code. Therefore
6650     // it is desirable to avoid memory size penalty in retail scenarios.
6651     typedef SimplerHashTable<GenTreePtr, PtrKeyFuncs<GenTree>, IL_OFFSETX, JitSimplerHashBehavior>
6652                            CallSiteILOffsetTable;
6653     CallSiteILOffsetTable* genCallSite2ILOffsetMap;
6654
6655     unsigned    genReturnLocal; // Local number for the return value when applicable.
6656     BasicBlock* genReturnBB;    // jumped to when not optimizing for speed.
6657
6658     // The following properties are part of CodeGenContext.  Getters are provided here for
6659     // convenience and backward compatibility, but the properties can only be set by invoking
6660     // the setter on CodeGenContext directly.
6661
6662     __declspec(property(get = getEmitter)) emitter* genEmitter;
6663     emitter* getEmitter()
6664     {
6665         return codeGen->getEmitter();
6666     }
6667
6668     const bool isFramePointerUsed()
6669     {
6670         return codeGen->isFramePointerUsed();
6671     }
6672
6673     __declspec(property(get = getInterruptible, put = setInterruptible)) bool genInterruptible;
6674     bool getInterruptible()
6675     {
6676         return codeGen->genInterruptible;
6677     }
6678     void setInterruptible(bool value)
6679     {
6680         codeGen->setInterruptible(value);
6681     }
6682
6683 #if DOUBLE_ALIGN
6684     const bool genDoubleAlign()
6685     {
6686         return codeGen->doDoubleAlign();
6687     }
6688     DWORD getCanDoubleAlign();
6689     bool shouldDoubleAlign(unsigned refCntStk,
6690                            unsigned refCntReg,
6691                            unsigned refCntWtdReg,
6692                            unsigned refCntStkParam,
6693                            unsigned refCntWtdStkDbl);
6694 #endif // DOUBLE_ALIGN
6695
6696     __declspec(property(get = getFullPtrRegMap, put = setFullPtrRegMap)) bool genFullPtrRegMap;
6697     bool getFullPtrRegMap()
6698     {
6699         return codeGen->genFullPtrRegMap;
6700     }
6701     void setFullPtrRegMap(bool value)
6702     {
6703         codeGen->setFullPtrRegMap(value);
6704     }
6705
6706 // Things that MAY belong either in CodeGen or CodeGenContext
6707
6708 #if FEATURE_EH_FUNCLETS
6709     FuncInfoDsc*   compFuncInfos;
6710     unsigned short compCurrFuncIdx;
6711     unsigned short compFuncInfoCount;
6712
6713     unsigned short compFuncCount()
6714     {
6715         assert(fgFuncletsCreated);
6716         return compFuncInfoCount;
6717     }
6718
6719 #else // !FEATURE_EH_FUNCLETS
6720
6721     // This is a no-op when there are no funclets!
6722     void genUpdateCurrentFunclet(BasicBlock* block)
6723     {
6724         return;
6725     }
6726
6727     FuncInfoDsc compFuncInfoRoot;
6728
6729     static const unsigned compCurrFuncIdx = 0;
6730
6731     unsigned short compFuncCount()
6732     {
6733         return 1;
6734     }
6735
6736 #endif // !FEATURE_EH_FUNCLETS
6737
6738     FuncInfoDsc* funCurrentFunc();
6739     void funSetCurrentFunc(unsigned funcIdx);
6740     FuncInfoDsc* funGetFunc(unsigned funcIdx);
6741     unsigned int funGetFuncIdx(BasicBlock* block);
6742
6743     // LIVENESS
6744
6745     VARSET_TP  compCurLife;     // current live variables
6746     GenTreePtr compCurLifeTree; // node after which compCurLife has been computed
6747
6748     template <bool ForCodeGen>
6749     void compChangeLife(VARSET_VALARG_TP newLife DEBUGARG(GenTreePtr tree));
6750
6751     void genChangeLife(VARSET_VALARG_TP newLife DEBUGARG(GenTreePtr tree))
6752     {
6753         compChangeLife</*ForCodeGen*/ true>(newLife DEBUGARG(tree));
6754     }
6755
6756     template <bool ForCodeGen>
6757     void compUpdateLife(GenTreePtr tree);
6758
6759     // Updates "compCurLife" to its state after evaluate of "true".  If "pLastUseVars" is
6760     // non-null, sets "*pLastUseVars" to the set of tracked variables for which "tree" was a last
6761     // use.  (Can be more than one var in the case of dependently promoted struct vars.)
6762     template <bool ForCodeGen>
6763     void compUpdateLifeVar(GenTreePtr tree, VARSET_TP* pLastUseVars = nullptr);
6764
6765     template <bool ForCodeGen>
6766     inline void compUpdateLife(VARSET_VALARG_TP newLife);
6767
6768     // Gets a register mask that represent the kill set for a helper call since
6769     // not all JIT Helper calls follow the standard ABI on the target architecture.
6770     regMaskTP compHelperCallKillSet(CorInfoHelpFunc helper);
6771
6772     // Gets a register mask that represent the kill set for a NoGC helper call.
6773     regMaskTP compNoGCHelperCallKillSet(CorInfoHelpFunc helper);
6774
6775 #ifdef _TARGET_ARM_
6776     // Requires that "varDsc" be a promoted struct local variable being passed as an argument, beginning at
6777     // "firstArgRegNum", which is assumed to have already been aligned to the register alignment restriction of the
6778     // struct type. Adds bits to "*pArgSkippedRegMask" for any argument registers *not* used in passing "varDsc" --
6779     // i.e., internal "holes" caused by internal alignment constraints.  For example, if the struct contained an int and
6780     // a double, and we at R0 (on ARM), then R1 would be skipped, and the bit for R1 would be added to the mask.
6781     void fgAddSkippedRegsInPromotedStructArg(LclVarDsc* varDsc, unsigned firstArgRegNum, regMaskTP* pArgSkippedRegMask);
6782 #endif // _TARGET_ARM_
6783
6784     // If "tree" is a indirection (GT_IND, or GT_OBJ) whose arg is an ADDR, whose arg is a LCL_VAR, return that LCL_VAR
6785     // node, else NULL.
6786     static GenTreePtr fgIsIndirOfAddrOfLocal(GenTreePtr tree);
6787
6788     // This is indexed by GT_OBJ nodes that are address of promoted struct variables, which
6789     // have been annotated with the GTF_VAR_DEATH flag.  If such a node is *not* mapped in this
6790     // table, one may assume that all the (tracked) field vars die at this point.  Otherwise,
6791     // the node maps to a pointer to a VARSET_TP, containing set bits for each of the tracked field
6792     // vars of the promoted struct local that go dead at the given node (the set bits are the bits
6793     // for the tracked var indices of the field vars, as in a live var set).
6794     NodeToVarsetPtrMap* m_promotedStructDeathVars;
6795
6796     NodeToVarsetPtrMap* GetPromotedStructDeathVars()
6797     {
6798         if (m_promotedStructDeathVars == nullptr)
6799         {
6800             m_promotedStructDeathVars = new (getAllocator()) NodeToVarsetPtrMap(getAllocator());
6801         }
6802         return m_promotedStructDeathVars;
6803     }
6804
6805 /*
6806 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6807 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6808 XX                                                                           XX
6809 XX                           UnwindInfo                                      XX
6810 XX                                                                           XX
6811 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6812 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6813 */
6814
6815 #if !defined(__GNUC__)
6816 #pragma region Unwind information
6817 #endif
6818
6819 public:
6820     //
6821     // Infrastructure functions: start/stop/reserve/emit.
6822     //
6823
6824     void unwindBegProlog();
6825     void unwindEndProlog();
6826     void unwindBegEpilog();
6827     void unwindEndEpilog();
6828     void unwindReserve();
6829     void unwindEmit(void* pHotCode, void* pColdCode);
6830
6831     //
6832     // Specific unwind information functions: called by code generation to indicate a particular
6833     // prolog or epilog unwindable instruction has been generated.
6834     //
6835
6836     void unwindPush(regNumber reg);
6837     void unwindAllocStack(unsigned size);
6838     void unwindSetFrameReg(regNumber reg, unsigned offset);
6839     void unwindSaveReg(regNumber reg, unsigned offset);
6840
6841 #if defined(_TARGET_ARM_)
6842     void unwindPushMaskInt(regMaskTP mask);
6843     void unwindPushMaskFloat(regMaskTP mask);
6844     void unwindPopMaskInt(regMaskTP mask);
6845     void unwindPopMaskFloat(regMaskTP mask);
6846     void unwindBranch16();                    // The epilog terminates with a 16-bit branch (e.g., "bx lr")
6847     void unwindNop(unsigned codeSizeInBytes); // Generate unwind NOP code. 'codeSizeInBytes' is 2 or 4 bytes. Only
6848                                               // called via unwindPadding().
6849     void unwindPadding(); // Generate a sequence of unwind NOP codes representing instructions between the last
6850                           // instruction and the current location.
6851 #endif                    // _TARGET_ARM_
6852
6853 #if defined(_TARGET_ARM64_)
6854     void unwindNop();
6855     void unwindPadding(); // Generate a sequence of unwind NOP codes representing instructions between the last
6856                           // instruction and the current location.
6857     void unwindSaveReg(regNumber reg, int offset);                                // str reg, [sp, #offset]
6858     void unwindSaveRegPreindexed(regNumber reg, int offset);                      // str reg, [sp, #offset]!
6859     void unwindSaveRegPair(regNumber reg1, regNumber reg2, int offset);           // stp reg1, reg2, [sp, #offset]
6860     void unwindSaveRegPairPreindexed(regNumber reg1, regNumber reg2, int offset); // stp reg1, reg2, [sp, #offset]!
6861     void unwindSaveNext();                                                        // unwind code: save_next
6862     void unwindReturn(regNumber reg);                                             // ret lr
6863 #endif                                                                            // defined(_TARGET_ARM64_)
6864
6865     //
6866     // Private "helper" functions for the unwind implementation.
6867     //
6868
6869 private:
6870 #if FEATURE_EH_FUNCLETS
6871     void unwindGetFuncLocations(FuncInfoDsc*             func,
6872                                 bool                     getHotSectionData,
6873                                 /* OUT */ emitLocation** ppStartLoc,
6874                                 /* OUT */ emitLocation** ppEndLoc);
6875 #endif // FEATURE_EH_FUNCLETS
6876
6877     void unwindReserveFunc(FuncInfoDsc* func);
6878     void unwindEmitFunc(FuncInfoDsc* func, void* pHotCode, void* pColdCode);
6879
6880 #if defined(_TARGET_AMD64_) || (defined(_TARGET_X86_) && FEATURE_EH_FUNCLETS)
6881
6882     void unwindReserveFuncHelper(FuncInfoDsc* func, bool isHotCode);
6883     void unwindEmitFuncHelper(FuncInfoDsc* func, void* pHotCode, void* pColdCode, bool isHotCode);
6884
6885 #endif // _TARGET_AMD64_ || (_TARGET_X86_ && FEATURE_EH_FUNCLETS)
6886
6887 #if defined(_TARGET_AMD64_)
6888
6889     UNATIVE_OFFSET unwindGetCurrentOffset(FuncInfoDsc* func);
6890
6891     void unwindBegPrologWindows();
6892     void unwindPushWindows(regNumber reg);
6893     void unwindAllocStackWindows(unsigned size);
6894     void unwindSetFrameRegWindows(regNumber reg, unsigned offset);
6895     void unwindSaveRegWindows(regNumber reg, unsigned offset);
6896
6897 #ifdef UNIX_AMD64_ABI
6898     void unwindBegPrologCFI();
6899     void unwindPushCFI(regNumber reg);
6900     void unwindAllocStackCFI(unsigned size);
6901     void unwindSetFrameRegCFI(regNumber reg, unsigned offset);
6902     void unwindSaveRegCFI(regNumber reg, unsigned offset);
6903     int mapRegNumToDwarfReg(regNumber reg);
6904     void createCfiCode(FuncInfoDsc* func, UCHAR codeOffset, UCHAR opcode, USHORT dwarfReg, INT offset = 0);
6905 #endif // UNIX_AMD64_ABI
6906 #elif defined(_TARGET_ARM_)
6907
6908     void unwindPushPopMaskInt(regMaskTP mask, bool useOpsize16);
6909     void unwindPushPopMaskFloat(regMaskTP mask);
6910     void unwindSplit(FuncInfoDsc* func);
6911
6912 #endif // _TARGET_ARM_
6913
6914 #if !defined(__GNUC__)
6915 #pragma endregion // Note: region is NOT under !defined(__GNUC__)
6916 #endif
6917
6918     /*
6919     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6920     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6921     XX                                                                           XX
6922     XX                               SIMD                                        XX
6923     XX                                                                           XX
6924     XX   Info about SIMD types, methods and the SIMD assembly (i.e. the assembly XX
6925     XX   that contains the distinguished, well-known SIMD type definitions).     XX
6926     XX                                                                           XX
6927     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6928     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
6929     */
6930
6931     // Get highest available instruction set for floating point codegen
6932     InstructionSet getFloatingPointInstructionSet()
6933     {
6934 #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
6935         if (canUseAVX())
6936         {
6937             return InstructionSet_AVX;
6938         }
6939
6940         if (CanUseSSE3_4())
6941         {
6942             return InstructionSet_SSE3_4;
6943         }
6944
6945         // min bar is SSE2
6946         assert(canUseSSE2());
6947         return InstructionSet_SSE2;
6948 #else
6949         assert(!"getFPInstructionSet() is not implemented for target arch");
6950         unreached();
6951         return InstructionSet_NONE;
6952 #endif
6953     }
6954
6955     // Get highest available instruction set for SIMD codegen
6956     InstructionSet getSIMDInstructionSet()
6957     {
6958 #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
6959         return getFloatingPointInstructionSet();
6960 #else
6961         assert(!"Available instruction set(s) for SIMD codegen is not defined for target arch");
6962         unreached();
6963         return InstructionSet_NONE;
6964 #endif
6965     }
6966
6967 #ifdef FEATURE_SIMD
6968
6969     // Should we support SIMD intrinsics?
6970     bool featureSIMD;
6971
6972     // Have we identified any SIMD types?
6973     // This is currently used by struct promotion to avoid getting type information for a struct
6974     // field to see if it is a SIMD type, if we haven't seen any SIMD types or operations in
6975     // the method.
6976     bool _usesSIMDTypes;
6977     bool usesSIMDTypes()
6978     {
6979         return _usesSIMDTypes;
6980     }
6981     void setUsesSIMDTypes(bool value)
6982     {
6983         _usesSIMDTypes = value;
6984     }
6985
6986     // This is a temp lclVar allocated on the stack as TYP_SIMD.  It is used to implement intrinsics
6987     // that require indexed access to the individual fields of the vector, which is not well supported
6988     // by the hardware.  It is allocated when/if such situations are encountered during Lowering.
6989     unsigned lvaSIMDInitTempVarNum;
6990
6991     // SIMD Types
6992     CORINFO_CLASS_HANDLE SIMDFloatHandle;
6993     CORINFO_CLASS_HANDLE SIMDDoubleHandle;
6994     CORINFO_CLASS_HANDLE SIMDIntHandle;
6995     CORINFO_CLASS_HANDLE SIMDUShortHandle;
6996     CORINFO_CLASS_HANDLE SIMDUByteHandle;
6997     CORINFO_CLASS_HANDLE SIMDShortHandle;
6998     CORINFO_CLASS_HANDLE SIMDByteHandle;
6999     CORINFO_CLASS_HANDLE SIMDLongHandle;
7000     CORINFO_CLASS_HANDLE SIMDUIntHandle;
7001     CORINFO_CLASS_HANDLE SIMDULongHandle;
7002     CORINFO_CLASS_HANDLE SIMDVector2Handle;
7003     CORINFO_CLASS_HANDLE SIMDVector3Handle;
7004     CORINFO_CLASS_HANDLE SIMDVector4Handle;
7005     CORINFO_CLASS_HANDLE SIMDVectorHandle;
7006
7007     // Get the handle for a SIMD type.
7008     CORINFO_CLASS_HANDLE gtGetStructHandleForSIMD(var_types simdType, var_types simdBaseType)
7009     {
7010         if (simdBaseType == TYP_FLOAT)
7011         {
7012             switch (simdType)
7013             {
7014                 case TYP_SIMD8:
7015                     return SIMDVector2Handle;
7016                 case TYP_SIMD12:
7017                     return SIMDVector3Handle;
7018                 case TYP_SIMD16:
7019                     if ((getSIMDVectorType() == TYP_SIMD32) || (SIMDVector4Handle != NO_CLASS_HANDLE))
7020                     {
7021                         return SIMDVector4Handle;
7022                     }
7023                     break;
7024                 case TYP_SIMD32:
7025                     break;
7026                 default:
7027                     unreached();
7028             }
7029         }
7030         assert(simdType == getSIMDVectorType());
7031         switch (simdBaseType)
7032         {
7033             case TYP_FLOAT:
7034                 return SIMDFloatHandle;
7035             case TYP_DOUBLE:
7036                 return SIMDDoubleHandle;
7037             case TYP_INT:
7038                 return SIMDIntHandle;
7039             case TYP_CHAR:
7040                 return SIMDUShortHandle;
7041             case TYP_USHORT:
7042                 return SIMDUShortHandle;
7043             case TYP_UBYTE:
7044                 return SIMDUByteHandle;
7045             case TYP_SHORT:
7046                 return SIMDShortHandle;
7047             case TYP_BYTE:
7048                 return SIMDByteHandle;
7049             case TYP_LONG:
7050                 return SIMDLongHandle;
7051             case TYP_UINT:
7052                 return SIMDUIntHandle;
7053             case TYP_ULONG:
7054                 return SIMDULongHandle;
7055             default:
7056                 assert(!"Didn't find a class handle for simdType");
7057         }
7058         return NO_CLASS_HANDLE;
7059     }
7060
7061     // SIMD Methods
7062     CORINFO_METHOD_HANDLE SIMDVectorFloat_set_Item;
7063     CORINFO_METHOD_HANDLE SIMDVectorFloat_get_Length;
7064     CORINFO_METHOD_HANDLE SIMDVectorFloat_op_Addition;
7065
7066     // Returns true if the tree corresponds to a TYP_SIMD lcl var.
7067     // Note that both SIMD vector args and locals are mared as lvSIMDType = true, but
7068     // type of an arg node is TYP_BYREF and a local node is TYP_SIMD or TYP_STRUCT.
7069     bool isSIMDTypeLocal(GenTree* tree)
7070     {
7071         return tree->OperIsLocal() && lvaTable[tree->AsLclVarCommon()->gtLclNum].lvSIMDType;
7072     }
7073
7074     // Returns true if the type of the tree is a byref of TYP_SIMD
7075     bool isAddrOfSIMDType(GenTree* tree)
7076     {
7077         if (tree->TypeGet() == TYP_BYREF || tree->TypeGet() == TYP_I_IMPL)
7078         {
7079             switch (tree->OperGet())
7080             {
7081                 case GT_ADDR:
7082                     return varTypeIsSIMD(tree->gtGetOp1());
7083
7084                 case GT_LCL_VAR_ADDR:
7085                     return lvaTable[tree->AsLclVarCommon()->gtLclNum].lvSIMDType;
7086
7087                 default:
7088                     return isSIMDTypeLocal(tree);
7089             }
7090         }
7091
7092         return false;
7093     }
7094
7095     static bool isRelOpSIMDIntrinsic(SIMDIntrinsicID intrinsicId)
7096     {
7097         return (intrinsicId == SIMDIntrinsicEqual || intrinsicId == SIMDIntrinsicLessThan ||
7098                 intrinsicId == SIMDIntrinsicLessThanOrEqual || intrinsicId == SIMDIntrinsicGreaterThan ||
7099                 intrinsicId == SIMDIntrinsicGreaterThanOrEqual);
7100     }
7101
7102     // Returns base type of a TYP_SIMD local.
7103     // Returns TYP_UNKNOWN if the local is not TYP_SIMD.
7104     var_types getBaseTypeOfSIMDLocal(GenTree* tree)
7105     {
7106         if (isSIMDTypeLocal(tree))
7107         {
7108             return lvaTable[tree->AsLclVarCommon()->gtLclNum].lvBaseType;
7109         }
7110
7111         return TYP_UNKNOWN;
7112     }
7113
7114     bool isSIMDClass(CORINFO_CLASS_HANDLE clsHnd)
7115     {
7116         return info.compCompHnd->isInSIMDModule(clsHnd);
7117     }
7118
7119     bool isSIMDClass(typeInfo* pTypeInfo)
7120     {
7121         return pTypeInfo->IsStruct() && isSIMDClass(pTypeInfo->GetClassHandleForValueClass());
7122     }
7123
7124     // Get the base (element) type and size in bytes for a SIMD type. Returns TYP_UNKNOWN
7125     // if it is not a SIMD type or is an unsupported base type.
7126     var_types getBaseTypeAndSizeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd, unsigned* sizeBytes = nullptr);
7127
7128     var_types getBaseTypeOfSIMDType(CORINFO_CLASS_HANDLE typeHnd)
7129     {
7130         return getBaseTypeAndSizeOfSIMDType(typeHnd, nullptr);
7131     }
7132
7133     // Get SIMD Intrinsic info given the method handle.
7134     // Also sets typeHnd, argCount, baseType and sizeBytes out params.
7135     const SIMDIntrinsicInfo* getSIMDIntrinsicInfo(CORINFO_CLASS_HANDLE* typeHnd,
7136                                                   CORINFO_METHOD_HANDLE methodHnd,
7137                                                   CORINFO_SIG_INFO*     sig,
7138                                                   bool                  isNewObj,
7139                                                   unsigned*             argCount,
7140                                                   var_types*            baseType,
7141                                                   unsigned*             sizeBytes);
7142
7143     // Pops and returns GenTree node from importers type stack.
7144     // Normalizes TYP_STRUCT value in case of GT_CALL, GT_RET_EXPR and arg nodes.
7145     GenTreePtr impSIMDPopStack(var_types type, bool expectAddr = false);
7146
7147     // Create a GT_SIMD tree for a Get property of SIMD vector with a fixed index.
7148     GenTreeSIMD* impSIMDGetFixed(var_types simdType, var_types baseType, unsigned simdSize, int index);
7149
7150     // Creates a GT_SIMD tree for Select operation
7151     GenTreePtr impSIMDSelect(CORINFO_CLASS_HANDLE typeHnd,
7152                              var_types            baseType,
7153                              unsigned             simdVectorSize,
7154                              GenTree*             op1,
7155                              GenTree*             op2,
7156                              GenTree*             op3);
7157
7158     // Creates a GT_SIMD tree for Min/Max operation
7159     GenTreePtr impSIMDMinMax(SIMDIntrinsicID      intrinsicId,
7160                              CORINFO_CLASS_HANDLE typeHnd,
7161                              var_types            baseType,
7162                              unsigned             simdVectorSize,
7163                              GenTree*             op1,
7164                              GenTree*             op2);
7165
7166     // Transforms operands and returns the SIMD intrinsic to be applied on
7167     // transformed operands to obtain given relop result.
7168     SIMDIntrinsicID impSIMDRelOp(SIMDIntrinsicID      relOpIntrinsicId,
7169                                  CORINFO_CLASS_HANDLE typeHnd,
7170                                  unsigned             simdVectorSize,
7171                                  var_types*           baseType,
7172                                  GenTree**            op1,
7173                                  GenTree**            op2);
7174
7175     // Creates a GT_SIMD tree for Abs intrinsic.
7176     GenTreePtr impSIMDAbs(CORINFO_CLASS_HANDLE typeHnd, var_types baseType, unsigned simdVectorSize, GenTree* op1);
7177
7178 #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
7179     // Transforms operands and returns the SIMD intrinsic to be applied on
7180     // transformed operands to obtain == comparison result.
7181     SIMDIntrinsicID impSIMDLongRelOpEqual(CORINFO_CLASS_HANDLE typeHnd,
7182                                           unsigned             simdVectorSize,
7183                                           GenTree**            op1,
7184                                           GenTree**            op2);
7185
7186     // Transforms operands and returns the SIMD intrinsic to be applied on
7187     // transformed operands to obtain > comparison result.
7188     SIMDIntrinsicID impSIMDLongRelOpGreaterThan(CORINFO_CLASS_HANDLE typeHnd,
7189                                                 unsigned             simdVectorSize,
7190                                                 GenTree**            op1,
7191                                                 GenTree**            op2);
7192
7193     // Transforms operands and returns the SIMD intrinsic to be applied on
7194     // transformed operands to obtain >= comparison result.
7195     SIMDIntrinsicID impSIMDLongRelOpGreaterThanOrEqual(CORINFO_CLASS_HANDLE typeHnd,
7196                                                        unsigned             simdVectorSize,
7197                                                        GenTree**            op1,
7198                                                        GenTree**            op2);
7199
7200     // Transforms operands and returns the SIMD intrinsic to be applied on
7201     // transformed operands to obtain >= comparison result in case of int32
7202     // and small int base type vectors.
7203     SIMDIntrinsicID impSIMDIntegralRelOpGreaterThanOrEqual(
7204         CORINFO_CLASS_HANDLE typeHnd, unsigned simdVectorSize, var_types baseType, GenTree** op1, GenTree** op2);
7205 #endif // defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
7206
7207     void setLclRelatedToSIMDIntrinsic(GenTreePtr tree);
7208     bool areFieldsContiguous(GenTreePtr op1, GenTreePtr op2);
7209     bool areArrayElementsContiguous(GenTreePtr op1, GenTreePtr op2);
7210     bool areArgumentsContiguous(GenTreePtr op1, GenTreePtr op2);
7211     GenTreePtr createAddressNodeForSIMDInit(GenTreePtr tree, unsigned simdSize);
7212
7213     // check methodHnd to see if it is a SIMD method that is expanded as an intrinsic in the JIT.
7214     GenTreePtr impSIMDIntrinsic(OPCODE                opcode,
7215                                 GenTreePtr            newobjThis,
7216                                 CORINFO_CLASS_HANDLE  clsHnd,
7217                                 CORINFO_METHOD_HANDLE method,
7218                                 CORINFO_SIG_INFO*     sig,
7219                                 int                   memberRef);
7220
7221     GenTreePtr getOp1ForConstructor(OPCODE opcode, GenTreePtr newobjThis, CORINFO_CLASS_HANDLE clsHnd);
7222
7223     // Whether SIMD vector occupies part of SIMD register.
7224     // SSE2: vector2f/3f are considered sub register SIMD types.
7225     // AVX: vector2f, 3f and 4f are all considered sub register SIMD types.
7226     bool isSubRegisterSIMDType(CORINFO_CLASS_HANDLE typeHnd)
7227     {
7228         unsigned  sizeBytes = 0;
7229         var_types baseType  = getBaseTypeAndSizeOfSIMDType(typeHnd, &sizeBytes);
7230         return (baseType == TYP_FLOAT) && (sizeBytes < getSIMDVectorRegisterByteLength());
7231     }
7232
7233     bool isSubRegisterSIMDType(GenTreeSIMD* simdNode)
7234     {
7235         return (simdNode->gtSIMDSize < getSIMDVectorRegisterByteLength());
7236     }
7237
7238     // Get the type for the hardware SIMD vector.
7239     // This is the maximum SIMD type supported for this target.
7240     var_types getSIMDVectorType()
7241     {
7242 #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
7243         if (canUseAVX())
7244         {
7245             return TYP_SIMD32;
7246         }
7247         else
7248         {
7249             assert(canUseSSE2());
7250             return TYP_SIMD16;
7251         }
7252 #else
7253         assert(!"getSIMDVectorType() unimplemented on target arch");
7254         unreached();
7255 #endif
7256     }
7257
7258     // Get the size of the SIMD type in bytes
7259     int getSIMDTypeSizeInBytes(CORINFO_CLASS_HANDLE typeHnd)
7260     {
7261         unsigned sizeBytes = 0;
7262         (void)getBaseTypeAndSizeOfSIMDType(typeHnd, &sizeBytes);
7263         return sizeBytes;
7264     }
7265
7266     // Get the the number of elements of basetype of SIMD vector given by its size and baseType
7267     static int getSIMDVectorLength(unsigned simdSize, var_types baseType);
7268
7269     // Get the the number of elements of basetype of SIMD vector given by its type handle
7270     int getSIMDVectorLength(CORINFO_CLASS_HANDLE typeHnd);
7271
7272     // Get preferred alignment of SIMD type.
7273     int getSIMDTypeAlignment(var_types simdType);
7274
7275     // Get the number of bytes in a SIMD Vector for the current compilation.
7276     unsigned getSIMDVectorRegisterByteLength()
7277     {
7278 #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
7279         if (canUseAVX())
7280         {
7281             return YMM_REGSIZE_BYTES;
7282         }
7283         else
7284         {
7285             assert(canUseSSE2());
7286             return XMM_REGSIZE_BYTES;
7287         }
7288 #else
7289         assert(!"getSIMDVectorRegisterByteLength() unimplemented on target arch");
7290         unreached();
7291 #endif
7292     }
7293
7294     // The minimum and maximum possible number of bytes in a SIMD vector.
7295     unsigned int maxSIMDStructBytes()
7296     {
7297         return getSIMDVectorRegisterByteLength();
7298     }
7299     unsigned int minSIMDStructBytes()
7300     {
7301         return emitTypeSize(TYP_SIMD8);
7302     }
7303
7304 #ifdef FEATURE_AVX_SUPPORT
7305     // (maxPossibleSIMDStructBytes is for use in a context that requires a compile-time constant.)
7306     static const unsigned maxPossibleSIMDStructBytes = 32;
7307 #else  // !FEATURE_AVX_SUPPORT
7308     static const unsigned maxPossibleSIMDStructBytes = 16;
7309 #endif // !FEATURE_AVX_SUPPORT
7310
7311     // Returns the codegen type for a given SIMD size.
7312     var_types getSIMDTypeForSize(unsigned size)
7313     {
7314         var_types simdType = TYP_UNDEF;
7315         if (size == 8)
7316         {
7317             simdType = TYP_SIMD8;
7318         }
7319         else if (size == 12)
7320         {
7321             simdType = TYP_SIMD12;
7322         }
7323         else if (size == 16)
7324         {
7325             simdType = TYP_SIMD16;
7326         }
7327 #ifdef FEATURE_AVX_SUPPORT
7328         else if (size == 32)
7329         {
7330             simdType = TYP_SIMD32;
7331         }
7332 #endif // FEATURE_AVX_SUPPORT
7333         else
7334         {
7335             noway_assert(!"Unexpected size for SIMD type");
7336         }
7337         return simdType;
7338     }
7339
7340     unsigned getSIMDInitTempVarNum()
7341     {
7342         if (lvaSIMDInitTempVarNum == BAD_VAR_NUM)
7343         {
7344             lvaSIMDInitTempVarNum                  = lvaGrabTempWithImplicitUse(false DEBUGARG("SIMDInitTempVar"));
7345             lvaTable[lvaSIMDInitTempVarNum].lvType = getSIMDVectorType();
7346         }
7347         return lvaSIMDInitTempVarNum;
7348     }
7349
7350 #endif // FEATURE_SIMD
7351
7352 public:
7353     //------------------------------------------------------------------------
7354     // largestEnregisterableStruct: The size in bytes of the largest struct that can be enregistered.
7355     //
7356     // Notes: It is not guaranteed that the struct of this size or smaller WILL be a
7357     //        candidate for enregistration.
7358
7359     unsigned largestEnregisterableStructSize()
7360     {
7361 #ifdef FEATURE_SIMD
7362         unsigned vectorRegSize = getSIMDVectorRegisterByteLength();
7363         if (vectorRegSize > TARGET_POINTER_SIZE)
7364         {
7365             return vectorRegSize;
7366         }
7367         else
7368 #endif // FEATURE_SIMD
7369         {
7370             return TARGET_POINTER_SIZE;
7371         }
7372     }
7373
7374 private:
7375     // These routines need not be enclosed under FEATURE_SIMD since lvIsSIMDType()
7376     // is defined for both FEATURE_SIMD and !FEATURE_SIMD apropriately. The use
7377     // of this routines also avoids the need of #ifdef FEATURE_SIMD specific code.
7378
7379     // Is this var is of type simd struct?
7380     bool lclVarIsSIMDType(unsigned varNum)
7381     {
7382         LclVarDsc* varDsc = lvaTable + varNum;
7383         return varDsc->lvIsSIMDType();
7384     }
7385
7386     // Is this Local node a SIMD local?
7387     bool lclVarIsSIMDType(GenTreeLclVarCommon* lclVarTree)
7388     {
7389         return lclVarIsSIMDType(lclVarTree->gtLclNum);
7390     }
7391
7392     // Returns true if the TYP_SIMD locals on stack are aligned at their
7393     // preferred byte boundary specified by getSIMDTypeAlignment().
7394     //
7395     // As per the Intel manual, the preferred alignment for AVX vectors is 32-bytes. On Amd64,
7396     // RSP/EBP is aligned at 16-bytes, therefore to align SIMD types at 32-bytes we need even
7397     // RSP/EBP to be 32-byte aligned. It is not clear whether additional stack space used in
7398     // aligning stack is worth the benefit and for now will use 16-byte alignment for AVX
7399     // 256-bit vectors with unaligned load/stores to/from memory. On x86, the stack frame
7400     // is aligned to 4 bytes. We need to extend existing support for double (8-byte) alignment
7401     // to 16 or 32 byte alignment for frames with local SIMD vars, if that is determined to be
7402     // profitable.
7403     //
7404     bool isSIMDTypeLocalAligned(unsigned varNum)
7405     {
7406 #if defined(FEATURE_SIMD) && ALIGN_SIMD_TYPES
7407         if (lclVarIsSIMDType(varNum) && lvaTable[varNum].lvType != TYP_BYREF)
7408         {
7409             bool ebpBased;
7410             int  off = lvaFrameAddress(varNum, &ebpBased);
7411             // TODO-Cleanup: Can't this use the lvExactSize on the varDsc?
7412             int  alignment = getSIMDTypeAlignment(lvaTable[varNum].lvType);
7413             bool isAligned = (alignment <= STACK_ALIGN) && ((off % alignment) == 0);
7414             return isAligned;
7415         }
7416 #endif // FEATURE_SIMD
7417
7418         return false;
7419     }
7420
7421     // Whether SSE2 is available
7422     bool canUseSSE2() const
7423     {
7424 #ifdef _TARGET_XARCH_
7425         return opts.compCanUseSSE2;
7426 #else
7427         return false;
7428 #endif
7429     }
7430
7431     // Whether SSE3, SSE3, SSE4.1 and SSE4.2 is available
7432     bool CanUseSSE3_4() const
7433     {
7434 #ifdef _TARGET_XARCH_
7435         return opts.compCanUseSSE3_4;
7436 #else
7437         return false;
7438 #endif
7439     }
7440
7441     bool canUseAVX() const
7442     {
7443 #ifdef FEATURE_AVX_SUPPORT
7444         return opts.compCanUseAVX;
7445 #else
7446         return false;
7447 #endif
7448     }
7449
7450     /*
7451     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
7452     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
7453     XX                                                                           XX
7454     XX                           Compiler                                        XX
7455     XX                                                                           XX
7456     XX   Generic info about the compilation and the method being compiled.       XX
7457     XX   It is responsible for driving the other phases.                         XX
7458     XX   It is also responsible for all the memory management.                   XX
7459     XX                                                                           XX
7460     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
7461     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
7462     */
7463
7464 public:
7465     Compiler* InlineeCompiler; // The Compiler instance for the inlinee
7466
7467     InlineResult* compInlineResult; // The result of importing the inlinee method.
7468
7469     bool compDoAggressiveInlining; // If true, mark every method as CORINFO_FLG_FORCEINLINE
7470     bool compJmpOpUsed;            // Does the method do a JMP
7471     bool compLongUsed;             // Does the method use TYP_LONG
7472     bool compFloatingPointUsed;    // Does the method use TYP_FLOAT or TYP_DOUBLE
7473     bool compTailCallUsed;         // Does the method do a tailcall
7474     bool compLocallocUsed;         // Does the method use localloc.
7475     bool compQmarkUsed;            // Does the method use GT_QMARK/GT_COLON
7476     bool compQmarkRationalized;    // Is it allowed to use a GT_QMARK/GT_COLON node.
7477     bool compUnsafeCastUsed;       // Does the method use LDIND/STIND to cast between scalar/refernce types
7478
7479     // NOTE: These values are only reliable after
7480     //       the importing is completely finished.
7481
7482     ExpandArrayStack<GenTreePtr>* compQMarks; // The set of QMark nodes created in the current compilation, so
7483                                               // we can iterate over these efficiently.
7484
7485 #if CPU_USES_BLOCK_MOVE
7486     bool compBlkOpUsed; // Does the method do a COPYBLK or INITBLK
7487 #endif
7488
7489 #ifdef DEBUG
7490     // State information - which phases have completed?
7491     // These are kept together for easy discoverability
7492
7493     bool    bRangeAllowStress;
7494     bool    compCodeGenDone;
7495     int64_t compNumStatementLinksTraversed; // # of links traversed while doing debug checks
7496     bool    fgNormalizeEHDone;              // Has the flowgraph EH normalization phase been done?
7497     size_t  compSizeEstimate;               // The estimated size of the method as per `gtSetEvalOrder`.
7498     size_t  compCycleEstimate;              // The estimated cycle count of the method as per `gtSetEvalOrder`
7499 #endif                                      // DEBUG
7500
7501     bool fgLocalVarLivenessDone; // Note that this one is used outside of debug.
7502     bool fgLocalVarLivenessChanged;
7503 #if STACK_PROBES
7504     bool compStackProbePrologDone;
7505 #endif
7506 #ifndef LEGACY_BACKEND
7507     bool compLSRADone;
7508 #endif // !LEGACY_BACKEND
7509     bool compRationalIRForm;
7510
7511     bool compUsesThrowHelper; // There is a call to a THOROW_HELPER for the compiled method.
7512
7513     bool compGeneratingProlog;
7514     bool compGeneratingEpilog;
7515     bool compNeedsGSSecurityCookie; // There is an unsafe buffer (or localloc) on the stack.
7516                                     // Insert cookie on frame and code to check the cookie, like VC++ -GS.
7517     bool compGSReorderStackLayout;  // There is an unsafe buffer on the stack, reorder locals and make local
7518     // copies of susceptible parameters to avoid buffer overrun attacks through locals/params
7519     bool getNeedsGSSecurityCookie() const
7520     {
7521         return compNeedsGSSecurityCookie;
7522     }
7523     void setNeedsGSSecurityCookie()
7524     {
7525         compNeedsGSSecurityCookie = true;
7526     }
7527
7528     FrameLayoutState lvaDoneFrameLayout; // The highest frame layout state that we've completed. During
7529                                          // frame layout calculations, this is the level we are currently
7530                                          // computing.
7531
7532     //---------------------------- JITing options -----------------------------
7533
7534     enum codeOptimize
7535     {
7536         BLENDED_CODE,
7537         SMALL_CODE,
7538         FAST_CODE,
7539
7540         COUNT_OPT_CODE
7541     };
7542
7543     struct Options
7544     {
7545         JitFlags* jitFlags;  // all flags passed from the EE
7546         unsigned  compFlags; // method attributes
7547
7548         codeOptimize compCodeOpt; // what type of code optimizations
7549
7550         bool compUseFCOMI;
7551         bool compUseCMOV;
7552 #ifdef _TARGET_XARCH_
7553         bool compCanUseSSE2;   // Allow CodeGen to use "movq XMM" instructions
7554         bool compCanUseSSE3_4; // Allow CodeGen to use SSE3, SSSE3, SSE4.1 and SSE4.2 instructions
7555
7556 #ifdef FEATURE_AVX_SUPPORT
7557         bool compCanUseAVX; // Allow CodeGen to use AVX 256-bit vectors for SIMD operations
7558 #endif                      // FEATURE_AVX_SUPPORT
7559 #endif                      // _TARGET_XARCH_
7560
7561 // optimize maximally and/or favor speed over size?
7562
7563 #define DEFAULT_MIN_OPTS_CODE_SIZE 60000
7564 #define DEFAULT_MIN_OPTS_INSTR_COUNT 20000
7565 #define DEFAULT_MIN_OPTS_BB_COUNT 2000
7566 #define DEFAULT_MIN_OPTS_LV_NUM_COUNT 2000
7567 #define DEFAULT_MIN_OPTS_LV_REF_COUNT 8000
7568
7569 // Maximun number of locals before turning off the inlining
7570 #define MAX_LV_NUM_COUNT_FOR_INLINING 512
7571
7572         bool     compMinOpts;
7573         unsigned instrCount;
7574         unsigned lvRefCount;
7575         bool     compMinOptsIsSet;
7576 #ifdef DEBUG
7577         bool compMinOptsIsUsed;
7578
7579         inline bool MinOpts()
7580         {
7581             assert(compMinOptsIsSet);
7582             compMinOptsIsUsed = true;
7583             return compMinOpts;
7584         }
7585         inline bool IsMinOptsSet()
7586         {
7587             return compMinOptsIsSet;
7588         }
7589 #else  // !DEBUG
7590         inline bool MinOpts()
7591         {
7592             return compMinOpts;
7593         }
7594         inline bool IsMinOptsSet()
7595         {
7596             return compMinOptsIsSet;
7597         }
7598 #endif // !DEBUG
7599         inline void SetMinOpts(bool val)
7600         {
7601             assert(!compMinOptsIsUsed);
7602             assert(!compMinOptsIsSet || (compMinOpts == val));
7603             compMinOpts      = val;
7604             compMinOptsIsSet = true;
7605         }
7606
7607         // true if the CLFLG_* for an optimization is set.
7608         inline bool OptEnabled(unsigned optFlag)
7609         {
7610             return !!(compFlags & optFlag);
7611         }
7612
7613 #ifdef FEATURE_READYTORUN_COMPILER
7614         inline bool IsReadyToRun()
7615         {
7616             return jitFlags->IsSet(JitFlags::JIT_FLAG_READYTORUN);
7617         }
7618 #else
7619         inline bool IsReadyToRun()
7620         {
7621             return false;
7622         }
7623 #endif
7624
7625         // true if we should use the PINVOKE_{BEGIN,END} helpers instead of generating
7626         // PInvoke transitions inline (e.g. when targeting CoreRT).
7627         inline bool ShouldUsePInvokeHelpers()
7628         {
7629 #if COR_JIT_EE_VERSION > 460
7630             return jitFlags->IsSet(JitFlags::JIT_FLAG_USE_PINVOKE_HELPERS);
7631 #else
7632             return false;
7633 #endif
7634         }
7635
7636         // true if we should use insert the REVERSE_PINVOKE_{ENTER,EXIT} helpers in the method
7637         // prolog/epilog
7638         inline bool IsReversePInvoke()
7639         {
7640 #if COR_JIT_EE_VERSION > 460
7641             return jitFlags->IsSet(JitFlags::JIT_FLAG_REVERSE_PINVOKE);
7642 #else
7643             return false;
7644 #endif
7645         }
7646
7647         // true if we must generate code compatible with JIT32 quirks
7648         inline bool IsJit32Compat()
7649         {
7650 #if defined(_TARGET_X86_) && COR_JIT_EE_VERSION > 460
7651             return jitFlags->IsSet(JitFlags::JIT_FLAG_DESKTOP_QUIRKS);
7652 #else
7653             return false;
7654 #endif
7655         }
7656
7657         // true if we must generate code compatible with Jit64 quirks
7658         inline bool IsJit64Compat()
7659         {
7660 #if defined(_TARGET_AMD64_) && COR_JIT_EE_VERSION > 460
7661             return jitFlags->IsSet(JitFlags::JIT_FLAG_DESKTOP_QUIRKS);
7662 #elif defined(_TARGET_AMD64_) && !defined(FEATURE_CORECLR)
7663             return true;
7664 #else
7665             return false;
7666 #endif
7667         }
7668
7669         bool compScopeInfo; // Generate the LocalVar info ?
7670         bool compDbgCode;   // Generate debugger-friendly code?
7671         bool compDbgInfo;   // Gather debugging info?
7672         bool compDbgEnC;
7673
7674 #ifdef PROFILING_SUPPORTED
7675         bool compNoPInvokeInlineCB;
7676 #else
7677         static const bool compNoPInvokeInlineCB;
7678 #endif
7679
7680 #ifdef DEBUG
7681         bool compGcChecks;         // Check arguments and return values to ensure they are sane
7682         bool compStackCheckOnRet;  // Check ESP on return to ensure it is correct
7683         bool compStackCheckOnCall; // Check ESP after every call to ensure it is correct
7684
7685 #endif
7686
7687         bool compNeedSecurityCheck; // This flag really means where or not a security object needs
7688                                     // to be allocated on the stack.
7689                                     // It will be set to true in the following cases:
7690                                     //   1. When the method being compiled has a declarative security
7691                                     //        (i.e. when CORINFO_FLG_NOSECURITYWRAP is reset for the current method).
7692                                     //        This is also the case when we inject a prolog and epilog in the method.
7693                                     //   (or)
7694                                     //   2. When the method being compiled has imperative security (i.e. the method
7695                                     //        calls into another method that has CORINFO_FLG_SECURITYCHECK flag set).
7696                                     //   (or)
7697                                     //   3. When opts.compDbgEnC is true. (See also Compiler::compCompile).
7698                                     //
7699 // When this flag is set, jit will allocate a gc-reference local variable (lvaSecurityObject),
7700 // which gets reported as a GC root to stackwalker.
7701 // (See also ICodeManager::GetAddrOfSecurityObject.)
7702
7703 #if RELOC_SUPPORT
7704         bool compReloc;
7705 #endif
7706
7707 #ifdef DEBUG
7708 #if defined(_TARGET_XARCH_) && !defined(LEGACY_BACKEND)
7709         bool compEnablePCRelAddr; // Whether absolute addr be encoded as PC-rel offset by RyuJIT where possible
7710 #endif
7711 #endif // DEBUG
7712
7713 #ifdef UNIX_AMD64_ABI
7714         // This flag  is indicating if there is a need to align the frame.
7715         // On AMD64-Windows, if there are calls, 4 slots for the outgoing ars are allocated, except for
7716         // FastTailCall. This slots makes the frame size non-zero, so alignment logic will be called.
7717         // On AMD64-Unix, there are no such slots. There is a possibility to have calls in the method with frame size of
7718         // 0. The frame alignment logic won't kick in. This flags takes care of the AMD64-Unix case by remembering that
7719         // there are calls and making sure the frame alignment logic is executed.
7720         bool compNeedToAlignFrame;
7721 #endif // UNIX_AMD64_ABI
7722
7723         bool compProcedureSplitting; // Separate cold code from hot code
7724
7725         bool genFPorder; // Preserve FP order (operations are non-commutative)
7726         bool genFPopt;   // Can we do frame-pointer-omission optimization?
7727         bool altJit;     // True if we are an altjit and are compiling this method
7728
7729 #ifdef DEBUG
7730         bool optRepeat;                // Repeat optimizer phases k times
7731         bool compProcedureSplittingEH; // Separate cold code from hot code for functions with EH
7732         bool dspCode;                  // Display native code generated
7733         bool dspEHTable;               // Display the EH table reported to the VM
7734         bool dspInstrs;                // Display the IL instructions intermixed with the native code output
7735         bool dspEmit;                  // Display emitter output
7736         bool dspLines;                 // Display source-code lines intermixed with native code output
7737         bool dmpHex;                   // Display raw bytes in hex of native code output
7738         bool varNames;                 // Display variables names in native code output
7739         bool disAsm;                   // Display native code as it is generated
7740         bool disAsmSpilled;            // Display native code when any register spilling occurs
7741         bool disDiffable;              // Makes the Disassembly code 'diff-able'
7742         bool disAsm2;                  // Display native code after it is generated using external disassembler
7743         bool dspOrder;                 // Display names of each of the methods that we ngen/jit
7744         bool dspUnwind;                // Display the unwind info output
7745         bool dspDiffable;     // Makes the Jit Dump 'diff-able' (currently uses same COMPlus_* flag as disDiffable)
7746         bool compLongAddress; // Force using large pseudo instructions for long address
7747                               // (IF_LARGEJMP/IF_LARGEADR/IF_LARGLDC)
7748         bool dspGCtbls;       // Display the GC tables
7749 #endif
7750
7751 #ifdef LATE_DISASM
7752         bool doLateDisasm; // Run the late disassembler
7753 #endif                     // LATE_DISASM
7754
7755 #if DUMP_GC_TABLES && !defined(DEBUG) && defined(JIT32_GCENCODER)
7756 // Only the JIT32_GCENCODER implements GC dumping in non-DEBUG code.
7757 #pragma message("NOTE: this non-debug build has GC ptr table dumping always enabled!")
7758         static const bool dspGCtbls = true;
7759 #endif
7760
7761         // We need stack probes to guarantee that we won't trigger a stack overflow
7762         // when calling unmanaged code until they get a chance to set up a frame, because
7763         // the EE will have no idea where it is.
7764         //
7765         // We will only be doing this currently for hosted environments. Unfortunately
7766         // we need to take care of stubs, so potentially, we will have to do the probes
7767         // for any call. We have a plan for not needing for stubs though
7768         bool compNeedStackProbes;
7769
7770 #ifdef PROFILING_SUPPORTED
7771         // Whether to emit Enter/Leave/TailCall hooks using a dummy stub (DummyProfilerELTStub()).
7772         // This option helps make the JIT behave as if it is running under a profiler.
7773         bool compJitELTHookEnabled;
7774 #endif // PROFILING_SUPPORTED
7775
7776 #if FEATURE_TAILCALL_OPT
7777         // Whether opportunistic or implicit tail call optimization is enabled.
7778         bool compTailCallOpt;
7779         // Whether optimization of transforming a recursive tail call into a loop is enabled.
7780         bool compTailCallLoopOpt;
7781 #endif
7782
7783 #ifdef ARM_SOFTFP
7784         static const bool compUseSoftFP = true;
7785 #else // !ARM_SOFTFP
7786         static const bool compUseSoftFP = false;
7787 #endif
7788
7789         GCPollType compGCPollType;
7790     } opts;
7791
7792 #ifdef ALT_JIT
7793     static bool                s_pAltJitExcludeAssembliesListInitialized;
7794     static AssemblyNamesList2* s_pAltJitExcludeAssembliesList;
7795 #endif // ALT_JIT
7796
7797 #ifdef DEBUG
7798
7799     template <typename T>
7800     T dspPtr(T p)
7801     {
7802         return (p == ZERO) ? ZERO : (opts.dspDiffable ? T(0xD1FFAB1E) : p);
7803     }
7804
7805     template <typename T>
7806     T dspOffset(T o)
7807     {
7808         return (o == ZERO) ? ZERO : (opts.dspDiffable ? T(0xD1FFAB1E) : o);
7809     }
7810
7811     static int dspTreeID(GenTree* tree)
7812     {
7813         return tree->gtTreeID;
7814     }
7815     static void printTreeID(GenTree* tree)
7816     {
7817         if (tree == nullptr)
7818         {
7819             printf("[------]");
7820         }
7821         else
7822         {
7823             printf("[%06d]", dspTreeID(tree));
7824         }
7825     }
7826
7827 #endif // DEBUG
7828
7829 // clang-format off
7830 #define STRESS_MODES                                                                            \
7831                                                                                                 \
7832         STRESS_MODE(NONE)                                                                       \
7833                                                                                                 \
7834         /* "Variations" stress areas which we try to mix up with each other. */                 \
7835         /* These should not be exhaustively used as they might */                               \
7836         /* hide/trivialize other areas */                                                       \
7837                                                                                                 \
7838         STRESS_MODE(REGS) STRESS_MODE(DBL_ALN) STRESS_MODE(LCL_FLDS) STRESS_MODE(UNROLL_LOOPS)  \
7839         STRESS_MODE(MAKE_CSE) STRESS_MODE(LEGACY_INLINE) STRESS_MODE(CLONE_EXPR)                \
7840         STRESS_MODE(USE_FCOMI) STRESS_MODE(USE_CMOV) STRESS_MODE(FOLD)                          \
7841         STRESS_MODE(BB_PROFILE) STRESS_MODE(OPT_BOOLS_GC) STRESS_MODE(REMORPH_TREES)            \
7842         STRESS_MODE(64RSLT_MUL) STRESS_MODE(DO_WHILE_LOOPS) STRESS_MODE(MIN_OPTS)               \
7843         STRESS_MODE(REVERSE_FLAG)     /* Will set GTF_REVERSE_OPS whenever we can */            \
7844         STRESS_MODE(REVERSE_COMMA)    /* Will reverse commas created  with gtNewCommaNode */    \
7845         STRESS_MODE(TAILCALL)         /* Will make the call as a tailcall whenever legal */     \
7846         STRESS_MODE(CATCH_ARG)        /* Will spill catch arg */                                \
7847         STRESS_MODE(UNSAFE_BUFFER_CHECKS)                                                       \
7848         STRESS_MODE(NULL_OBJECT_CHECK)                                                          \
7849         STRESS_MODE(PINVOKE_RESTORE_ESP)                                                        \
7850         STRESS_MODE(RANDOM_INLINE)                                                              \
7851                                                                                                 \
7852         STRESS_MODE(GENERIC_VARN) STRESS_MODE(COUNT_VARN)                                       \
7853                                                                                                 \
7854         /* "Check" stress areas that can be exhaustively used if we */                          \
7855         /*  dont care about performance at all */                                               \
7856                                                                                                 \
7857         STRESS_MODE(FORCE_INLINE) /* Treat every method as AggressiveInlining */                \
7858         STRESS_MODE(CHK_FLOW_UPDATE)                                                            \
7859         STRESS_MODE(EMITTER) STRESS_MODE(CHK_REIMPORT) STRESS_MODE(FLATFP)                      \
7860                                                                                                 \
7861         STRESS_MODE(GENERIC_CHECK) STRESS_MODE(COUNT)                                           \
7862
7863     enum                compStressArea
7864     {
7865 #define STRESS_MODE(mode) STRESS_##mode,
7866         STRESS_MODES
7867 #undef STRESS_MODE
7868     };
7869 // clang-format on
7870
7871 #ifdef DEBUG
7872     static const LPCWSTR s_compStressModeNames[STRESS_COUNT + 1];
7873     BYTE                 compActiveStressModes[STRESS_COUNT];
7874 #endif // DEBUG
7875
7876 #define MAX_STRESS_WEIGHT 100
7877
7878     bool compStressCompile(compStressArea stressArea, unsigned weightPercentage);
7879
7880 #ifdef DEBUG
7881
7882     bool compInlineStress()
7883     {
7884         return compStressCompile(STRESS_LEGACY_INLINE, 50);
7885     }
7886
7887     bool compRandomInlineStress()
7888     {
7889         return compStressCompile(STRESS_RANDOM_INLINE, 50);
7890     }
7891
7892 #endif // DEBUG
7893
7894     bool compTailCallStress()
7895     {
7896 #ifdef DEBUG
7897         return (JitConfig.TailcallStress() != 0 || compStressCompile(STRESS_TAILCALL, 5));
7898 #else
7899         return false;
7900 #endif
7901     }
7902
7903     codeOptimize compCodeOpt()
7904     {
7905 #if 0
7906         // Switching between size & speed has measurable throughput impact
7907         // (3.5% on NGen mscorlib when measured). It used to be enabled for
7908         // DEBUG, but should generate identical code between CHK & RET builds,
7909         // so that's not acceptable.
7910         // TODO-Throughput: Figure out what to do about size vs. speed & throughput.
7911         //                  Investigate the cause of the throughput regression.
7912
7913         return opts.compCodeOpt;
7914 #else
7915         return BLENDED_CODE;
7916 #endif
7917     }
7918
7919     //--------------------- Info about the procedure --------------------------
7920
7921     struct Info
7922     {
7923         COMP_HANDLE           compCompHnd;
7924         CORINFO_MODULE_HANDLE compScopeHnd;
7925         CORINFO_CLASS_HANDLE  compClassHnd;
7926         CORINFO_METHOD_HANDLE compMethodHnd;
7927         CORINFO_METHOD_INFO*  compMethodInfo;
7928
7929         BOOL hasCircularClassConstraints;
7930         BOOL hasCircularMethodConstraints;
7931
7932 #if defined(DEBUG) || defined(LATE_DISASM)
7933         const char* compMethodName;
7934         const char* compClassName;
7935         const char* compFullName;
7936 #endif // defined(DEBUG) || defined(LATE_DISASM)
7937
7938 #if defined(DEBUG) || defined(INLINE_DATA)
7939         // Method hash is logcally const, but computed
7940         // on first demand.
7941         mutable unsigned compMethodHashPrivate;
7942         unsigned         compMethodHash() const;
7943 #endif // defined(DEBUG) || defined(INLINE_DATA)
7944
7945 #ifdef PSEUDORANDOM_NOP_INSERTION
7946         // things for pseudorandom nop insertion
7947         unsigned  compChecksum;
7948         CLRRandom compRNG;
7949 #endif
7950
7951         // The following holds the FLG_xxxx flags for the method we're compiling.
7952         unsigned compFlags;
7953
7954         // The following holds the class attributes for the method we're compiling.
7955         unsigned compClassAttr;
7956
7957         const BYTE*    compCode;
7958         IL_OFFSET      compILCodeSize;     // The IL code size
7959         UNATIVE_OFFSET compNativeCodeSize; // The native code size, after instructions are issued. This
7960                                            // is less than (compTotalHotCodeSize + compTotalColdCodeSize) only if:
7961         // (1) the code is not hot/cold split, and we issued less code than we expected, or
7962         // (2) the code is hot/cold split, and we issued less code than we expected
7963         // in the cold section (the hot section will always be padded out to compTotalHotCodeSize).
7964
7965         bool compIsStatic : 1;         // Is the method static (no 'this' pointer)?
7966         bool compIsVarArgs : 1;        // Does the method have varargs parameters?
7967         bool compIsContextful : 1;     // contextful method
7968         bool compInitMem : 1;          // Is the CORINFO_OPT_INIT_LOCALS bit set in the method info options?
7969         bool compUnwrapContextful : 1; // JIT should unwrap proxies when possible
7970         bool compProfilerCallback : 1; // JIT inserted a profiler Enter callback
7971         bool compPublishStubParam : 1; // EAX captured in prolog will be available through an instrinsic
7972         bool compRetBuffDefStack : 1;  // The ret buff argument definitely points into the stack.
7973
7974         var_types compRetType;       // Return type of the method as declared in IL
7975         var_types compRetNativeType; // Normalized return type as per target arch ABI
7976         unsigned  compILargsCount;   // Number of arguments (incl. implicit but not hidden)
7977         unsigned  compArgsCount;     // Number of arguments (incl. implicit and     hidden)
7978         unsigned  compRetBuffArg;    // position of hidden return param var (0, 1) (BAD_VAR_NUM means not present);
7979         int compTypeCtxtArg; // position of hidden param for type context for generic code (CORINFO_CALLCONV_PARAMTYPE)
7980         unsigned       compThisArg; // position of implicit this pointer param (not to be confused with lvaArg0Var)
7981         unsigned       compILlocalsCount; // Number of vars : args + locals (incl. implicit but not hidden)
7982         unsigned       compLocalsCount;   // Number of vars : args + locals (incl. implicit and     hidden)
7983         unsigned       compMaxStack;
7984         UNATIVE_OFFSET compTotalHotCodeSize;  // Total number of bytes of Hot Code in the method
7985         UNATIVE_OFFSET compTotalColdCodeSize; // Total number of bytes of Cold Code in the method
7986
7987         unsigned compCallUnmanaged;   // count of unmanaged calls
7988         unsigned compLvFrameListRoot; // lclNum for the Frame root
7989         unsigned compXcptnsCount;     // Number of exception-handling clauses read in the method's IL.
7990                                       // You should generally use compHndBBtabCount instead: it is the
7991                                       // current number of EH clauses (after additions like synchronized
7992                                       // methods and funclets, and removals like unreachable code deletion).
7993
7994         bool compMatchedVM; // true if the VM is "matched": either the JIT is a cross-compiler
7995                             // and the VM expects that, or the JIT is a "self-host" compiler
7996                             // (e.g., x86 hosted targeting x86) and the VM expects that.
7997
7998         /*  The following holds IL scope information about local variables.
7999          */
8000
8001         unsigned     compVarScopesCount;
8002         VarScopeDsc* compVarScopes;
8003
8004         /* The following holds information about instr offsets for
8005          * which we need to report IP-mappings
8006          */
8007
8008         IL_OFFSET*                   compStmtOffsets; // sorted
8009         unsigned                     compStmtOffsetsCount;
8010         ICorDebugInfo::BoundaryTypes compStmtOffsetsImplicit;
8011
8012 #define CPU_X86 0x0100 // The generic X86 CPU
8013 #define CPU_X86_PENTIUM_4 0x0110
8014
8015 #define CPU_X64 0x0200       // The generic x64 CPU
8016 #define CPU_AMD_X64 0x0210   // AMD x64 CPU
8017 #define CPU_INTEL_X64 0x0240 // Intel x64 CPU
8018
8019 #define CPU_ARM 0x0300 // The generic ARM CPU
8020
8021         unsigned genCPU; // What CPU are we running on
8022     } info;
8023
8024     // Returns true if the method being compiled returns a non-void and non-struct value.
8025     // Note that lvaInitTypeRef() normalizes compRetNativeType for struct returns in a
8026     // single register as per target arch ABI (e.g on Amd64 Windows structs of size 1, 2,
8027     // 4 or 8 gets normalized to TYP_BYTE/TYP_SHORT/TYP_INT/TYP_LONG; On Arm HFA structs).
8028     // Methods returning such structs are considered to return non-struct return value and
8029     // this method returns true in that case.
8030     bool compMethodReturnsNativeScalarType()
8031     {
8032         return (info.compRetType != TYP_VOID) && !varTypeIsStruct(info.compRetNativeType);
8033     }
8034
8035     // Returns true if the method being compiled returns RetBuf addr as its return value
8036     bool compMethodReturnsRetBufAddr()
8037     {
8038         // There are cases where implicit RetBuf argument should be explicitly returned in a register.
8039         // In such cases the return type is changed to TYP_BYREF and appropriate IR is generated.
8040         // These cases are:
8041         // 1. Profiler Leave calllback expects the address of retbuf as return value for
8042         //    methods with hidden RetBuf argument.  impReturnInstruction() when profiler
8043         //    callbacks are needed creates GT_RETURN(TYP_BYREF, op1 = Addr of RetBuf) for
8044         //    methods with hidden RetBufArg.
8045         //
8046         // 2. As per the System V ABI, the address of RetBuf needs to be returned by
8047         //    methods with hidden RetBufArg in RAX. In such case GT_RETURN is of TYP_BYREF,
8048         //    returning the address of RetBuf.
8049         //
8050         // 3. Windows 64-bit native calling convention also requires the address of RetBuff
8051         //    to be returned in RAX.
8052         CLANG_FORMAT_COMMENT_ANCHOR;
8053
8054 #ifdef _TARGET_AMD64_
8055         return (info.compRetBuffArg != BAD_VAR_NUM);
8056 #else  // !_TARGET_AMD64_
8057         return (compIsProfilerHookNeeded()) && (info.compRetBuffArg != BAD_VAR_NUM);
8058 #endif // !_TARGET_AMD64_
8059     }
8060
8061     // Returns true if the method returns a value in more than one return register
8062     // TODO-ARM-Bug: Deal with multi-register genReturnLocaled structs?
8063     // TODO-ARM64: Does this apply for ARM64 too?
8064     bool compMethodReturnsMultiRegRetType()
8065     {
8066 #if FEATURE_MULTIREG_RET
8067 #if defined(_TARGET_X86_)
8068         // On x86 only 64-bit longs are returned in multiple registers
8069         return varTypeIsLong(info.compRetNativeType);
8070 #else  // targets: X64-UNIX, ARM64 or ARM32
8071         // On all other targets that support multireg return values:
8072         // Methods returning a struct in multiple registers have a return value of TYP_STRUCT.
8073         // Such method's compRetNativeType is TYP_STRUCT without a hidden RetBufArg
8074         return varTypeIsStruct(info.compRetNativeType) && (info.compRetBuffArg == BAD_VAR_NUM);
8075 #endif // TARGET_XXX
8076
8077 #else // not FEATURE_MULTIREG_RET
8078
8079         // For this architecture there are no multireg returns
8080         return false;
8081
8082 #endif // FEATURE_MULTIREG_RET
8083     }
8084
8085 #if FEATURE_MULTIREG_ARGS
8086     // Given a GenTree node of TYP_STRUCT that represents a pass by value argument
8087     // return the gcPtr layout for the pointers sized fields
8088     void getStructGcPtrsFromOp(GenTreePtr op, BYTE* gcPtrsOut);
8089 #endif // FEATURE_MULTIREG_ARGS
8090
8091     // Returns true if the method being compiled returns a value
8092     bool compMethodHasRetVal()
8093     {
8094         return compMethodReturnsNativeScalarType() || compMethodReturnsRetBufAddr() ||
8095                compMethodReturnsMultiRegRetType();
8096     }
8097
8098 #if defined(DEBUG)
8099
8100     void compDispLocalVars();
8101
8102 #endif // DEBUG
8103
8104 //-------------------------- Global Compiler Data ------------------------------------
8105
8106 #ifdef DEBUG
8107     static unsigned s_compMethodsCount; // to produce unique label names
8108     unsigned        compGenTreeID;
8109 #endif
8110
8111     BasicBlock* compCurBB;   // the current basic block in process
8112     GenTreePtr  compCurStmt; // the current statement in process
8113 #ifdef DEBUG
8114     unsigned compCurStmtNum; // to give all statements an increasing StmtNum when printing dumps
8115 #endif
8116
8117     //  The following is used to create the 'method JIT info' block.
8118     size_t compInfoBlkSize;
8119     BYTE*  compInfoBlkAddr;
8120
8121     EHblkDsc* compHndBBtab;           // array of EH data
8122     unsigned  compHndBBtabCount;      // element count of used elements in EH data array
8123     unsigned  compHndBBtabAllocCount; // element count of allocated elements in EH data array
8124
8125 #if defined(_TARGET_X86_)
8126
8127     //-------------------------------------------------------------------------
8128     //  Tracking of region covered by the monitor in synchronized methods
8129     void* syncStartEmitCookie; // the emitter cookie for first instruction after the call to MON_ENTER
8130     void* syncEndEmitCookie;   // the emitter cookie for first instruction after the call to MON_EXIT
8131
8132 #endif // !_TARGET_X86_
8133
8134     Phases previousCompletedPhase; // the most recently completed phase
8135
8136     //-------------------------------------------------------------------------
8137     //  The following keeps track of how many bytes of local frame space we've
8138     //  grabbed so far in the current function, and how many argument bytes we
8139     //  need to pop when we return.
8140     //
8141
8142     unsigned compLclFrameSize; // secObject+lclBlk+locals+temps
8143
8144     // Count of callee-saved regs we pushed in the prolog.
8145     // Does not include EBP for isFramePointerUsed() and double-aligned frames.
8146     // In case of Amd64 this doesn't include float regs saved on stack.
8147     unsigned compCalleeRegsPushed;
8148
8149 #if defined(_TARGET_XARCH_) && !FEATURE_STACK_FP_X87
8150     // Mask of callee saved float regs on stack.
8151     regMaskTP compCalleeFPRegsSavedMask;
8152 #endif
8153 #ifdef _TARGET_AMD64_
8154 // Quirk for VS debug-launch scenario to work:
8155 // Bytes of padding between save-reg area and locals.
8156 #define VSQUIRK_STACK_PAD (2 * REGSIZE_BYTES)
8157     unsigned compVSQuirkStackPaddingNeeded;
8158     bool     compQuirkForPPPflag;
8159 #endif
8160
8161     unsigned compArgSize; // total size of arguments in bytes (including register args (lvIsRegArg))
8162
8163     unsigned compMapILargNum(unsigned ILargNum); // map accounting for hidden args
8164     unsigned compMapILvarNum(unsigned ILvarNum); // map accounting for hidden args
8165     unsigned compMap2ILvarNum(unsigned varNum);  // map accounting for hidden args
8166
8167     //-------------------------------------------------------------------------
8168
8169     static void compStartup();  // One-time initialization
8170     static void compShutdown(); // One-time finalization
8171
8172     void compInit(ArenaAllocator* pAlloc, InlineInfo* inlineInfo);
8173     void compDone();
8174
8175     static void compDisplayStaticSizes(FILE* fout);
8176
8177     //------------ Some utility functions --------------
8178
8179     void* compGetHelperFtn(CorInfoHelpFunc ftnNum,         /* IN  */
8180                            void**          ppIndirection); /* OUT */
8181
8182     // Several JIT/EE interface functions return a CorInfoType, and also return a
8183     // class handle as an out parameter if the type is a value class.  Returns the
8184     // size of the type these describe.
8185     unsigned compGetTypeSize(CorInfoType cit, CORINFO_CLASS_HANDLE clsHnd);
8186
8187 #ifdef DEBUG
8188     // Components used by the compiler may write unit test suites, and
8189     // have them run within this method.  They will be run only once per process, and only
8190     // in debug.  (Perhaps should be under the control of a COMPlus_ flag.)
8191     // These should fail by asserting.
8192     void compDoComponentUnitTestsOnce();
8193 #endif // DEBUG
8194
8195     int compCompile(CORINFO_METHOD_HANDLE methodHnd,
8196                     CORINFO_MODULE_HANDLE classPtr,
8197                     COMP_HANDLE           compHnd,
8198                     CORINFO_METHOD_INFO*  methodInfo,
8199                     void**                methodCodePtr,
8200                     ULONG*                methodCodeSize,
8201                     JitFlags*             compileFlags);
8202     void compCompileFinish();
8203     int compCompileHelper(CORINFO_MODULE_HANDLE            classPtr,
8204                           COMP_HANDLE                      compHnd,
8205                           CORINFO_METHOD_INFO*             methodInfo,
8206                           void**                           methodCodePtr,
8207                           ULONG*                           methodCodeSize,
8208                           JitFlags*                        compileFlags,
8209                           CorInfoInstantiationVerification instVerInfo);
8210
8211     ArenaAllocator* compGetAllocator();
8212
8213 #if MEASURE_MEM_ALLOC
8214
8215     static bool s_dspMemStats; // Display per-phase memory statistics for every function
8216
8217     struct MemStats
8218     {
8219         unsigned allocCnt;                 // # of allocs
8220         UINT64   allocSz;                  // total size of those alloc.
8221         UINT64   allocSzMax;               // Maximum single allocation.
8222         UINT64   allocSzByKind[CMK_Count]; // Classified by "kind".
8223         UINT64   nraTotalSizeAlloc;
8224         UINT64   nraTotalSizeUsed;
8225
8226         static const char* s_CompMemKindNames[]; // Names of the kinds.
8227
8228         MemStats() : allocCnt(0), allocSz(0), allocSzMax(0), nraTotalSizeAlloc(0), nraTotalSizeUsed(0)
8229         {
8230             for (int i = 0; i < CMK_Count; i++)
8231             {
8232                 allocSzByKind[i] = 0;
8233             }
8234         }
8235         MemStats(const MemStats& ms)
8236             : allocCnt(ms.allocCnt)
8237             , allocSz(ms.allocSz)
8238             , allocSzMax(ms.allocSzMax)
8239             , nraTotalSizeAlloc(ms.nraTotalSizeAlloc)
8240             , nraTotalSizeUsed(ms.nraTotalSizeUsed)
8241         {
8242             for (int i = 0; i < CMK_Count; i++)
8243             {
8244                 allocSzByKind[i] = ms.allocSzByKind[i];
8245             }
8246         }
8247
8248         // Until we have ubiquitous constructors.
8249         void Init()
8250         {
8251             this->MemStats::MemStats();
8252         }
8253
8254         void AddAlloc(size_t sz, CompMemKind cmk)
8255         {
8256             allocCnt += 1;
8257             allocSz += sz;
8258             if (sz > allocSzMax)
8259             {
8260                 allocSzMax = sz;
8261             }
8262             allocSzByKind[cmk] += sz;
8263         }
8264
8265         void Print(FILE* f);       // Print these stats to f.
8266         void PrintByKind(FILE* f); // Do just the by-kind histogram part.
8267     };
8268     MemStats genMemStats;
8269
8270     struct AggregateMemStats : public MemStats
8271     {
8272         unsigned nMethods;
8273
8274         AggregateMemStats() : MemStats(), nMethods(0)
8275         {
8276         }
8277
8278         void Add(const MemStats& ms)
8279         {
8280             nMethods++;
8281             allocCnt += ms.allocCnt;
8282             allocSz += ms.allocSz;
8283             allocSzMax = max(allocSzMax, ms.allocSzMax);
8284             for (int i = 0; i < CMK_Count; i++)
8285             {
8286                 allocSzByKind[i] += ms.allocSzByKind[i];
8287             }
8288             nraTotalSizeAlloc += ms.nraTotalSizeAlloc;
8289             nraTotalSizeUsed += ms.nraTotalSizeUsed;
8290         }
8291
8292         void Print(FILE* f); // Print these stats to jitstdout.
8293     };
8294
8295     static CritSecObject     s_memStatsLock;    // This lock protects the data structures below.
8296     static MemStats          s_maxCompMemStats; // Stats for the compilation with the largest amount allocated.
8297     static AggregateMemStats s_aggMemStats;     // Aggregates statistics for all compilations.
8298
8299 #endif // MEASURE_MEM_ALLOC
8300
8301 #if LOOP_HOIST_STATS
8302     unsigned m_loopsConsidered;
8303     bool     m_curLoopHasHoistedExpression;
8304     unsigned m_loopsWithHoistedExpressions;
8305     unsigned m_totalHoistedExpressions;
8306
8307     void AddLoopHoistStats();
8308     void PrintPerMethodLoopHoistStats();
8309
8310     static CritSecObject s_loopHoistStatsLock; // This lock protects the data structures below.
8311     static unsigned      s_loopsConsidered;
8312     static unsigned      s_loopsWithHoistedExpressions;
8313     static unsigned      s_totalHoistedExpressions;
8314
8315     static void PrintAggregateLoopHoistStats(FILE* f);
8316 #endif // LOOP_HOIST_STATS
8317
8318     void* compGetMemArray(size_t numElem, size_t elemSize, CompMemKind cmk = CMK_Unknown);
8319     void* compGetMemArrayA(size_t numElem, size_t elemSize, CompMemKind cmk = CMK_Unknown);
8320     void* compGetMem(size_t sz, CompMemKind cmk = CMK_Unknown);
8321     void* compGetMemA(size_t sz, CompMemKind cmk = CMK_Unknown);
8322     static void* compGetMemCallback(void*, size_t, CompMemKind cmk = CMK_Unknown);
8323     void compFreeMem(void*);
8324
8325     bool compIsForImportOnly();
8326     bool compIsForInlining();
8327     bool compDonotInline();
8328
8329 #ifdef DEBUG
8330     const char* compLocalVarName(unsigned varNum, unsigned offs);
8331     VarName compVarName(regNumber reg, bool isFloatReg = false);
8332     const char* compRegVarName(regNumber reg, bool displayVar = false, bool isFloatReg = false);
8333     const char* compRegPairName(regPairNo regPair);
8334     const char* compRegNameForSize(regNumber reg, size_t size);
8335     const char* compFPregVarName(unsigned fpReg, bool displayVar = false);
8336     void compDspSrcLinesByNativeIP(UNATIVE_OFFSET curIP);
8337     void compDspSrcLinesByLineNum(unsigned line, bool seek = false);
8338 #endif // DEBUG
8339
8340     //-------------------------------------------------------------------------
8341
8342     typedef ListNode<VarScopeDsc*> VarScopeListNode;
8343
8344     struct VarScopeMapInfo
8345     {
8346         VarScopeListNode*       head;
8347         VarScopeListNode*       tail;
8348         static VarScopeMapInfo* Create(VarScopeListNode* node, IAllocator* alloc)
8349         {
8350             VarScopeMapInfo* info = new (alloc) VarScopeMapInfo;
8351             info->head            = node;
8352             info->tail            = node;
8353             return info;
8354         }
8355     };
8356
8357     // Max value of scope count for which we would use linear search; for larger values we would use hashtable lookup.
8358     static const unsigned MAX_LINEAR_FIND_LCL_SCOPELIST = 32;
8359
8360     typedef SimplerHashTable<unsigned, SmallPrimitiveKeyFuncs<unsigned>, VarScopeMapInfo*, JitSimplerHashBehavior>
8361         VarNumToScopeDscMap;
8362
8363     // Map to keep variables' scope indexed by varNum containing it's scope dscs at the index.
8364     VarNumToScopeDscMap* compVarScopeMap;
8365
8366     VarScopeDsc* compFindLocalVar(unsigned varNum, unsigned lifeBeg, unsigned lifeEnd);
8367
8368     VarScopeDsc* compFindLocalVar(unsigned varNum, unsigned offs);
8369
8370     VarScopeDsc* compFindLocalVarLinear(unsigned varNum, unsigned offs);
8371
8372     void compInitVarScopeMap();
8373
8374     VarScopeDsc** compEnterScopeList; // List has the offsets where variables
8375                                       // enter scope, sorted by instr offset
8376     unsigned compNextEnterScope;
8377
8378     VarScopeDsc** compExitScopeList; // List has the offsets where variables
8379                                      // go out of scope, sorted by instr offset
8380     unsigned compNextExitScope;
8381
8382     void compInitScopeLists();
8383
8384     void compResetScopeLists();
8385
8386     VarScopeDsc* compGetNextEnterScope(unsigned offs, bool scan = false);
8387
8388     VarScopeDsc* compGetNextExitScope(unsigned offs, bool scan = false);
8389
8390     void compProcessScopesUntil(unsigned   offset,
8391                                 VARSET_TP* inScope,
8392                                 void (Compiler::*enterScopeFn)(VARSET_TP* inScope, VarScopeDsc*),
8393                                 void (Compiler::*exitScopeFn)(VARSET_TP* inScope, VarScopeDsc*));
8394
8395 #ifdef DEBUG
8396     void compDispScopeLists();
8397 #endif // DEBUG
8398
8399     bool compIsProfilerHookNeeded();
8400
8401     //-------------------------------------------------------------------------
8402     /*               Statistical Data Gathering                               */
8403
8404     void compJitStats(); // call this function and enable
8405                          // various ifdef's below for statistical data
8406
8407 #if CALL_ARG_STATS
8408     void        compCallArgStats();
8409     static void compDispCallArgStats(FILE* fout);
8410 #endif
8411
8412     //-------------------------------------------------------------------------
8413
8414 protected:
8415 #ifdef DEBUG
8416     bool skipMethod();
8417 #endif
8418
8419     ArenaAllocator* compAllocator;
8420
8421 public:
8422     // This one presents an implementation of the "IAllocator" abstract class that uses "compAllocator",
8423     // suitable for use by utilcode collection types.
8424     IAllocator* compAsIAllocator;
8425
8426 #if MEASURE_MEM_ALLOC
8427     IAllocator* compAsIAllocatorBitset;    // An allocator that uses the CMK_bitset tracker.
8428     IAllocator* compAsIAllocatorGC;        // An allocator that uses the CMK_GC tracker.
8429     IAllocator* compAsIAllocatorLoopHoist; // An allocator that uses the CMK_LoopHoist tracker.
8430 #ifdef DEBUG
8431     IAllocator* compAsIAllocatorDebugOnly; // An allocator that uses the CMK_DebugOnly tracker.
8432 #endif                                     // DEBUG
8433 #endif                                     // MEASURE_MEM_ALLOC
8434
8435     void compFunctionTraceStart();
8436     void compFunctionTraceEnd(void* methodCodePtr, ULONG methodCodeSize, bool isNYI);
8437
8438 protected:
8439     size_t compMaxUncheckedOffsetForNullObject;
8440
8441     void compInitOptions(JitFlags* compileFlags);
8442
8443     void compSetProcessor();
8444     void compInitDebuggingInfo();
8445     void compSetOptimizationLevel();
8446 #ifdef _TARGET_ARMARCH_
8447     bool compRsvdRegCheck(FrameLayoutState curState);
8448 #endif
8449     void compCompile(void** methodCodePtr, ULONG* methodCodeSize, JitFlags* compileFlags);
8450
8451     // Clear annotations produced during optimizations; to be used between iterations when repeating opts.
8452     void ResetOptAnnotations();
8453
8454     // Regenerate loop descriptors; to be used between iterations when repeating opts.
8455     void RecomputeLoopInfo();
8456
8457 #ifdef PROFILING_SUPPORTED
8458     // Data required for generating profiler Enter/Leave/TailCall hooks
8459
8460     bool  compProfilerHookNeeded; // Whether profiler Enter/Leave/TailCall hook needs to be generated for the method
8461     void* compProfilerMethHnd;    // Profiler handle of the method being compiled. Passed as param to ELT callbacks
8462     bool  compProfilerMethHndIndirected; // Whether compProfilerHandle is pointer to the handle or is an actual handle
8463 #endif
8464
8465 #ifdef _TARGET_AMD64_
8466     bool compQuirkForPPP(); // Check if this method should be Quirked for the PPP issue
8467 #endif
8468 public:
8469     // Assumes called as part of process shutdown; does any compiler-specific work associated with that.
8470     static void ProcessShutdownWork(ICorStaticInfo* statInfo);
8471
8472     IAllocator* getAllocator()
8473     {
8474         return compAsIAllocator;
8475     }
8476
8477 #if MEASURE_MEM_ALLOC
8478     IAllocator* getAllocatorBitset()
8479     {
8480         return compAsIAllocatorBitset;
8481     }
8482     IAllocator* getAllocatorGC()
8483     {
8484         return compAsIAllocatorGC;
8485     }
8486     IAllocator* getAllocatorLoopHoist()
8487     {
8488         return compAsIAllocatorLoopHoist;
8489     }
8490 #else  // !MEASURE_MEM_ALLOC
8491     IAllocator* getAllocatorBitset()
8492     {
8493         return compAsIAllocator;
8494     }
8495     IAllocator* getAllocatorGC()
8496     {
8497         return compAsIAllocator;
8498     }
8499     IAllocator* getAllocatorLoopHoist()
8500     {
8501         return compAsIAllocator;
8502     }
8503 #endif // !MEASURE_MEM_ALLOC
8504
8505 #ifdef DEBUG
8506     IAllocator* getAllocatorDebugOnly()
8507     {
8508 #if MEASURE_MEM_ALLOC
8509         return compAsIAllocatorDebugOnly;
8510 #else  // !MEASURE_MEM_ALLOC
8511         return compAsIAllocator;
8512 #endif // !MEASURE_MEM_ALLOC
8513     }
8514 #endif // DEBUG
8515
8516     /*
8517     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8518     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8519     XX                                                                           XX
8520     XX                           typeInfo                                        XX
8521     XX                                                                           XX
8522     XX   Checks for type compatibility and merges types                          XX
8523     XX                                                                           XX
8524     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8525     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8526     */
8527
8528 public:
8529     // Set to TRUE if verification cannot be skipped for this method
8530     // If we detect unverifiable code, we will lazily check
8531     // canSkipMethodVerification() to see if verification is REALLY needed.
8532     BOOL tiVerificationNeeded;
8533
8534     // It it initially TRUE, and it gets set to FALSE if we run into unverifiable code
8535     // Note that this is valid only if tiVerificationNeeded was ever TRUE.
8536     BOOL tiIsVerifiableCode;
8537
8538     // Set to TRUE if runtime callout is needed for this method
8539     BOOL tiRuntimeCalloutNeeded;
8540
8541     // Set to TRUE if security prolog/epilog callout is needed for this method
8542     // Note: This flag is different than compNeedSecurityCheck.
8543     //     compNeedSecurityCheck means whether or not a security object needs
8544     //         to be allocated on the stack, which is currently true for EnC as well.
8545     //     tiSecurityCalloutNeeded means whether or not security callouts need
8546     //         to be inserted in the jitted code.
8547     BOOL tiSecurityCalloutNeeded;
8548
8549     // Returns TRUE if child is equal to or a subtype of parent for merge purposes
8550     // This support is necessary to suport attributes that are not described in
8551     // for example, signatures. For example, the permanent home byref (byref that
8552     // points to the gc heap), isn't a property of method signatures, therefore,
8553     // it is safe to have mismatches here (that tiCompatibleWith will not flag),
8554     // but when deciding if we need to reimport a block, we need to take these
8555     // in account
8556     BOOL tiMergeCompatibleWith(const typeInfo& pChild, const typeInfo& pParent, bool normalisedForStack) const;
8557
8558     // Returns TRUE if child is equal to or a subtype of parent.
8559     // normalisedForStack indicates that both types are normalised for the stack
8560     BOOL tiCompatibleWith(const typeInfo& pChild, const typeInfo& pParent, bool normalisedForStack) const;
8561
8562     // Merges pDest and pSrc. Returns FALSE if merge is undefined.
8563     // *pDest is modified to represent the merged type.  Sets "*changed" to true
8564     // if this changes "*pDest".
8565     BOOL tiMergeToCommonParent(typeInfo* pDest, const typeInfo* pSrc, bool* changed) const;
8566
8567     // Set pDest from the primitive value type.
8568     // Eg. System.Int32 -> ELEMENT_TYPE_I4
8569
8570     BOOL tiFromPrimitiveValueClass(typeInfo* pDest, const typeInfo* pVC) const;
8571
8572 #ifdef DEBUG
8573     // <BUGNUM> VSW 471305
8574     // IJW allows assigning REF to BYREF. The following allows us to temporarily
8575     // bypass the assert check in gcMarkRegSetGCref and gcMarkRegSetByref
8576     // We use a "short" as we need to push/pop this scope.
8577     // </BUGNUM>
8578     short compRegSetCheckLevel;
8579 #endif
8580
8581     /*
8582     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8583     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8584     XX                                                                           XX
8585     XX                           IL verification stuff                           XX
8586     XX                                                                           XX
8587     XX                                                                           XX
8588     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8589     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8590     */
8591
8592 public:
8593     // The following is used to track liveness of local variables, initialization
8594     // of valueclass constructors, and type safe use of IL instructions.
8595
8596     // dynamic state info needed for verification
8597     EntryState verCurrentState;
8598
8599     // this ptr of object type .ctors are considered intited only after
8600     // the base class ctor is called, or an alternate ctor is called.
8601     // An uninited this ptr can be used to access fields, but cannot
8602     // be used to call a member function.
8603     BOOL verTrackObjCtorInitState;
8604
8605     void verInitBBEntryState(BasicBlock* block, EntryState* currentState);
8606
8607     // Requires that "tis" is not TIS_Bottom -- it's a definite init/uninit state.
8608     void verSetThisInit(BasicBlock* block, ThisInitState tis);
8609     void verInitCurrentState();
8610     void verResetCurrentState(BasicBlock* block, EntryState* currentState);
8611
8612     // Merges the current verification state into the entry state of "block", return FALSE if that merge fails,
8613     // TRUE if it succeeds.  Further sets "*changed" to true if this changes the entry state of "block".
8614     BOOL verMergeEntryStates(BasicBlock* block, bool* changed);
8615
8616     void verConvertBBToThrowVerificationException(BasicBlock* block DEBUGARG(bool logMsg));
8617     void verHandleVerificationFailure(BasicBlock* block DEBUGARG(bool logMsg));
8618     typeInfo verMakeTypeInfo(CORINFO_CLASS_HANDLE clsHnd,
8619                              bool bashStructToRef = false); // converts from jit type representation to typeInfo
8620     typeInfo verMakeTypeInfo(CorInfoType          ciType,
8621                              CORINFO_CLASS_HANDLE clsHnd); // converts from jit type representation to typeInfo
8622     BOOL verIsSDArray(typeInfo ti);
8623     typeInfo verGetArrayElemType(typeInfo ti);
8624
8625     typeInfo verParseArgSigToTypeInfo(CORINFO_SIG_INFO* sig, CORINFO_ARG_LIST_HANDLE args);
8626     BOOL verNeedsVerification();
8627     BOOL verIsByRefLike(const typeInfo& ti);
8628     BOOL verIsSafeToReturnByRef(const typeInfo& ti);
8629
8630     // generic type variables range over types that satisfy IsBoxable
8631     BOOL verIsBoxable(const typeInfo& ti);
8632
8633     void DECLSPEC_NORETURN verRaiseVerifyException(INDEBUG(const char* reason) DEBUGARG(const char* file)
8634                                                        DEBUGARG(unsigned line));
8635     void verRaiseVerifyExceptionIfNeeded(INDEBUG(const char* reason) DEBUGARG(const char* file)
8636                                              DEBUGARG(unsigned line));
8637     bool verCheckTailCallConstraint(OPCODE                  opcode,
8638                                     CORINFO_RESOLVED_TOKEN* pResolvedToken,
8639                                     CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken, // Is this a "constrained." call
8640                                                                                        // on a type parameter?
8641                                     bool speculative // If true, won't throw if verificatoin fails. Instead it will
8642                                                      // return false to the caller.
8643                                                      // If false, it will throw.
8644                                     );
8645     bool verIsBoxedValueType(typeInfo ti);
8646
8647     void verVerifyCall(OPCODE                  opcode,
8648                        CORINFO_RESOLVED_TOKEN* pResolvedToken,
8649                        CORINFO_RESOLVED_TOKEN* pConstrainedResolvedToken,
8650                        bool                    tailCall,
8651                        bool                    readonlyCall, // is this a "readonly." call?
8652                        const BYTE*             delegateCreateStart,
8653                        const BYTE*             codeAddr,
8654                        CORINFO_CALL_INFO* callInfo DEBUGARG(const char* methodName));
8655
8656     BOOL verCheckDelegateCreation(const BYTE* delegateCreateStart, const BYTE* codeAddr, mdMemberRef& targetMemberRef);
8657
8658     typeInfo verVerifySTIND(const typeInfo& ptr, const typeInfo& value, const typeInfo& instrType);
8659     typeInfo verVerifyLDIND(const typeInfo& ptr, const typeInfo& instrType);
8660     void verVerifyField(CORINFO_RESOLVED_TOKEN*   pResolvedToken,
8661                         const CORINFO_FIELD_INFO& fieldInfo,
8662                         const typeInfo*           tiThis,
8663                         BOOL                      mutator,
8664                         BOOL                      allowPlainStructAsThis = FALSE);
8665     void verVerifyCond(const typeInfo& tiOp1, const typeInfo& tiOp2, unsigned opcode);
8666     void verVerifyThisPtrInitialised();
8667     BOOL verIsCallToInitThisPtr(CORINFO_CLASS_HANDLE context, CORINFO_CLASS_HANDLE target);
8668
8669     // Register allocator
8670     void raInitStackFP();
8671     void raEnregisterVarsPrePassStackFP();
8672     void raSetRegLclBirthDeath(GenTreePtr tree, VARSET_VALARG_TP lastlife, bool fromLDOBJ);
8673     void raEnregisterVarsPostPassStackFP();
8674     void raGenerateFPRefCounts();
8675     void raEnregisterVarsStackFP();
8676     void raUpdateHeightsForVarsStackFP(VARSET_VALARG_TP mask);
8677
8678     regNumber raRegForVarStackFP(unsigned varTrackedIndex);
8679     void raAddPayloadStackFP(VARSET_VALARG_TP mask, unsigned weight);
8680
8681     // returns true if enregistering v1 would save more mem accesses than v2
8682     bool raVarIsGreaterValueStackFP(LclVarDsc* lv1, LclVarDsc* lv2);
8683
8684 #ifdef DEBUG
8685     void raDumpHeightsStackFP();
8686     void raDumpVariableRegIntfFloat();
8687 #endif
8688
8689 #if FEATURE_STACK_FP_X87
8690
8691     // Currently, we use FP transition blocks in only 2 situations:
8692     //
8693     //      -conditional jump on longs where FP stack differs with target: it's not strictly
8694     //       necessary, but its low frequency and the code would get complicated if we try to
8695     //       inline the FP stack adjustment, as we have a lot of special casing going on to try
8696     //       minimize the way we generate the jump code.
8697     //      -case statements of switch where the FP stack differs with the one of evaluating the switch () statement
8698     //       We do this as we want to codegen switch as a jumptable. Again, this is low frequency.
8699     //
8700     //      However, transition blocks have 2 problems
8701     //
8702     //          - Procedure splitting: current implementation of procedure splitting requires all basic blocks to
8703     //            be known at codegen time, as it generates all hot blocks first and cold blocks later. This ties
8704     //            us up in codegen and is a solvable problem (we could make procedure splitting generate blocks
8705     //            in the right place without preordering them), this causes us to have to generate the transition
8706     //            blocks in the cold area if we want procedure splitting.
8707     //
8708     //
8709     //          - Thread abort exceptions and transition blocks. Transition blocks were designed under the assumption
8710     //            that no exceptions can happen inside them. Unfortunately Thread.Abort can happen in any instruction,
8711     //            and if we have handlers we will have to try to call them. Fixing this the right way would imply
8712     //            having multiple try native code regions for a single try il region. This is doable and shouldnt be
8713     //            a big change in the exception.
8714     //
8715     //      Given the low frequency of the cases where we have transition blocks, I've decided to dumb down
8716     //      optimizations. For these 2 cases:
8717     //
8718     //          - When there is a chance that we will have FP transition blocks, we won't do procedure splitting.
8719     //          - When a method has a handler, it won't enregister any FP variables that go thru a conditional long or
8720     //          a switch statement.
8721     //
8722     //      If at any point we find we need to optimize this, we should throw work at unblocking the restrictions our
8723     //      current procedure splitting and exception code have.
8724     bool compMayHaveTransitionBlocks;
8725
8726     VARSET_TP raMaskDontEnregFloat; // mask for additional restrictions
8727
8728     VARSET_TP raLclRegIntfFloat[REG_FPCOUNT];
8729
8730     unsigned raCntStkStackFP;
8731     unsigned raCntWtdStkDblStackFP;
8732     unsigned raCntStkParamDblStackFP;
8733
8734     // Payload in mem accesses for enregistering a variable (we dont want to mix with refcounts)
8735     // TODO: Do we want to put this in LclVarDsc?
8736     unsigned raPayloadStackFP[lclMAX_TRACKED];
8737     unsigned raHeightsStackFP[lclMAX_TRACKED][FP_VIRTUALREGISTERS + 1];
8738 #ifdef DEBUG
8739     // Useful for debugging
8740     unsigned raHeightsNonWeightedStackFP[lclMAX_TRACKED][FP_VIRTUALREGISTERS + 1];
8741 #endif
8742 #endif // FEATURE_STACK_FP_X87
8743
8744 #ifdef DEBUG
8745     // One line log function. Default level is 0. Increasing it gives you
8746     // more log information
8747
8748     // levels are currently unused: #define JITDUMP(level,...)                     ();
8749     void JitLogEE(unsigned level, const char* fmt, ...);
8750
8751     bool compDebugBreak;
8752
8753     bool compJitHaltMethod();
8754
8755 #endif
8756
8757     /*
8758     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8759     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8760     XX                                                                           XX
8761     XX                   GS Security checks for unsafe buffers                   XX
8762     XX                                                                           XX
8763     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8764     XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
8765     */
8766 public:
8767     struct ShadowParamVarInfo
8768     {
8769         FixedBitVect* assignGroup; // the closure set of variables whose values depend on each other
8770         unsigned      shadowCopy;  // Lcl var num, valid only if not set to NO_SHADOW_COPY
8771
8772         static bool mayNeedShadowCopy(LclVarDsc* varDsc)
8773         {
8774 #if defined(_TARGET_AMD64_) && !defined(LEGACY_BACKEND)
8775             // GS cookie logic to create shadow slots, create trees to copy reg args to shadow
8776             // slots and update all trees to refer to shadow slots is done immediately after
8777             // fgMorph().  Lsra could potentially mark a param as DoNotEnregister after JIT determines
8778             // not to shadow a parameter.  Also, LSRA could potentially spill a param which is passed
8779             // in register. Therefore, conservatively all params may need a shadow copy.  Note that
8780             // GS cookie logic further checks whether the param is a ptr or an unsafe buffer before
8781             // creating a shadow slot even though this routine returns true.
8782             //
8783             // TODO-AMD64-CQ: Revisit this conservative approach as it could create more shadow slots than
8784             // required. There are two cases under which a reg arg could potentially be used from its
8785             // home location:
8786             //   a) LSRA marks it as DoNotEnregister (see LinearScan::identifyCandidates())
8787             //   b) LSRA spills it
8788             //
8789             // Possible solution to address case (a)
8790             //   - The conditions under which LSRA marks a varDsc as DoNotEnregister could be checked
8791             //     in this routine.  Note that live out of exception handler is something we may not be
8792             //     able to do it here since GS cookie logic is invoked ahead of liveness computation.
8793             //     Therefore, for methods with exception handling and need GS cookie check we might have
8794             //     to take conservative approach.
8795             //
8796             // Possible solution to address case (b)
8797             //   - Whenver a parameter passed in an argument register needs to be spilled by LSRA, we
8798             //     create a new spill temp if the method needs GS cookie check.
8799             return varDsc->lvIsParam;
8800 #else // !(defined(_TARGET_AMD64_) && defined(LEGACY_BACKEND))
8801             return varDsc->lvIsParam && !varDsc->lvIsRegArg;
8802 #endif
8803         }
8804
8805 #ifdef DEBUG
8806         void Print()
8807         {
8808             printf("assignGroup [%p]; shadowCopy: [%d];\n", assignGroup, shadowCopy);
8809         }
8810 #endif
8811     };
8812
8813     GSCookie*           gsGlobalSecurityCookieAddr; // Address of global cookie for unsafe buffer checks
8814     GSCookie            gsGlobalSecurityCookieVal;  // Value of global cookie if addr is NULL
8815     ShadowParamVarInfo* gsShadowVarInfo;            // Table used by shadow param analysis code
8816
8817     void gsGSChecksInitCookie();   // Grabs cookie variable
8818     void gsCopyShadowParams();     // Identify vulnerable params and create dhadow copies
8819     bool gsFindVulnerableParams(); // Shadow param analysis code
8820     void gsParamsToShadows();      // Insert copy code and replave param uses by shadow
8821
8822     static fgWalkPreFn gsMarkPtrsAndAssignGroups; // Shadow param analysis tree-walk
8823     static fgWalkPreFn gsReplaceShadowParams;     // Shadow param replacement tree-walk
8824
8825 #define DEFAULT_MAX_INLINE_SIZE 100 // Methods with >  DEFAULT_MAX_INLINE_SIZE IL bytes will never be inlined.
8826                                     // This can be overwritten by setting complus_JITInlineSize env variable.
8827
8828 #define DEFAULT_MAX_INLINE_DEPTH 20 // Methods at more than this level deep will not be inlined
8829
8830 private:
8831 #ifdef FEATURE_JIT_METHOD_PERF
8832     JitTimer*                  pCompJitTimer;         // Timer data structure (by phases) for current compilation.
8833     static CompTimeSummaryInfo s_compJitTimerSummary; // Summary of the Timer information for the whole run.
8834
8835     static LPCWSTR JitTimeLogCsv();        // Retrieve the file name for CSV from ConfigDWORD.
8836     static LPCWSTR compJitTimeLogFilename; // If a log file for JIT time is desired, filename to write it to.
8837 #endif
8838     inline void EndPhase(Phases phase); // Indicate the end of the given phase.
8839
8840 #if MEASURE_CLRAPI_CALLS
8841     // Thin wrappers that call into JitTimer (if present).
8842     inline void CLRApiCallEnter(unsigned apix);
8843     inline void CLRApiCallLeave(unsigned apix);
8844
8845 public:
8846     inline void CLR_API_Enter(API_ICorJitInfo_Names ename);
8847     inline void CLR_API_Leave(API_ICorJitInfo_Names ename);
8848
8849 private:
8850 #endif
8851
8852 #if defined(DEBUG) || defined(INLINE_DATA) || defined(FEATURE_CLRSQM)
8853     // These variables are associated with maintaining SQM data about compile time.
8854     unsigned __int64 m_compCyclesAtEndOfInlining; // The thread-virtualized cycle count at the end of the inlining phase
8855                                                   // in the current compilation.
8856     unsigned __int64 m_compCycles;                // Net cycle count for current compilation
8857     DWORD m_compTickCountAtEndOfInlining; // The result of GetTickCount() (# ms since some epoch marker) at the end of
8858                                           // the inlining phase in the current compilation.
8859 #endif                                    // defined(DEBUG) || defined(INLINE_DATA) || defined(FEATURE_CLRSQM)
8860
8861     // Records the SQM-relevant (cycles and tick count).  Should be called after inlining is complete.
8862     // (We do this after inlining because this marks the last point at which the JIT is likely to cause
8863     // type-loading and class initialization).
8864     void RecordStateAtEndOfInlining();
8865     // Assumes being called at the end of compilation.  Update the SQM state.
8866     void RecordStateAtEndOfCompilation();
8867
8868 #ifdef FEATURE_CLRSQM
8869     // Does anything SQM related necessary at process shutdown time.
8870     static void ProcessShutdownSQMWork(ICorStaticInfo* statInfo);
8871 #endif // FEATURE_CLRSQM
8872
8873 public:
8874 #if FUNC_INFO_LOGGING
8875     static LPCWSTR compJitFuncInfoFilename; // If a log file for per-function information is required, this is the
8876                                             // filename to write it to.
8877     static FILE* compJitFuncInfoFile;       // And this is the actual FILE* to write to.
8878 #endif                                      // FUNC_INFO_LOGGING
8879
8880     Compiler* prevCompiler; // Previous compiler on stack for TLS Compiler* linked list for reentrant compilers.
8881
8882     // Is the compilation in a full trust context?
8883     bool compIsFullTrust();
8884
8885 #ifndef FEATURE_TRACELOGGING
8886     // Should we actually fire the noway assert body and the exception handler?
8887     bool compShouldThrowOnNoway();
8888 #else  // FEATURE_TRACELOGGING
8889     // Should we actually fire the noway assert body and the exception handler?
8890     bool compShouldThrowOnNoway(const char* filename, unsigned line);
8891
8892     // Telemetry instance to use per method compilation.
8893     JitTelemetry compJitTelemetry;
8894
8895     // Get common parameters that have to be logged with most telemetry data.
8896     void compGetTelemetryDefaults(const char** assemblyName,
8897                                   const char** scopeName,
8898                                   const char** methodName,
8899                                   unsigned*    methodHash);
8900 #endif // !FEATURE_TRACELOGGING
8901
8902 #ifdef DEBUG
8903 private:
8904     NodeToTestDataMap* m_nodeTestData;
8905
8906     static const unsigned FIRST_LOOP_HOIST_CSE_CLASS = 1000;
8907     unsigned              m_loopHoistCSEClass; // LoopHoist test annotations turn into CSE requirements; we
8908                                                // label them with CSE Class #'s starting at FIRST_LOOP_HOIST_CSE_CLASS.
8909                                                // Current kept in this.
8910 public:
8911     NodeToTestDataMap* GetNodeTestData()
8912     {
8913         Compiler* compRoot = impInlineRoot();
8914         if (compRoot->m_nodeTestData == nullptr)
8915         {
8916             compRoot->m_nodeTestData = new (getAllocatorDebugOnly()) NodeToTestDataMap(getAllocatorDebugOnly());
8917         }
8918         return compRoot->m_nodeTestData;
8919     }
8920
8921     typedef SimplerHashTable<GenTreePtr, PtrKeyFuncs<GenTree>, int, JitSimplerHashBehavior> NodeToIntMap;
8922
8923     // Returns the set (i.e., the domain of the result map) of nodes that are keys in m_nodeTestData, and
8924     // currently occur in the AST graph.
8925     NodeToIntMap* FindReachableNodesInNodeTestData();
8926
8927     // Node "from" is being eliminated, and being replaced by node "to".  If "from" had any associated
8928     // test data, associate that data with "to".
8929     void TransferTestDataToNode(GenTreePtr from, GenTreePtr to);
8930
8931     // Requires that "to" is a clone of "from".  If any nodes in the "from" tree
8932     // have annotations, attach similar annotations to the corresponding nodes in "to".
8933     void CopyTestDataToCloneTree(GenTreePtr from, GenTreePtr to);
8934
8935     // These are the methods that test that the various conditions implied by the
8936     // test attributes are satisfied.
8937     void JitTestCheckSSA(); // SSA builder tests.
8938     void JitTestCheckVN();  // Value numbering tests.
8939 #endif                      // DEBUG
8940
8941     // The "FieldSeqStore", for canonicalizing field sequences.  See the definition of FieldSeqStore for
8942     // operations.
8943     FieldSeqStore* m_fieldSeqStore;
8944
8945     FieldSeqStore* GetFieldSeqStore()
8946     {
8947         Compiler* compRoot = impInlineRoot();
8948         if (compRoot->m_fieldSeqStore == nullptr)
8949         {
8950             // Create a CompAllocator that labels sub-structure with CMK_FieldSeqStore, and use that for allocation.
8951             IAllocator* ialloc        = new (this, CMK_FieldSeqStore) CompAllocator(this, CMK_FieldSeqStore);
8952             compRoot->m_fieldSeqStore = new (ialloc) FieldSeqStore(ialloc);
8953         }
8954         return compRoot->m_fieldSeqStore;
8955     }
8956
8957     typedef SimplerHashTable<GenTreePtr, PtrKeyFuncs<GenTree>, FieldSeqNode*, JitSimplerHashBehavior> NodeToFieldSeqMap;
8958
8959     // Some nodes of "TYP_BYREF" or "TYP_I_IMPL" actually represent the address of a field within a struct, but since
8960     // the offset of the field is zero, there's no "GT_ADD" node.  We normally attach a field sequence to the constant
8961     // that is added, but what do we do when that constant is zero, and is thus not present?  We use this mechanism to
8962     // attach the field sequence directly to the address node.
8963     NodeToFieldSeqMap* m_zeroOffsetFieldMap;
8964
8965     NodeToFieldSeqMap* GetZeroOffsetFieldMap()
8966     {
8967         // Don't need to worry about inlining here
8968         if (m_zeroOffsetFieldMap == nullptr)
8969         {
8970             // Create a CompAllocator that labels sub-structure with CMK_ZeroOffsetFieldMap, and use that for
8971             // allocation.
8972             IAllocator* ialloc   = new (this, CMK_ZeroOffsetFieldMap) CompAllocator(this, CMK_ZeroOffsetFieldMap);
8973             m_zeroOffsetFieldMap = new (ialloc) NodeToFieldSeqMap(ialloc);
8974         }
8975         return m_zeroOffsetFieldMap;
8976     }
8977
8978     // Requires that "op1" is a node of type "TYP_BYREF" or "TYP_I_IMPL".  We are dereferencing this with the fields in
8979     // "fieldSeq", whose offsets are required all to be zero.  Ensures that any field sequence annotation currently on
8980     // "op1" or its components is augmented by appending "fieldSeq".  In practice, if "op1" is a GT_LCL_FLD, it has
8981     // a field sequence as a member; otherwise, it may be the addition of an a byref and a constant, where the const
8982     // has a field sequence -- in this case "fieldSeq" is appended to that of the constant; otherwise, we
8983     // record the the field sequence using the ZeroOffsetFieldMap described above.
8984     //
8985     // One exception above is that "op1" is a node of type "TYP_REF" where "op1" is a GT_LCL_VAR.
8986     // This happens when System.Object vtable pointer is a regular field at offset 0 in System.Private.CoreLib in
8987     // CoreRT. Such case is handled same as the default case.
8988     void fgAddFieldSeqForZeroOffset(GenTreePtr op1, FieldSeqNode* fieldSeq);
8989
8990     typedef SimplerHashTable<const GenTree*, PtrKeyFuncs<GenTree>, ArrayInfo, JitSimplerHashBehavior>
8991                         NodeToArrayInfoMap;
8992     NodeToArrayInfoMap* m_arrayInfoMap;
8993
8994     NodeToArrayInfoMap* GetArrayInfoMap()
8995     {
8996         Compiler* compRoot = impInlineRoot();
8997         if (compRoot->m_arrayInfoMap == nullptr)
8998         {
8999             // Create a CompAllocator that labels sub-structure with CMK_ArrayInfoMap, and use that for allocation.
9000             IAllocator* ialloc       = new (this, CMK_ArrayInfoMap) CompAllocator(this, CMK_ArrayInfoMap);
9001             compRoot->m_arrayInfoMap = new (ialloc) NodeToArrayInfoMap(ialloc);
9002         }
9003         return compRoot->m_arrayInfoMap;
9004     }
9005
9006     NodeToUnsignedMap* m_heapSsaMap;
9007
9008     // In some cases, we want to assign intermediate SSA #'s to heap states, and know what nodes create those heap
9009     // states. (We do this for try blocks, where, if the try block doesn't do a call that loses track of the heap state,
9010     // all the possible heap states are possible initial states of the corresponding catch block(s).)
9011     NodeToUnsignedMap* GetHeapSsaMap()
9012     {
9013         Compiler* compRoot = impInlineRoot();
9014         if (compRoot->m_heapSsaMap == nullptr)
9015         {
9016             // Create a CompAllocator that labels sub-structure with CMK_ArrayInfoMap, and use that for allocation.
9017             IAllocator* ialloc     = new (this, CMK_ArrayInfoMap) CompAllocator(this, CMK_ArrayInfoMap);
9018             compRoot->m_heapSsaMap = new (ialloc) NodeToUnsignedMap(ialloc);
9019         }
9020         return compRoot->m_heapSsaMap;
9021     }
9022
9023     // The Refany type is the only struct type whose structure is implicitly assumed by IL.  We need its fields.
9024     CORINFO_CLASS_HANDLE m_refAnyClass;
9025     CORINFO_FIELD_HANDLE GetRefanyDataField()
9026     {
9027         if (m_refAnyClass == nullptr)
9028         {
9029             m_refAnyClass = info.compCompHnd->getBuiltinClass(CLASSID_TYPED_BYREF);
9030         }
9031         return info.compCompHnd->getFieldInClass(m_refAnyClass, 0);
9032     }
9033     CORINFO_FIELD_HANDLE GetRefanyTypeField()
9034     {
9035         if (m_refAnyClass == nullptr)
9036         {
9037             m_refAnyClass = info.compCompHnd->getBuiltinClass(CLASSID_TYPED_BYREF);
9038         }
9039         return info.compCompHnd->getFieldInClass(m_refAnyClass, 1);
9040     }
9041
9042 #if VARSET_COUNTOPS
9043     static BitSetSupport::BitSetOpCounter m_varsetOpCounter;
9044 #endif
9045 #if ALLVARSET_COUNTOPS
9046     static BitSetSupport::BitSetOpCounter m_allvarsetOpCounter;
9047 #endif
9048
9049     static HelperCallProperties s_helperCallProperties;
9050
9051 #ifdef FEATURE_UNIX_AMD64_STRUCT_PASSING
9052     static var_types GetTypeFromClassificationAndSizes(SystemVClassificationType classType, int size);
9053     static var_types GetEightByteType(const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR& structDesc,
9054                                       unsigned                                                   slotNum);
9055     static void GetStructTypeOffset(const SYSTEMV_AMD64_CORINFO_STRUCT_REG_PASSING_DESCRIPTOR& structDesc,
9056                                     var_types*                                                 type0,
9057                                     var_types*                                                 type1,
9058                                     unsigned __int8*                                           offset0,
9059                                     unsigned __int8*                                           offset1);
9060     void fgMorphSystemVStructArgs(GenTreeCall* call, bool hasStructArgument);
9061 #endif // defined(FEATURE_UNIX_AMD64_STRUCT_PASSING)
9062
9063     void fgMorphMultiregStructArgs(GenTreeCall* call);
9064     GenTreePtr fgMorphMultiregStructArg(GenTreePtr arg, fgArgTabEntryPtr fgEntryPtr);
9065
9066 }; // end of class Compiler
9067
9068 // Inline methods of CompAllocator.
9069 void* CompAllocator::Alloc(size_t sz)
9070 {
9071 #if MEASURE_MEM_ALLOC
9072     return m_comp->compGetMem(sz, m_cmk);
9073 #else
9074     return m_comp->compGetMem(sz);
9075 #endif
9076 }
9077
9078 void* CompAllocator::ArrayAlloc(size_t elems, size_t elemSize)
9079 {
9080 #if MEASURE_MEM_ALLOC
9081     return m_comp->compGetMemArray(elems, elemSize, m_cmk);
9082 #else
9083     return m_comp->compGetMemArray(elems, elemSize);
9084 #endif
9085 }
9086
9087 // LclVarDsc constructor. Uses Compiler, so must come after Compiler definition.
9088 inline LclVarDsc::LclVarDsc(Compiler* comp)
9089     : // Initialize the ArgRegs to REG_STK.
9090     // The morph will do the right thing to change
9091     // to the right register if passed in register.
9092     _lvArgReg(REG_STK)
9093     ,
9094 #if FEATURE_MULTIREG_ARGS
9095     _lvOtherArgReg(REG_STK)
9096     ,
9097 #endif // FEATURE_MULTIREG_ARGS
9098 #if ASSERTION_PROP
9099     lvRefBlks(BlockSetOps::UninitVal())
9100     ,
9101 #endif // ASSERTION_PROP
9102     lvPerSsaData(comp->getAllocator())
9103 {
9104 }
9105
9106 /*
9107 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9108 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9109 XX                                                                           XX
9110 XX                   Miscellaneous Compiler stuff                            XX
9111 XX                                                                           XX
9112 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9113 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9114 */
9115
9116 // Values used to mark the types a stack slot is used for
9117
9118 const unsigned TYPE_REF_INT      = 0x01; // slot used as a 32-bit int
9119 const unsigned TYPE_REF_LNG      = 0x02; // slot used as a 64-bit long
9120 const unsigned TYPE_REF_FLT      = 0x04; // slot used as a 32-bit float
9121 const unsigned TYPE_REF_DBL      = 0x08; // slot used as a 64-bit float
9122 const unsigned TYPE_REF_PTR      = 0x10; // slot used as a 32-bit pointer
9123 const unsigned TYPE_REF_BYR      = 0x20; // slot used as a byref pointer
9124 const unsigned TYPE_REF_STC      = 0x40; // slot used as a struct
9125 const unsigned TYPE_REF_TYPEMASK = 0x7F; // bits that represent the type
9126
9127 // const unsigned TYPE_REF_ADDR_TAKEN  = 0x80; // slots address was taken
9128
9129 /*****************************************************************************
9130  *
9131  *  Variables to keep track of total code amounts.
9132  */
9133
9134 #if DISPLAY_SIZES
9135
9136 extern size_t grossVMsize;
9137 extern size_t grossNCsize;
9138 extern size_t totalNCsize;
9139
9140 extern unsigned genMethodICnt;
9141 extern unsigned genMethodNCnt;
9142 extern size_t   gcHeaderISize;
9143 extern size_t   gcPtrMapISize;
9144 extern size_t   gcHeaderNSize;
9145 extern size_t   gcPtrMapNSize;
9146
9147 #endif // DISPLAY_SIZES
9148
9149 /*****************************************************************************
9150  *
9151  *  Variables to keep track of basic block counts (more data on 1 BB methods)
9152  */
9153
9154 #if COUNT_BASIC_BLOCKS
9155 extern Histogram bbCntTable;
9156 extern Histogram bbOneBBSizeTable;
9157 #endif
9158
9159 /*****************************************************************************
9160  *
9161  *  Used by optFindNaturalLoops to gather statistical information such as
9162  *   - total number of natural loops
9163  *   - number of loops with 1, 2, ... exit conditions
9164  *   - number of loops that have an iterator (for like)
9165  *   - number of loops that have a constant iterator
9166  */
9167
9168 #if COUNT_LOOPS
9169
9170 extern unsigned totalLoopMethods;        // counts the total number of methods that have natural loops
9171 extern unsigned maxLoopsPerMethod;       // counts the maximum number of loops a method has
9172 extern unsigned totalLoopOverflows;      // # of methods that identified more loops than we can represent
9173 extern unsigned totalLoopCount;          // counts the total number of natural loops
9174 extern unsigned totalUnnatLoopCount;     // counts the total number of (not-necessarily natural) loops
9175 extern unsigned totalUnnatLoopOverflows; // # of methods that identified more unnatural loops than we can represent
9176 extern unsigned iterLoopCount;           // counts the # of loops with an iterator (for like)
9177 extern unsigned simpleTestLoopCount;     // counts the # of loops with an iterator and a simple loop condition (iter <
9178                                          // const)
9179 extern unsigned  constIterLoopCount;     // counts the # of loops with a constant iterator (for like)
9180 extern bool      hasMethodLoops;         // flag to keep track if we already counted a method as having loops
9181 extern unsigned  loopsThisMethod;        // counts the number of loops in the current method
9182 extern bool      loopOverflowThisMethod; // True if we exceeded the max # of loops in the method.
9183 extern Histogram loopCountTable;         // Histogram of loop counts
9184 extern Histogram loopExitCountTable;     // Histogram of loop exit counts
9185
9186 #endif // COUNT_LOOPS
9187
9188 /*****************************************************************************
9189  * variables to keep track of how many iterations we go in a dataflow pass
9190  */
9191
9192 #if DATAFLOW_ITER
9193
9194 extern unsigned CSEiterCount; // counts the # of iteration for the CSE dataflow
9195 extern unsigned CFiterCount;  // counts the # of iteration for the Const Folding dataflow
9196
9197 #endif // DATAFLOW_ITER
9198
9199 #if MEASURE_BLOCK_SIZE
9200 extern size_t genFlowNodeSize;
9201 extern size_t genFlowNodeCnt;
9202 #endif // MEASURE_BLOCK_SIZE
9203
9204 #if MEASURE_NODE_SIZE
9205 struct NodeSizeStats
9206 {
9207     void Init()
9208     {
9209         genTreeNodeCnt        = 0;
9210         genTreeNodeSize       = 0;
9211         genTreeNodeActualSize = 0;
9212     }
9213
9214     size_t genTreeNodeCnt;
9215     size_t genTreeNodeSize;       // The size we allocate
9216     size_t genTreeNodeActualSize; // The actual size of the node. Note that the actual size will likely be smaller
9217                                   //   than the allocated size, but we sometimes use SetOper()/ChangeOper() to change
9218                                   //   a smaller node to a larger one. TODO-Cleanup: add stats on
9219                                   //   SetOper()/ChangeOper() usage to quanitfy this.
9220 };
9221 extern NodeSizeStats genNodeSizeStats;        // Total node size stats
9222 extern NodeSizeStats genNodeSizeStatsPerFunc; // Per-function node size stats
9223 extern Histogram     genTreeNcntHist;
9224 extern Histogram     genTreeNsizHist;
9225 #endif // MEASURE_NODE_SIZE
9226
9227 /*****************************************************************************
9228  *  Count fatal errors (including noway_asserts).
9229  */
9230
9231 #if MEASURE_FATAL
9232 extern unsigned fatal_badCode;
9233 extern unsigned fatal_noWay;
9234 extern unsigned fatal_NOMEM;
9235 extern unsigned fatal_noWayAssertBody;
9236 #ifdef DEBUG
9237 extern unsigned fatal_noWayAssertBodyArgs;
9238 #endif // DEBUG
9239 extern unsigned fatal_NYI;
9240 #endif // MEASURE_FATAL
9241
9242 /*****************************************************************************
9243  * Codegen
9244  */
9245
9246 #ifdef _TARGET_XARCH_
9247
9248 const instruction INS_SHIFT_LEFT_LOGICAL  = INS_shl;
9249 const instruction INS_SHIFT_RIGHT_LOGICAL = INS_shr;
9250 const instruction INS_SHIFT_RIGHT_ARITHM  = INS_sar;
9251
9252 const instruction INS_AND             = INS_and;
9253 const instruction INS_OR              = INS_or;
9254 const instruction INS_XOR             = INS_xor;
9255 const instruction INS_NEG             = INS_neg;
9256 const instruction INS_TEST            = INS_test;
9257 const instruction INS_MUL             = INS_imul;
9258 const instruction INS_SIGNED_DIVIDE   = INS_idiv;
9259 const instruction INS_UNSIGNED_DIVIDE = INS_div;
9260 const instruction INS_BREAKPOINT      = INS_int3;
9261 const instruction INS_ADDC            = INS_adc;
9262 const instruction INS_SUBC            = INS_sbb;
9263 const instruction INS_NOT             = INS_not;
9264
9265 #endif
9266
9267 #ifdef _TARGET_ARM_
9268
9269 const instruction INS_SHIFT_LEFT_LOGICAL  = INS_lsl;
9270 const instruction INS_SHIFT_RIGHT_LOGICAL = INS_lsr;
9271 const instruction INS_SHIFT_RIGHT_ARITHM  = INS_asr;
9272
9273 const instruction INS_AND             = INS_and;
9274 const instruction INS_OR              = INS_orr;
9275 const instruction INS_XOR             = INS_eor;
9276 const instruction INS_NEG             = INS_rsb;
9277 const instruction INS_TEST            = INS_tst;
9278 const instruction INS_MUL             = INS_mul;
9279 const instruction INS_SIGNED_DIVIDE   = INS_sdiv;
9280 const instruction INS_UNSIGNED_DIVIDE = INS_udiv;
9281 const instruction INS_BREAKPOINT      = INS_bkpt;
9282 const instruction INS_ADDC            = INS_adc;
9283 const instruction INS_SUBC            = INS_sbc;
9284 const instruction INS_NOT             = INS_mvn;
9285
9286 #endif
9287
9288 #ifdef _TARGET_ARM64_
9289
9290 const instruction INS_SHIFT_LEFT_LOGICAL  = INS_lsl;
9291 const instruction INS_SHIFT_RIGHT_LOGICAL = INS_lsr;
9292 const instruction INS_SHIFT_RIGHT_ARITHM  = INS_asr;
9293
9294 const instruction INS_AND             = INS_and;
9295 const instruction INS_OR              = INS_orr;
9296 const instruction INS_XOR             = INS_eor;
9297 const instruction INS_NEG             = INS_neg;
9298 const instruction INS_TEST            = INS_tst;
9299 const instruction INS_MUL             = INS_mul;
9300 const instruction INS_SIGNED_DIVIDE   = INS_sdiv;
9301 const instruction INS_UNSIGNED_DIVIDE = INS_udiv;
9302 const instruction INS_BREAKPOINT      = INS_bkpt;
9303 const instruction INS_ADDC            = INS_adc;
9304 const instruction INS_SUBC            = INS_sbc;
9305 const instruction INS_NOT             = INS_mvn;
9306
9307 #endif
9308
9309 /*****************************************************************************/
9310
9311 extern const BYTE genTypeSizes[];
9312 extern const BYTE genTypeAlignments[];
9313 extern const BYTE genTypeStSzs[];
9314 extern const BYTE genActualTypes[];
9315
9316 /*****************************************************************************/
9317
9318 // VERY_LARGE_FRAME_SIZE_REG_MASK is the set of registers we need to use for
9319 // the probing loop generated for very large stack frames (see `getVeryLargeFrameSize`).
9320
9321 #ifdef _TARGET_ARM_
9322 #define VERY_LARGE_FRAME_SIZE_REG_MASK (RBM_R4 | RBM_R5 | RBM_R6)
9323 #elif defined(_TARGET_ARM64_)
9324 #define VERY_LARGE_FRAME_SIZE_REG_MASK (RBM_R9 | RBM_R10 | RBM_R11)
9325 #endif
9326
9327 /*****************************************************************************/
9328
9329 #define REG_CORRUPT regNumber(REG_NA + 1)
9330 #define RBM_CORRUPT (RBM_ILLEGAL | regMaskTP(1))
9331 #define REG_PAIR_CORRUPT regPairNo(REG_PAIR_NONE + 1)
9332
9333 /*****************************************************************************/
9334
9335 extern BasicBlock dummyBB;
9336
9337 /*****************************************************************************/
9338 /*****************************************************************************/
9339
9340 // foreach_treenode_execution_order: An iterator that iterates through all the tree
9341 // nodes of a statement in execution order.
9342 //      __stmt: a GT_STMT type GenTree*
9343 //      __node: a GenTree*, already declared, that gets updated with each node in the statement, in execution order
9344
9345 #define foreach_treenode_execution_order(__node, __stmt)                                                               \
9346     for ((__node) = (__stmt)->gtStmt.gtStmtList; (__node); (__node) = (__node)->gtNext)
9347
9348 // foreach_block: An iterator over all blocks in the function.
9349 //    __compiler: the Compiler* object
9350 //    __block   : a BasicBlock*, already declared, that gets updated each iteration.
9351
9352 #define foreach_block(__compiler, __block)                                                                             \
9353     for ((__block) = (__compiler)->fgFirstBB; (__block); (__block) = (__block)->bbNext)
9354
9355 /*****************************************************************************/
9356 /*****************************************************************************/
9357
9358 #ifdef DEBUG
9359
9360 void dumpConvertedVarSet(Compiler* comp, VARSET_VALARG_TP vars);
9361
9362 /*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9363 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9364 XX                                                                           XX
9365 XX                          Debugging helpers                                XX
9366 XX                                                                           XX
9367 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9368 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
9369 */
9370
9371 /*****************************************************************************/
9372 /* The following functions are intended to be called from the debugger, to dump
9373  * various data structures. The can be used in the debugger Watch or Quick Watch
9374  * windows. They are designed to be short to type and take as few arguments as
9375  * possible. The 'c' versions take a Compiler*, whereas the 'd' versions use the TlsCompiler.
9376  * See the function definition comment for more details.
9377  */
9378
9379 void cBlock(Compiler* comp, BasicBlock* block);
9380 void cBlocks(Compiler* comp);
9381 void cBlocksV(Compiler* comp);
9382 void cTree(Compiler* comp, GenTree* tree);
9383 void cTrees(Compiler* comp);
9384 void cEH(Compiler* comp);
9385 void cVar(Compiler* comp, unsigned lclNum);
9386 void cVarDsc(Compiler* comp, LclVarDsc* varDsc);
9387 void cVars(Compiler* comp);
9388 void cVarsFinal(Compiler* comp);
9389 void cBlockPreds(Compiler* comp, BasicBlock* block);
9390 void cReach(Compiler* comp);
9391 void cDoms(Compiler* comp);
9392 void cLiveness(Compiler* comp);
9393 void cCVarSet(Compiler* comp, VARSET_VALARG_TP vars);
9394
9395 void cFuncIR(Compiler* comp);
9396 void cBlockIR(Compiler* comp, BasicBlock* block);
9397 void cLoopIR(Compiler* comp, Compiler::LoopDsc* loop);
9398 void cTreeIR(Compiler* comp, GenTree* tree);
9399 int cTreeTypeIR(Compiler* comp, GenTree* tree);
9400 int cTreeKindsIR(Compiler* comp, GenTree* tree);
9401 int cTreeFlagsIR(Compiler* comp, GenTree* tree);
9402 int cOperandIR(Compiler* comp, GenTree* operand);
9403 int cLeafIR(Compiler* comp, GenTree* tree);
9404 int cIndirIR(Compiler* comp, GenTree* tree);
9405 int cListIR(Compiler* comp, GenTree* list);
9406 int cSsaNumIR(Compiler* comp, GenTree* tree);
9407 int cValNumIR(Compiler* comp, GenTree* tree);
9408 int cDependsIR(Compiler* comp, GenTree* comma, bool* first);
9409
9410 void dBlock(BasicBlock* block);
9411 void dBlocks();
9412 void dBlocksV();
9413 void dTree(GenTree* tree);
9414 void dTrees();
9415 void dEH();
9416 void dVar(unsigned lclNum);
9417 void dVarDsc(LclVarDsc* varDsc);
9418 void dVars();
9419 void dVarsFinal();
9420 void dBlockPreds(BasicBlock* block);
9421 void dReach();
9422 void dDoms();
9423 void dLiveness();
9424 void dCVarSet(VARSET_VALARG_TP vars);
9425
9426 void dVarSet(VARSET_VALARG_TP vars);
9427 void dRegMask(regMaskTP mask);
9428
9429 void dFuncIR();
9430 void dBlockIR(BasicBlock* block);
9431 void dTreeIR(GenTree* tree);
9432 void dLoopIR(Compiler::LoopDsc* loop);
9433 void dLoopNumIR(unsigned loopNum);
9434 int dTabStopIR(int curr, int tabstop);
9435 int dTreeTypeIR(GenTree* tree);
9436 int dTreeKindsIR(GenTree* tree);
9437 int dTreeFlagsIR(GenTree* tree);
9438 int dOperandIR(GenTree* operand);
9439 int dLeafIR(GenTree* tree);
9440 int dIndirIR(GenTree* tree);
9441 int dListIR(GenTree* list);
9442 int dSsaNumIR(GenTree* tree);
9443 int dValNumIR(GenTree* tree);
9444 int dDependsIR(GenTree* comma);
9445 void dFormatIR();
9446
9447 GenTree* dFindTree(GenTree* tree, unsigned id);
9448 GenTree* dFindTree(unsigned id);
9449 GenTreeStmt* dFindStmt(unsigned id);
9450 BasicBlock* dFindBlock(unsigned bbNum);
9451
9452 #endif // DEBUG
9453
9454 #include "compiler.hpp" // All the shared inline functions
9455
9456 /*****************************************************************************/
9457 #endif //_COMPILER_H_
9458 /*****************************************************************************/