Skip to content

Instantly share code, notes, and snippets.

@TIHan

TIHan/gist:50701d8d8ae801a008d63f99c9745623

Created November 10, 2022 20:46
Show Gist options
  • Star 0 You must be signed in to star a gist
  • Fork 0 You must be signed in to fork a gist
  • Save TIHan/50701d8d8ae801a008d63f99c9745623 to your computer and use it in GitHub Desktop.
Save TIHan/50701d8d8ae801a008d63f99c9745623 to your computer and use it in GitHub Desktop.
Download ZIP
Before Dump on IsBuffering
Raw
gistfile1.txt
****** START compiling B:get_IsBuffering():bool:this (MethodHash=30e43e07)
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 PGO data
IL to import:
IL_0000 02 ldarg.0
IL_0001 28 06 00 00 06 call 0x6000006
IL_0006 0a stloc.0
IL_0007 17 ldc.i4.1
IL_0008 0b stloc.1
IL_0009 12 00 ldloca.s 0x0
IL_000b 28 11 00 00 0a call 0xA000011
IL_0010 07 ldloc.1
IL_0011 fe 01 ceq
IL_0013 12 00 ldloca.s 0x0
IL_0015 28 12 00 00 0a call 0xA000012
IL_001a 5f and
IL_001b 2a ret
lvaSetClass: setting class for V00 to (00000000D1FFAB1E) B
'this' passed in register rcx
lvaGrabTemp returning 3 (V03 tmp0) (a long lifetime temp) called for OutgoingArgSpace.
; Initial local variable assignments
;
; V00 this ref this class-hnd
; V01 loc0 struct <System.Nullable`1[XY], 8>
; V02 loc1 int
; V03 OutArgs lclBlk <na> "OutgoingArgSpace"
*************** In compInitDebuggingInfo() for B:get_IsBuffering():bool:this
getVars() returned cVars = 0, extendOthers = true
info.compVarScopesCount = 3
VarNum LVNum Name Beg End
0: 00h 00h V00 this 000h 01Ch
1: 01h 01h V01 loc0 000h 01Ch
2: 02h 02h V02 loc1 000h 01Ch
info.compStmtOffsetsCount = 0
info.compStmtOffsetsImplicit = 0005h ( STACK_EMPTY CALL_SITE )
*************** In fgFindBasicBlocks() for B:get_IsBuffering():bool:this
Marked V02 as a single def local
Jump targets:
none
New Basic Block BB01 [0000] created.
BB01 [000..01C)
IL Code Size,Instr 28, 13, Basic Block count 1, Local Variable Num,Ref count 4, 6 for method B:get_IsBuffering():bool:this
OPTIONS: opts.MinOpts() == false
Basic block list for 'B:get_IsBuffering():bool:this'
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000] 1 1 [000..01C) (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..01C) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (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 B:get_IsBuffering():bool:this
impImportBlockPending for BB01
Importing BB01 (PC=000) of 'B:get_IsBuffering():bool:this'
[ 0] 0 (0x000) ldarg.0
[ 1] 1 (0x001) call 06000006
In Compiler::impImportCall: opcode is call, kind=0, callRetType is struct, structSize is 8
INLINER: during 'impMarkInlineCandidate' result 'failed this callee' reason 'noinline per IL/cached result' for 'B:get_IsBuffering():bool:this' calling 'A:get_XYValue():System.Nullable`1[int]:this'
INLINER: during 'impMarkInlineCandidate' result 'failed this callee' reason 'noinline per IL/cached result'
[ 1] 6 (0x006) stloc.0
STMT00000 ( 0x000[E-] ... ??? )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
[ 0] 7 (0x007) ldc.i4.1 1
[ 1] 8 (0x008) stloc.1
STMT00001 ( 0x007[E-] ... ??? )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
[ 0] 9 (0x009) ldloca.s 0
[ 1] 11 (0x00b) call 0A000011
In Compiler::impImportCall: opcode is call, kind=0, callRetType is int, structSize is 0
INLINER: during 'impMarkInlineCandidate' result 'CheckCanInline Success' reason 'CheckCanInline Success' for 'B:get_IsBuffering():bool:this' calling 'System.Nullable`1[int]:GetValueOrDefault():int:this'
INLINER: during 'impMarkInlineCandidate' result 'CheckCanInline Success' reason 'CheckCanInline Success'
STMT00002 ( 0x009[E-] ... ??? )
[000010] I-C-G------ * CALL int System.Nullable`1[XY][XY].GetValueOrDefault (exactContextHnd=0x00000000D1FFAB1E)
[000009] ----------- this \--* ADDR byref
[000008] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[ 1] 16 (0x010) ldloc.1
[ 2] 17 (0x011) ceq
[ 1] 19 (0x013) ldloca.s 0
[ 2] 21 (0x015) call 0A000012
In Compiler::impImportCall: opcode is call, kind=0, callRetType is bool, structSize is 0
INLINER: during 'impMarkInlineCandidate' result 'CheckCanInline Success' reason 'CheckCanInline Success' for 'B:get_IsBuffering():bool:this' calling 'System.Nullable`1[int]:get_HasValue():bool:this'
INLINER: during 'impMarkInlineCandidate' result 'CheckCanInline Success' reason 'CheckCanInline Success'
lvaGrabTemp returning 4 (V04 tmp1) called for impAppendStmt.
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000011] --C-------- +--* RET_EXPR int (for [000010])
[000012] ----------- \--* LCL_VAR int V02 loc1
STMT00003 ( 0x009[E-] ... ??? )
[000016] I-C-G------ * CALL int System.Nullable`1[XY][XY].get_HasValue (exactContextHnd=0x00000000D1FFAB1E)
[000015] ----------- this \--* ADDR byref
[000014] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[ 2] 26 (0x01a) and
[ 1] 27 (0x01b) ret
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000020] --C-------- \--* RET_EXPR int (for [000016])
*************** Finishing PHASE Importation
Trees after Importation
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000] 1 1 [000..01C) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
***** BB01
STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
***** BB01
STMT00002 ( 0x009[E-] ... 0x01B )
[000010] I-C-G------ * CALL int System.Nullable`1[XY][XY].GetValueOrDefault (exactContextHnd=0x00000000D1FFAB1E)
[000009] ----------- this \--* ADDR byref
[000008] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
***** BB01
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000011] --C-------- +--* RET_EXPR int (for [000010])
[000012] ----------- \--* LCL_VAR int V02 loc1
***** BB01
STMT00003 ( 0x009[E-] ... ??? )
[000016] I-C-G------ * CALL int System.Nullable`1[XY][XY].get_HasValue (exactContextHnd=0x00000000D1FFAB1E)
[000015] ----------- this \--* ADDR byref
[000014] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
***** BB01
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000020] --C-------- \--* RET_EXPR int (for [000016])
-------------------------------------------------------------------------------------------------------------------
*************** 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
INLINER: during 'fgNoteNonInlineCandidate' result 'failed this callee' reason 'noinline per IL/cached result' for 'B:get_IsBuffering():bool:this' calling 'A:get_XYValue():System.Nullable`1[int]:this'
INLINER: during 'fgNoteNonInlineCandidate' result 'failed this callee' reason 'noinline per IL/cached result'
Expanding INLINE_CANDIDATE in statement STMT00002 in BB01:
STMT00002 ( 0x009[E-] ... 0x01B )
[000010] I-C-G------ * CALL int System.Nullable`1[XY][XY].GetValueOrDefault (exactContextHnd=0x00000000D1FFAB1E)
[000009] ----------- this \--* ADDR byref
[000008] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
thisArg: is a constant or invariant is byref to a struct local
[000009] ----------- * ADDR byref
[000008] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
INLINER: inlineInfo.tokenLookupContextHandle for System.Nullable`1[int]:GetValueOrDefault():int:this set to 0x00000000D1FFAB1E:
Invoking compiler for the inlinee method System.Nullable`1[int]:GetValueOrDefault():int:this :
IL to import:
IL_0000 02 ldarg.0
IL_0001 7b 09 06 00 0a ldfld 0xA000609
IL_0006 2a ret
INLINER impTokenLookupContextHandle for System.Nullable`1[int]:GetValueOrDefault():int:this is 0x00000000D1FFAB1E.
*************** In compInitDebuggingInfo() for System.Nullable`1[int]:GetValueOrDefault():int:this
info.compStmtOffsetsCount = 0
info.compStmtOffsetsImplicit = 0005h ( STACK_EMPTY CALL_SITE )
*************** In fgFindBasicBlocks() for System.Nullable`1[int]:GetValueOrDefault():int:this
Jump targets:
none
New Basic Block BB02 [0001] created.
BB02 [000..007)
Basic block list for 'System.Nullable`1[int]:GetValueOrDefault():int:this'
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB02 [0001] 1 1 [000..007) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
*************** Inline @[000010] Starting PHASE Pre-import
*************** Inline @[000010] 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..007) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB02 [000..007) (return), preds={} succs={}
-------------------------------------------------------------------------------------------------------------------
*************** Inline @[000010] 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 @[000010] 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..007) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB02 [000..007) (return), preds={} succs={}
-------------------------------------------------------------------------------------------------------------------
*************** Inline @[000010] Starting PHASE Importation
*************** In impImport() for System.Nullable`1[int]:GetValueOrDefault():int:this
impImportBlockPending for BB02
Importing BB02 (PC=000) of 'System.Nullable`1[int]:GetValueOrDefault():int:this'
[ 0] 0 (0x000) ldarg.0
[ 1] 1 (0x001) ldfld 0A000609
[ 1] 6 (0x006) ret
Inlinee Return expression (before normalization) =>
[000025] ----------- * FIELD int value
[000023] ----------- \--* ADDR byref
[000024] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
Inlinee Return expression (after normalization) =>
[000025] ----------- * FIELD int value
[000023] ----------- \--* ADDR byref
[000024] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
** Note: inlinee IL was partially imported -- imported 0 of 7 bytes of method IL
*************** Inline @[000010] Finishing PHASE Importation
Trees after Importation
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB02 [0001] 1 1 [000..007) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB02 [000..007) (return), preds={} succs={}
-------------------------------------------------------------------------------------------------------------------
*************** Inline @[000010] Starting PHASE Expand patchpoints
-- no patchpoints to transform
*************** Inline @[000010] Finishing PHASE Expand patchpoints [no changes]
*************** Inline @[000010] Starting PHASE Indirect call transform
-- no candidates to transform
*************** Inline @[000010] Finishing PHASE Indirect call transform [no changes]
*************** Inline @[000010] Starting PHASE Post-import
*************** Inline @[000010] Finishing PHASE Post-import [no changes]
----------- Statements (and blocks) added due to the inlining of call [000010] -----------
Arguments setup:
Inlinee method body:fgInlineAppendStatements: no gc ref inline locals.
Successfully inlined System.Nullable`1[int]:GetValueOrDefault():int:this (7 IL bytes) (depth 1) [below ALWAYS_INLINE size]
--------------------------------------------------------------------------------------------
INLINER: during 'fgInline' result 'success' reason 'below ALWAYS_INLINE size' for 'B:get_IsBuffering():bool:this' calling 'System.Nullable`1[int]:GetValueOrDefault():int:this'
INLINER: during 'fgInline' result 'success' reason 'below ALWAYS_INLINE size'
Replacing the return expression placeholder [000011] with [000025]
[000011] --C-------- * RET_EXPR int (for [000010]) -> [000025]
Inserting the inline return expression
[000025] ----------- * FIELD int value
[000023] ----------- \--* ADDR byref
[000024] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
Expanding INLINE_CANDIDATE in statement STMT00003 in BB01:
STMT00003 ( 0x009[E-] ... ??? )
[000016] I-C-G------ * CALL int System.Nullable`1[XY][XY].get_HasValue (exactContextHnd=0x00000000D1FFAB1E)
[000015] ----------- this \--* ADDR byref
[000014] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
thisArg: is a constant or invariant is byref to a struct local
[000015] ----------- * ADDR byref
[000014] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
INLINER: inlineInfo.tokenLookupContextHandle for System.Nullable`1[int]:get_HasValue():bool:this set to 0x00000000D1FFAB1E:
Invoking compiler for the inlinee method System.Nullable`1[int]:get_HasValue():bool:this :
IL to import:
IL_0000 02 ldarg.0
IL_0001 7b 0a 06 00 0a ldfld 0xA00060A
IL_0006 2a ret
INLINER impTokenLookupContextHandle for System.Nullable`1[int]:get_HasValue():bool:this is 0x00000000D1FFAB1E.
*************** In compInitDebuggingInfo() for System.Nullable`1[int]:get_HasValue():bool:this
info.compStmtOffsetsCount = 0
info.compStmtOffsetsImplicit = 0005h ( STACK_EMPTY CALL_SITE )
*************** In fgFindBasicBlocks() for System.Nullable`1[int]:get_HasValue():bool:this
Jump targets:
none
New Basic Block BB03 [0002] created.
BB03 [000..007)
Basic block list for 'System.Nullable`1[int]:get_HasValue():bool:this'
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB03 [0002] 1 1 [000..007) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
*************** Inline @[000016] Starting PHASE Pre-import
*************** Inline @[000016] Finishing PHASE Pre-import
Trees after Pre-import
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB03 [0002] 1 1 [000..007) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB03 [000..007) (return), preds={} succs={}
-------------------------------------------------------------------------------------------------------------------
*************** Inline @[000016] 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 @[000016] Finishing PHASE Profile incorporation
Trees after Profile incorporation
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB03 [0002] 1 1 [000..007) (return)
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB03 [000..007) (return), preds={} succs={}
-------------------------------------------------------------------------------------------------------------------
*************** Inline @[000016] Starting PHASE Importation
*************** In impImport() for System.Nullable`1[int]:get_HasValue():bool:this
impImportBlockPending for BB03
Importing BB03 (PC=000) of 'System.Nullable`1[int]:get_HasValue():bool:this'
[ 0] 0 (0x000) ldarg.0
[ 1] 1 (0x001) ldfld 0A00060A
[ 1] 6 (0x006) ret
Inlinee Return expression (before normalization) =>
[000029] ----------- * FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
Inlinee Return expression (after normalization) =>
[000029] ----------- * FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
** Note: inlinee IL was partially imported -- imported 0 of 7 bytes of method IL
*************** Inline @[000016] Finishing PHASE Importation
Trees after Importation
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB03 [0002] 1 1 [000..007) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB03 [000..007) (return), preds={} succs={}
-------------------------------------------------------------------------------------------------------------------
*************** Inline @[000016] Starting PHASE Expand patchpoints
-- no patchpoints to transform
*************** Inline @[000016] Finishing PHASE Expand patchpoints [no changes]
*************** Inline @[000016] Starting PHASE Indirect call transform
-- no candidates to transform
*************** Inline @[000016] Finishing PHASE Indirect call transform [no changes]
*************** Inline @[000016] Starting PHASE Post-import
*************** Inline @[000016] Finishing PHASE Post-import [no changes]
----------- Statements (and blocks) added due to the inlining of call [000016] -----------
Arguments setup:
Inlinee method body:fgInlineAppendStatements: no gc ref inline locals.
Successfully inlined System.Nullable`1[int]:get_HasValue():bool:this (7 IL bytes) (depth 1) [below ALWAYS_INLINE size]
--------------------------------------------------------------------------------------------
INLINER: during 'fgInline' result 'success' reason 'below ALWAYS_INLINE size' for 'B:get_IsBuffering():bool:this' calling 'System.Nullable`1[int]:get_HasValue():bool:this'
INLINER: during 'fgInline' result 'success' reason 'below ALWAYS_INLINE size'
Replacing the return expression placeholder [000020] with [000029]
[000020] --C-------- * RET_EXPR int (for [000016]) -> [000029]
Inserting the inline return expression
[000029] ----------- * FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
**************** Inline Tree
Inlines into 06000008 [via ExtendedDefaultPolicy] B:get_IsBuffering():bool:this:
[INL00 IL=0001 TR=000001 06000006] [FAILED: callee: noinline per IL/cached result] A:get_XYValue():System.Nullable`1[int]:this
[INL01 IL=0011 TR=000010 060017F3] [INLINED: callee: below ALWAYS_INLINE size] System.Nullable`1[int]:GetValueOrDefault():int:this
[INL02 IL=0021 TR=000016 060017F1] [INLINED: callee: below ALWAYS_INLINE size] System.Nullable`1[int]:get_HasValue():bool:this
Budget: initialTime=144, finalTime=116, initialBudget=1440, currentBudget=1440
Budget: initialSize=769, finalSize=769
*************** 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..01C) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
***** BB01
STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
***** BB01
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000025] ----------- +--* FIELD int value
[000023] ----------- | \--* ADDR byref
[000024] -------N--- | \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[000012] ----------- \--* LCL_VAR int V02 loc1
***** BB01
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000029] ----------- \--* FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
-------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (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..01C) (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..01C) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
***** BB01
STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
***** BB01
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000025] ----------- +--* FIELD int value
[000023] ----------- | \--* ADDR byref
[000024] -------N--- | \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
[000012] ----------- \--* LCL_VAR int V02 loc1
***** BB01
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000029] ----------- \--* FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8> V01 loc0
-------------------------------------------------------------------------------------------------------------------
*************** Starting PHASE Tail merge
*************** Finishing PHASE Tail merge [no changes]
*************** 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 loc0 struct <System.Nullable`1[XY], 8> ld-addr-op
; V02 loc1 int
; V03 OutArgs lclBlk <na> "OutgoingArgSpace"
; V04 tmp1 int "impAppendStmt"
Promoting struct local V01 (System.Nullable`1[int]):
lvaGrabTemp returning 5 (V05 tmp2) (a long lifetime temp) called for field V01.hasValue (fldOffset=0x0).
lvaGrabTemp returning 6 (V06 tmp3) (a long lifetime temp) called for field V01.value (fldOffset=0x4).
lvaTable after fgPromoteStructs
; Initial local variable assignments
;
; V00 this ref this class-hnd
; V01 loc0 struct <System.Nullable`1[XY], 8> ld-addr-op
; V02 loc1 int
; V03 OutArgs lclBlk <na> "OutgoingArgSpace"
; V04 tmp1 int "impAppendStmt"
; V05 tmp2 bool V01.hasValue(offs=0x00) P-INDEP "field V01.hasValue (fldOffset=0x0)"
; V06 tmp3 int V01.value(offs=0x04) P-INDEP "field V01.value (fldOffset=0x4)"
*************** Finishing PHASE Morph - Promote Structs
Trees after Morph - Promote Structs
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000] 1 1 [000..01C) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
***** BB01
STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
***** BB01
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000025] ----------- +--* FIELD int value
[000023] ----------- | \--* ADDR byref
[000024] -------N--- | \--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
| \--* bool V01.hasValue (offs=0x00) -> V05 tmp2
| \--* int V01.value (offs=0x04) -> V06 tmp3
[000012] ----------- \--* LCL_VAR int V02 loc1
***** BB01
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000029] ----------- \--* FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
\--* bool V01.hasValue (offs=0x00) -> V05 tmp2
\--* int V01.value (offs=0x04) -> V06 tmp3
-------------------------------------------------------------------------------------------------------------------
*************** Starting PHASE Morph - Structs/AddrExp
LocalAddressVisitor visiting statement:
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
LocalAddressVisitor visiting statement:
STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
LocalAddressVisitor visiting statement:
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000025] ----------- +--* FIELD int value
[000023] ----------- | \--* ADDR byref
[000024] -------N--- | \--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
| \--* bool V01.hasValue (offs=0x00) -> V05 tmp2
| \--* int V01.value (offs=0x04) -> V06 tmp3
[000012] ----------- \--* LCL_VAR int V02 loc1
Replacing the field in promoted struct with local var V06
LocalAddressVisitor modified statement:
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000025] ----------- +--* LCL_VAR int V06 tmp3
[000012] ----------- \--* LCL_VAR int V02 loc1
LocalAddressVisitor visiting statement:
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000029] ----------- \--* FIELD bool hasValue
[000027] ----------- \--* ADDR byref
[000028] -------N--- \--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
\--* bool V01.hasValue (offs=0x00) -> V05 tmp2
\--* int V01.value (offs=0x04) -> V06 tmp3
Replacing the field in promoted struct with local var V05
LocalAddressVisitor modified statement:
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000029] ----------- \--* LCL_VAR bool V05 tmp2
*************** Finishing PHASE Morph - Structs/AddrExp
Trees after Morph - Structs/AddrExp
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000] 1 1 [000..01C) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
***** BB01
STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
***** BB01
STMT00004 ( 0x009[E-] ... ??? )
[000018] -AC-------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] --C-------- \--* EQ int
[000025] ----------- +--* LCL_VAR int V06 tmp3
[000012] ----------- \--* LCL_VAR int V02 loc1
***** BB01
STMT00005 ( ??? ... ??? )
[000022] --C-------- * RETURN int
[000021] --C-------- \--* AND int
[000019] ----------- +--* LCL_VAR int V04 tmp1
[000029] ----------- \--* LCL_VAR bool V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** Starting PHASE Forward Substitution
===> BB01
[000004]: not asg (single-use lcl)
[000007]: [000012] is only use of [000006] (V02) -- fwd subbing [000005]; new next stmt is
STMT00004 ( 0x009[E-] ... ??? )
[000018] -A--------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] ----------- \--* EQ int
[000025] ----------- +--* LCL_VAR int V06 tmp3
[000005] ----------- \--* CNS_INT int 1
removing useless STMT00001 ( 0x007[E-] ... 0x008 )
[000007] -A--------- * ASG int
[000006] D------N--- +--* LCL_VAR int V02 loc1
[000005] ----------- \--* CNS_INT int 1
from BB01
[000004]: not asg (single-use lcl)
[000018]: [000019] is only use of [000017] (V04) -- fwd subbing [000013]; new next stmt is
STMT00005 ( ??? ... ??? )
[000022] ----------- * RETURN int
[000021] ----------- \--* AND int
[000013] ----------- +--* EQ int
[000025] ----------- | +--* LCL_VAR int V06 tmp3
[000005] ----------- | \--* CNS_INT int 1
[000029] ----------- \--* LCL_VAR bool V05 tmp2
removing useless STMT00004 ( 0x009[E-] ... ??? )
[000018] -A--------- * ASG int
[000017] D------N--- +--* LCL_VAR int V04 tmp1
[000013] ----------- \--* EQ int
[000025] ----------- +--* LCL_VAR int V06 tmp3
[000005] ----------- \--* CNS_INT int 1
from BB01
[000004]: not asg (single-use lcl)
*************** Finishing PHASE Forward Substitution
Trees after Forward Substitution
-----------------------------------------------------------------------------------------------------------------------------------------
BBnum BBid ref try hnd preds weight lp [IL range] [jump] [EH region] [flags]
-----------------------------------------------------------------------------------------------------------------------------------------
BB01 [0000] 1 1 [000..01C) (return) i
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
***** BB01
STMT00005 ( ??? ... ??? )
[000022] ----------- * RETURN int
[000021] ----------- \--* AND int
[000013] ----------- +--* EQ int
[000025] ----------- | +--* LCL_VAR int V06 tmp3
[000005] ----------- | \--* CNS_INT int 1
[000029] ----------- \--* LCL_VAR bool V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** Starting PHASE Morph - ByRefs
*************** Finishing PHASE Morph - ByRefs [no changes]
*************** Starting PHASE Morph - Global
*************** In fgMorphBlocks()
Morphing BB01 of 'B:get_IsBuffering():bool:this'
fgMorphTree BB01, STMT00000 (before)
[000004] -AC-G------ * ASG struct (copy)
[000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --C-G------ \--* CALL struct A.get_XYValue
[000000] ----------- this \--* LCL_VAR ref V00 this
Notify VM instruction set (SSE2) must be supported.
Initializing arg info for 1.CALL:
Args for call [000001] CALL after AddFinalArgsAndDetermineABIInfo:
CallArg[[000000].LCL_VAR ref (By value), 1 reg: rcx, byteAlignment=8, wellKnown[ThisPointer]]
Morphing args for 1.CALL:
Sorting the arguments:
Deferred argument ('rcx'):
[000000] -----+----- * LCL_VAR ref V00 this
Moved to late list
Register placement order: rcx
Args for [000001].CALL after fgMorphArgs:
CallArg[[000000].LCL_VAR ref (By value), 1 reg: rcx, byteAlignment=8, isLate, processed, wellKnown[ThisPointer]]
OutgoingArgsStackSize is 32
MorphCopyBlock:
MorphBlock for dst tree, before:
[000002] D----+-N--- * LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
MorphBlock after:
[000002] D----+-N--- * LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
PrepareDst for [000002] have found a local var V01.
MorphBlock for src tree, before:
[000001] --CXG+----- * CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
MorphBlock after:
[000001] --CXG+----- * CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
block assignment to morph:
[000004] -ACXG------ * ASG struct (copy)
[000002] D----+-N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --CXG+----- \--* CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
(m_dstDoFldAsg=true) src is a not an L-value this requires a CopyBlock.
Local V01 should not be enregistered because: written/read in a block op
MorphCopyBlock (after):
[000004] -ACXG------ * ASG struct (copy)
[000002] D----+-N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --CXG+----- \--* CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
fgMorphTree BB01, STMT00005 (before)
[000022] ----------- * RETURN int
[000021] ----------- \--* AND int
[000013] ----------- +--* EQ int
[000025] ----------- | +--* LCL_VAR int V06 tmp3
[000005] ----------- | \--* CNS_INT int 1
[000029] ----------- \--* LCL_VAR bool V05 tmp2
fgMorphTree BB01, STMT00005 (after)
[000022] -----+----- * RETURN int
[000021] -----+----- \--* AND int
[000013] -----+----- +--* EQ int
[000025] -----+----- | +--* LCL_VAR int V06 tmp3
[000005] -----+----- | \--* CNS_INT int 1
[000032] -----+----- \--* CAST int <- bool <- int
[000029] -----+----- \--* LCL_VAR int V05 tmp2
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -ACXG+----- * ASG struct (copy)
[000002] D----+-N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --CXG+----- \--* CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
***** BB01
STMT00005 ( ??? ... ??? )
[000022] -----+----- * RETURN int
[000021] -----+----- \--* AND int
[000013] -----+----- +--* EQ int
[000025] -----+----- | +--* LCL_VAR int V06 tmp3
[000005] -----+----- | \--* CNS_INT int 1
[000032] -----+----- \--* CAST int <- bool <- int
[000029] -----+----- \--* LCL_VAR int V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
-- 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -ACXG+----- * ASG struct (copy)
[000002] D----+-N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --CXG+----- \--* CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
***** BB01
STMT00005 ( ??? ... ??? )
[000022] -----+----- * RETURN int
[000021] -----+----- \--* AND int
[000013] -----+----- +--* EQ int
[000025] -----+----- | +--* LCL_VAR int V06 tmp3
[000005] -----+----- | \--* CNS_INT int 1
[000032] -----+----- \--* CAST int <- bool <- int
[000029] -----+----- \--* LCL_VAR int V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid
*************** Starting PHASE Post-morph tail merge
*************** Finishing PHASE Post-morph tail merge [no changes]
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -ACXG+----- * ASG struct (copy)
[000002] D----+-N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --CXG+----- \--* CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
***** BB01
STMT00005 ( ??? ... ??? )
[000022] -----+----- * RETURN int
[000021] -----+----- \--* AND int
[000013] -----+----- +--* EQ int
[000025] -----+----- | +--* LCL_VAR int V06 tmp3
[000005] -----+----- | \--* CNS_INT int 1
[000032] -----+----- \--* CAST int <- bool <- int
[000029] -----+----- \--* LCL_VAR int V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** 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 )
STMT00000 ( 0x000[E-] ... 0x006 )
[000004] -ACXG+----- * ASG struct (copy)
[000002] D----+-N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
[000001] --CXG+----- \--* CALL struct A.get_XYValue
[000000] -----+----- this in rcx \--* LCL_VAR ref V00 this
New refCnts for V05: refCnt = 1, refCntWtd = 1
New refCnts for V06: refCnt = 1, refCntWtd = 1
New refCnts for V01: refCnt = 1, refCntWtd = 1
New refCnts for V00: refCnt = 1, refCntWtd = 1
STMT00005 ( ??? ... ??? )
[000022] -----+----- * RETURN int
[000021] -----+----- \--* AND int
[000013] -----+----- +--* EQ int
[000025] -----+----- | +--* LCL_VAR int V06 tmp3
[000005] -----+----- | \--* CNS_INT int 1
[000032] -----+----- \--* CAST int <- bool <- int
[000029] -----+----- \--* LCL_VAR int V05 tmp2
New refCnts for V01: refCnt = 2, refCntWtd = 2
New refCnts for V06: refCnt = 2, refCntWtd = 2
New refCnts for V01: refCnt = 3, refCntWtd = 3
New refCnts for V05: refCnt = 2, refCntWtd = 2
*** lvaComputeRefCounts -- implicit counts ***
New refCnts for V00: refCnt = 2, refCntWtd = 2
New refCnts for V00: 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
( 25, 14) [000004] -ACXG---R-- * ASG struct (copy)
( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue
( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this
***** BB01
STMT00005 ( ??? ... ??? )
( 14, 10) [000022] ----------- * RETURN int
( 13, 9) [000021] ----------- \--* AND int
( 8, 4) [000013] ----------- +--* EQ int
( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3
( 1, 1) [000005] ----------- | \--* CNS_INT int 1
( 4, 4) [000032] ----------- \--* CAST int <- bool <- int
( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable
*************** Starting PHASE Set block order
*************** In fgSetBlockOrder()
The biggest BB has 7 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy)
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2
+--* int V01.value (offs=0x04) -> V06 tmp3
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this
***** BB01
STMT00005 ( ??? ... ??? )
N007 ( 14, 10) [000022] ----------- * RETURN int
N006 ( 13, 9) [000021] ----------- \--* AND int
N003 ( 8, 4) [000013] ----------- +--* EQ int
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2
-------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** Exception Handling table is empty
[SsaBuilder] Topologically sorted the graph.
[SsaBuilder::ComputeImmediateDom]
Inside fgBuildDomTree
After computing the Dominance Tree:
*************** In fgLocalVarLiveness()
In fgLocalVarLivenessInit
Local V05 should not be enregistered because: field of a dependently promoted struct
Local V06 should not be enregistered because: field of a dependently promoted struct
Tracked variable (3 out of 7) table:
V00 this [ ref]: refCnt = 3, refCntWtd = 3
V05 tmp2 [ bool]: refCnt = 2, refCntWtd = 2
V06 tmp3 [ int]: refCnt = 2, refCntWtd = 2
*************** In fgPerBlockLocalVarLiveness()
BB01 USE(1)={V00 } + ByrefExposed + GcHeap
DEF(2)={ V05 V06} + ByrefExposed* + GcHeap*
** Memory liveness computed, GcHeap states and ByrefExposed states match
*************** In fgInterBlockLocalVarLiveness()
BB liveness after fgLiveVarAnalysis():
BB01 IN (1)={V00} + ByrefExposed + GcHeap
OUT(0)={ }
*************** In optRemoveRedundantZeroInits()
Marking V01 as having an explicit init
*************** In SsaBuilder::InsertPhiFunctions()
Inserting phi functions:
*************** In SsaBuilder::RenameVariables()
V00.1: defined in BB00 1 uses (global)
V05.1: defined in BB00 0 uses (local)
V05.2: defined in BB01 1 uses (local)
V06.1: defined in BB00 0 uses (local)
V06.2: defined in BB01 1 uses (local)
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy)
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
+--* int V01.value (offs=0x04) -> V06 tmp3 d:2
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this u:1 (last use)
***** BB01
STMT00005 ( ??? ... ??? )
N007 ( 14, 10) [000022] ----------- * RETURN int
N006 ( 13, 9) [000021] ----------- \--* AND int
N003 ( 8, 4) [000013] ----------- +--* EQ int
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3 u:2 (last use)
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2 u:2 (last use)
-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
[info] HasGlobalUse overestimated for V00.1
SSA checks completed successfully
*************** In fgDebugCheckLoopTable
*************** Starting PHASE Early Value Propagation
no arrays or null checks in the method
*************** Finishing PHASE Early Value Propagation [no changes]
*************** Starting PHASE Do value numbering
*************** In fgValueNumber()
Memory Initial Value in BB01 is: $c0
The SSA definition for ByrefExposed (#1) at start of BB01 is $c0 {InitVal($41)}
The SSA definition for GcHeap (#1) at start of BB01 is $c0 {InitVal($41)}
***** BB01, STMT00000(before)
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy)
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
+--* int V01.value (offs=0x04) -> V06 tmp3 d:2
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this u:1 (last use)
N001 [000000] LCL_VAR V00 this u:1 (last use) => $80 {InitVal($40)}
fgCurMemoryVN[GcHeap] assigned for CALL at [000001] to VN: $c1.
N002 [000001] CALL => $100 {MemOpaque:NotInLoop}
N003 [000002] LCL_VAR V01 loc0
bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
int V01.value (offs=0x04) -> V06 tmp3 d:2 => $VN.Void
VNForLoad:
VNForMapPhysicalSelect($100, [0]):bool returns $180 {$100[$140]}
VNForLoad:
VNForMapPhysicalSelect($100, [0]):bool returns $180 {$100[$140]}
Tree [000004] assigned VN to local var V05/2: $180 {$100[$140]}
VNForLoad:
VNForMapPhysicalSelect($100, [4:7]):int returns $1c0 {$100[$141]}
VNForLoad:
VNForMapPhysicalSelect($100, [4:7]):int returns $1c0 {$100[$141]}
Tree [000004] assigned VN to local var V06/2: $1c0 {$100[$141]}
N004 [000004] ASG => $VN.Void
***** BB01, STMT00000(after)
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy) $VN.Void
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
+--* int V01.value (offs=0x04) -> V06 tmp3 d:2 $VN.Void
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue $100
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this u:1 (last use) $80
---------
***** BB01, STMT00005(before)
N007 ( 14, 10) [000022] ----------- * RETURN int
N006 ( 13, 9) [000021] ----------- \--* AND int
N003 ( 8, 4) [000013] ----------- +--* EQ int
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3 u:2 (last use)
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2 u:2 (last use)
N001 [000025] LCL_VAR V06 tmp3 u:2 (last use) => $1c0 {$100[$141]}
N002 [000005] CNS_INT 1 => $42 {IntCns 1}
N003 [000013] EQ => $1c1 {EQ($1c0, $42)}
N004 [000029] LCL_VAR V05 tmp2 u:2 (last use) => $180 {$100[$140]}
N005 [000032] CAST => $1c2 {$180, int <- bool}
N006 [000021] AND => $1c3 {AND($1c1, $1c2)}
N007 [000022] RETURN => $VN.Void
***** BB01, STMT00005(after)
N007 ( 14, 10) [000022] ----------- * RETURN int $VN.Void
N006 ( 13, 9) [000021] ----------- \--* AND int $1c3
N003 ( 8, 4) [000013] ----------- +--* EQ int $1c1
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1 $42
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int $1c2
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2 u:2 (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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy) $VN.Void
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
+--* int V01.value (offs=0x04) -> V06 tmp3 d:2 $VN.Void
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue $100
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this u:1 (last use) $80
***** BB01
STMT00005 ( ??? ... ??? )
N007 ( 14, 10) [000022] ----------- * RETURN int $VN.Void
N006 ( 13, 9) [000021] ----------- \--* AND int $1c3
N003 ( 8, 4) [000013] ----------- +--* EQ int $1c1
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1 $42
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int $1c2
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2 u:2 (last use) $180
-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
[info] HasGlobalUse overestimated for V00.1
SSA checks completed successfully
*************** 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} => {}
Live vars: {} => {V05 V06}
Live vars: {V05 V06} => {V05}
Live vars: {V05} => {}
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy) $VN.Void
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
+--* int V01.value (offs=0x04) -> V06 tmp3 d:2 $VN.Void
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue $100
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this u:1 (last use) $80
***** BB01
STMT00005 ( ??? ... ??? )
N007 ( 14, 10) [000022] ----------- * RETURN int $VN.Void
N006 ( 13, 9) [000021] ----------- \--* AND int $1c3
N003 ( 8, 4) [000013] ----------- +--* EQ int $1c1
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1 $42
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int $1c2
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2 u:2 (last use) $180
-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
[info] HasGlobalUse overestimated for V00.1
SSA checks completed successfully
*************** In fgDebugCheckLoopTable
Disabling SSA checking before assertion prop
*************** Starting PHASE Assertion prop
GenTreeNode creates assertion:
N005 ( 4, 4) [000032] ----------- * CAST int <- bool <- int $1c2
In BB01 New Global Subrange Assertion: ($180,$0) V05.02 in [0..255], index = #01
BB01 valueGen = #NA
BB01:
in = #NA
out = #NA
Propagating #NA for BB01, stmt STMT00000, tree [000000], tree -> #NA
Propagating #NA for BB01, stmt STMT00000, tree [000001], tree -> #NA
Propagating #NA for BB01, stmt STMT00000, tree [000002], tree -> #NA
Propagating #NA for BB01, stmt STMT00000, tree [000004], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000025], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000005], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000013], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000029], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000032], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000021], tree -> #NA
Propagating #NA for BB01, stmt STMT00005, tree [000022], tree -> #NA
*************** Finishing PHASE Assertion prop [no changes]
*************** Starting PHASE If conversion
*************** Finishing PHASE If conversion [no changes]
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
*************** 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..01C) (return) i hascall gcsafe
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
***** BB01
STMT00000 ( 0x000[E-] ... 0x006 )
N004 ( 25, 14) [000004] -ACXG---R-- * ASG struct (copy) $VN.Void
N003 ( 9, 6) [000002] D------N--- +--* LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
+--* bool V01.hasValue (offs=0x00) -> V05 tmp2 d:2
+--* int V01.value (offs=0x04) -> V06 tmp3 d:2 $VN.Void
N002 ( 15, 7) [000001] --CXG------ \--* CALL struct A.get_XYValue $100
N001 ( 1, 1) [000000] ----------- this in rcx \--* LCL_VAR ref V00 this u:1 (last use) $80
***** BB01
STMT00005 ( ??? ... ??? )
N007 ( 14, 10) [000022] ----------- * RETURN int $VN.Void
N006 ( 13, 9) [000021] ----------- \--* AND int $1c3
N003 ( 8, 4) [000013] ----------- +--* EQ int $1c1
N001 ( 3, 2) [000025] ----------- | +--* LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] ----------- | \--* CNS_INT int 1 $42
N005 ( 4, 4) [000032] ----------- \--* CAST int <- bool <- int $1c2
N004 ( 3, 2) [000029] ----------- \--* LCL_VAR int V05 tmp2 u:2 (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)
N004 ( 25, 14) [000004] DACXG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
*************** 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..01C) (return) i hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
[000033] ----------- IL_OFFSET void INLRT @ 0x000[E-]
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref this in rcx
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL struct A.get_XYValue $100
/--* t1 struct
N004 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
N001 ( 3, 2) [000025] ----------- t25 = LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] ----------- t5 = CNS_INT int 1 $42
/--* t25 int
+--* t5 int
N003 ( 8, 4) [000013] ----------- t13 = * EQ int $1c1
N004 ( 3, 2) [000029] ----------- t29 = LCL_VAR int V05 tmp2 u:2 (last use) $180
/--* t29 int
N005 ( 4, 4) [000032] ----------- t32 = * CAST int <- bool <- int $1c2
/--* t13 int
+--* t32 int
N006 ( 13, 9) [000021] ----------- t21 = * AND int $1c3
/--* t21 int
N007 ( 14, 10) [000022] ----------- * RETURN int $VN.Void
-------------------------------------------------------------------------------------------------------------------
*************** In fgDebugCheckBBlist
*************** In fgDebugCheckLoopTable: loop table not valid
*************** Starting PHASE Do 'simple' lowering
Bumping outgoingArgSpaceSize from 0 to 32 for call [000001]
*************** Finishing PHASE Do 'simple' lowering [no changes]
*************** Starting PHASE Lowering nodeinfo
lowering call (before):
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref this in rcx
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL struct A.get_XYValue $100
args:
======
late:
======
lowering arg : N001 ( 1, 1) [000000] ----------- * LCL_VAR ref V00 this u:1 (last use) $80
new node is : [000034] ----------- * PUTARG_REG ref REG rcx
results of lowering call:
N001 ( 3, 10) [000035] H---------- t35 = CNS_INT(h) long 0xd1ffab1e ftn
/--* t35 long
N002 ( 5, 12) [000036] ----------- t36 = * IND long
lowering call (after):
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref
[000034] ----------- t34 = * PUTARG_REG ref REG rcx
N001 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn
/--* t35 long
N002 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue $100
lowering store lcl var/field (before):
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref
[000034] ----------- t34 = * PUTARG_REG ref REG rcx
N001 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn
/--* t35 long
N002 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue $100
/--* t1 long
N004 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
lowering store lcl var/field (after):
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref
[000034] ----------- t34 = * PUTARG_REG ref REG rcx
N001 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn
/--* t35 long
N002 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue $100
/--* t1 long
N004 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
lowering GT_RETURN
N007 ( 14, 10) [000022] ----------- * RETURN int $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..01C) (return) i hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
[000033] ----------- IL_OFFSET void INLRT @ 0x000[E-]
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref
[000034] ----------- t34 = * PUTARG_REG ref REG rcx
N001 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn
/--* t35 long
N002 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue $100
/--* t1 long
N004 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
N001 ( 3, 2) [000025] -c--------- t25 = LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] -c--------- t5 = CNS_INT int 1 $42
/--* t25 int
+--* t5 int
N003 ( 8, 4) [000013] ----------- t13 = * EQ int $1c1
N004 ( 3, 2) [000029] -c--------- t29 = LCL_VAR int V05 tmp2 u:2 (last use) $180
/--* t29 int
N005 ( 4, 4) [000032] ----------- t32 = * CAST int <- bool <- int $1c2
/--* t13 int
+--* t32 int
N006 ( 13, 9) [000021] ----------- t21 = * AND int $1c3
/--* t21 int
N007 ( 14, 10) [000022] ----------- * RETURN int $VN.Void
-------------------------------------------------------------------------------------------------------------------
*** lvaComputeRefCounts ***
*** lvaComputeRefCounts -- explicit counts ***
New refCnts for V00: refCnt = 1, refCntWtd = 1
New refCnts for V05: refCnt = 1, refCntWtd = 1
New refCnts for V06: refCnt = 1, refCntWtd = 1
New refCnts for V01: refCnt = 1, refCntWtd = 1
New refCnts for V01: refCnt = 2, refCntWtd = 2
New refCnts for V06: refCnt = 2, refCntWtd = 2
New refCnts for V01: refCnt = 3, refCntWtd = 3
New refCnts for V05: refCnt = 2, refCntWtd = 2
*** lvaComputeRefCounts -- implicit counts ***
New refCnts for V00: refCnt = 2, refCntWtd = 2
New refCnts for V00: refCnt = 3, refCntWtd = 3
*************** In fgLocalVarLiveness()
; Initial local variable assignments
;
; V00 this ref this class-hnd single-def
; V01 loc0 struct <System.Nullable`1[XY], 8> do-not-enreg[SB] ld-addr-op
; V02 loc1 int
; V03 OutArgs lclBlk <32> "OutgoingArgSpace"
; V04 tmp1 int "impAppendStmt"
; V05 tmp2 bool do-not-enreg[] V01.hasValue(offs=0x00) P-DEP "field V01.hasValue (fldOffset=0x0)"
; V06 tmp3 int do-not-enreg[] V01.value(offs=0x04) P-DEP "field V01.value (fldOffset=0x4)"
In fgLocalVarLivenessInit
Local V05 should not be enregistered because: field of a dependently promoted struct
Local V06 should not be enregistered because: field of a dependently promoted struct
Tracked variable (3 out of 7) table:
V00 this [ ref]: refCnt = 3, refCntWtd = 3
V05 tmp2 [ bool]: refCnt = 2, refCntWtd = 2
V06 tmp3 [ int]: refCnt = 2, refCntWtd = 2
*************** In fgPerBlockLocalVarLiveness()
BB01 USE(1)={V00 } + ByrefExposed + GcHeap
DEF(2)={ V05 V06} + ByrefExposed* + GcHeap*
** Memory liveness computed, GcHeap states and ByrefExposed states match
*************** In fgInterBlockLocalVarLiveness()
BB liveness after fgLiveVarAnalysis():
BB01 IN (1)={V00} + 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..01C) (return) i hascall gcsafe 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 V05: refCnt = 1, refCntWtd = 1
New refCnts for V06: refCnt = 1, refCntWtd = 1
New refCnts for V01: refCnt = 1, refCntWtd = 1
New refCnts for V01: refCnt = 2, refCntWtd = 2
New refCnts for V06: refCnt = 2, refCntWtd = 2
New refCnts for V01: refCnt = 3, refCntWtd = 3
New refCnts for V05: refCnt = 2, refCntWtd = 2
*** lvaComputeRefCounts -- implicit counts ***
New refCnts for V00: refCnt = 2, refCntWtd = 2
New refCnts for V00: 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..01C) (return) i hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
[000033] ----------- IL_OFFSET void INLRT @ 0x000[E-]
N001 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 (last use) $80
/--* t0 ref
[000034] ----------- t34 = * PUTARG_REG ref REG rcx
N001 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn
/--* t35 long
N002 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N002 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue $100
/--* t1 long
N004 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3
N001 ( 3, 2) [000025] -c--------- t25 = LCL_VAR int V06 tmp3 u:2 (last use) $1c0
N002 ( 1, 1) [000005] -c--------- t5 = CNS_INT int 1 $42
/--* t25 int
+--* t5 int
N003 ( 8, 4) [000013] ----------- t13 = * EQ int $1c1
N004 ( 3, 2) [000029] -c--------- t29 = LCL_VAR int V05 tmp2 u:2 (last use) $180
/--* t29 int
N005 ( 4, 4) [000032] ----------- t32 = * CAST int <- bool <- int $1c2
/--* t13 int
+--* t32 int
N006 ( 13, 9) [000021] ----------- t21 = * AND int $1c3
/--* t21 int
N007 ( 14, 10) [000022] ----------- * RETURN int $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}
def: {V05 V06}
in: {V00}
out: {}
Interval 0: ref RefPositions {} physReg:NA Preferences=[allInt]
Interval 0: (V00) ref 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..01C) (return), preds={} succs={}
=====
N000. IL_OFFSET INLRT @ 0x000[E-]
N001. V00(t0*)
N000. t34 = PUTARG_REG; t0*
N001. CNS_INT(h) 0xd1ffab1e ftn
N002. IND
N002. t1 = CALL ; t34
N004. V01 MEM; t1
N001. V06 MEM
N002. CNS_INT 1
N003. t13 = EQ
N004. V05 MEM
N005. t32 = CAST
N006. t21 = AND ; t13,t32
N007. RETURN ; t21
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>
NEW BLOCK BB01
<RefPosition #1 @1 RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
DefList: { }
N003 (???,???) [000033] ----------- * IL_OFFSET void INLRT @ 0x000[E-] REG NA
DefList: { }
N005 ( 1, 1) [000000] ----------- * LCL_VAR ref V00 this u:1 NA (last use) REG NA $80
DefList: { }
N007 (???,???) [000034] ----------- * PUTARG_REG ref REG rcx
<RefPosition #2 @7 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #3 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
Interval 1: ref RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #4 @8 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #5 @8 RefTypeDef <Ivl:1> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
DefList: { N007.t34. PUTARG_REG }
N009 ( 3, 10) [000035] Hc--------- * CNS_INT(h) long 0xd1ffab1e ftn REG NA
Contained
DefList: { N007.t34. PUTARG_REG }
N011 ( 5, 12) [000036] -c--------- * IND long REG NA
Contained
DefList: { N007.t34. PUTARG_REG }
N013 ( 15, 7) [000001] --CXG------ * CALL long A.get_XYValue REG NA $100
<RefPosition #6 @13 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #7 @13 RefTypeUse <Ivl:1> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #8 @14 RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #9 @14 RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #10 @14 RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 wt=100.00>
<RefPosition #11 @14 RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 wt=100.00>
<RefPosition #12 @14 RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 wt=100.00>
<RefPosition #13 @14 RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 wt=100.00>
<RefPosition #14 @14 RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 wt=100.00>
Interval 2: long RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #15 @14 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #16 @14 RefTypeDef <Ivl:2> CALL BB01 regmask=[rax] minReg=1 fixed wt=400.00>
DefList: { N013.t1. CALL }
N015 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0 NA
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3 REG NA
<RefPosition #17 @15 RefTypeUse <Ivl:2> BB01 regmask=[allInt] minReg=1 last wt=100.00>
DefList: { }
N017 ( 3, 2) [000025] -c--------- * LCL_VAR int V06 tmp3 u:2 NA (last use) REG NA $1c0
Contained
DefList: { }
N019 ( 1, 1) [000005] -c--------- * CNS_INT int 1 REG NA $42
Contained
DefList: { }
N021 ( 8, 4) [000013] ----------- * EQ int REG NA $1c1
Interval 3: int RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #18 @22 RefTypeDef <Ivl:3> EQ BB01 regmask=[allInt] minReg=1 wt=400.00>
DefList: { N021.t13. EQ }
N023 ( 3, 2) [000029] -c--------- * LCL_VAR int V05 tmp2 u:2 NA (last use) REG NA $180
Contained
DefList: { N021.t13. EQ }
N025 ( 4, 4) [000032] ----------- * CAST int <- bool <- int REG NA $1c2
Interval 4: int RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #19 @26 RefTypeDef <Ivl:4> CAST BB01 regmask=[allInt] minReg=1 wt=400.00>
DefList: { N021.t13. EQ; N025.t32. CAST }
N027 ( 13, 9) [000021] ----------- * AND int REG NA $1c3
<RefPosition #20 @27 RefTypeUse <Ivl:3> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #21 @27 RefTypeUse <Ivl:4> BB01 regmask=[allInt] minReg=1 last wt=100.00>
Interval 5: int RefPositions {} physReg:NA Preferences=[allInt]
<RefPosition #22 @28 RefTypeDef <Ivl:5> AND BB01 regmask=[allInt] minReg=1 wt=400.00>
Assigning related <I5> to <I3>
Assigning related <I5> to <I4>
DefList: { N027.t21. AND }
N029 ( 14, 10) [000022] ----------- * RETURN int REG NA $VN.Void
<RefPosition #23 @29 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #24 @29 RefTypeUse <Ivl:5> BB01 regmask=[rax] minReg=1 last fixed wt=100.00>
CHECKING LAST USES for BB01, liveout={}
==============================
use: {V00}
def: {V05 V06}
Linear scan intervals BEFORE VALIDATING INTERVALS:
Interval 0: (V00) ref RefPositions {#0@0 #3@7} physReg:rcx Preferences=[rcx]
Interval 1: ref RefPositions {#5@8 #7@13} physReg:NA Preferences=[rcx]
Interval 2: long RefPositions {#16@14 #17@15} physReg:NA Preferences=[rax]
Interval 3: int RefPositions {#18@22 #20@27} physReg:NA Preferences=[allInt] RelatedInterval <I5>
Interval 4: int RefPositions {#19@26 #21@27} physReg:NA Preferences=[allInt] RelatedInterval <I5>
Interval 5: int RefPositions {#22@28 #24@29} physReg:NA Preferences=[rax]
------------
REFPOSITIONS BEFORE VALIDATING INTERVALS:
------------
<RefPosition #0 @0 RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #1 @1 RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
<RefPosition #2 @7 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #3 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
<RefPosition #4 @8 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #5 @8 RefTypeDef <Ivl:1> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
<RefPosition #6 @13 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #7 @13 RefTypeUse <Ivl:1> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #8 @14 RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #9 @14 RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #10 @14 RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #11 @14 RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 last wt=100.00>
<RefPosition #12 @14 RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 last wt=100.00>
<RefPosition #13 @14 RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 last wt=100.00>
<RefPosition #14 @14 RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 last wt=100.00>
<RefPosition #15 @14 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #16 @14 RefTypeDef <Ivl:2> CALL BB01 regmask=[rax] minReg=1 fixed wt=400.00>
<RefPosition #17 @15 RefTypeUse <Ivl:2> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #18 @22 RefTypeDef <Ivl:3> EQ BB01 regmask=[allInt] minReg=1 wt=400.00>
<RefPosition #19 @26 RefTypeDef <Ivl:4> CAST BB01 regmask=[allInt] minReg=1 wt=400.00>
<RefPosition #20 @27 RefTypeUse <Ivl:3> BB01 regmask=[allInt] minReg=1 last regOptional wt=100.00>
<RefPosition #21 @27 RefTypeUse <Ivl:4> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #22 @28 RefTypeDef <Ivl:5> AND BB01 regmask=[rax] minReg=1 wt=400.00>
<RefPosition #23 @29 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #24 @29 RefTypeUse <Ivl:5> BB01 regmask=[rax] minReg=1 last fixed wt=100.00>
------------
REFPOSITIONS DURING VALIDATE INTERVALS (RefPositions per interval)
------------
-----------------
<RefPosition #0 @0 RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #3 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
TUPLE STYLE DUMP WITH REF POSITIONS
Incoming Parameters: V00
BB01 [000..01C) (return), preds={} succs={}
=====
N003. IL_OFFSET INLRT @ 0x000[E-]
N005. V00(L0)
N007. PUTARG_REG
Use:<V00/L0>(#3) Fixed:rcx(#2) *
Def:<I1>(#5) rcx
N009. CNS_INT(h) 0xd1ffab1e ftn
N011. IND
N013. CALL
Use:<I1>(#7) Fixed:rcx(#6) *
Kill: rax rcx rdx r8 r9 r10 r11
Def:<I2>(#16) rax
N015. V01 MEM
Use:<I2>(#17) *
N017. V06 MEM
N019. CNS_INT 1
N021. EQ
Def:<I3>(#18) Pref:<I5>
N023. V05 MEM
N025. CAST
Def:<I4>(#19) Pref:<I5>
N027. AND
Use:<I3>(#20) *
Use:<I4>(#21) *
Def:<I5>(#22)
N029. RETURN
Use:<I5>(#24) Fixed:rax(#23) *
Linear scan intervals after buildIntervals:
Interval 0: (V00) ref RefPositions {#0@0 #3@7} physReg:rcx Preferences=[rcx]
Interval 1: ref RefPositions {#5@8 #7@13} physReg:NA Preferences=[rcx]
Interval 2: long RefPositions {#16@14 #17@15} physReg:NA Preferences=[rax]
Interval 3: int RefPositions {#18@22 #20@27} physReg:NA Preferences=[allInt] RelatedInterval <I5>
Interval 4: int RefPositions {#19@26 #21@27} physReg:NA Preferences=[allInt] RelatedInterval <I5>
Interval 5: int RefPositions {#22@28 #24@29} physReg:NA Preferences=[rax]
*************** In LinearScan::allocateRegisters()
Linear scan intervals before allocateRegisters:
Interval 0: (V00) ref RefPositions {#0@0 #3@7} physReg:rcx Preferences=[rcx]
Interval 1: ref RefPositions {#5@8 #7@13} physReg:NA Preferences=[rcx]
Interval 2: long RefPositions {#16@14 #17@15} physReg:NA Preferences=[rax]
Interval 3: int RefPositions {#18@22 #20@27} physReg:NA Preferences=[allInt] RelatedInterval <I5>
Interval 4: int RefPositions {#19@26 #21@27} physReg:NA Preferences=[allInt] RelatedInterval <I5>
Interval 5: int RefPositions {#22@28 #24@29} physReg:NA Preferences=[rax]
------------
REFPOSITIONS BEFORE ALLOCATION:
------------
<RefPosition #0 @0 RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #1 @1 RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
<RefPosition #2 @7 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #3 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
<RefPosition #4 @8 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #5 @8 RefTypeDef <Ivl:1> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
<RefPosition #6 @13 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #7 @13 RefTypeUse <Ivl:1> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #8 @14 RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #9 @14 RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #10 @14 RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #11 @14 RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 last wt=100.00>
<RefPosition #12 @14 RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 last wt=100.00>
<RefPosition #13 @14 RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 last wt=100.00>
<RefPosition #14 @14 RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 last wt=100.00>
<RefPosition #15 @14 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #16 @14 RefTypeDef <Ivl:2> CALL BB01 regmask=[rax] minReg=1 fixed wt=400.00>
<RefPosition #17 @15 RefTypeUse <Ivl:2> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #18 @22 RefTypeDef <Ivl:3> EQ BB01 regmask=[allInt] minReg=1 wt=400.00>
<RefPosition #19 @26 RefTypeDef <Ivl:4> CAST BB01 regmask=[allInt] minReg=1 wt=400.00>
<RefPosition #20 @27 RefTypeUse <Ivl:3> BB01 regmask=[allInt] minReg=1 last regOptional wt=100.00>
<RefPosition #21 @27 RefTypeUse <Ivl:4> BB01 regmask=[allInt] minReg=1 last wt=100.00>
<RefPosition #22 @28 RefTypeDef <Ivl:5> AND BB01 regmask=[rax] minReg=1 wt=400.00>
<RefPosition #23 @29 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #24 @29 RefTypeUse <Ivl:5> BB01 regmask=[rax] minReg=1 last fixed 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 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
--- V01
--- V02
--- V03
--- V04
--- V05
--- V06
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.
------------------------------------------+----+----+----+----+----+----+----+----+----+
TreeID LocRP# Name Type Action Reg |rax |rcx |rdx |rbx |rbp |rsi |rdi |r8 |r9 |
------------------------------------------+----+----+----+----+----+----+----+----+----+
| |V0 a| | | | | | | |
0.#0 V0 Parm Keep rcx | |V0 a| | | | | | | |
1.#1 BB1 PredBB0 | |V0 a| | | | | | | |
[000034] 7.#2 rcx Fixd Keep rcx | |V0 a| | | | | | | |
7.#3 V0 Use * Keep rcx | |V0 a| | | | | | | |
8.#4 rcx Fixd Keep rcx | | | | | | | | | |
8.#5 I1 Def Alloc rcx | |I1 a| | | | | | | |
[000001] 13.#6 rcx Fixd Keep rcx | |I1 a| | | | | | | |
13.#7 I1 Use * Keep rcx | |I1 a| | | | | | | |
14.#8 rax Kill Keep rax | | | | | | | | | |
14.#9 rcx Kill Keep rcx | | | | | | | | | |
14.#10 rdx Kill Keep rdx | | | | | | | | | |
14.#11 r8 Kill Keep r8 | | | | | | | | | |
14.#12 r9 Kill Keep r9 | | | | | | | | | |
14.#13 r10 Kill Keep r10 | | | | | | | | | |
14.#14 r11 Kill Keep r11 | | | | | | | | | |
14.#15 rax Fixd Keep rax | | | | | | | | | |
14.#16 I2 Def Alloc rax |I2 a| | | | | | | | |
[000004] 15.#17 I2 Use * Keep rax |I2 a| | | | | | | | |
[000013] 22.#18 I3 Def RELPR(A) rax |I3 a| | | | | | | | |
[000032] 26.#19 I4 Def ORDER(A) rdx |I3 a| |I4 a| | | | | | |
[000021] 27.#20 I3 Use * Keep rax |I3 a| |I4 a| | | | | | |
27.#21 I4 Use * Keep rdx |I3 a| |I4 a| | | | | | |
28.#22 I5 Def Alloc rax |I5 a| | | | | | | | |
[000022] 29.#23 rax Fixd Keep rax |I5 a| | | | | | | | |
29.#24 I5 Use * Keep rax | | | | | | | | | |
------------
REFPOSITIONS AFTER ALLOCATION:
------------
<RefPosition #0 @0 RefTypeParamDef <Ivl:0 V00> BB00 regmask=[rcx] minReg=1 fixed regOptional wt=100.00>
<RefPosition #1 @1 RefTypeBB BB01 regmask=[] minReg=1 wt=100.00>
<RefPosition #2 @7 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #3 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
<RefPosition #4 @8 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #5 @8 RefTypeDef <Ivl:1> PUTARG_REG BB01 regmask=[rcx] minReg=1 fixed wt=400.00>
<RefPosition #6 @13 RefTypeFixedReg <Reg:rcx> BB01 regmask=[rcx] minReg=1 wt=100.00>
<RefPosition #7 @13 RefTypeUse <Ivl:1> BB01 regmask=[rcx] minReg=1 last fixed wt=100.00>
<RefPosition #8 @14 RefTypeKill <Reg:rax> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #9 @14 RefTypeKill <Reg:rcx> BB01 regmask=[rcx] minReg=1 last wt=100.00>
<RefPosition #10 @14 RefTypeKill <Reg:rdx> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #11 @14 RefTypeKill <Reg:r8 > BB01 regmask=[r8] minReg=1 last wt=100.00>
<RefPosition #12 @14 RefTypeKill <Reg:r9 > BB01 regmask=[r9] minReg=1 last wt=100.00>
<RefPosition #13 @14 RefTypeKill <Reg:r10> BB01 regmask=[r10] minReg=1 last wt=100.00>
<RefPosition #14 @14 RefTypeKill <Reg:r11> BB01 regmask=[r11] minReg=1 last wt=100.00>
<RefPosition #15 @14 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #16 @14 RefTypeDef <Ivl:2> CALL BB01 regmask=[rax] minReg=1 fixed wt=400.00>
<RefPosition #17 @15 RefTypeUse <Ivl:2> BB01 regmask=[rax] minReg=1 last wt=100.00>
<RefPosition #18 @22 RefTypeDef <Ivl:3> EQ BB01 regmask=[rax] minReg=1 wt=400.00>
<RefPosition #19 @26 RefTypeDef <Ivl:4> CAST BB01 regmask=[rdx] minReg=1 wt=400.00>
<RefPosition #20 @27 RefTypeUse <Ivl:3> BB01 regmask=[rax] minReg=1 last regOptional wt=100.00>
<RefPosition #21 @27 RefTypeUse <Ivl:4> BB01 regmask=[rdx] minReg=1 last wt=100.00>
<RefPosition #22 @28 RefTypeDef <Ivl:5> AND BB01 regmask=[rax] minReg=1 wt=400.00>
<RefPosition #23 @29 RefTypeFixedReg <Reg:rax> BB01 regmask=[rax] minReg=1 wt=100.00>
<RefPosition #24 @29 RefTypeUse <Ivl:5> BB01 regmask=[rax] minReg=1 last fixed 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 @7 RefTypeUse <Ivl:0 V00> LCL_VAR BB01 regmask=[rcx] minReg=1 last fixed wt=300.00>
--- V01
--- V02
--- V03
--- V04
--- V05
--- V06
Active intervals at end of allocation:
-----------------------
RESOLVING BB BOUNDARIES
-----------------------
Resolution Candidates: {V00}
Has No Critical Edges
Prior to Resolution
BB01
use: {V00}
def: {V05 V06}
in: {V00}
out: {}
Var=Reg beg of BB01: V00=rcx
Var=Reg end of BB01: none
RESOLVING EDGES
Set V00 argument initial register to rcx
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..01C) (return) i hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
N003 (???,???) [000033] ----------- IL_OFFSET void INLRT @ 0x000[E-] REG NA
N005 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 rcx (last use) REG rcx $80
/--* t0 ref
N007 (???,???) [000034] ----------- t34 = * PUTARG_REG ref REG rcx
N009 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn REG NA
/--* t35 long
N011 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N013 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue REG rax $100
/--* t1 long
N015 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0 NA
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3 REG NA
N017 ( 3, 2) [000025] -c--------- t25 = LCL_VAR int V06 tmp3 u:2 NA (last use) REG NA $1c0
N019 ( 1, 1) [000005] -c--------- t5 = CNS_INT int 1 REG NA $42
/--* t25 int
+--* t5 int
N021 ( 8, 4) [000013] ----------- t13 = * EQ int REG rax $1c1
N023 ( 3, 2) [000029] -c--------- t29 = LCL_VAR int V05 tmp2 u:2 NA (last use) REG NA $180
/--* t29 int
N025 ( 4, 4) [000032] ----------- t32 = * CAST int <- bool <- int REG rdx $1c2
/--* t13 int
+--* t32 int
N027 ( 13, 9) [000021] ----------- t21 = * AND int REG rax $1c3
/--* t21 int
N029 ( 14, 10) [000022] ----------- * RETURN int REG NA $VN.Void
-------------------------------------------------------------------------------------------------------------------
Final allocation
------------------------------------------+----+----+----+----+----+----+----+----+----+
TreeID LocRP# Name Type Action Reg |rax |rcx |rdx |rbx |rbp |rsi |rdi |r8 |r9 |
------------------------------------------+----+----+----+----+----+----+----+----+----+
0.#0 V0 Parm Alloc rcx | |V0 a| | | | | | | |
1.#1 BB1 PredBB0 | |V0 a| | | | | | | |
[000034] 7.#2 rcx Fixd Keep rcx | |V0 a| | | | | | | |
7.#3 V0 Use * Keep rcx | |V0 i| | | | | | | |
8.#4 rcx Fixd Keep rcx | | | | | | | | | |
8.#5 I1 Def Alloc rcx | |I1 a| | | | | | | |
[000001] 13.#6 rcx Fixd Keep rcx | |I1 a| | | | | | | |
13.#7 I1 Use * Keep rcx | |I1 i| | | | | | | |
14.#8 rax Kill Keep rax | | | | | | | | | |
14.#9 rcx Kill Keep rcx | | | | | | | | | |
14.#10 rdx Kill Keep rdx | | | | | | | | | |
14.#11 r8 Kill Keep r8 | | | | | | | | | |
14.#12 r9 Kill Keep r9 | | | | | | | | | |
14.#13 r10 Kill Keep r10 | | | | | | | | | |
14.#14 r11 Kill Keep r11 | | | | | | | | | |
14.#15 rax Fixd Keep rax | | | | | | | | | |
14.#16 I2 Def Alloc rax |I2 a| | | | | | | | |
[000004] 15.#17 I2 Use * Keep rax |I2 i| | | | | | | | |
[000013] 22.#18 I3 Def Alloc rax |I3 a| | | | | | | | |
[000032] 26.#19 I4 Def Alloc rdx |I3 a| |I4 a| | | | | | |
[000021] 27.#20 I3 Use * Keep rax |I3 i| |I4 a| | | | | | |
27.#21 I4 Use * Keep rdx | | |I4 i| | | | | | |
28.#22 I5 Def Alloc rax |I5 a| | | | | | | | |
[000022] 29.#23 rax Fixd Keep rax |I5 a| | | | | | | | |
29.#24 I5 Use * Keep rax |I5 i| | | | | | | | |
Recording the maximum number of concurrent spills:
----------
LSRA Stats
----------
Register selection order: ABCDEFGHIJKLMNOPQ
Total Tracked Vars: 3
Total Reg Cand Vars: 1
Total number of Intervals: 5
Total number of RefPositions: 24
Total Number of spill temps created: 0
..........
BB01 [ 100.00]: RELATED_PREFERENCE = 1, REG_ORDER = 1
..........
Total SpillCount : 0 Weighted: 0.000000
Total CopyReg : 0 Weighted: 0.000000
Total ResolutionMovs : 0 Weighted: 0.000000
Total SplitEdges : 0 Weighted: 0.000000
..........
Total RELATED_PREFERENCE [# 7] : 1 Weighted: 100.000000
Total REG_ORDER [#13] : 1 Weighted: 100.000000
TUPLE STYLE DUMP WITH REGISTER ASSIGNMENTS
Incoming Parameters: V00(rcx)
BB01 [000..01C) (return), preds={} succs={}
=====
N003. IL_OFFSET INLRT @ 0x000[E-]
N005. V00(rcx*)
N007. rcx = PUTARG_REG; rcx*
N009. CNS_INT(h) 0xd1ffab1e ftn
N011. IND
N013. rax = CALL ; rcx
N015. V01 MEM; rax
N017. V06 MEM
N019. CNS_INT 1
N021. rax = EQ
N023. V05 MEM
N025. rdx = CAST
N027. rax = AND ; rax,rdx
N029. RETURN ; rax
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..01C) (return) i hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
------------ BB01 [000..01C) (return), preds={} succs={}
N003 (???,???) [000033] ----------- IL_OFFSET void INLRT @ 0x000[E-] REG NA
N005 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 rcx (last use) REG rcx $80
/--* t0 ref
N007 (???,???) [000034] ----------- t34 = * PUTARG_REG ref REG rcx
N009 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn REG NA
/--* t35 long
N011 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
N013 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue REG rax $100
/--* t1 long
N015 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0 NA
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3 REG NA
N017 ( 3, 2) [000025] -c--------- t25 = LCL_VAR int V06 tmp3 u:2 NA (last use) REG NA $1c0
N019 ( 1, 1) [000005] -c--------- t5 = CNS_INT int 1 REG NA $42
/--* t25 int
+--* t5 int
N021 ( 8, 4) [000013] ----------- t13 = * EQ int REG rax $1c1
N023 ( 3, 2) [000029] -c--------- t29 = LCL_VAR int V05 tmp2 u:2 NA (last use) REG NA $180
/--* t29 int
N025 ( 4, 4) [000032] ----------- t32 = * CAST int <- bool <- int REG rdx $1c2
/--* t13 int
+--* t32 int
N027 ( 13, 9) [000021] ----------- t21 = * AND int REG rax $1c3
/--* t21 int
N029 ( 14, 10) [000022] ----------- * RETURN int 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..01C) (return) i hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
*************** Starting PHASE Generate code
*************** In fgDebugCheckBBlist
Finalizing stack frame
Recording Var Locations at start of BB01
V00(rcx)
Modified regs: [rax rcx rdx r8-r11]
Callee-saved registers pushed: 0 []
*************** In lvaAssignFrameOffsets(FINAL_FRAME_LAYOUT)
Assign V01 loc0, size=8, stkOffs=-0x10
Assign V03 OutArgs, size=32, stkOffs=-0x30
--- delta bump 8 for RA
--- delta bump 40 for RSP frame
--- virtual stack offset to actual stack offset delta is 48
-- V00 was 0, now 48
-- V01 was -16, now 32
-- V03 was -48, now 0
Adjusting offset of dependent V05 of V01: parent 32 field 0 net 32
Adjusting offset of dependent V06 of V01: parent 32 field 4 net 36
; Final local variable assignments
;
; V00 this [V00,T00] ( 3, 3 ) ref -> rcx this class-hnd single-def
; V01 loc0 [V01 ] ( 3, 3 ) struct ( 8) [rsp+20H] do-not-enreg[SB] ld-addr-op
;* V02 loc1 [V02 ] ( 0, 0 ) int -> zero-ref
; V03 OutArgs [V03 ] ( 1, 1 ) lclBlk (32) [rsp+00H] "OutgoingArgSpace"
;* V04 tmp1 [V04 ] ( 0, 0 ) int -> zero-ref "impAppendStmt"
; V05 tmp2 [V05,T01] ( 2, 2 ) bool -> [rsp+20H] do-not-enreg[] V01.hasValue(offs=0x00) P-DEP "field V01.hasValue (fldOffset=0x0)"
; V06 tmp3 [V06,T02] ( 2, 2 ) int -> [rsp+24H] do-not-enreg[] V01.value(offs=0x04) P-DEP "field V01.value (fldOffset=0x4)"
;
; Lcl frame size = 40
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..01C) (return) i label hascall gcsafe LIR
-----------------------------------------------------------------------------------------------------------------------------------------
Setting stack level from -572662307 to 0
=============== Generating BB01 [000..01C) (return), preds={} succs={} flags=0x00000002.20090020: i label hascall gcsafe LIR
BB01 IN (1)={V00} + ByrefExposed + GcHeap
OUT(0)={ }
Recording Var Locations at start of BB01
V00(rcx)
Change life 0000000000000000 {} -> 0000000000000001 {V00}
V00 in reg rcx is becoming live [------]
Live regs: 00000000 {} => 00000002 {rcx}
New debug range: first
Live regs: (unchanged) 00000002 {rcx}
GC regs: (unchanged) 00000002 {rcx}
Byref regs: (unchanged) 00000000 {}
L_M49656_BB01:
Mapped BB01 to G_M49656_IG02
Label: IG02, GCvars=0000000000000000 {}, gcrefRegs=00000002 {rcx}, byrefRegs=00000000 {}
Scope info: begin block BB01, IL range [000..01C)
Added IP mapping: 0x0000 STACK_EMPTY (G_M49656_IG02,ins#0,ofs#0) label
Generating: N003 (???,???) [000033] ----------- IL_OFFSET void INLRT @ 0x000[E-] REG NA
Generating: N005 ( 1, 1) [000000] ----------- t0 = LCL_VAR ref V00 this u:1 rcx (last use) REG rcx $80
/--* t0 ref
Generating: N007 (???,???) [000034] ----------- t34 = * PUTARG_REG ref REG rcx
V00 in reg rcx is becoming dead [000000]
Live regs: 00000002 {rcx} => 00000000 {}
Live vars: {V00} => {}
GC regs: 00000002 {rcx} => 00000000 {}
GC regs: 00000000 {} => 00000002 {rcx}
Generating: N009 ( 3, 10) [000035] Hc--------- t35 = CNS_INT(h) long 0xd1ffab1e ftn REG NA
/--* t35 long
Generating: N011 ( 5, 12) [000036] -c--------- t36 = * IND long REG NA
/--* t34 ref this in rcx
+--* t36 long control expr
Generating: N013 ( 15, 7) [000001] --CXG------ t1 = * CALL long A.get_XYValue REG rax $100
GC regs: 00000002 {rcx} => 00000000 {}
Call: GCvars=0000000000000000 {}, gcrefRegs=00000000 {}, byrefRegs=00000000 {}
IN0001: call [A:get_XYValue():System.Nullable`1[int]:this]
/--* t1 long
Generating: N015 ( 25, 14) [000004] DA-XG------ * STORE_LCL_VAR struct<System.Nullable`1[XY], 8>(P) V01 loc0 NA
* bool V01.hasValue (offs=0x00) -> V05 tmp2
* int V01.value (offs=0x04) -> V06 tmp3 REG NA
IN0002: mov qword ptr [V01 rsp+20H], rax
Live vars: {} => {V05 V06}
Generating: N017 ( 3, 2) [000025] -c--------- t25 = LCL_VAR int V06 tmp3 u:2 NA (last use) REG NA $1c0
Generating: N019 ( 1, 1) [000005] -c--------- t5 = CNS_INT int 1 REG NA $42
/--* t25 int
+--* t5 int
Generating: N021 ( 8, 4) [000013] ----------- t13 = * EQ int REG rax $1c1
Live vars: {V05 V06} => {V05}
IN0003: xor rax, rax
IN0004: cmp dword ptr [V06 rsp+24H], 1
IN0005: sete al
Generating: N023 ( 3, 2) [000029] -c--------- t29 = LCL_VAR int V05 tmp2 u:2 NA (last use) REG NA $180
/--* t29 int
Generating: N025 ( 4, 4) [000032] ----------- t32 = * CAST int <- bool <- int REG rdx $1c2
Live vars: {V05} => {}
IN0006: movzx rdx, byte ptr [V05 rsp+20H]
/--* t13 int
+--* t32 int
Generating: N027 ( 13, 9) [000021] ----------- t21 = * AND int REG rax $1c3
IN0007: and eax, edx
/--* t21 int
Generating: N029 ( 14, 10) [000022] ----------- * RETURN int REG NA $VN.Void
Added IP mapping: EPILOG (G_M49656_IG02,ins#7,ofs#28) label
Reserving epilog IG for block BB01
G_M49656_IG02: ; offs=000000H, funclet=00, bbWeight=1 , byref
*************** After placeholder IG creation
G_M49656_IG01: ; func=00, offs=000000H, size=0000H, gcrefRegs=00000000 {} <-- Prolog IG
G_M49656_IG02: ; offs=000000H, size=001CH, gcrefRegs=00000002 {rcx}, byrefRegs=00000000 {}, BB01 [0000], byref
G_M49656_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=00000000 {}
Variable Live Range History Dump for BB01
V00 this: rcx [(G_M49656_IG02,ins#0,ofs#0), (G_M49656_IG02,ins#0,ofs#0)]
Liveness not changing: 0000000000000000 {}
# compCycleEstimate = 39, compSizeEstimate = 24 B:get_IsBuffering():bool:this
; Final local variable assignments
;
; V00 this [V00,T00] ( 3, 3 ) ref -> rcx this class-hnd single-def
; V01 loc0 [V01 ] ( 3, 3 ) struct ( 8) [rsp+20H] do-not-enreg[SB] ld-addr-op
;* V02 loc1 [V02 ] ( 0, 0 ) int -> zero-ref
; V03 OutArgs [V03 ] ( 1, 1 ) lclBlk (32) [rsp+00H] "OutgoingArgSpace"
;* V04 tmp1 [V04 ] ( 0, 0 ) int -> zero-ref "impAppendStmt"
; V05 tmp2 [V05,T01] ( 2, 2 ) bool -> [rsp+20H] do-not-enreg[] V01.hasValue(offs=0x00) P-DEP "field V01.hasValue (fldOffset=0x0)"
; V06 tmp3 [V06,T02] ( 2, 2 ) int -> [rsp+24H] do-not-enreg[] V01.value(offs=0x04) P-DEP "field V01.value (fldOffset=0x4)"
;
; Lcl frame size = 40
*************** Before prolog / epilog generation
G_M49656_IG01: ; func=00, offs=000000H, size=0000H, gcrefRegs=00000000 {} <-- Prolog IG
G_M49656_IG02: ; offs=000000H, size=001CH, gcrefRegs=00000002 {rcx}, byrefRegs=00000000 {}, BB01 [0000], byref
G_M49656_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=00000000 {}
Recording Var Locations at start of BB01
V00(rcx)
*************** In genFnProlog()
Added IP mapping to front: PROLOG (G_M49656_IG01,ins#0,ofs#0) label
__prolog:
New debug range: first
IN0008: sub rsp, 40
*************** In genFnPrologCalleeRegArgs() for int regs
*************** In genEnregisterIncomingStackArgs()
G_M49656_IG01: ; offs=000000H, funclet=00, bbWeight=1 , byref, nogc
*************** In genFnEpilog()
__epilog:
gcVarPtrSetCur=0000000000000000 {}, gcRegGCrefSetCur=00000002 {rcx}, gcRegByrefSetCur=00000000 {}
IN0009: add rsp, 40
IN000a: ret
G_M49656_IG03: ; offs=00001CH, funclet=00, bbWeight=1 , epilog, nogc, extend
0 prologs, 1 epilogs, 0 funclet prologs, 0 funclet epilogs
*************** After prolog / epilog generation
G_M49656_IG01: ; func=00, offs=000000H, size=0004H, gcrefRegs=00000000 {}, byrefRegs=00000000 {}, byref, nogc <-- Prolog IG
G_M49656_IG02: ; offs=000004H, size=001CH, gcrefRegs=00000002 {rcx}, byrefRegs=00000000 {}, BB01 [0000], byref
G_M49656_IG03: ; offs=000020H, size=0005H, epilog, nogc, extend
*************** In emitJumpDistBind()
Emitter Jump List:
total jump count: 0
*************** Finishing PHASE Generate code
*************** Starting PHASE Emit code
Hot code size = 0x25 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_M49656_IG01: ; func=00, offs=000000H, size=0004H, gcrefRegs=00000000 {}, byrefRegs=00000000 {}, byref, nogc <-- Prolog IG
IN0008: 000000 sub rsp, 40
;; size=4 bbWeight=1 PerfScore 0.25
G_M49656_IG02: ; func=00, offs=000004H, size=001CH, gcrefRegs=00000002 {rcx}, byrefRegs=00000000 {}, BB01 [0000], byref
; gcrRegs +[rcx]
recordRelocation: 00000000D1FFAB1E (rw: 00000000D1FFAB1E) => 00000000D1FFAB1E, type 16 (IMAGE_REL_BASED_DISP32), delta 0
IN0001: 000004 call [A:get_XYValue():System.Nullable`1[int]:this]
; gcrRegs -[rcx]
; gcr arg pop 0
IN0002: 00000A mov qword ptr [rsp+20H], rax
IN0003: 00000F xor eax, eax
IN0004: 000011 cmp dword ptr [rsp+24H], 1
IN0005: 000016 sete al
IN0006: 000019 movzx rdx, byte ptr [rsp+20H]
IN0007: 00001E and eax, edx
;; size=28 bbWeight=1 PerfScore 8.50
G_M49656_IG03: ; func=00, offs=000020H, size=0005H, epilog, nogc, extend
IN0009: 000020 add rsp, 40
IN000a: 000024 ret
;; size=5 bbWeight=1 PerfScore 1.25Allocated method code size = 37 , actual size = 37, unused size = 0
; Total bytes of code 37, prolog size 4, PerfScore 13.70, instruction count 10, allocated bytes for code 37 (MethodHash=30e43e07) for method B:get_IsBuffering():bool:this
; ============================================================
*************** After end code gen, before unwindEmit()
G_M49656_IG01: ; func=00, offs=000000H, size=0004H, bbWeight=1 PerfScore 0.25, gcrefRegs=00000000 {}, byrefRegs=00000000 {}, byref, nogc <-- Prolog IG
IN0008: 000000 sub rsp, 40
G_M49656_IG02: ; offs=000004H, size=001CH, bbWeight=1 PerfScore 8.50, gcrefRegs=00000002 {rcx}, byrefRegs=00000000 {}, BB01 [0000], byref
IN0001: 000004 call [A:get_XYValue():System.Nullable`1[int]:this]
IN0002: 00000A mov qword ptr [V01 rsp+20H], rax
IN0003: 00000F xor eax, eax
IN0004: 000011 cmp dword ptr [V06 rsp+24H], 1
IN0005: 000016 sete al
IN0006: 000019 movzx rdx, byte ptr [V05 rsp+20H]
IN0007: 00001E and eax, edx
G_M49656_IG03: ; offs=000020H, size=0005H, bbWeight=1 PerfScore 1.25, epilog, nogc, extend
IN0009: 000020 add rsp, 40
IN000a: 000024 ret
*************** Finishing PHASE Emit code
*************** Starting PHASE Emit GC+EH tables
Unwind Info:
>> Start offset : 0x000000 (not in unwind data)
>> End offset : 0xd1ffab1e (not in unwind data)
Version : 1
Flags : 0x00
SizeOfProlog : 0x04
CountOfUnwindCodes: 1
FrameRegister : none (0)
FrameOffset : N/A (no FrameRegister) (Value=0)
UnwindCodes :
CodeOffset: 0x04 UnwindOp: UWOP_ALLOC_SMALL (2) OpInfo: 4 * 8 + 8 = 40 = 0x28
allocUnwindInfo(pHotCode=0x00000000D1FFAB1E, pColdCode=0x0000000000000000, startOffset=0x0, endOffset=0x25, unwindSize=0x6, pUnwindBlock=0x00000000D1FFAB1E, funKind=0 (main function))
*************** In genIPmappingGen()
IP mapping count : 3
IL offs PROLOG : 0x00000000 ( STACK_EMPTY )
IL offs 0x0000 : 0x00000004 ( STACK_EMPTY )
IL offs EPILOG : 0x00000020 ( STACK_EMPTY )
*************** In genSetScopeInfo()
VarLocInfo count is 2
; Variable debug info: 1 live ranges, 1 vars for method B:get_IsBuffering():bool:this
(V00 this) : From 00000000h to 00000004h, in rcx
*************** In gcInfoBlockHdrSave()
Set code length to 37.
Set ReturnKind to Scalar.
Set Outgoing stack arg area size to 32.
Defining 1 call sites:
Offset 0x4, size 6.
*************** Finishing PHASE Emit GC+EH tables
Method code size: 37
Allocations for B:get_IsBuffering():bool:this (MethodHash=30e43e07)
count: 507, size: 57826, max = 3272
allocateMemory: 65536, nraUsed: 62992
Alloc'd bytes by kind:
kind | size | pct
---------------------+------------+--------
AssertionProp | 6596 | 11.41%
ASTNode | 5272 | 9.12%
InstDesc | 2552 | 4.41%
ImpStack | 384 | 0.66%
BasicBlock | 1432 | 2.48%
CallArgs | 240 | 0.42%
FlowList | 0 | 0.00%
TreeStatementList | 0 | 0.00%
SiScope | 0 | 0.00%
DominatorMemory | 96 | 0.17%
LSRA | 4764 | 8.24%
LSRA_Interval | 480 | 0.83%
LSRA_RefPosition | 1800 | 3.11%
Reachability | 40 | 0.07%
SSA | 392 | 0.68%
ValueNumber | 6362 | 11.00%
LvaTable | 1948 | 3.37%
UnwindInfo | 0 | 0.00%
hashBv | 128 | 0.22%
bitset | 56 | 0.10%
FixedBitVect | 48 | 0.08%
Generic | 1850 | 3.20%
LocalAddressVisitor | 0 | 0.00%
FieldSeqStore | 0 | 0.00%
MemorySsaMap | 40 | 0.07%
MemoryPhiArg | 0 | 0.00%
CSE | 1384 | 2.39%
GC | 1341 | 2.32%
CorTailCallInfo | 0 | 0.00%
Inlining | 2608 | 4.51%
ArrayStack | 0 | 0.00%
DebugInfo | 264 | 0.46%
DebugOnly | 15186 | 26.26%
Codegen | 848 | 1.47%
LoopOpt | 24 | 0.04%
LoopClone | 0 | 0.00%
LoopHoist | 0 | 0.00%
Unknown | 155 | 0.27%
RangeCheck | 0 | 0.00%
CopyProp | 600 | 1.04%
SideEffects | 0 | 0.00%
ObjectAllocator | 0 | 0.00%
VariableLiveRanges | 616 | 1.07%
ClassLayout | 80 | 0.14%
TailMergeThrows | 0 | 0.00%
EarlyProp | 0 | 0.00%
ZeroInit | 240 | 0.42%
Pgo | 0 | 0.00%
****** DONE compiling B:get_IsBuffering():bool:this
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment