x86-allocate-registers bug

Thu, 13 Sep 2001 09:43:29 -0700

> Could you run that G0 on the regressions and benchmarks and see if it
> shows up on anything smaller?

The only one of the normal regressions that failed was tststrcmp.  I've appended
the log.  Of the benchmarks, hamlet and vliw failed.  I can send the log for
those if you need.

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

testing tststrcmp
handling respill intoRegisterMemLoc
entries:
%esp MEM<l>{Locals}[(localint)+(0*4)] 1029 true NO
%edi MEM<l>{GCStateHold}[((gcState+40))+(0*4)] 969 true NO
%esi MEM<l>{GCStateHold}[((gcState+12))+(0*4)] 1993 true NO
%eax MEM<l>{Temp}[(indexTemp)+(0*4)] 999 true NO
reserved:
%eax
fltstack:
	idivl $10,MEM<l>{Locals}[(localint)+(0*4)]
entries:
%esi MEM<l>{GCStateHold}[((gcState+12))+(0*4)] 1993 false NO
%edi MEM<l>{GCStateHold}[((gcState+40))+(0*4)] 969 false NO
%eax MEM<l>{Temp}[(indexTemp)+(0*4)] 999 true NO
%esp MEM<l>{Locals}[(localint)+(0*4)] 1029 false NO
reserved:
%eax
fltstack:

.p2align 2
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

L_639:
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Assume: assumes: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi 
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: FltAssume: assumes: 
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: RestoreRegAlloc: live: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] MEM<l>{GCStateHold}[((gcState+12))+(0*4)] RegAlloc32
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

L_654:
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	cmpl $0,MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
commit: MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Force: commit_memlocs: commit_classes: ThreadStack IntInfRes GCState CStatic Globals Stack Heap Code CStack remove_memlocs: remove_classes: dead_memlocs: dead_classes: 
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: SaveRegAlloc: live: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] MEM<l>{GCStateHold}[((gcState+12))+(0*4)] RegAlloc33
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	jge L_650
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

L_655:
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	movl MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)],MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
remove: MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(4*1)]
future (post): FUSEDEF MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	incl MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Force: commit_memlocs: commit_classes: ThreadStack IntInfRes GCState CStatic Globals Stack Heap Code CStack remove_memlocs: remove_classes: dead_memlocs: dead_classes: 
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: SaveRegAlloc: live: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] MEM<l>{GCStateHold}[((gcState+12))+(0*4)] RegAlloc34
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	jo L_651
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

noOverflow_3:
future (post): FUSE MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	movl MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)],MEM<l>{Locals}[(localint)+(0*4)]
dead: MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FDEAD MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Force: commit_memlocs: commit_classes: remove_memlocs: remove_classes: dead_memlocs: MEM<l>{StaticTemp}[(overflowCheckTemp)+(0*4)] dead_classes: 
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	idivl $10,MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSEDEF MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %eax
hint: MEM<l>{Temp}[(0)+(1*1)] -> %edx
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	decl MEM<l>{Locals}[(localint)+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %ebp

# directive: Cache: caches: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi (reserved) MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi (reserved) 
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %ebp

# directive: FltCache: caches: 
future (post): FLIVE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %ebp

# directive: Cache: caches: MEM<l>{Locals}[(localint)+(0*4)] -> %ebp (reserved) 
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{Locals}[(localint)+(0*4)] -> %ebp

# directive: Force: commit_memlocs: commit_classes: ThreadStack IntInfRes GCState CStatic Globals Stack Heap Code CStack remove_memlocs: remove_classes: dead_memlocs: dead_classes: 

# directive: Unreserve: registers: %ebp %esi %edi 

# directive: Reset
future (post): FUSE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FDEAD MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP

L_656:
future (post): FUSE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FDEAD MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Assume: assumes: MEM<l>{Locals}[(localint)+(0*4)] -> %ebp MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi 
future (post): FUSE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FDEAD MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: FltAssume: assumes: 
future (post): FUSE MEM<l>{Locals}[(localint)+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FDEAD MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	movl MEM<l>{Locals}[(localint)+(0*4)],MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
dead: MEM<l>{Locals}[(localint)+(0*4)]
remove: MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FDEAD MEM<l>{Locals}[(localint)+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Force: commit_memlocs: commit_classes: remove_memlocs: remove_classes: dead_memlocs: MEM<l>{Locals}[(localint)+(0*4)] dead_classes: 
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Force: commit_memlocs: MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(12*1)] commit_classes: remove_memlocs: remove_classes: dead_memlocs: dead_classes: 
future (post): FUSEDEF MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	addl $8,MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FUSE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FDEF MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

	movl $L_657,MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
remove: MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMIT MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)]
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Force: commit_memlocs: MEM<l>{Stack}[(MEM<l>{GCStateHold}[((gcState+40))+(0*4)])+(0*4)] commit_classes: remove_memlocs: remove_classes: dead_memlocs: dead_classes: 
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+12))+(0*4)]
future (post): FLIVE MEM<l>{GCStateHold}[((gcState+40))+(0*4)]
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: Cache: caches: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi (reserved) MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi (reserved) 
future (post): FMREMOVEP
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP
hint: MEM<l>{GCStateHold}[((gcState+12))+(0*4)] -> %esi
hint: MEM<l>{GCStateHold}[((gcState+40))+(0*4)] -> %edi

# directive: ClearFlt
future (post): FCOMMITP
future (post): FREMOVEP
future (post): FDEADP

# directive: Force: commit_memlocs: commit_classes: ThreadStack IntInfRes GCState CStatic Globals Stack Heap Code CStack remove_memlocs: remove_classes: dead_memlocs: dead_classes: 

	jmp stringP_0

mlton: x86AllocateRegister.allocateRegisters::toRegisterMemLoc:reSpill
compilation of tststrcmp failed