## Patch operands, etc. that reference pc offsets.# P_CASE,P_OTHER:	con iota+1; Patch: adt {	kind:	byte;		# P_xxx	i:	ref Inst;	n:	int;		# number of cases in ...	jmptbl:	array of int;	# ... case jump table	next:	cyclic ref Patch;}; plist:	ref Patch; ## Allocate a Patch structure.# newPatch(kind: int, i: ref Inst): ref Patch{	p: ref Patch; 	p = ref Patch(byte kind, i, 0, nil, plist);	plist = p;	return p;} ## Record non-case branch instruction for later patching.# patchop(i: ref Inst){	newPatch(P_OTHER, i);} ## Record case jump table for later patching.# patchcase(i: ref Inst, n: int, jmptbl: array of int){	p: ref Patch; 	p = newPatch(P_CASE, i);	p.n = n;	p.jmptbl = jmptbl;} ## Calculate patch address; Java branches are relative.# patchaddr(i: ref Inst, pc: int): int{	j: ref Jinst;	span, srcjpc, dstjpc: int; 	span = pc;	srcjpc = i.j.pc;	dstjpc = srcjpc + span;	j = code.j[dstjpc]; 	# account for no-op's (dup, swap, pop, etc.), elided loads/stores	while(j.dis == nil) {		dstjpc += j.size;		j = code.j[dstjpc];	} 	return j.dis.pc;} ## Patch branch instructions and case jump tables of a method.# patchmethod(startpc: int){	p: ref Patch;	i: ref Inst;	jt: array of int;	n: int; 	for(p = plist; p != nil; p = p.next) {		i = p.i;		if(int p.kind == P_CASE) {			jt = p.jmptbl;			for(n = 0; n < p.n; n++)				jt[n*3+2] = patchaddr(i, jt[n*3+2]);			jt[p.n*3] = patchaddr(i, jt[p.n*3]);		} else {	# P_OTHER			i.d.ival = patchaddr(i, i.d.ival);			#			# jmp $start_of_method  ->  jmp $start_of_method+1			# skip (re-)allocation of Sys->Exception object			#			# no more Sys->Exception objects, we killed them all			#if(i.d.ival == startpc && int i.op == IJMP && code.nex != 0)			#	i.d.ival += 1;		}	}} ## Clear the patch list after each method.# patchfree(){	plist = nil;}