****** START compiling EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this (MethodHash=8ba39168)
Generating code for Windows x64
OPTIONS: compCodeOpt = BLENDED_CODE
OPTIONS: compDbgCode = false
OPTIONS: compDbgInfo = true
OPTIONS: compDbgEnC  = false
OPTIONS: compProcedureSplitting   = false
OPTIONS: compProcedureSplittingEH = false
OPTIONS: No matching PGO data
IL to import:
IL_0000  02                ldarg.0     
IL_0001  7c 29 17 00 04    ldflda       0x4001729
IL_0006  28 5b 29 00 06    call         0x600295B
IL_000b  2a                ret         

lvaSetClass: setting class for V00 to (00007FF94FE18578) EnumeratorImpl 
'this'    passed in register rcx
'__retBuf'  passed in register rdx

lvaGrabTemp returning 2 (V02 loc0) (a long lifetime temp) called for OutgoingArgSpace.
; Initial local variable assignments
;
;  V00 this              ref  this class-hnd
;  V01 RetBuf          byref 
;  V02 OutArgs        lclBlk <na>  "OutgoingArgSpace"
*************** In compInitDebuggingInfo() for EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
getVars() returned cVars = 0, extendOthers = true
info.compVarScopesCount = 2
    	VarNum 	LVNum 	      Name 	Beg 	End
 0: 	00h 	00h 	  V00 this 	000h   	00Ch
 1: 	01h 	01h 	V01 RetBuf 	000h   	00Ch
info.compStmtOffsetsCount    = 0
info.compStmtOffsetsImplicit = 0005h ( STACK_EMPTY CALL_SITE )
*************** In fgFindBasicBlocks() for EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
Jump targets:
  none
New Basic Block BB01 [0000] created.
BB01 [000..00C)
IL Code Size,Instr   12,   4, Basic Block count   1, Local Variable Num,Ref count   3,  1 for method EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
OPTIONS: opts.MinOpts() == false
Basic block list for 'EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     
-----------------------------------------------------------------------------------------------------------------------------------------

*************** Starting PHASE Pre-import

*************** Finishing PHASE Pre-import
Trees after Pre-import

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

-------------------------------------------------------------------------------------------------------------------

*************** Starting PHASE Profile incorporation
BBOPT set, but no profile data available (hr=80004001)

*************** Finishing PHASE Profile incorporation [no changes]

*************** Starting PHASE Importation
*************** In impImport() for EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this

impImportBlockPending for BB01

Importing BB01 (PC=000) of 'EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'
    [ 0]   0 (0x000) ldarg.0
    [ 1]   1 (0x001) ldflda 04001729
    [ 1]   6 (0x006) call 0600295B
 (Implicit Tail call: prefixFlags |= PREFIX_TAILCALL_IMPLICIT)
In Compiler::impImportCall: opcode is call, kind=0, callRetType is struct, structSize is 24

GTF_CALL_M_IMPLICIT_TAILCALL set for call [000003]
INLINER: during 'impMarkInlineCandidate' result 'CheckCanInline Success' reason 'CheckCanInline Success' for 'EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this' calling 'Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'
INLINER: during 'impMarkInlineCandidate' result 'CheckCanInline Success' reason 'CheckCanInline Success'


STMT00000 ( 0x000[E-] ... ??? )
               [000003] I-CXG------                         ▌  CALL      struct Enumerator.get_Current (exactContextHnd=0x00007FF94FE18289)
               [000002] ---XG------ this                    └──▌  ADDR      byref 
               [000001] ---XG--N---                            └──▌  FIELD     struct hackishFieldName
               [000000] -----------                               └──▌  LCL_VAR   ref    V00 this         

    [ 1]  11 (0x00b) ret

STMT00001 ( 0x000[E-] ... ??? )
               [000004] --C--------                         ▌  RET_EXPR  void  (inl return expr [000003])


STMT00002 ( ??? ... ??? )
               [000007] -----------                         ▌  RETURN    byref 
               [000006] -----------                         └──▌  LCL_VAR   byref  V01 RetBuf       

*************** Finishing PHASE Importation
Trees after Importation

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00000 ( 0x000[E-] ... 0x00B )
               [000003] I-CXG------                         ▌  CALL      void   Enumerator.get_Current (exactContextHnd=0x00007FF94FE18289)
               [000002] ---XG------ this                    ├──▌  ADDR      byref 
               [000001] ---XG--N---                         │  └──▌  FIELD     struct hackishFieldName
               [000000] -----------                         │     └──▌  LCL_VAR   ref    V00 this         
               [000005] ----------- retbuf                  └──▌  LCL_VAR   byref  V01 RetBuf       

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
               [000004] --C--------                         ▌  RET_EXPR  void  (inl return expr [000003])

***** BB01
STMT00002 ( ??? ... ??? )
               [000007] -----------                         ▌  RETURN    byref 
               [000006] -----------                         └──▌  LCL_VAR   byref  V01 RetBuf       

-------------------------------------------------------------------------------------------------------------------

*************** Starting PHASE Expand patchpoints

 -- no patchpoints to transform

*************** Finishing PHASE Expand patchpoints [no changes]

*************** Starting PHASE Indirect call transform

 -- no candidates to transform

*************** Finishing PHASE Indirect call transform [no changes]

*************** Starting PHASE Post-import

*************** Finishing PHASE Post-import [no changes]

*************** Starting PHASE Morph - Init

New BlockSet epoch 1, # of blocks (including unused BB00): 2, bitset array size: 1 (short)

*************** Finishing PHASE Morph - Init [no changes]

*************** Starting PHASE Morph - Inlining
*************** In fgDebugCheckBBlist
Expanding INLINE_CANDIDATE in statement STMT00000 in BB01:
STMT00000 ( 0x000[E-] ... 0x00B )
               [000003] I-CXG------                         ▌  CALL      void   Enumerator.get_Current (exactContextHnd=0x00007FF94FE18289)
               [000002] ---XG------ this                    ├──▌  ADDR      byref 
               [000001] ---XG--N---                         │  └──▌  FIELD     struct hackishFieldName
               [000000] -----------                         │     └──▌  LCL_VAR   ref    V00 this         
               [000005] ----------- retbuf                  └──▌  LCL_VAR   byref  V01 RetBuf       
Note: candidate is implicit tail call
thisArg: has global refs has side effects
               [000002] ---XG------                         ▌  ADDR      byref 
               [000001] ---XG--N---                         └──▌  FIELD     struct hackishFieldName
               [000000] -----------                            └──▌  LCL_VAR   ref    V00 this         

INLINER: inlineInfo.tokenLookupContextHandle for Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this set to 0x00007FF94FE18289:

Invoking compiler for the inlinee method Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this :
IL to import:
IL_0000  02                ldarg.0     
IL_0001  7b 26 17 00 04    ldfld        0x4001726
IL_0006  02                ldarg.0     
IL_0007  7b 28 17 00 04    ldfld        0x4001728
IL_000c  28 72 12 00 06    call         0x6001272
IL_0011  2a                ret         

INLINER impTokenLookupContextHandle for Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this is 0x00007FF94FE18289.
*************** In compInitDebuggingInfo() for Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
info.compStmtOffsetsCount    = 0
info.compStmtOffsetsImplicit = 0005h ( STACK_EMPTY CALL_SITE )
*************** In fgFindBasicBlocks() for Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
weight= 31 : state 191 [ ldarg.0 -> ldfld ]
weight= 31 : state 191 [ ldarg.0 -> ldfld ]
weight= 79 : state  40 [ call ]
weight= 19 : state  42 [ ret ]

multiplier in methods of struct increased to 3.
Inline candidate returns a struct by value.  Multiplier increased to 5.
Inline candidate looks like a wrapper method.  Multiplier increased to 6.
Inline candidate is mostly loads and stores.  Multiplier increased to 9.
Inline candidate callsite is boring.  Multiplier increased to 10.3.
calleeNativeSizeEstimate=160
callsiteNativeSizeEstimate=85
benefit multiplier=10.3
threshold=875
Native estimate for function size is within threshold for inlining 16 <= 87.5 (multiplier = 10.3)
Jump targets:
  none
New Basic Block BB02 [0001] created.
BB02 [000..012)
Basic block list for 'Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB02 [0001]  1                             1       [000..012)        (return)                     
-----------------------------------------------------------------------------------------------------------------------------------------

*************** Inline @[000003] Starting PHASE Pre-import

*************** Inline @[000003] Finishing PHASE Pre-import
Trees after Pre-import

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB02 [0001]  1                             1       [000..012)        (return)                     
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB02 [000..012) (return), preds={} succs={}

-------------------------------------------------------------------------------------------------------------------

*************** Inline @[000003] Starting PHASE Profile incorporation
BBOPT set, but no profile data available (hr=80004001)
Computing inlinee profile scale:
   ... no callee profile data, will use non-pgo weight to scale
   ... call site not profiled, will use non-pgo weight to scale
   call site count 100 callee entry count 100 scale 1
Scaling inlinee blocks

*************** Inline @[000003] Finishing PHASE Profile incorporation
Trees after Profile incorporation

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB02 [0001]  1                             1       [000..012)        (return)                     
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB02 [000..012) (return), preds={} succs={}

-------------------------------------------------------------------------------------------------------------------

*************** Inline @[000003] Starting PHASE Importation
*************** In impImport() for Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this

impImportBlockPending for BB02

Importing BB02 (PC=000) of 'Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'
    [ 0]   0 (0x000) ldarg.0
lvaGrabTemp returning 3 (V03 tmp1) called for Inlining Arg.

    [ 1]   1 (0x001) ldfld 04001726
    [ 1]   6 (0x006) ldarg.0
    [ 2]   7 (0x007) ldfld 04001728
    [ 2]  12 (0x00c) call 06001272
 (Inline Implicit Tail call: prefixFlags |= PREFIX_TAILCALL_IMPLICIT)
In Compiler::impImportCall: opcode is call, kind=0, callRetType is struct, structSize is 24

GTF_CALL_M_IMPLICIT_TAILCALL set for call [000012]
INLINER: during 'impMarkInlineCandidate' result 'failed this callee' reason 'noinline per IL/cached result' for 'Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this' calling 'hackishMethodName'
INLINER: during 'impMarkInlineCandidate' result 'failed this callee' reason 'noinline per IL/cached result'

    [ 1]  17 (0x011) ret

    Inlinee Return expression (before normalization)  =>
               [000012] S-CXG------                         ▌  CALL      struct hackishModuleName.hackishMethodName
               [000009] ---XG------ arg0                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg1                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

** Note: inlinee IL was partially imported -- imported 0 of 18 bytes of method IL

*************** Inline @[000003] Finishing PHASE Importation
Trees after Importation

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB02 [0001]  1                             1       [000..012)        (return)                     i 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB02 [000..012) (return), preds={} succs={}

-------------------------------------------------------------------------------------------------------------------

*************** Inline @[000003] Starting PHASE Expand patchpoints

 -- no patchpoints to transform

*************** Inline @[000003] Finishing PHASE Expand patchpoints [no changes]

*************** Inline @[000003] Starting PHASE Indirect call transform

 -- no candidates to transform

*************** Inline @[000003] Finishing PHASE Indirect call transform [no changes]

*************** Inline @[000003] Starting PHASE Post-import

*************** Inline @[000003] Finishing PHASE Post-import [no changes]


----------- Statements (and blocks) added due to the inlining of call [000003] -----------

Arguments setup:
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG------                         ▌  ASG       byref 
               [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000002] ---XG------                         └──▌  ADDR      byref 
               [000001] ---XG--N---                            └──▌  FIELD     struct hackishFieldName
               [000000] -----------                               └──▌  LCL_VAR   ref    V00 this         

Inlinee method body:fgInlineAppendStatements: no gc ref inline locals.

Return expression for call at [000003] is
               [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
               [000013] ----------- retbuf                  ├──▌  LCL_VAR   byref  V01 RetBuf       
               [000009] ---XG------ arg1                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg2                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         
Successfully inlined Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this (18 IL bytes) (depth 1) [profitable inline]
--------------------------------------------------------------------------------------------
INLINER: during 'fgInline' result 'success' reason 'profitable inline' for 'EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this' calling 'Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'
INLINER: during 'fgInline' result 'success' reason 'profitable inline'

Replacing the return expression placeholder [000004] with [000012]
               [000004] --C--------                         ▌  RET_EXPR  void  (inl return expr [000012])

Inserting the inline return expression
               [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
               [000013] ----------- retbuf                  ├──▌  LCL_VAR   byref  V01 RetBuf       
               [000009] ---XG------ arg1                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg2                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

**************** Inline Tree

Inlines into 06000000 [via ExtendedDefaultPolicy] EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this:
  [INL01 IL=0006 TR=000003 06000000] [INLINED: call site: profitable inline] Enumerator:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
Budget: initialTime=96, finalTime=82, initialBudget=960, currentBudget=960
Budget: initialSize=404, finalSize=479

*************** Finishing PHASE Morph - Inlining
Trees after Morph - Inlining

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG------                         ▌  ASG       byref 
               [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000002] ---XG------                         └──▌  ADDR      byref 
               [000001] ---XG--N---                            └──▌  FIELD     struct hackishFieldName
               [000000] -----------                               └──▌  LCL_VAR   ref    V00 this         

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
               [000013] ----------- retbuf                  ├──▌  LCL_VAR   byref  V01 RetBuf       
               [000009] ---XG------ arg1                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg2                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

***** BB01
STMT00002 ( ??? ... ??? )
               [000007] -----------                         ▌  RETURN    byref 
               [000006] -----------                         └──▌  LCL_VAR   byref  V01 RetBuf       

-------------------------------------------------------------------------------------------------------------------

*************** Starting PHASE Allocate Objects
no newobjs in this method; punting

*************** Finishing PHASE Allocate Objects [no changes]

*************** Starting PHASE Morph - Add internal blocks

*************** After fgAddInternal()

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i 
-----------------------------------------------------------------------------------------------------------------------------------------

***************  Exception Handling table is empty

*************** Finishing PHASE Morph - Add internal blocks [no changes]

*************** Starting PHASE Remove empty try

*************** In fgRemoveEmptyTry()
No EH in this method, nothing to remove.

*************** Finishing PHASE Remove empty try [no changes]

*************** Starting PHASE Remove empty finally
No EH in this method, nothing to remove.

*************** Finishing PHASE Remove empty finally [no changes]

*************** Starting PHASE Merge callfinally chains
No EH in this method, nothing to merge.

*************** Finishing PHASE Merge callfinally chains [no changes]

*************** Starting PHASE Clone finally
No EH in this method, no cloning.

*************** Finishing PHASE Clone finally [no changes]

*************** Starting PHASE Compute preds

Renumbering the basic blocks for fgComputePred

*************** Before renumbering the basic blocks

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd                 weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i 
-----------------------------------------------------------------------------------------------------------------------------------------

***************  Exception Handling table is empty

*************** After renumbering the basic blocks
=============== No blocks renumbered!

New BlockSet epoch 2, # of blocks (including unused BB00): 2, bitset array size: 1 (short)

*************** Finishing PHASE Compute preds
Trees after Compute preds

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG------                         ▌  ASG       byref 
               [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000002] ---XG------                         └──▌  ADDR      byref 
               [000001] ---XG--N---                            └──▌  FIELD     struct hackishFieldName
               [000000] -----------                               └──▌  LCL_VAR   ref    V00 this         

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
               [000013] ----------- retbuf                  ├──▌  LCL_VAR   byref  V01 RetBuf       
               [000009] ---XG------ arg1                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg2                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

***** BB01
STMT00002 ( ??? ... ??? )
               [000007] -----------                         ▌  RETURN    byref 
               [000006] -----------                         └──▌  LCL_VAR   byref  V01 RetBuf       

-------------------------------------------------------------------------------------------------------------------

*************** Starting PHASE Merge throw blocks

*************** In fgTailMergeThrows
Method does not have multiple noreturn calls.

*************** Finishing PHASE Merge throw blocks [no changes]

*************** Starting PHASE Update flow graph early pass

*************** Finishing PHASE Update flow graph early pass [no changes]

*************** Starting PHASE Morph - Promote Structs

lvaTable before fgPromoteStructs
; Initial local variable assignments
;
;  V00 this              ref  this class-hnd
;  V01 RetBuf          byref 
;  V02 OutArgs        lclBlk <na>  "OutgoingArgSpace"
;  V03 tmp1            byref  "Inlining Arg"

*************** Finishing PHASE Morph - Promote Structs [no changes]

*************** Starting PHASE Morph - Structs/AddrExp
LocalAddressVisitor visiting statement:
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG------                         ▌  ASG       byref 
               [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000002] ---XG------                         └──▌  ADDR      byref 
               [000001] ---XG--N---                            └──▌  FIELD     struct hackishFieldName
               [000000] -----------                               └──▌  LCL_VAR   ref    V00 this         

LocalAddressVisitor visiting statement:
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
               [000013] ----------- retbuf                  ├──▌  LCL_VAR   byref  V01 RetBuf       
               [000009] ---XG------ arg1                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg2                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

LocalAddressVisitor visiting statement:
STMT00002 ( ??? ... ??? )
               [000007] -----------                         ▌  RETURN    byref 
               [000006] -----------                         └──▌  LCL_VAR   byref  V01 RetBuf       


*************** Finishing PHASE Morph - Structs/AddrExp [no changes]

*************** Starting PHASE Forward Substitution


===> BB01
    [000015]:  not asg (single-use lcl)

*************** Finishing PHASE Forward Substitution [no changes]

*************** Starting PHASE Morph - ByRefs

*************** Finishing PHASE Morph - ByRefs [no changes]

*************** Starting PHASE Morph - Global

*************** In fgMorphBlocks()

Morphing BB01 of 'EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this'

fgMorphTree BB01, STMT00003 (before)
               [000015] -A-XG------                         ▌  ASG       byref 
               [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000002] ---XG------                         └──▌  ADDR      byref 
               [000001] ---XG--N---                            └──▌  FIELD     struct hackishFieldName
               [000000] -----------                               └──▌  LCL_VAR   ref    V00 this         
Notify VM instruction set (SSE2) must be supported.
Before explicit null check morphing:
               [000001] ---XG--N---                         ▌  FIELD     struct hackishFieldName
               [000000] -----------                         └──▌  LCL_VAR   ref    V00 this         
After adding explicit null check:
               [000001] ---XG--N---                         ▌  IND       struct
               [000022] ---X-------                         └──▌  COMMA     byref 
               [000018] ---X-------                            ├──▌  NULLCHECK byte  
               [000017] -----------                            │  └──▌  LCL_VAR   ref    V00 this         
               [000021] -----------                            └──▌  ADD       byref 
               [000019] -----------                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----------                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]
GenTreeNode creates assertion:
               [000018] ---X-+-----                         ▌  NULLCHECK byte  
In BB01 New Local Constant Assertion: V00 != null, index = #01

Final value of Compiler::fgMorphField after calling fgMorphSmpOp:
               [000022] ---XG+-N---                         ▌  COMMA     struct
               [000018] ---X-+-----                         ├──▌  NULLCHECK byte  
               [000017] -----+-----                         │  └──▌  LCL_VAR   ref    V00 this         
               [000023] ---XG+-N---                         └──▌  IND       struct
               [000021] -----+-----                            └──▌  ADD       byref 
               [000019] -----+-----                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----+-----                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

fgMorphTree BB01, STMT00003 (after)
               [000015] -A-XG+-----                         ▌  ASG       byref 
               [000014] D----+-N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000022] ---XG+-N---                         └──▌  COMMA     byref 
               [000018] ---X-+-----                            ├──▌  NULLCHECK byte  
               [000017] -----+-----                            │  └──▌  LCL_VAR   ref    V00 this         
               [000021] -----+-----                            └──▌  ADD       byref 
               [000019] -----+-----                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----+-----                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

fgMorphTree BB01, STMT00001 (before)
               [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
               [000013] ----------- retbuf                  ├──▌  LCL_VAR   byref  V01 RetBuf       
               [000009] ---XG------ arg1                    ├──▌  FIELD     ref    hackishFieldName
               [000008] -----------                         │  └──▌  LCL_VAR   byref  V03 tmp1         
               [000011] ---XG------ arg2                    └──▌  FIELD     int    hackishFieldName
               [000010] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         
Initializing arg info for 12.CALL:
Args for call [000012] CALL after AddFinalArgsAndDetermineABIInfo:
CallArg[[000013].LCL_VAR byref (By value), 1 reg: rcx, byteAlignment=8, wellKnown[RetBuffer]]
CallArg[[000009].FIELD ref (By value), 1 reg: rdx, byteAlignment=8]
CallArg[[000011].FIELD int (By value), 1 reg: r8, byteAlignment=8]

[Fast tailcall decision]: Will fast tailcall

GTF_CALL_M_TAILCALL bit set for call [000012]
Remove all stmts after the call.

removing useless STMT00002 ( ??? ... ??? )
               [000007] -----------                         ▌  RETURN    byref 
               [000006] -----------                         └──▌  LCL_VAR   byref  V01 RetBuf       
 from BB01
Morphing args for 12.CALL:

Final value of Compiler::fgMorphField after calling fgMorphSmpOp:
               [000009] ---XG------                         ▌  IND       ref   
               [000008] -----+-----                         └──▌  LCL_VAR   byref  V03 tmp1         

Final value of Compiler::fgMorphField after calling fgMorphSmpOp:
               [000011] ---XG------                         ▌  IND       int   
               [000025] -----+-----                         └──▌  ADD       byref 
               [000010] -----+-----                            ├──▌  LCL_VAR   byref  V03 tmp1         
               [000024] -----+-----                            └──▌  CNS_INT   long   12

Sorting the arguments:
  [000013] -> #2 (non-struct local)
    [000011] [000009] [000013]
  [000011] -> #0 (cost 6)
    [000011] [000009] [000013]
  [000009] -> #1 (last arg)
    [000011] [000009] [000013]
  [000009] -> #2 (clobbers rdx used by [000013])
    [000011] [000013] [000009]
Deferred argument ('r8'):
     (  6,  5) [000011] ---XG------                         ▌  IND       int   
     (  4,  3) [000025] -------N---                         └──▌  ADD       byref 
     (  3,  2) [000010] -----------                            ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                            └──▌  CNS_INT   long   12
Moved to late list
Deferred argument ('rcx'):
               [000013] -----+-----                         ▌  LCL_VAR   byref  V01 RetBuf       
Moved to late list
Deferred argument ('rdx'):
     (  6,  4) [000009] ---XG------                         ▌  IND       ref   
     (  3,  2) [000008] -----------                         └──▌  LCL_VAR   byref  V03 tmp1         
Moved to late list

Register placement order:    r8 rcx rdx 
Args for [000012].CALL after fgMorphArgs:
CallArg[[000013].LCL_VAR byref (By value), 1 reg: rcx, byteAlignment=8, isLate, processed, wellKnown[RetBuffer]]
CallArg[[000009].IND ref (By value), 1 reg: rdx, byteAlignment=8, isLate, processed]
CallArg[[000011].IND int (By value), 1 reg: r8, byteAlignment=8, isLate, processed]
OutgoingArgsStackSize is 32


fgMorphTree BB01, STMT00001 (after)
               [000012] S-CXG+-----                         ▌  CALL      void   hackishModuleName.hackishMethodName
     (  6,  5) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
     (  4,  3) [000025] -------N---                         │  └──▌  ADD       byref 
     (  3,  2) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
               [000013] -----+----- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
     (  6,  4) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
     (  3,  2) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

*************** In fgMarkDemotedImplicitByRefArgs()

*************** Finishing PHASE Morph - Global
Trees after Morph - Global

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG+-----                         ▌  ASG       byref 
               [000014] D----+-N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000022] ---XG+-N---                         └──▌  COMMA     byref 
               [000018] ---X-+-----                            ├──▌  NULLCHECK byte  
               [000017] -----+-----                            │  └──▌  LCL_VAR   ref    V00 this         
               [000021] -----+-----                            └──▌  ADD       byref 
               [000019] -----+-----                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----+-----                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG+-----                         ▌  CALL      void   hackishModuleName.hackishMethodName
     (  6,  5) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
     (  4,  3) [000025] -------N---                         │  └──▌  ADD       byref 
     (  3,  2) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
               [000013] -----+----- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
     (  6,  4) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
     (  3,  2) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid

*************** Starting PHASE GS Cookie
No GS security needed

*************** Finishing PHASE GS Cookie [no changes]

*************** Starting PHASE Compute edge weights (1, false)

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

 -- no profile data, so using default called count
 -- not optimizing or no profile data, so not computing edge weights

*************** Finishing PHASE Compute edge weights (1, false) [no changes]

*************** Starting PHASE Create EH funclets

*************** Finishing PHASE Create EH funclets [no changes]

*************** Starting PHASE Invert loops

*************** Finishing PHASE Invert loops [no changes]

*************** Starting PHASE Optimize control flow

*************** In fgUpdateFlowGraph()
Before updating the flow graph:

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** In fgDebugCheckBBlist

*************** In fgUpdateFlowGraph()
Before updating the flow graph:

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** In fgDebugCheckBBlist

*************** Finishing PHASE Optimize control flow
Trees after Optimize control flow

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG+-----                         ▌  ASG       byref 
               [000014] D----+-N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000022] ---XG+-N---                         └──▌  COMMA     byref 
               [000018] ---X-+-----                            ├──▌  NULLCHECK byte  
               [000017] -----+-----                            │  └──▌  LCL_VAR   ref    V00 this         
               [000021] -----+-----                            └──▌  ADD       byref 
               [000019] -----+-----                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----+-----                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG+-----                         ▌  CALL      void   hackishModuleName.hackishMethodName
     (  6,  5) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
     (  4,  3) [000025] -------N---                         │  └──▌  ADD       byref 
     (  3,  2) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
               [000013] -----+----- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
     (  6,  4) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
     (  3,  2) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid

*************** Starting PHASE Compute blocks reachability
Return blocks: BB01

Renumbering the basic blocks for fgComputeReachability pass #1

*************** Before renumbering the basic blocks

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

***************  Exception Handling table is empty

*************** After renumbering the basic blocks
=============== No blocks renumbered!
Enter blocks: BB01 

After computing reachability sets:
------------------------------------------------
BBnum  Reachable by 
------------------------------------------------
BB01 : BB01 
*************** In fgComputeDoms
*************** In fgDebugCheckBBlist

Dominator computation start blocks (those blocks with no incoming edges):
BB01 
------------------------------------------------
BBnum  Dominated by
------------------------------------------------
BB01:  BB01 

Inside fgBuildDomTree

After computing the Dominance Tree:


After numbering the dominator tree:
BB01: pre=01, post=01

*************** Finishing PHASE Compute blocks reachability [no changes]

*************** Starting PHASE Set block weights

*************** Finishing PHASE Set block weights [no changes]

*************** Starting PHASE Find loops
*************** In optFindLoops()
*************** In optMarkLoopHeads()
0 loop heads marked

*************** Finishing PHASE Find loops
Trees after Find loops

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG+-----                         ▌  ASG       byref 
               [000014] D----+-N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000022] ---XG+-N---                         └──▌  COMMA     byref 
               [000018] ---X-+-----                            ├──▌  NULLCHECK byte  
               [000017] -----+-----                            │  └──▌  LCL_VAR   ref    V00 this         
               [000021] -----+-----                            └──▌  ADD       byref 
               [000019] -----+-----                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----+-----                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG+-----                         ▌  CALL      void   hackishModuleName.hackishMethodName
     (  6,  5) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
     (  4,  3) [000025] -------N---                         │  └──▌  ADD       byref 
     (  3,  2) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
               [000013] -----+----- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
     (  6,  4) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
     (  3,  2) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Clone loops

*************** In optCloneLoops()
  No loops to clone

*************** Finishing PHASE Clone loops [no changes]

*************** Starting PHASE Unroll loops

*************** Finishing PHASE Unroll loops [no changes]

*************** Starting PHASE Clear loop info

*************** Finishing PHASE Clear loop info [no changes]

*************** Starting PHASE Morph array ops
No multi-dimensional array references in the function

*************** Finishing PHASE Morph array ops [no changes]

*************** Starting PHASE Mark local vars

*************** In lvaMarkLocalVars()
*** lvaComputeRefCounts ***

*** lvaComputeRefCounts -- explicit counts ***

*** marking local variables in block BB01 (weight=1   )
STMT00003 ( 0x000[E-] ... ??? )
               [000015] -A-XG+-----                         ▌  ASG       byref 
               [000014] D----+-N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
               [000022] ---XG+-N---                         └──▌  COMMA     byref 
               [000018] ---X-+-----                            ├──▌  NULLCHECK byte  
               [000017] -----+-----                            │  └──▌  LCL_VAR   ref    V00 this         
               [000021] -----+-----                            └──▌  ADD       byref 
               [000019] -----+-----                               ├──▌  LCL_VAR   ref    V00 this         
               [000020] -----+-----                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]
New refCnts for V03: refCnt =  1, refCntWtd = 2   
Marking EH Var V03 as a register candidate.
New refCnts for V00: refCnt =  1, refCntWtd = 1   
New refCnts for V00: refCnt =  2, refCntWtd = 2   
STMT00001 ( 0x000[E-] ... ??? )
               [000012] S-CXG+-----                         ▌  CALL      void   hackishModuleName.hackishMethodName
     (  6,  5) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
     (  4,  3) [000025] -------N---                         │  └──▌  ADD       byref 
     (  3,  2) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
               [000013] -----+----- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
     (  6,  4) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
     (  3,  2) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         
New refCnts for V03: refCnt =  2, refCntWtd = 4   
New refCnts for V01: refCnt =  1, refCntWtd = 1   
New refCnts for V03: refCnt =  3, refCntWtd = 6   

*** lvaComputeRefCounts -- implicit counts ***
New refCnts for V00: refCnt =  3, refCntWtd = 3   
New refCnts for V00: refCnt =  4, refCntWtd = 4   
New refCnts for V01: refCnt =  2, refCntWtd = 2   
New refCnts for V01: refCnt =  3, refCntWtd = 3   

*************** Finishing PHASE Mark local vars [no changes]

*************** Starting PHASE Opt add copies

*************** In optAddCopies()


*************** Finishing PHASE Opt add copies [no changes]

*************** Starting PHASE Find oper order
*************** In fgFindOperOrder()

*************** Finishing PHASE Find oper order
Trees after Find oper order

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
     (  5,  5) [000015] -A-XG---R--                         ▌  ASG       byref 
     (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
     (  5,  5) [000022] ---XG--N---                         └──▌  COMMA     byref 
     (  2,  2) [000018] ---X-------                            ├──▌  NULLCHECK byte  
     (  1,  1) [000017] -----------                            │  └──▌  LCL_VAR   ref    V00 this         
     (  3,  3) [000021] -----------                            └──▌  ADD       byref 
     (  1,  1) [000019] -----------                               ├──▌  LCL_VAR   ref    V00 this         
     (  1,  1) [000020] -----------                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
     ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
     (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
     (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref 
     (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
     (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
     (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
     (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
     (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Set block order
*************** In fgSetBlockOrder()
The biggest BB has    8 tree nodes

*************** Finishing PHASE Set block order
Trees after Set block order

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N008 (  5,  5) [000015] -A-XG---R--                         ▌  ASG       byref 
N007 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         
N006 (  5,  5) [000022] ---XG--N---                         └──▌  COMMA     byref 
N002 (  2,  2) [000018] ---X-------                            ├──▌  NULLCHECK byte  
N001 (  1,  1) [000017] -----------                            │  └──▌  LCL_VAR   ref    V00 this         
N005 (  3,  3) [000021] -----------                            └──▌  ADD       byref 
N003 (  1,  1) [000019] -----------                               ├──▌  LCL_VAR   ref    V00 this         
N004 (  1,  1) [000020] -----------                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref 
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Build SSA representation
*************** In SsaBuilder::Build()
[SsaBuilder] Max block count is 2.

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

***************  Exception Handling table is empty
[SsaBuilder] Topologically sorted the graph.
[SsaBuilder::ComputeImmediateDom]

Inside fgBuildDomTree

After computing the Dominance Tree:

*************** In fgLocalVarLiveness()
In fgLocalVarLivenessInit
Tracked variable (3 out of 4) table:
V00 this          [   ref]: refCnt =    4, refCntWtd =   4   
V03 tmp1          [ byref]: refCnt =    3, refCntWtd =   6   
V01 RetBuf        [ byref]: refCnt =    3, refCntWtd =   3   

*************** In fgPerBlockLocalVarLiveness()
BB01 USE(2)={V00     V01} + ByrefExposed + GcHeap
     DEF(1)={    V03    } + ByrefExposed* + GcHeap*

** Memory liveness computed, GcHeap states and ByrefExposed states match
*************** In fgInterBlockLocalVarLiveness()

BB liveness after fgLiveVarAnalysis():

BB01 IN (2)={V00 V01} + ByrefExposed + GcHeap
     OUT(0)={       }

*************** In optRemoveRedundantZeroInits()
*************** In SsaBuilder::InsertPhiFunctions()
Inserting phi functions:
*************** In SsaBuilder::RenameVariables()

*************** Finishing PHASE Build SSA representation
Trees after Build SSA representation

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N008 (  5,  5) [000015] -A-XG---R--                         ▌  ASG       byref 
N007 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1
N006 (  5,  5) [000022] ---XG--N---                         └──▌  COMMA     byref 
N002 (  2,  2) [000018] ---X-------                            ├──▌  NULLCHECK byte  
N001 (  1,  1) [000017] -----------                            │  └──▌  LCL_VAR   ref    V00 this         u:1
N005 (  3,  3) [000021] -----------                            └──▌  ADD       byref 
N003 (  1,  1) [000019] -----------                               ├──▌  LCL_VAR   ref    V00 this         u:1 (last use)
N004 (  1,  1) [000020] -----------                               └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref 
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use)
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use)

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Early Value Propagation
optEarlyProp Marking a null check for removal
N002 (  2,  2) [000018] ---X-------                         ▌  NULLCHECK byte  
N001 (  1,  1) [000017] -----------                         └──▌  LCL_VAR   ref    V00 this         u:1

optFoldNullCheck morphed tree:
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref 
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref 
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use)
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName]


Optimized 1 trees

*************** Finishing PHASE Early Value Propagation
Trees after Early Value Propagation

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref 
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref 
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use)
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref 
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use)
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use)

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Do value numbering

*************** In fgValueNumber()
Memory Initial Value in BB01 is: $100
The SSA definition for ByrefExposed (#1) at start of BB01 is $100 {InitVal($42)}
The SSA definition for GcHeap (#1) at start of BB01 is $100 {InitVal($42)}

***** BB01, STMT00003(before)
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref 
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref 
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use)
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName]

N001 [000019]   LCL_VAR   V00 this         u:1 (last use) => $80 {InitVal($40)}
N002 [000020]   CNS_INT   8 Fseq[hackishFieldName] => $140 {LngCns:  8}
N003 [000021]   ADD       => $180 {ADD($80, $140)}
N004 [000014]   LCL_VAR   V03 tmp1         d:1 => $VN.Void
Tree [000015] assigned VN to local var V03/1: $180 {ADD($80, $140)}
N005 [000015]   ASG       => $VN.Void

***** BB01, STMT00003(after)
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref  $VN.Void
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1 $VN.Void
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref  $180
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName] $140

---------

***** BB01, STMT00001(before)
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int   
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref 
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use)
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref   
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use)

N001 [000010]   LCL_VAR   V03 tmp1         u:1 => $180 {ADD($80, $140)}
N002 [000024]   CNS_INT   12 => $141 {LngCns:  12}
N003 [000025]   ADD       => $181 {ADD($141, $180)}
N004 [000011]   IND       => <l:$280 {norm=$1c0 {ByrefExposedLoad($43, $181, $100)}, exc=$240 {NullPtrExc($80)}}, c:$281 {norm=$200 {MemOpaque:NotInLoop}, exc=$240 {NullPtrExc($80)}}>
N005 [000013]   LCL_VAR   V01 RetBuf       u:1 (last use) => $c0 {InitVal($41)}
N006 [000008]   LCL_VAR   V03 tmp1         u:1 (last use) => $180 {ADD($80, $140)}
N007 [000009]   IND       => <l:$241 {norm=$2c0 {ByrefExposedLoad($44, $180, $100)}, exc=$240 {NullPtrExc($80)}}, c:$242 {norm=$82 {MemOpaque:NotInLoop}, exc=$240 {NullPtrExc($80)}}>
  fgCurMemoryVN[GcHeap] assigned for CALL at [000012] to VN: $101.
N008 [000012]   CALL      => $VN.Void

***** BB01, STMT00001(after)
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180

finish(BB01).

*************** Finishing PHASE Do value numbering
Trees after Do value numbering

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref  $VN.Void
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1 $VN.Void
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref  $180
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName] $140

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Hoist loop code

No loops; no hoisting

*************** Finishing PHASE Hoist loop code [no changes]

*************** Starting PHASE VN based copy prop
Copy Assertion for BB01
  curSsaName stack: { }

							Live vars: {V00 V01} => {V01}
							Live vars: {V01} => {V01 V03}
							Live vars: {V01 V03} => {V03}
							Live vars: {V03} => {}

*************** Finishing PHASE VN based copy prop [no changes]

*************** Starting PHASE Redundant branch opts

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** Finishing PHASE Redundant branch opts [no changes]

*************** Starting PHASE Optimize Valnum CSEs

*************** Finishing PHASE Optimize Valnum CSEs
Trees after Optimize Valnum CSEs

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref  $VN.Void
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1 $VN.Void
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref  $180
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName] $140

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] ---XG------ arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Assertion prop
GenTreeNode creates assertion:
N004 (  4,  4) [000011] ---XG------                         ▌  IND       int    <l:$280, c:$281>
In BB01 New Global Constant Assertion: ($80,$0) Value_Number {InitVal($40)} is not null, index = #01

BB01 valueGen = #01

BB01:
 in   = #NA
 out  = #01

Propagating #NA for BB01, stmt STMT00003, tree [000019], tree -> #NA
Propagating #NA for BB01, stmt STMT00003, tree [000020], tree -> #NA
Propagating #NA for BB01, stmt STMT00003, tree [000021], tree -> #NA
Propagating #NA for BB01, stmt STMT00003, tree [000014], tree -> #NA
Propagating #NA for BB01, stmt STMT00003, tree [000015], tree -> #NA
Propagating #NA for BB01, stmt STMT00001, tree [000010], tree -> #NA
Propagating #NA for BB01, stmt STMT00001, tree [000024], tree -> #NA
Propagating #NA for BB01, stmt STMT00001, tree [000025], tree -> #NA
Propagating #NA for BB01, stmt STMT00001, tree [000011], tree -> #01
Propagating #01 for BB01, stmt STMT00001, tree [000013], tree -> #NA
Propagating #01 for BB01, stmt STMT00001, tree [000008], tree -> #NA
Propagating #01 for BB01, stmt STMT00001, tree [000009], tree -> #01

VN based non-null prop in BB01:
N007 (  3,  2) [000009] ---XG------                         ▌  IND       ref    <l:$241, c:$242>
Propagating #01 for BB01, stmt STMT00001, tree [000012], tree -> #NA
Re-morphing this stmt:
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXG------                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] n---GO----- arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180

ReMorphing args for 12.CALL:
Args for [000012].CALL after fgMorphArgs:
CallArg[[000013].LCL_VAR byref (By value), 1 reg: rcx, byteAlignment=8, isLate, processed, wellKnown[RetBuffer]]
CallArg[[000009].IND ref (By value), 1 reg: rdx, byteAlignment=8, isLate, processed]
CallArg[[000011].IND int (By value), 1 reg: r8, byteAlignment=8, isLate, processed]
OutgoingArgsStackSize is 32

optAssertionPropMain morphed tree:
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] n---GO----- arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180


*************** Finishing PHASE Assertion prop
Trees after Assertion prop

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref  $VN.Void
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1 $VN.Void
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref  $180
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName] $140

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] n---GO----- arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable

*************** Starting PHASE Optimize index checks

*************** Finishing PHASE Optimize index checks [no changes]

*************** Starting PHASE Insert GC Polls

*************** Finishing PHASE Insert GC Polls [no changes]

*************** Starting PHASE Optimize bools
*************** In optOptimizeBools()

optimized 0 BBJ_COND cases, 0 BBJ_RETURN cases in 1 passes

*************** Finishing PHASE Optimize bools [no changes]

*************** Starting PHASE Optimize layout

*************** In fgUpdateFlowGraph()
Before updating the flow graph:

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** In fgDebugCheckBBlist

*************** In fgUpdateFlowGraph()
Before updating the flow graph:

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** In fgDebugCheckBBlist

*************** Finishing PHASE Optimize layout
Trees after Optimize layout

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}

***** BB01
STMT00003 ( 0x000[E-] ... ??? )
N005 (  3,  3) [000015] -A--G---R--                         ▌  ASG       byref  $VN.Void
N004 (  1,  1) [000014] D------N---                         ├──▌  LCL_VAR   byref  V03 tmp1         d:1 $VN.Void
N003 (  3,  3) [000021] -----------                         └──▌  ADD       byref  $180
N001 (  1,  1) [000019] -----------                            ├──▌  LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -----------                            └──▌  CNS_INT   long   8 Fseq[hackishFieldName] $140

***** BB01
STMT00001 ( 0x000[E-] ... ??? )
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void
N004 (  4,  4) [000011] ---XG------ arg2 in r8              ├──▌  IND       int    <l:$280, c:$281>
N003 (  2,  2) [000025] -------N---                         │  └──▌  ADD       byref  $181
N001 (  1,  1) [000010] -----------                         │     ├──▌  LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                         │     └──▌  CNS_INT   long   12 $141
N005 (  1,  1) [000013] ----------- retbuf in rcx           ├──▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N007 (  3,  2) [000009] n---GO----- arg1 in rdx             └──▌  IND       ref    <l:$241, c:$242>
N006 (  1,  1) [000008] -----------                            └──▌  LCL_VAR   byref  V03 tmp1         u:1 (last use) $180

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid

*************** Starting PHASE Determine first cold block
No procedure splitting will be done for this method

*************** Finishing PHASE Determine first cold block [no changes]

*************** Starting PHASE Rationalize IR
rewriting asg(LCL_VAR, X) to STORE_LCL_VAR(X)
N005 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1


*************** Finishing PHASE Rationalize IR
Trees after Rationalize IR

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}
               [000026] -----------                            IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -----------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N003 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  $180
                                                            ┌──▌  t21    byref  
N005 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1
               [000027] -----------                            IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  1,  1) [000010] -----------                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 $180
N002 (  1,  1) [000024] -----------                   t24 =    CNS_INT   long   12 $141
                                                            ┌──▌  t10    byref  
                                                            ├──▌  t24    long   
N003 (  2,  2) [000025] -------N---                   t25 = ▌  ADD       byref  $181
                                                            ┌──▌  t25    byref  
N004 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    <l:$280, c:$281>
N005 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N006 (  1,  1) [000008] -----------                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 (last use) $180
                                                            ┌──▌  t8     byref  
N007 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    <l:$241, c:$242>
                                                            ┌──▌  t11    int    arg2 in r8
                                                            ├──▌  t13    byref  retbuf in rcx
                                                            ├──▌  t9     ref    arg1 in rdx
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid

*************** Starting PHASE Do 'simple' lowering
outgoingArgSpaceSize not impacted by fast tail call [000012]

*************** Finishing PHASE Do 'simple' lowering [no changes]

*************** Starting PHASE Lowering nodeinfo
lowering store lcl var/field (before):
N001 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N003 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  $180
                                                            ┌──▌  t21    byref  
N005 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1

lowering store lcl var/field (after):
N001 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N003 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  $180
                                                            ┌──▌  t21    byref  
N005 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1

Addressing mode:
  Base
    N001 (  1,  1) [000010] -----------                         ▌  LCL_VAR   byref  V03 tmp1         u:1 $180
  + 12
Removing unused node:
  N002 (  1,  1) [000024] -c---------                         ▌  CNS_INT   long   12 $141
New addressing mode node:
  N003 (  2,  2) [000025] -----------                         ▌  LEA(b+12) byref 

lowering call (before):
N001 (  1,  1) [000010] -----------                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 $180
                                                            ┌──▌  t10    byref  
N003 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref 
                                                            ┌──▌  t25    byref  
N004 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    <l:$280, c:$281>
N005 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
N006 (  1,  1) [000008] -----------                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 (last use) $180
                                                            ┌──▌  t8     byref  
N007 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    <l:$241, c:$242>
                                                            ┌──▌  t11    int    arg2 in r8
                                                            ├──▌  t13    byref  retbuf in rcx
                                                            ├──▌  t9     ref    arg1 in rdx
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void

args:
======

late:
======
lowering arg : N004 (  4,  4) [000011] ---XG------                         ▌  IND       int    <l:$280, c:$281>
new node is :                [000028] ---XG------                         ▌  PUTARG_REG int    REG r8

lowering arg : N005 (  1,  1) [000013] -----------                         ▌  LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
new node is :                [000029] -----------                         ▌  PUTARG_REG byref  REG rcx

lowering arg : N007 (  3,  2) [000009] n---GO-----                         ▌  IND       ref    <l:$241, c:$242>
new node is :                [000030] ----GO-----                         ▌  PUTARG_REG ref    REG rdx

results of lowering call:
N001 (  3, 10) [000031] H----------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn
                                                            ┌──▌  t31    long   
N002 (  5, 12) [000032] -----------                   t32 = ▌  IND       long  
lowering call (after):
N001 (  1,  1) [000010] -----------                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 $180
                                                            ┌──▌  t10    byref  
N003 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref 
                                                            ┌──▌  t25    byref  
N004 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    <l:$280, c:$281>
                                                            ┌──▌  t11    int    
               [000028] ---XG------                   t28 = ▌  PUTARG_REG int    REG r8
N005 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
                                                            ┌──▌  t13    byref  
               [000029] -----------                   t29 = ▌  PUTARG_REG byref  REG rcx
N006 (  1,  1) [000008] -----------                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 (last use) $180
                                                            ┌──▌  t8     byref  
N007 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    <l:$241, c:$242>
                                                            ┌──▌  t9     ref    
               [000030] ----GO-----                   t30 = ▌  PUTARG_REG ref    REG rdx
N001 (  3, 10) [000031] Hc---------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn
                                                            ┌──▌  t31    long   
N002 (  5, 12) [000032] -c---------                   t32 = ▌  IND       long   REG NA
                                                            ┌──▌  t28    int    arg2 in r8
                                                            ├──▌  t29    byref  retbuf in rcx
                                                            ├──▌  t30    ref    arg1 in rdx
                                                            ├──▌  t32    long   control expr
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void

Lower has completed modifying nodes.

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}
               [000026] -----------                            IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N003 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  $180
                                                            ┌──▌  t21    byref  
N005 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1
               [000027] -----------                            IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  1,  1) [000010] -----------                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 $180
                                                            ┌──▌  t10    byref  
N003 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref 
                                                            ┌──▌  t25    byref  
N004 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    <l:$280, c:$281>
                                                            ┌──▌  t11    int    
               [000028] ---XG------                   t28 = ▌  PUTARG_REG int    REG r8
N005 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
                                                            ┌──▌  t13    byref  
               [000029] -----------                   t29 = ▌  PUTARG_REG byref  REG rcx
N006 (  1,  1) [000008] -----------                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 (last use) $180
                                                            ┌──▌  t8     byref  
N007 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    <l:$241, c:$242>
                                                            ┌──▌  t9     ref    
               [000030] ----GO-----                   t30 = ▌  PUTARG_REG ref    REG rdx
N001 (  3, 10) [000031] Hc---------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn
                                                            ┌──▌  t31    long   
N002 (  5, 12) [000032] -c---------                   t32 = ▌  IND       long   REG NA
                                                            ┌──▌  t28    int    arg2 in r8
                                                            ├──▌  t29    byref  retbuf in rcx
                                                            ├──▌  t30    ref    arg1 in rdx
                                                            ├──▌  t32    long   control expr
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void

-------------------------------------------------------------------------------------------------------------------

*** lvaComputeRefCounts ***

*** lvaComputeRefCounts -- explicit counts ***
New refCnts for V00: refCnt =  1, refCntWtd = 1   
New refCnts for V03: refCnt =  1, refCntWtd = 2   
New refCnts for V03: refCnt =  2, refCntWtd = 4   
New refCnts for V01: refCnt =  1, refCntWtd = 1   
New refCnts for V03: refCnt =  3, refCntWtd = 6   

*** lvaComputeRefCounts -- implicit counts ***
New refCnts for V00: refCnt =  2, refCntWtd = 2   
New refCnts for V00: refCnt =  3, refCntWtd = 3   
New refCnts for V01: refCnt =  2, refCntWtd = 2   
New refCnts for V01: refCnt =  3, refCntWtd = 3   
*************** In fgLocalVarLiveness()
; Initial local variable assignments
;
;  V00 this              ref  this class-hnd single-def
;  V01 RetBuf          byref  single-def
;  V02 OutArgs        lclBlk <0>  "OutgoingArgSpace"
;  V03 tmp1            byref  single-def "Inlining Arg"
In fgLocalVarLivenessInit
Tracked variable (3 out of 4) table:
V03 tmp1          [ byref]: refCnt =    3, refCntWtd =   6   
V00 this          [   ref]: refCnt =    3, refCntWtd =   3   
V01 RetBuf        [ byref]: refCnt =    3, refCntWtd =   3   

*************** In fgPerBlockLocalVarLiveness()
BB01 USE(2)={    V00 V01} + ByrefExposed + GcHeap
     DEF(1)={V03        } + ByrefExposed* + GcHeap*

** Memory liveness computed, GcHeap states and ByrefExposed states match
*************** In fgInterBlockLocalVarLiveness()

BB liveness after fgLiveVarAnalysis():

BB01 IN (2)={V00 V01} + ByrefExposed + GcHeap
     OUT(0)={       }


*************** In fgUpdateFlowGraph()
Before updating the flow graph:

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** In fgDebugCheckBBlist

*************** In fgRemoveDeadBlocks()
Removing unreachable blocks for fgRemoveDeadBlocks iteration #1
*************** In fgDebugCheckBBlist

*** lvaComputeRefCounts ***

*** lvaComputeRefCounts -- explicit counts ***
New refCnts for V00: refCnt =  1, refCntWtd = 1   
New refCnts for V03: refCnt =  1, refCntWtd = 2   
New refCnts for V03: refCnt =  2, refCntWtd = 4   
New refCnts for V01: refCnt =  1, refCntWtd = 1   
New refCnts for V03: refCnt =  3, refCntWtd = 6   

*** lvaComputeRefCounts -- implicit counts ***
New refCnts for V00: refCnt =  2, refCntWtd = 2   
New refCnts for V00: refCnt =  3, refCntWtd = 3   
New refCnts for V01: refCnt =  2, refCntWtd = 2   
New refCnts for V01: refCnt =  3, refCntWtd = 3   

*************** Finishing PHASE Lowering nodeinfo
Trees after Lowering nodeinfo

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}
               [000026] -----------                            IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 (last use) $80
N002 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N003 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  $180
                                                            ┌──▌  t21    byref  
N005 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1
               [000027] -----------                            IL_OFFSET void   INLRT @ 0x000[E-]
N001 (  1,  1) [000010] -----------                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 $180
                                                            ┌──▌  t10    byref  
N003 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref 
                                                            ┌──▌  t25    byref  
N004 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    <l:$280, c:$281>
                                                            ┌──▌  t11    int    
               [000028] ---XG------                   t28 = ▌  PUTARG_REG int    REG r8
N005 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 (last use) $c0
                                                            ┌──▌  t13    byref  
               [000029] -----------                   t29 = ▌  PUTARG_REG byref  REG rcx
N006 (  1,  1) [000008] -----------                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 (last use) $180
                                                            ┌──▌  t8     byref  
N007 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    <l:$241, c:$242>
                                                            ┌──▌  t9     ref    
               [000030] ----GO-----                   t30 = ▌  PUTARG_REG ref    REG rdx
N001 (  3, 10) [000031] Hc---------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn
                                                            ┌──▌  t31    long   
N002 (  5, 12) [000032] -c---------                   t32 = ▌  IND       long   REG NA
                                                            ┌──▌  t28    int    arg2 in r8
                                                            ├──▌  t29    byref  retbuf in rcx
                                                            ├──▌  t30    ref    arg1 in rdx
                                                            ├──▌  t32    long   control expr
N008 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName $VN.Void

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid

*************** Starting PHASE Calculate stack level slots

*************** Finishing PHASE Calculate stack level slots [no changes]

*************** Starting PHASE Linear scan register alloc
Clearing modified regs.

buildIntervals ========

-----------------
LIVENESS:
-----------------
BB01
use: {V00 V01}
def: {V03}
 in: {V00 V01}
out: {}
Interval  0: ref RefPositions {} physReg:NA Preferences=[allInt]
  Interval  0: (V00) ref RefPositions {} physReg:NA Preferences=[allInt]
Interval  1: byref RefPositions {} physReg:NA Preferences=[allInt]
  Interval  1: (V01) byref RefPositions {} physReg:NA Preferences=[allInt]
Interval  2: byref RefPositions {} physReg:NA Preferences=[allInt]
  Interval  2: (V03) byref RefPositions {} physReg:NA Preferences=[allInt]

FP callee save candidate vars: None

floatVarCount = 0; hasLoops = false, singleExit = true
TUPLE STYLE DUMP BEFORE LSRA
Start LSRA Block Sequence: 
Current block: BB01
Final LSRA Block Sequence:
BB01 (  1   )

BB01 [000..00C) (return), preds={} succs={}
=====
  N000.                    IL_OFFSET INLRT @ 0x000[E-]
  N001.                    V00(t19*)
  N002.                    CNS_INT   8 Fseq[hackishFieldName]
  N003. t21             =  ADD      ; t19*
  N005.                    V03(t15); t21
  N000.                    IL_OFFSET INLRT @ 0x000[E-]
  N001.                    V03(t10)
  N003. t25             =  LEA(b+12); t10
  N004. t11             =  IND      ; t25
  N000. t28             =  PUTARG_REG; t11
  N005.                    V01(t13*)
  N000. t29             =  PUTARG_REG; t13*
  N006.                    V03(t8*)
  N007. t9              =  IND      ; t8*
  N000. t30             =  PUTARG_REG; t9
  N001.                    CNS_INT(h) 0x7ff94f4c9618 ftn
  N002.                    IND      
  N008.                    CALL     ; t28,t29,t30




buildIntervals second part ========
Int arg V00 in reg rcx
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed wt=100.00>
Int arg V01 in reg rdx
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed wt=100.00>

NEW BLOCK BB01
<RefPosition #2   @1   RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>

DefList: {  }
N003 (???,???) [000026] -----------                         ▌  IL_OFFSET void   INLRT @ 0x000[E-] REG NA

DefList: {  }
N005 (  1,  1) [000019] -----------                         ▌  LCL_VAR   ref    V00 this         u:1 NA (last use) REG NA $80

DefList: {  }
N007 (  1,  1) [000020] -c---------                         ▌  CNS_INT   long   8 Fseq[hackishFieldName] REG NA $140
Contained
DefList: {  }
N009 (  3,  3) [000021] -----------                         ▌  ADD       byref  REG NA $180
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=300.00>
Interval  3: byref RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #4   @10  RefTypeDef <Ivl:3> ADD BB01 regmask=[allInt] minReg=1 wt=400.00>
Assigning related <I3> to <V00/L0>

DefList: { N009.t21. ADD }
N011 (  3,  3) [000015] DA--G------                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1 NA REG NA
<RefPosition #5   @11  RefTypeUse <Ivl:3> BB01 regmask=[allInt] minReg=1 last wt=100.00>
Assigning related <V03/L2> to <I3>
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>

DefList: {  }
N013 (???,???) [000027] -----------                         ▌  IL_OFFSET void   INLRT @ 0x000[E-] REG NA

DefList: {  }
N015 (  1,  1) [000010] -----------                         ▌  LCL_VAR   byref  V03 tmp1         u:1 NA REG NA $180

DefList: {  }
N017 (  2,  2) [000025] -c---------                         ▌  LEA(b+12) byref  REG NA
Contained
DefList: {  }
N019 (  4,  4) [000011] ---XG------                         ▌  IND       int    REG NA <l:$280, c:$281>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>
Interval  4: int RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #8   @20  RefTypeDef <Ivl:4> IND BB01 regmask=[allInt] minReg=1 wt=400.00>

DefList: { N019.t11. IND }
N021 (???,???) [000028] ---XG------                         ▌  PUTARG_REG int    REG r8
<RefPosition #9   @21  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #10  @21  RefTypeUse <Ivl:4> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
Interval  5: int RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #11  @22  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #12  @22  RefTypeDef <Ivl:5> PUTARG_REG BB01 regmask=[r8] minReg=1 fixed wt=400.00>

DefList: { N021.t28. PUTARG_REG }
N023 (  1,  1) [000013] -----------                         ▌  LCL_VAR   byref  V01 RetBuf       u:1 NA (last use) REG NA $c0

DefList: { N021.t28. PUTARG_REG }
N025 (???,???) [000029] -----------                         ▌  PUTARG_REG byref  REG rcx
<RefPosition #13  @25  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
Interval  6: byref RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #15  @26  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #16  @26  RefTypeDef <Ivl:6> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>

DefList: { N021.t28. PUTARG_REG; N025.t29. PUTARG_REG }
N027 (  1,  1) [000008] -----------                         ▌  LCL_VAR   byref  V03 tmp1         u:1 NA (last use) REG NA $180

DefList: { N021.t28. PUTARG_REG; N025.t29. PUTARG_REG }
N029 (  3,  2) [000009] n---GO-----                         ▌  IND       ref    REG NA <l:$241, c:$242>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>
Interval  7: ref RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #18  @30  RefTypeDef <Ivl:7> IND BB01 regmask=[allInt] minReg=1 wt=400.00>

DefList: { N021.t28. PUTARG_REG; N025.t29. PUTARG_REG; N029.t9. IND }
N031 (???,???) [000030] ----GO-----                         ▌  PUTARG_REG ref    REG rdx
<RefPosition #19  @31  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #20  @31  RefTypeUse <Ivl:7> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
Interval  8: ref RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #21  @32  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #22  @32  RefTypeDef <Ivl:8> PUTARG_REG BB01 regmask=[rdx] minReg=1 fixed wt=400.00>

DefList: { N021.t28. PUTARG_REG; N025.t29. PUTARG_REG; N031.t30. PUTARG_REG }
N033 (  3, 10) [000031] Hc---------                         ▌  CNS_INT(h) long   0x7ff94f4c9618 ftn REG NA
Contained
DefList: { N021.t28. PUTARG_REG; N025.t29. PUTARG_REG; N031.t30. PUTARG_REG }
N035 (  5, 12) [000032] -c---------                         ▌  IND       long   REG NA
Contained
DefList: { N021.t28. PUTARG_REG; N025.t29. PUTARG_REG; N031.t30. PUTARG_REG }
N037 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName REG NA $VN.Void
<RefPosition #23  @37  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #24  @37  RefTypeUse <Ivl:5> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #25  @37  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #26  @37  RefTypeUse <Ivl:6> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #27  @37  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #28  @37  RefTypeUse <Ivl:8> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #29  @38  RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #30  @38  RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #31  @38  RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #32  @38  RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #33  @38  RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 wt=100.00>
<RefPosition #34  @38  RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 wt=100.00>
<RefPosition #35  @38  RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 wt=100.00>



CHECKING LAST USES for BB01, liveout={}
==============================
use: {V00 V01}
def: {V03}

Linear scan intervals BEFORE VALIDATING INTERVALS:
Interval  0: (V00) ref RefPositions {#0@0 #3@9} physReg:rcx Preferences=[rcx] RelatedInterval <I3>
Interval  1: (V01) byref RefPositions {#1@0 #14@25} physReg:rdx Preferences=[rcx rdx]
Interval  2: (V03) byref RefPositions {#6@12 #7@19 #17@29} physReg:NA Preferences=[allInt]
Interval  3: byref RefPositions {#4@10 #5@11} physReg:NA Preferences=[allInt] RelatedInterval <V03/L2>
Interval  4: int RefPositions {#8@20 #10@21} physReg:NA Preferences=[r8]
Interval  5: int RefPositions {#12@22 #24@37} physReg:NA Preferences=[r8]
Interval  6: byref RefPositions {#16@26 #26@37} physReg:NA Preferences=[rcx]
Interval  7: ref RefPositions {#18@30 #20@31} physReg:NA Preferences=[rdx]
Interval  8: ref RefPositions {#22@32 #28@37} physReg:NA Preferences=[rdx]

------------
REFPOSITIONS BEFORE VALIDATING INTERVALS: 
------------
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #2   @1   RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=300.00>
<RefPosition #4   @10  RefTypeDef <Ivl:3> ADD BB01 regmask=[allInt] minReg=1 wt=400.00>
<RefPosition #5   @11  RefTypeUse <Ivl:3> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #8   @20  RefTypeDef <Ivl:4> IND BB01 regmask=[r8] minReg=1 wt=400.00>
<RefPosition #9   @21  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #10  @21  RefTypeUse <Ivl:4> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #11  @22  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #12  @22  RefTypeDef <Ivl:5> PUTARG_REG BB01 regmask=[r8] minReg=1 fixed wt=400.00>
<RefPosition #13  @25  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
<RefPosition #15  @26  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #16  @26  RefTypeDef <Ivl:6> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>
<RefPosition #18  @30  RefTypeDef <Ivl:7> IND BB01 regmask=[rdx] minReg=1 wt=400.00>
<RefPosition #19  @31  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #20  @31  RefTypeUse <Ivl:7> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #21  @32  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #22  @32  RefTypeDef <Ivl:8> PUTARG_REG BB01 regmask=[rdx] minReg=1 fixed wt=400.00>
<RefPosition #23  @37  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #24  @37  RefTypeUse <Ivl:5> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #25  @37  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #26  @37  RefTypeUse <Ivl:6> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #27  @37  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #28  @37  RefTypeUse <Ivl:8> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #29  @38  RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #30  @38  RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #31  @38  RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #32  @38  RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 last wt=100.00>
<RefPosition #33  @38  RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 last wt=100.00>
<RefPosition #34  @38  RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 last wt=100.00>
<RefPosition #35  @38  RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 last wt=100.00>

------------
REFPOSITIONS DURING VALIDATE INTERVALS (RefPositions per interval)
------------

-----------------
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>
-----------------
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=300.00>
-----------------
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
TUPLE STYLE DUMP WITH REF POSITIONS
Incoming Parameters:  V00 V01
BB01 [000..00C) (return), preds={} succs={}
=====
  N003.                    IL_OFFSET INLRT @ 0x000[E-]
  N005.                    V00(L0)
  N007.                    CNS_INT   8 Fseq[hackishFieldName]
  N009.                    ADD      
                               Use:<V00/L0>(#3) *
        Def:<I3>(#4) Pref:<V03/L2>
  N011.                    V03(L2)
                               Use:<I3>(#5) *
        Def:<V03/L2>(#6)
  N013.                    IL_OFFSET INLRT @ 0x000[E-]
  N015.                    V03(L2)
  N017.                    LEA(b+12)
  N019.                    IND      
                               Use:<V03/L2>(#7)
        Def:<I4>(#8)
  N021.                    PUTARG_REG
                               Use:<I4>(#10) Fixed:r8(#9) *
        Def:<I5>(#12) r8
  N023.                    V01(L1)
  N025.                    PUTARG_REG
                               Use:<V01/L1>(#14) Fixed:rcx(#13) *
        Def:<I6>(#16) rcx
  N027.                    V03(L2)
  N029.                    IND      
                               Use:<V03/L2>(#17) *
        Def:<I7>(#18)
  N031.                    PUTARG_REG
                               Use:<I7>(#20) Fixed:rdx(#19) *
        Def:<I8>(#22) rdx
  N033.                    CNS_INT(h) 0x7ff94f4c9618 ftn
  N035.                    IND      
  N037.                    CALL     
                               Use:<I5>(#24) Fixed:r8(#23) *
                               Use:<I6>(#26) Fixed:rcx(#25) *
                               Use:<I8>(#28) Fixed:rdx(#27) *
        Kill: rax rcx rdx r8 r9 r10 r11 




Linear scan intervals after buildIntervals:
Interval  0: (V00) ref RefPositions {#0@0 #3@9} physReg:rcx Preferences=[rcx] RelatedInterval <I3>
Interval  1: (V01) byref RefPositions {#1@0 #14@25} physReg:rdx Preferences=[rcx rdx]
Interval  2: (V03) byref RefPositions {#6@12 #7@19 #17@29} physReg:NA Preferences=[allInt]
Interval  3: byref RefPositions {#4@10 #5@11} physReg:NA Preferences=[allInt] RelatedInterval <V03/L2>
Interval  4: int RefPositions {#8@20 #10@21} physReg:NA Preferences=[r8]
Interval  5: int RefPositions {#12@22 #24@37} physReg:NA Preferences=[r8]
Interval  6: byref RefPositions {#16@26 #26@37} physReg:NA Preferences=[rcx]
Interval  7: ref RefPositions {#18@30 #20@31} physReg:NA Preferences=[rdx]
Interval  8: ref RefPositions {#22@32 #28@37} physReg:NA Preferences=[rdx]

*************** In LinearScan::allocateRegisters()

Linear scan intervals before allocateRegisters:
Interval  0: (V00) ref RefPositions {#0@0 #3@9} physReg:rcx Preferences=[rcx] RelatedInterval <I3>
Interval  1: (V01) byref RefPositions {#1@0 #14@25} physReg:rdx Preferences=[rcx rdx]
Interval  2: (V03) byref RefPositions {#6@12 #7@19 #17@29} physReg:NA Preferences=[allInt]
Interval  3: byref RefPositions {#4@10 #5@11} physReg:NA Preferences=[allInt] RelatedInterval <V03/L2>
Interval  4: int RefPositions {#8@20 #10@21} physReg:NA Preferences=[r8]
Interval  5: int RefPositions {#12@22 #24@37} physReg:NA Preferences=[r8]
Interval  6: byref RefPositions {#16@26 #26@37} physReg:NA Preferences=[rcx]
Interval  7: ref RefPositions {#18@30 #20@31} physReg:NA Preferences=[rdx]
Interval  8: ref RefPositions {#22@32 #28@37} physReg:NA Preferences=[rdx]

------------
REFPOSITIONS BEFORE ALLOCATION: 
------------
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #2   @1   RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=300.00>
<RefPosition #4   @10  RefTypeDef <Ivl:3> ADD BB01 regmask=[allInt] minReg=1 wt=400.00>
<RefPosition #5   @11  RefTypeUse <Ivl:3> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #8   @20  RefTypeDef <Ivl:4> IND BB01 regmask=[r8] minReg=1 wt=400.00>
<RefPosition #9   @21  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #10  @21  RefTypeUse <Ivl:4> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #11  @22  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #12  @22  RefTypeDef <Ivl:5> PUTARG_REG BB01 regmask=[r8] minReg=1 fixed wt=400.00>
<RefPosition #13  @25  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
<RefPosition #15  @26  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #16  @26  RefTypeDef <Ivl:6> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>
<RefPosition #18  @30  RefTypeDef <Ivl:7> IND BB01 regmask=[rdx] minReg=1 wt=400.00>
<RefPosition #19  @31  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #20  @31  RefTypeUse <Ivl:7> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #21  @32  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #22  @32  RefTypeDef <Ivl:8> PUTARG_REG BB01 regmask=[rdx] minReg=1 fixed wt=400.00>
<RefPosition #23  @37  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #24  @37  RefTypeUse <Ivl:5> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #25  @37  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #26  @37  RefTypeUse <Ivl:6> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #27  @37  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #28  @37  RefTypeUse <Ivl:8> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #29  @38  RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #30  @38  RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #31  @38  RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #32  @38  RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 last wt=100.00>
<RefPosition #33  @38  RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 last wt=100.00>
<RefPosition #34  @38  RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 last wt=100.00>
<RefPosition #35  @38  RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 last wt=100.00>

VAR REFPOSITIONS BEFORE ALLOCATION
--- V00  (Interval 0)
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=300.00>
--- V01  (Interval 1)
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
--- V02
--- V03  (Interval 2)
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 wt=600.00>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[allInt] minReg=1 last wt=600.00>



Allocating Registers
--------------------
The following table has one or more rows for each RefPosition that is handled during allocation.
The columns are: (1) Loc: LSRA location, (2) RP#: RefPosition number, (3) Name, (4) Type (e.g. Def, Use,
Fixd, Parm, DDef (Dummy Def), ExpU (Exposed Use), Kill) followed by a '*' if it is a last use, and a 'D'
if it is delayRegFree, (5) Action taken during allocation. Some actions include (a) Alloc a new register,
(b) Keep an existing register, (c) Spill a register, (d) ReLod (Reload) a register. If an ALL-CAPS name
such as COVRS is displayed, it is a score name from lsra_score.h, with a trailing '(A)' indicating alloc,
'(C)' indicating copy, and '(R)' indicating re-use. See dumpLsraAllocationEvent() for details.
The subsequent columns show the Interval occupying each register, if any, followed by 'a' if it is
active, 'p' if it is a large vector that has been partially spilled, and 'i' if it is inactive.
Columns are only printed up to the last modified register, which may increase during allocation,
in which case additional columns will appear. Registers which are not marked modified have ---- in
their column.

─────────────────────────────────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
LocRP# Name Type  Action    Reg  │rax │rcx │rdx │rbx │rbp │rsi │rdi │r8  │r9  │
─────────────────────────────────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
                                 │    │V0 a│V1 a│    │    │    │    │    │    │
 0.#0  V0   Parm   Keep     rcx  │    │V0 a│V1 a│    │    │    │    │    │    │
 0.#1  V1   Parm   Keep     rdx  │    │V0 a│V1 a│    │    │    │    │    │    │
 1.#2  BB1 PredBB0               │    │V0 a│V1 a│    │    │    │    │    │    │
 9.#3  V0   Use *  Keep     rcx  │    │V0 a│V1 a│    │    │    │    │    │    │
10.#4  I3   Def    COVRS(A) rcx  │    │I3 a│V1 a│    │    │    │    │    │    │
11.#5  I3   Use *  Keep     rcx  │    │I3 a│V1 a│    │    │    │    │    │    │
12.#6  V3   Def    COVRS(A) rcx  │    │V3 a│V1 a│    │    │    │    │    │    │
19.#7  V3   Use    Keep     rcx  │    │V3 a│V1 a│    │    │    │    │    │    │
20.#8  I4   Def    Alloc    r8   │    │V3 a│V1 a│    │    │    │    │I4 a│    │
21.#9  r8   Fixd   Keep     r8   │    │V3 a│V1 a│    │    │    │    │I4 a│    │
21.#10 I4   Use *  Keep     r8   │    │V3 a│V1 a│    │    │    │    │I4 a│    │
22.#11 r8   Fixd   Keep     r8   │    │V3 a│V1 a│    │    │    │    │    │    │
22.#12 I5   Def    Alloc    r8   │    │V3 a│V1 a│    │    │    │    │I5 a│    │
25.#13 rcx  Fixd   Keep     rcx  │    │V3 a│V1 a│    │    │    │    │I5 a│    │
25.#14 V1   Use *  Spill    rcx  │    │    │V1 i│    │    │    │    │I5 a│    │
                   Copy     rcx  │    │V1 a│V1 a│    │    │    │    │I5 a│    │
26.#15 rcx  Fixd   Keep     rcx  │    │    │    │    │    │    │    │I5 a│    │
26.#16 I6   Def    Alloc    rcx  │    │I6 a│    │    │    │    │    │I5 a│    │
29.#17 V3   Use *  ReLod    NA   │    │I6 a│    │    │    │    │    │I5 a│    │
                   BSFIT(A) rdx  │    │I6 a│V3 a│    │    │    │    │I5 a│    │
30.#18 I7   Def    Alloc    rdx  │    │I6 a│I7 a│    │    │    │    │I5 a│    │
31.#19 rdx  Fixd   Keep     rdx  │    │I6 a│I7 a│    │    │    │    │I5 a│    │
31.#20 I7   Use *  Keep     rdx  │    │I6 a│I7 a│    │    │    │    │I5 a│    │
32.#21 rdx  Fixd   Keep     rdx  │    │I6 a│    │    │    │    │    │I5 a│    │
32.#22 I8   Def    Alloc    rdx  │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#23 r8   Fixd   Keep     r8   │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#24 I5   Use *  Keep     r8   │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#25 rcx  Fixd   Keep     rcx  │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#26 I6   Use *  Keep     rcx  │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#27 rdx  Fixd   Keep     rdx  │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#28 I8   Use *  Keep     rdx  │    │I6 a│I8 a│    │    │    │    │I5 a│    │
38.#29 rax  Kill   Keep     rax  │    │    │    │    │    │    │    │    │    │
38.#30 rcx  Kill   Keep     rcx  │    │    │    │    │    │    │    │    │    │
38.#31 rdx  Kill   Keep     rdx  │    │    │    │    │    │    │    │    │    │
38.#32 r8   Kill   Keep     r8   │    │    │    │    │    │    │    │    │    │
38.#33 r9   Kill   Keep     r9   │    │    │    │    │    │    │    │    │    │
38.#34 r10  Kill   Keep     r10  │    │    │    │    │    │    │    │    │    │
38.#35 r11  Kill   Keep     r11  │    │    │    │    │    │    │    │    │    │

------------
REFPOSITIONS AFTER ALLOCATION: 
------------
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #2   @1   RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last wt=300.00>
<RefPosition #4   @10  RefTypeDef <Ivl:3> ADD BB01 regmask=[rcx] minReg=1 wt=400.00>
<RefPosition #5   @11  RefTypeUse <Ivl:3> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[rcx] minReg=1 singleDefSpill wt=300.00>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[rcx] minReg=1 spillAfter wt=300.00>
<RefPosition #8   @20  RefTypeDef <Ivl:4> IND BB01 regmask=[r8] minReg=1 wt=400.00>
<RefPosition #9   @21  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #10  @21  RefTypeUse <Ivl:4> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #11  @22  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #12  @22  RefTypeDef <Ivl:5> PUTARG_REG BB01 regmask=[r8] minReg=1 fixed wt=400.00>
<RefPosition #13  @25  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last copy fixed wt=300.00>
<RefPosition #15  @26  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #16  @26  RefTypeDef <Ivl:6> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[rdx] minReg=1 last reload wt=300.00>
<RefPosition #18  @30  RefTypeDef <Ivl:7> IND BB01 regmask=[rdx] minReg=1 wt=400.00>
<RefPosition #19  @31  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #20  @31  RefTypeUse <Ivl:7> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #21  @32  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #22  @32  RefTypeDef <Ivl:8> PUTARG_REG BB01 regmask=[rdx] minReg=1 fixed wt=400.00>
<RefPosition #23  @37  RefTypeFixedReg <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #24  @37  RefTypeUse <Ivl:5> BB01 regmask=[r8] minReg=1 last fixed wt=100.00>
<RefPosition #25  @37  RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #26  @37  RefTypeUse <Ivl:6> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #27  @37  RefTypeFixedReg <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #28  @37  RefTypeUse <Ivl:8> BB01 regmask=[rdx] minReg=1 last fixed wt=100.00>
<RefPosition #29  @38  RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #30  @38  RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #31  @38  RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #32  @38  RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 last wt=100.00>
<RefPosition #33  @38  RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 last wt=100.00>
<RefPosition #34  @38  RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 last wt=100.00>
<RefPosition #35  @38  RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 last wt=100.00>

VAR REFPOSITIONS AFTER ALLOCATION
--- V00  (Interval 0)
<RefPosition #0   @0   RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #3   @9   RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last wt=300.00>
--- V01  (Interval 1)
<RefPosition #1   @0   RefTypeParamDef <Ivl:1 V01> BB00 regmask=[rdx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #14  @25  RefTypeUse <Ivl:1 V01> LCL_VAR BB01 regmask=[rcx] minReg=1 last copy fixed wt=300.00>
--- V02
--- V03  (Interval 2)
<RefPosition #6   @12  RefTypeDef <Ivl:2 V03> STORE_LCL_VAR BB01 regmask=[rcx] minReg=1 singleDefSpill wt=300.00>
<RefPosition #7   @19  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[rcx] minReg=1 spillAfter wt=300.00>
<RefPosition #17  @29  RefTypeUse <Ivl:2 V03> LCL_VAR BB01 regmask=[rdx] minReg=1 last reload wt=300.00>

Active intervals at end of allocation:

-----------------------
RESOLVING BB BOUNDARIES
-----------------------
Resolution Candidates: {V00 V01}
Has No Critical Edges

Prior to Resolution

BB01
use: {V00 V01}
def: {V03}
 in: {V00 V01}
out: {}
Var=Reg beg of BB01: V00=rcx V01=rdx 
Var=Reg end of BB01: none


RESOLVING EDGES
  Set V00 argument initial register to rcx
  Set V01 argument initial register to rdx
Trees after linear scan register allocator (LSRA)

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}
N003 (???,???) [000026] -----------                            IL_OFFSET void   INLRT @ 0x000[E-] REG NA
N005 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 rcx (last use) REG rcx $80
N007 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] REG NA $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N009 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  REG rcx $180
                                                            ┌──▌  t21    byref  
N011 (  3,  3) [000015] DA--G-----z                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1 rcx REG rcx
N013 (???,???) [000027] -----------                            IL_OFFSET void   INLRT @ 0x000[E-] REG NA
N015 (  1,  1) [000010] ----------Z                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 rcx REG rcx $180
                                                            ┌──▌  t10    byref  
N017 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref  REG NA
                                                            ┌──▌  t25    byref  
N019 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    REG r8 <l:$280, c:$281>
                                                            ┌──▌  t11    int    
N021 (???,???) [000028] ---XG------                   t28 = ▌  PUTARG_REG int    REG r8
N023 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 rdx (last use) REG rdx $c0
                                                            ┌──▌  t13    byref  
N025 (???,???) [000029] -----------                   t29 = ▌  PUTARG_REG byref  REG rcx
N027 (  1,  1) [000008] ----------z                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 rdx (last use) REG rdx $180
                                                            ┌──▌  t8     byref  
N029 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    REG rdx <l:$241, c:$242>
                                                            ┌──▌  t9     ref    
N031 (???,???) [000030] ----GO-----                   t30 = ▌  PUTARG_REG ref    REG rdx
N033 (  3, 10) [000031] Hc---------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn REG NA
                                                            ┌──▌  t31    long   
N035 (  5, 12) [000032] -c---------                   t32 = ▌  IND       long   REG NA
                                                            ┌──▌  t28    int    arg2 in r8
                                                            ├──▌  t29    byref  retbuf in rcx
                                                            ├──▌  t30    ref    arg1 in rdx
                                                            ├──▌  t32    long   control expr
N037 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName REG NA $VN.Void

-------------------------------------------------------------------------------------------------------------------

Final allocation
─────────────────────────────────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
LocRP# Name Type  Action    Reg  │rax │rcx │rdx │rbx │rbp │rsi │rdi │r8  │r9  │
─────────────────────────────────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
 0.#0  V0   Parm   Alloc    rcx  │    │V0 a│    │    │    │    │    │    │    │
 0.#1  V1   Parm   Alloc    rdx  │    │V0 a│V1 a│    │    │    │    │    │    │
 1.#2  BB1 PredBB0               │    │V0 a│V1 a│    │    │    │    │    │    │
 9.#3  V0   Use *  Keep     rcx  │    │V0 i│V1 a│    │    │    │    │    │    │
10.#4  I3   Def    Alloc    rcx  │    │I3 a│V1 a│    │    │    │    │    │    │
11.#5  I3   Use *  Keep     rcx  │    │I3 i│V1 a│    │    │    │    │    │    │
12.#6  V3   Def    Alloc    rcx  │    │V3 a│V1 a│    │    │    │    │    │    │
19.#7  V3   Use    Keep     rcx  │    │V3 i│V1 a│    │    │    │    │    │    │
                   Spill    rcx  │    │V3 i│V1 a│    │    │    │    │    │    │
20.#8  I4   Def    Alloc    r8   │    │    │V1 a│    │    │    │    │I4 a│    │
21.#9  r8   Fixd   Keep     r8   │    │    │V1 a│    │    │    │    │I4 a│    │
21.#10 I4   Use *  Keep     r8   │    │    │V1 a│    │    │    │    │I4 i│    │
22.#11 r8   Fixd   Keep     r8   │    │    │V1 a│    │    │    │    │    │    │
22.#12 I5   Def    Alloc    r8   │    │    │V1 a│    │    │    │    │I5 a│    │
25.#13 rcx  Fixd   Keep     rcx  │    │    │V1 a│    │    │    │    │I5 a│    │
25.#14 V1   Use *  Copy     rcx  │    │V1 i│V1 i│    │    │    │    │I5 a│    │
26.#15 rcx  Fixd   Keep     rcx  │    │    │    │    │    │    │    │I5 a│    │
26.#16 I6   Def    Alloc    rcx  │    │I6 a│    │    │    │    │    │I5 a│    │
29.#17 V3   Use *  ReLod    rdx  │    │I6 a│V3 a│    │    │    │    │I5 a│    │
                   Keep     rdx  │    │I6 a│V3 i│    │    │    │    │I5 a│    │
30.#18 I7   Def    Alloc    rdx  │    │I6 a│I7 a│    │    │    │    │I5 a│    │
31.#19 rdx  Fixd   Keep     rdx  │    │I6 a│I7 a│    │    │    │    │I5 a│    │
31.#20 I7   Use *  Keep     rdx  │    │I6 a│I7 i│    │    │    │    │I5 a│    │
32.#21 rdx  Fixd   Keep     rdx  │    │I6 a│    │    │    │    │    │I5 a│    │
32.#22 I8   Def    Alloc    rdx  │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#23 r8   Fixd   Keep     r8   │    │I6 a│I8 a│    │    │    │    │I5 a│    │
37.#24 I5   Use *  Keep     r8   │    │I6 a│I8 a│    │    │    │    │I5 i│    │
37.#25 rcx  Fixd   Keep     rcx  │    │I6 a│I8 a│    │    │    │    │    │    │
37.#26 I6   Use *  Keep     rcx  │    │I6 i│I8 a│    │    │    │    │    │    │
37.#27 rdx  Fixd   Keep     rdx  │    │    │I8 a│    │    │    │    │    │    │
37.#28 I8   Use *  Keep     rdx  │    │    │I8 i│    │    │    │    │    │    │
38.#29 rax  Kill   Keep     rax  │    │    │    │    │    │    │    │    │    │
38.#30 rcx  Kill   Keep     rcx  │    │    │    │    │    │    │    │    │    │
38.#31 rdx  Kill   Keep     rdx  │    │    │    │    │    │    │    │    │    │
38.#32 r8   Kill   Keep     r8   │    │    │    │    │    │    │    │    │    │
38.#33 r9   Kill   Keep     r9   │    │    │    │    │    │    │    │    │    │
38.#34 r10  Kill   Keep     r10  │    │    │    │    │    │    │    │    │    │
38.#35 r11  Kill   Keep     r11  │    │    │    │    │    │    │    │    │    │

Recording the maximum number of concurrent spills:

----------
LSRA Stats
----------
Register selection order: ABCDEFGHIJKLMNOPQ
Total Tracked Vars:  3
Total Reg Cand Vars: 3
Total number of Intervals: 8
Total number of RefPositions: 35
Total Number of spill temps created: 0
..........
BB01 [  100.00]: SpillCount = 1, COVERS = 2, BEST_FIT = 1
..........
Total SpillCount : 1   Weighted: 100.000000
Total CopyReg : 0   Weighted: 0.000000
Total ResolutionMovs : 0   Weighted: 0.000000
Total SplitEdges : 0   Weighted: 0.000000
..........
Total COVERS [# 4] : 2   Weighted: 200.000000
Total BEST_FIT [#11] : 1   Weighted: 100.000000

TUPLE STYLE DUMP WITH REGISTER ASSIGNMENTS
Incoming Parameters:  V00(rcx) V01(rdx)
BB01 [000..00C) (return), preds={} succs={}
=====
  N003.                    IL_OFFSET INLRT @ 0x000[E-]
  N005.                    V00(rcx*)
  N007.                    CNS_INT   8 Fseq[hackishFieldName]
  N009. rcx             =  ADD      ; rcx*
$ N011.                    V03(rcx)R; rcx
  N013.                    IL_OFFSET INLRT @ 0x000[E-]
S N015.                    V03(rcx)
  N017. STK             =  LEA(b+12); rcx
  N019. r8              =  IND      ; STK
  N021. r8              =  PUTARG_REG; r8
  N023.                    V01(rdx*)
  N025. rcx             =  PUTARG_REG; rdx*
  N027.                    V03(rdx*)R
  N029. rdx             =  IND      ; rdx*
  N031. rdx             =  PUTARG_REG; rdx
  N033.                    CNS_INT(h) 0x7ff94f4c9618 ftn
  N035.                    IND      
  N037.                    CALL     ; r8,rcx,rdx
Var=Reg end of BB01: none




*************** Finishing PHASE Linear scan register alloc
Trees after Linear scan register alloc

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

------------ BB01 [000..00C) (return), preds={} succs={}
N003 (???,???) [000026] -----------                            IL_OFFSET void   INLRT @ 0x000[E-] REG NA
N005 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 rcx (last use) REG rcx $80
N007 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] REG NA $140
                                                            ┌──▌  t19    ref    
                                                            ├──▌  t20    long   
N009 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  REG rcx $180
                                                            ┌──▌  t21    byref  
N011 (  3,  3) [000015] DA--G-----z                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1 rcx REG rcx
N013 (???,???) [000027] -----------                            IL_OFFSET void   INLRT @ 0x000[E-] REG NA
N015 (  1,  1) [000010] ----------Z                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 rcx REG rcx $180
                                                            ┌──▌  t10    byref  
N017 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref  REG NA
                                                            ┌──▌  t25    byref  
N019 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    REG r8 <l:$280, c:$281>
                                                            ┌──▌  t11    int    
N021 (???,???) [000028] ---XG------                   t28 = ▌  PUTARG_REG int    REG r8
N023 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 rdx (last use) REG rdx $c0
                                                            ┌──▌  t13    byref  
N025 (???,???) [000029] -----------                   t29 = ▌  PUTARG_REG byref  REG rcx
N027 (  1,  1) [000008] ----------z                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 rdx (last use) REG rdx $180
                                                            ┌──▌  t8     byref  
N029 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    REG rdx <l:$241, c:$242>
                                                            ┌──▌  t9     ref    
N031 (???,???) [000030] ----GO-----                   t30 = ▌  PUTARG_REG ref    REG rdx
N033 (  3, 10) [000031] Hc---------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn REG NA
                                                            ┌──▌  t31    long   
N035 (  5, 12) [000032] -c---------                   t32 = ▌  IND       long   REG NA
                                                            ┌──▌  t28    int    arg2 in r8
                                                            ├──▌  t29    byref  retbuf in rcx
                                                            ├──▌  t30    ref    arg1 in rdx
                                                            ├──▌  t32    long   control expr
N037 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName REG NA $VN.Void

-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid

*************** Starting PHASE Place 'align' instructions

*************** Finishing PHASE Place 'align' instructions [no changes]
*************** In genGenerateCode()

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------

*************** Starting PHASE Generate code
*************** In fgDebugCheckBBlist
Finalizing stack frame
Recording Var Locations at start of BB01
  V00(rcx)  V01(rdx)
Modified regs: [rax rcx rdx r8-r11]
Callee-saved registers pushed: 0 []
*************** In lvaAssignFrameOffsets(FINAL_FRAME_LAYOUT)
Assign V03 tmp1, size=8, stkOffs=-0x10
--- delta bump 8 for RA
--- delta bump 8 for RSP frame
--- virtual stack offset to actual stack offset delta is 16
-- V00 was 0, now 16
-- V01 was 8, now 24
-- V02 was 0, now 16
-- V03 was -16, now 0
; Final local variable assignments
;
;  V00 this         [V00,T01] (  3,  3   )     ref  ->  rcx         this class-hnd single-def
;  V01 RetBuf       [V01,T02] (  3,  3   )   byref  ->  rdx         single-def
;# V02 OutArgs      [V02    ] (  1,  1   )  lclBlk ( 0) [rsp+00H]   "OutgoingArgSpace"
;  V03 tmp1         [V03,T00] (  3,  6   )   byref  ->  [rsp+00H]   spill-single-def "Inlining Arg"
;
; Lcl frame size = 8
Mark labels for codegen
  BB01 : first block
*************** After genMarkLabelsForCodegen()

-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds           weight    lp [IL range]     [jump]      [EH region]         [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000]  1                             1       [000..00C)        (return)                     i label jmp hascall nullcheck LIR 
-----------------------------------------------------------------------------------------------------------------------------------------
Setting stack level from -572662307 to 0

=============== Generating BB01 [000..00C) (return), preds={} succs={} flags=0x00000002.20050420: i label jmp hascall nullcheck LIR 
BB01 IN (2)={V00 V01} + ByrefExposed + GcHeap
     OUT(0)={       }

Recording Var Locations at start of BB01
  V00(rcx)  V01(rdx)
Change life 0000000000000000 {} -> 0000000000000006 {V00 V01}
							V00 in reg rcx is becoming live  [------]
							Live regs: 00000000 {} => 00000002 {rcx}
New debug range: first
							V01 in reg rdx is becoming live  [------]
							Live regs: 00000002 {rcx} => 00000006 {rcx rdx}
New debug range: first
							Live regs: (unchanged) 00000006 {rcx rdx}
							GC regs: (unchanged) 00000002 {rcx}
							Byref regs: (unchanged) 00000004 {rdx}

      L_M28311_BB01:
Mapped BB01 to G_M28311_IG02
Label: IG02, GCvars=0000000000000000 {}, gcrefRegs=00000002 {rcx}, byrefRegs=00000004 {rdx}

Scope info: begin block BB01, IL range [000..00C)
Added IP mapping: 0x0000 STACK_EMPTY (G_M28311_IG02,ins#0,ofs#0) label
Generating: N003 (???,???) [000026] -----------                            IL_OFFSET void   INLRT @ 0x000[E-] REG NA
Generating: N005 (  1,  1) [000019] -----------                   t19 =    LCL_VAR   ref    V00 this         u:1 rcx (last use) REG rcx $80
Generating: N007 (  1,  1) [000020] -c---------                   t20 =    CNS_INT   long   8 Fseq[hackishFieldName] REG NA $140
                                                                        ┌──▌  t19    ref    
                                                                        ├──▌  t20    long   
Generating: N009 (  3,  3) [000021] -----------                   t21 = ▌  ADD       byref  REG rcx $180
							V00 in reg rcx is becoming dead  [000019]
							Live regs: 00000006 {rcx rdx} => 00000004 {rdx}
							Live vars: {V00 V01} => {V01}
							GC regs: 00000002 {rcx} => 00000000 {}
IN0001:        add      rcx, 8
							Byref regs: 00000004 {rdx} => 00000006 {rcx rdx}
                                                                        ┌──▌  t21    byref  
Generating: N011 (  3,  3) [000015] DA--G-----z                         ▌  STORE_LCL_VAR byref  V03 tmp1         d:1 rcx REG rcx
							Byref regs: 00000006 {rcx rdx} => 00000004 {rdx}
IN0002:        mov      bword ptr [V03 rsp], rcx
							V03 in reg rcx is becoming live  [000015]
							Live regs: 00000004 {rdx} => 00000006 {rcx rdx}
							Live vars: {V01} => {V01 V03}
							GCvars: {} => {V03}
							Byref regs: 00000004 {rdx} => 00000006 {rcx rdx}
genIPmappingAdd: ignoring duplicate IL offset 0x0
Generating: N013 (???,???) [000027] -----------                            IL_OFFSET void   INLRT @ 0x000[E-] REG NA
Generating: N015 (  1,  1) [000010] ----------Z                   t10 =    LCL_VAR   byref  V03 tmp1         u:1 rcx REG rcx $180
                                                                        ┌──▌  t10    byref  
Generating: N017 (  2,  2) [000025] -c---------                   t25 = ▌  LEA(b+12) byref  REG NA
                                                                        ┌──▌  t25    byref  
Generating: N019 (  4,  4) [000011] ---XG------                   t11 = ▌  IND       int    REG r8 <l:$280, c:$281>
							V03 in reg rcx is becoming dead  [000010]
							Live regs: 00000006 {rcx rdx} => 00000004 {rdx}
							Byref regs: 00000006 {rcx rdx} => 00000004 {rdx}
							Var V03 continuing live
IN0003:        mov      r8d, dword ptr [rcx+0CH]
                                                                        ┌──▌  t11    int    
Generating: N021 (???,???) [000028] ---XG------                   t28 = ▌  PUTARG_REG int    REG r8
Generating: N023 (  1,  1) [000013] -----------                   t13 =    LCL_VAR   byref  V01 RetBuf       u:1 rdx (last use) REG rdx $c0
                                                                        ┌──▌  t13    byref  
Generating: N025 (???,???) [000029] -----------                   t29 = ▌  PUTARG_REG byref  REG rcx
							V01 in reg rdx is becoming dead  [000013]
							Live regs: 00000004 {rdx} => 00000000 {}
							Live vars: {V01 V03} => {V03}
							Byref regs: 00000004 {rdx} => 00000000 {}
IN0004:        mov      rcx, rdx
							Byref regs: 00000000 {} => 00000002 {rcx}
Generating: N027 (  1,  1) [000008] ----------z                    t8 =    LCL_VAR   byref  V03 tmp1         u:1 rdx (last use) REG rdx $180
                                                                        ┌──▌  t8     byref  
Generating: N029 (  3,  2) [000009] n---GO-----                    t9 = ▌  IND       ref    REG rdx <l:$241, c:$242>
IN0005:        mov      rdx, bword ptr [V03 rsp]
							V03 in reg rdx is becoming live  [000008]
							Live regs: 00000000 {} => 00000004 {rdx}
							Byref regs: 00000002 {rcx} => 00000006 {rcx rdx}
							V03 in reg rdx is becoming dead  [000008]
							Live regs: 00000004 {rdx} => 00000000 {}
							Live vars: {V03} => {}
							GCvars: {V03} => {}
							Byref regs: 00000006 {rcx rdx} => 00000002 {rcx}
IN0006:        mov      rdx, gword ptr [rdx]
							GC regs: 00000000 {} => 00000004 {rdx}
                                                                        ┌──▌  t9     ref    
Generating: N031 (???,???) [000030] ----GO-----                   t30 = ▌  PUTARG_REG ref    REG rdx
							GC regs: 00000004 {rdx} => 00000000 {}
							GC regs: 00000000 {} => 00000004 {rdx}
Generating: N033 (  3, 10) [000031] Hc---------                   t31 =    CNS_INT(h) long   0x7ff94f4c9618 ftn REG NA
                                                                        ┌──▌  t31    long   
Generating: N035 (  5, 12) [000032] -c---------                   t32 = ▌  IND       long   REG NA
                                                                        ┌──▌  t28    int    arg2 in r8
                                                                        ├──▌  t29    byref  retbuf in rcx
                                                                        ├──▌  t30    ref    arg1 in rdx
                                                                        ├──▌  t32    long   control expr
Generating: N037 ( 22, 15) [000012] S-CXGO-----                         ▌  CALL      void   hackishModuleName.hackishMethodName REG NA $VN.Void
							Byref regs: 00000002 {rcx} => 00000000 {}
							GC regs: 00000004 {rdx} => 00000000 {}
Added IP mapping: EPILOG (G_M28311_IG02,ins#6,ofs#22) label
Reserving epilog IG for block BB01

      G_M28311_IG02:        ; offs=000000H, funclet=00, bbWeight=1   , byref
*************** After placeholder IG creation
G_M28311_IG01:        ; func=00, offs=000000H, size=0000H, gcrefRegs=00000000 {} <-- Prolog IG
G_M28311_IG02:        ; offs=000000H, size=0016H, gcrefRegs=00000002 {rcx}, byrefRegs=00000004 {rdx}, BB01 [0000], byref
G_M28311_IG03:        ; epilog placeholder, next placeholder=<END>, BB01 [0000], epilog, extend <-- First placeholder <-- Last placeholder
                      ;   PrevGCVars=0000000000000000 {}, PrevGCrefRegs=00000000 {}, PrevByrefRegs=00000000 {}
                      ;   InitGCVars=0000000000000000 {}, InitGCrefRegs=00000002 {rcx}, InitByrefRegs=00000004 {rdx}

Variable Live Range History Dump for BB01
V00 this: rcx [(G_M28311_IG02,ins#0,ofs#0), (G_M28311_IG02,ins#0,ofs#0)]
V01 RetBuf: rdx [(G_M28311_IG02,ins#0,ofs#0), (G_M28311_IG02,ins#3,ofs#12)]
Liveness not changing: 0000000000000000 {}

# compCycleEstimate =     25, compSizeEstimate =    18 EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
; Final local variable assignments
;
;  V00 this         [V00,T01] (  3,  3   )     ref  ->  rcx         this class-hnd single-def
;  V01 RetBuf       [V01,T02] (  3,  3   )   byref  ->  rdx         single-def
;# V02 OutArgs      [V02    ] (  1,  1   )  lclBlk ( 0) [rsp+00H]   "OutgoingArgSpace"
;  V03 tmp1         [V03,T00] (  3,  6   )   byref  ->  [rsp+00H]   spill-single-def "Inlining Arg"
;
; Lcl frame size = 8
*************** Before prolog / epilog generation
G_M28311_IG01:        ; func=00, offs=000000H, size=0000H, gcrefRegs=00000000 {} <-- Prolog IG
G_M28311_IG02:        ; offs=000000H, size=0016H, gcrefRegs=00000002 {rcx}, byrefRegs=00000004 {rdx}, BB01 [0000], byref
G_M28311_IG03:        ; epilog placeholder, next placeholder=<END>, BB01 [0000], epilog, extend <-- First placeholder <-- Last placeholder
                      ;   PrevGCVars=0000000000000000 {}, PrevGCrefRegs=00000000 {}, PrevByrefRegs=00000000 {}
                      ;   InitGCVars=0000000000000000 {}, InitGCrefRegs=00000002 {rcx}, InitByrefRegs=00000004 {rdx}
Recording Var Locations at start of BB01
  V00(rcx)  V01(rdx)
*************** In genFnProlog()
Added IP mapping to front: PROLOG (G_M28311_IG01,ins#0,ofs#0) label

__prolog:
New debug range: first
New debug range: first
IN0007:        push     rax
*************** In genFnPrologCalleeRegArgs() for int regs
*************** In genEnregisterIncomingStackArgs()
1 tracked GC refs are at stack offsets  0000 ...  0008


      G_M28311_IG01:        ; offs=000000H, funclet=00, bbWeight=1   , byref, nogc
*************** In genFnEpilog()

__epilog:
gcVarPtrSetCur=0000000000000000 {}, gcRegGCrefSetCur=00000002 {rcx}, gcRegByrefSetCur=00000004 {rdx}
IN0008:        add      rsp, 8
							Call: GCvars=0000000000000000 {}, gcrefRegs=00000000 {}, byrefRegs=00000000 {}
IN0009:        tail.jmp [hackishMethodName]

      G_M28311_IG03:        ; offs=000016H, funclet=00, bbWeight=1   , epilog, nogc, extend
0 prologs, 1 epilogs, 0 funclet prologs, 0 funclet epilogs
*************** After prolog / epilog generation
G_M28311_IG01:        ; func=00, offs=000000H, size=0001H, gcrefRegs=00000000 {}, byrefRegs=00000000 {}, byref, nogc <-- Prolog IG
G_M28311_IG02:        ; offs=000001H, size=0016H, gcrefRegs=00000002 {rcx}, byrefRegs=00000004 {rdx}, BB01 [0000], byref
G_M28311_IG03:        ; offs=000017H, size=000AH, epilog, nogc, extend
*************** In emitJumpDistBind()
Emitter Jump List:
  total jump count: 0

*************** Finishing PHASE Generate code

*************** Starting PHASE Emit code

Hot  code size = 0x21 bytes
Cold code size = 0x0 bytes
reserveUnwindInfo(isFunclet=false, isColdCode=false, unwindSize=0x6)
*************** In emitEndCodeGen()
Converting emitMaxStackDepth from bytes (0) to elements (0)

***************************************************************************
Instructions as they come out of the scheduler


G_M28311_IG01:        ; func=00, offs=000000H, size=0001H, gcrefRegs=00000000 {}, byrefRegs=00000000 {}, byref, nogc <-- Prolog IG
IN0007: 000000 50                   push     rax
						;; size=1 bbWeight=1    PerfScore 1.00
G_M28311_IG02:        ; func=00, offs=000001H, size=0016H, gcrefRegs=00000002 {rcx}, byrefRegs=00000004 {rdx}, BB01 [0000], byref
                            ; gcrRegs +[rcx]
                            ; byrRegs +[rdx]
IN0001: 000001 4883C108             add      rcx, 8
                            ; gcrRegs -[rcx]
                            ; byrRegs +[rcx]
IN0002: 000005 48890C24             mov      bword ptr [rsp], rcx
                            ; GC ptr vars +{V03}
IN0003: 000009 448B410C             mov      r8d, dword ptr [rcx+0CH]
IN0004: 00000D 488BCA               mov      rcx, rdx
IN0005: 000010 488B1424             mov      rdx, bword ptr [rsp]
IN0006: 000014 488B12               mov      rdx, gword ptr [rdx]
                            ; gcrRegs +[rdx]
                            ; byrRegs -[rdx]
						;; size=22 bbWeight=1    PerfScore 6.50
G_M28311_IG03:        ; func=00, offs=000017H, size=000AH, epilog, nogc, extend
IN0008: 000017 4883C408             add      rsp, 8
recordRelocation: 000001267BD886DD (rw: 000001267BD886DD) => 00007FF94F4C9618, type 16 (IMAGE_REL_BASED_DISP32), delta 0
IN0009: 00001B FF2500000000         tail.jmp [hackishMethodName]
                            ; gcr arg pop 0
						;; size=10 bbWeight=1    PerfScore 2.25Allocated method code size =   33 , actual size =   33, unused size =    0

; Total bytes of code 33, prolog size 1, PerfScore 13.05, instruction count 9, allocated bytes for code 33 (MethodHash=8ba39168) for method EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
; ============================================================

*************** After end code gen, before unwindEmit()
G_M28311_IG01:        ; func=00, offs=000000H, size=0001H, bbWeight=1    PerfScore 1.00, gcrefRegs=00000000 {}, byrefRegs=00000000 {}, byref, nogc <-- Prolog IG

IN0007: 000000 push     rax

G_M28311_IG02:        ; offs=000001H, size=0016H, bbWeight=1    PerfScore 6.50, gcrefRegs=00000002 {rcx}, byrefRegs=00000004 {rdx}, BB01 [0000], byref

IN0001: 000001 add      rcx, 8
IN0002: 000005 mov      bword ptr [V03 rsp], rcx
IN0003: 000009 mov      r8d, dword ptr [rcx+0CH]
IN0004: 00000D mov      rcx, rdx
IN0005: 000010 mov      rdx, bword ptr [V03 rsp]
IN0006: 000014 mov      rdx, gword ptr [rdx]

G_M28311_IG03:        ; offs=000017H, size=000AH, bbWeight=1    PerfScore 2.25, epilog, nogc, extend

IN0008: 000017 add      rsp, 8
IN0009: 00001B tail.jmp [hackishMethodName]


*************** Finishing PHASE Emit code

*************** Starting PHASE Emit GC+EH tables
Unwind Info:
  >> Start offset   : 0x000000 (not in unwind data)
  >>   End offset   : 0x000021 (not in unwind data)
  Version           : 1
  Flags             : 0x00
  SizeOfProlog      : 0x01
  CountOfUnwindCodes: 1
  FrameRegister     : none (0)
  FrameOffset       : N/A (no FrameRegister) (Value=0)
  UnwindCodes       :
    CodeOffset: 0x01 UnwindOp: UWOP_ALLOC_SMALL (2)     OpInfo: 0 * 8 + 8 = 8 = 0x08
allocUnwindInfo(pHotCode=0x000001267BD886C0, pColdCode=0x0000000000000000, startOffset=0x0, endOffset=0x21, unwindSize=0x6, pUnwindBlock=0x000001267BD902C2, funKind=0 (main function))
*************** In genIPmappingGen()
IP mapping count : 3
IL offs PROLOG : 0x00000000 ( STACK_EMPTY )
IL offs 0x0000 : 0x00000001 ( STACK_EMPTY )
IL offs EPILOG : 0x00000017 ( STACK_EMPTY )

*************** In genSetScopeInfo()
VarLocInfo count is 4
; Variable debug info: 2 live ranges, 1 vars for method EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
  0(   UNKNOWN) : From 00000000h to 00000001h, in rcx
 -2(   retBuff) : From 00000000h to 0000000Dh, in rdx
VARIABLE LIVE RANGES:
V00 this: rcx [1, 1)
V01 RetBuf: rdx [1, D)
*************** In gcInfoBlockHdrSave()
Set code length to 33.
Set ReturnKind to Scalar.
Set Outgoing stack arg area size to 0.
Stack slot id for offset 0 (0x0) (sp) (byref) = 0.
Register slot id for reg rcx = 1.
Register slot id for reg rdx (byref) = 2.
Register slot id for reg rcx (byref) = 3.
Register slot id for reg rdx = 4.
Set state of slot 0 at instr offset 0x9 to Live.
Set state of slot 0 at instr offset 0x21 to Dead.
Set state of slot 1 at instr offset 0x1 to Live.
Set state of slot 2 at instr offset 0x1 to Live.
Set state of slot 1 at instr offset 0x5 to Dead.
Set state of slot 3 at instr offset 0x5 to Live.
Set state of slot 2 at instr offset 0x17 to Dead.
Set state of slot 4 at instr offset 0x17 to Live.
Set state of slot 3 at instr offset 0x21 to Dead.
Set state of slot 4 at instr offset 0x21 to Dead.
Defining interruptible range: [0x1, 0x17).

*************** Finishing PHASE Emit GC+EH tables
Method code size: 33

Allocations for EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this (MethodHash=8ba39168)
count:        493, size:      58694, max =       3072
allocateMemory:      65536, nraUsed:      63808

Alloc'd bytes by kind:
                  kind |       size |     pct
  ---------------------+------------+--------
         AssertionProp |       6628 |  11.29%
               ASTNode |       4448 |   7.58%
              InstDesc |       2508 |   4.27%
              ImpStack |        384 |   0.65%
            BasicBlock |       1144 |   1.95%
              CallArgs |        400 |   0.68%
              FlowList |          0 |   0.00%
     TreeStatementList |          0 |   0.00%
               SiScope |          0 |   0.00%
       DominatorMemory |         96 |   0.16%
                  LSRA |       4452 |   7.59%
         LSRA_Interval |        720 |   1.23%
      LSRA_RefPosition |       2304 |   3.93%
          Reachability |         40 |   0.07%
                   SSA |        320 |   0.55%
           ValueNumber |      10386 |  17.70%
              LvaTable |       2064 |   3.52%
            UnwindInfo |          0 |   0.00%
                hashBv |         40 |   0.07%
                bitset |        120 |   0.20%
          FixedBitVect |         32 |   0.05%
               Generic |       1582 |   2.70%
   LocalAddressVisitor |          0 |   0.00%
         FieldSeqStore |        144 |   0.25%
          MemorySsaMap |         40 |   0.07%
          MemoryPhiArg |          0 |   0.00%
                   CSE |       1384 |   2.36%
                    GC |       2788 |   4.75%
       CorTailCallInfo |          0 |   0.00%
              Inlining |       1496 |   2.55%
            ArrayStack |          0 |   0.00%
             DebugInfo |        224 |   0.38%
             DebugOnly |      12444 |  21.20%
               Codegen |        848 |   1.44%
               LoopOpt |         24 |   0.04%
             LoopClone |          0 |   0.00%
             LoopHoist |          0 |   0.00%
               Unknown |        114 |   0.19%
            RangeCheck |          0 |   0.00%
              CopyProp |        600 |   1.02%
           SideEffects |          0 |   0.00%
       ObjectAllocator |          0 |   0.00%
    VariableLiveRanges |        616 |   1.05%
           ClassLayout |          0 |   0.00%
       TailMergeThrows |          0 |   0.00%
             EarlyProp |         96 |   0.16%
              ZeroInit |        208 |   0.35%
                   Pgo |          0 |   0.00%

****** DONE compiling EnumeratorImpl:get_Current():Microsoft.CodeAnalysis.SyntaxNodeOrToken:this
Using jit(C:\dev\dotnet\runtime3\artifacts\tests\coreclr\windows.x64.Checked\Tests\Core_Root\clrjit.dll) with input (C:\dev\dotnet\spmi\mch\11b4ea58-c400-4c3d-995e-4e2f0676f6e8.windows.x64\libraries.pmi.windows.x64.checked.mch)
 indexCount=1 (78804)
Jit startup took 3.283600ms
Loaded 1  Jitted 1  FailedCompile 0 Excluded 0 Missing 0
Total time: 97.017300ms