;;; -*- Mode:LISP; Package:LISP-INTERNALS; Base:10; Readtable:CL -*- ;;;;;;;;;;;Known Bugs;;;;;;;;;;;;;;; ;;; This file is being tested using the code in K-SYS:K;STACK-GROUP-TOGGLE. ;;; Stack-group-toggle sets up two control-pdl's and swaps them back and ;;; forth, dumping and restoring along its merry way. This has revealed several bugs. ;;; Some of this code has been written in assembler. This is because the ;;; compiler has a bug. The lisp code that generated the assembler is nearby ;;; and should be used as a reference only as slight changes in the assembler ;;; have been made since. ;;; After restoring a dumped control-pdl the frame associated with the currently running ;;; function is not correct. ;;; I suspect that frames are not being properly returned to the heap by the ;;; dumper. Something needs to be written for inspecting the current state of the heap ;;; and comparing that to the frames on the call stack. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; OPERATIONS ON CONTROL PDLs ;;; SWAP IN AND WIRE ;;; The control PDL (or at least the part being dumped to) must be wired ;;; since the call hardware dumper isn't allowed to take page faults (or ;;; any call hardware operation). ;;; UNWIRE ;;; only the current control pdl need be wired. ;;; ASSURE SPACE TO DUMP IN ;;; For the current stack group, there must be enough remaining space in the ;;; control pdl (which must be wired) to hold what could potentially be the ;;; entire state of the call hardware. ;;; GROW ;;; control flow for the program might have a deep enough call stack ;;; that the previously allocated control pdl might not be big enough. ;;; this operation is similar to that of growing arrays. ;;; Wiring and unwiring must occur when a bigger control pdl is created. ;;; CONTEXT SWITCH ;;; when a context switch between stack groups occurs the entire call hardware ;;; state must be dumped into the control pdl associated with the outgoing ;;; stack group and restored from the control pdl state of the incomming stack group. ;;; These operations are similar to overflow and underflow handling. ;;; Wiring and unwiring occur at this point. ;;; HANDLE OVERFLOW ;;; when the program overflows the call hardware then its state must be dumped ;;; to the control pdl and restored later. This dumping must occur on call boundaries. ;;; HANDLE UNDERFLOW ;;; when the program does more returns than the call hardware remembers and there ;;; was previously an overflow, then the state that was dumped to service the overflow ;;; must now be restored. If there was no previously dumped state then the machine ;;; will have returned to the event horizon. ;;; SCAVENGE ;;; The control pdl must be scavenged in a manner similar to the way the registers ;;; are scavenged. The scavenger must touch those pieces of the dumped call hardware state ;;; which are boxed, and only those which are boxed. ;;; TOOLS FOR THE DEBUGGER TO LOOK AT THEM ;;; It is probably the case that the debugger will run in a different stack group than ;;; the program being debugged. In this case, the entire state of the call hardware ;;; for the debugged stack group will be represented in a control pdl. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; at the base of the call hardware stack a CALL has just occurred. ;;; That call will have come from the call stack underflow handler. ;;; The call stack underflow handler (catcher) uses register set #xff for O and A. ;;; At the base of the call stack will be an entry which will return #xff to O and A, ;;; and the RPC will be a routine which preserves the return values, scrolls the call ;;; stack, and returns with the preserved return values. ;;; This is why the call hardware may only be scrolled so that the base is at a call boundary. ;;; These global registers are used by the control pdl code: ;;; GR:*CONTROL-PDL* contains the currently active control pdl. ;;; GR:*CONTROL-PDL-POINTER* virtual address into the current control pdl where the next ;;; record will be written as an unboxed locative. ;;; GR:*CONTROL-PDL-LIMIT* if GR:*CONTROL-PDL-POINTER* reaches this then the control pdl is full. ;;; GR:*CH-BASE-CSP* the value of the call stack pointer above which the call stack is valid. ;;; GR:*CH-TEMP-0* temporaries used by the call hardware dumper and restorer while ;;; GR:*CH-TEMP-1* they can't use locals ;;; GR:*CH-TEMP-2* ;;; GR:*CH-TEMP-3* ;;; GR:*CH-TEMP-4* ;;; GR:*CH-TEMP-5* ;;; GR:*CH-TEMP-6* ;;; GR:*CH-CONTROL-PDL-INDEX* used by the restorer. (could just be another temporary) ;;; The control pdl object. Control pdls are arrays of type ART-CONTROL-PDL. ;;; At the base of each control pdl are several words used for bookkeeping. Immediately after ;;; these words the call hardware dump starts. These words include ;;; - pointer to the stack group it belongs to ;;; - the allocation pointer where dumping continues ;;; The limit after which the control pdl structure must be grown to accomodate more call records ;;; can be calculated from the control pdl's size. ;;; Each frame of the control pdl consists of CONTROL-PDL-FRAME-SIZE words. ;;; The first word contains: ;;; - the type code: OPEN, OPEN-CALL, TOPEN (2 bits), PROTECTED-OPEN-CALL, ;;; - the return-destination (7 bits), ;;; - the global return destination (4 bits) and ;;; - 16 box bits for the saved registers ;;; The second word contains the typed RPC ;;; The third through eighteenth words contain the saved registers. (defconstant %%cpdl0-type-code (byte 2 0)) (defconstant %%cpdl0-rdest (byte 7 2)) (defconstant %%cpdl0-global-frame (byte 4 9)) (defconstant %%cpdl0-box-bits (byte 16 16)) ;register zero's box bit is LSB of this field (defconstant $$cpdl0-type-open 0) ;for type code field (defconstant $$cpdl0-type-open-call 1) (defconstant $$cpdl0-type-topen 2) (defconstant $$cpdl0-type-protected-open-call 3) (defconstant control-pdl-frame-size 18) (defconstant control-pdl-frame-offset-to-registers 2) ;;; The control pdl could be full of OPEN-CALL TOPEN frames (defconstant max-call-hardware-dump (* 2 control-pdl-frame-size 256) "The largest possible size that a call hardware dump can be") (defvar control-pdl-area nil "This is the area in which control pdls live") (defun make-control-pdl-area () (when (or (not (boundp 'control-pdl-area)) (null control-pdl-area)) (setq control-pdl-area (area-data:make-area 7 (vinc:dpb-multiple-boxed (ceiling max-call-hardware-dump vinc:*qs-in-cluster*) region-bits:%%region-bits-swapin-quantum region-bits:$$scavenge-enabled region-bits:%%region-bits-scavenge-bit region-bits:$$region-read-write region-bits:%%region-bits-read-only region-bits:$$region-space-structure region-bits:%%region-bits-space-type region-bits:$$region-new-space region-bits:%%region-bits-new-space ;;; what should this really be: region-bits:$$region-fixed region-bits:%%region-bits-flippable region-bits:$$region-internal-memory region-bits:%%region-bits-external-bus 0) 10)))) (defconstant control-pdl-allocation-quantum ;;#x4800 (* 2 max-call-hardware-dump) "amount by which a control pdl is grown when it fills up") ;at least enough for one full call hardware dump ;;; The zeroth slot of the control pdl contains a pointer ;;; back to the stack group to which the control pdl belongs. (defmacro CONTROL-PDL-STACK-GROUP (control-pdl) "Return the stack group associated with the CONTROL-PDL" `(array:%vm-read (hw:24+ 1 ,control-pdl))) (defmacro SET-CONTROL-PDL-STACK-GROUP (control-pdl stack-group) "Set the stack group associated with CONTROL-PDL to STACK-GROUP" `(array:%vm-write (hw:24+ 1 ,control-pdl) ,stack-group)) ;;; The first slot of the control pdl contains the saved value of the control pdl pointer ;;; when the control pdl is not the current one. (defmacro CONTROL-PDL-POINTER (control-pdl) "Return the saved value of CONTROL-PDL's top of stack pointer" `(array:%vm-read (hw:24+ 2 ,control-pdl))) (defmacro SET-CONTROL-PDL-POINTER (control-pdl new-pointer) "Changes the saved value of CONTROL-PDL's top of stack pointer to NEW-POINTER" `(array:%vm-write (hw:24+ 2 ,control-pdl) ,new-pointer)) (defconstant control-pdl-base 3 "Add to a control-pdl objects pointer to find the base for call hardware dumps") (defun make-control-pdl (stack-group &optional (total-size control-pdl-allocation-quantum)) (setq total-size (* (ceiling (max total-size control-pdl-allocation-quantum) vinc:*qs-in-cluster*) vinc:*qs-in-cluster*)) ;must fall on cluster boundary (for ease in wiring). (let ((control-pdl (cons:allocate-structure-in-area control-pdl-base ;3 words including header (- total-size 3) vinc:$$dtp-array (vinc:dpb-multiple-boxed (1- total-size) array::%%bounds ;don't count header word array:art-control-pdl array::%%sv-art vinc:$$dtp-array-header-single vinc:%%data-type 0) control-pdl-area))) ;;; touch each page (do ((i 3 (1+ i))) ((>= i (1- total-size))) (array:%vm-write32 control-pdl i (hw:unboxed-constant 0))) (set-control-pdl-pointer control-pdl control-pdl-base) (set-control-pdl-stack-group control-pdl stack-group) control-pdl)) ;control-pdl-p is array:control-pdl-p and this one don't work too good anyhow ;(defun control-pdl-p (object) ; (and (array:arrayp object) ; (= array:art-control-pdl ; (hw:ldb object array::%%sv-art 0)))) (defsubst control-pdl-empty-p (control-pdl) (progn (when (< (control-pdl-pointer control-pdl) control-pdl-base) (error "control-pdl-pointer below control-pdl-base")) (<= (control-pdl-pointer control-pdl) control-pdl-base))) (defsubst control-pdl-limit (control-pdl) "if control-pdl-pointer reaches here we are out of room" (hw:ldb (array:%vm-read32 control-pdl 0) array::%%bounds 0)) (defun control-pdl-assure-room (control-pdl) (if (>= (+ (control-pdl-pointer control-pdl) max-call-hardware-dump) ;max size of call hardware (control-pdl-limit control-pdl)) (grow-control-pdl control-pdl) control-pdl)) (defun grow-control-pdl (control-pdl) (let* ((stack-group (control-pdl-stack-group control-pdl)) (new-control-pdl (make-control-pdl stack-group (+ (control-pdl-limit control-pdl) control-pdl-allocation-quantum)))) ;;; this will copy stack-group, pointer and the dumped call hardware state (do ((offset 1 (1+ offset)) (end (control-pdl-limit control-pdl))) ((>= offset end)) (array:%vm-write32 new-control-pdl offset (array:%vm-read32 control-pdl offset))) ;;; change the control pdl in the stack group ;(setf (sg-control-pdl stack-group) new-control-pdl) ;**** causes it to bomb --rg 2/21/88 (set-control-pdl-stack-group control-pdl nil) ;disassociate the old control pdl from any stack group new-control-pdl)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; The state of the current control pdl is stored in global registers rather than ;;; in the object itself. These are used to maintain consistency and for context switching. (defsubst save-control-pdl-state () (set-control-pdl-pointer gr:*control-pdl* (hw:ldb (hw:24- gr:*control-pdl-pointer* gr:*control-pdl*) (byte 24 0) 0))) (defsubst load-control-pdl-state () (macrolet ((index-to-address (index) `(cons:make-pointer vinc:$$dtp-unboxed-locative (hw:24+ gr:*control-pdl* ,index)))) (setq gr:*control-pdl-limit* (index-to-address (control-pdl-limit gr:*control-pdl*)) gr:*control-pdl-pointer* (index-to-address (control-pdl-pointer gr:*control-pdl*))))) (defun select-control-pdl (control-pdl) "Set up the global registers associated with the call hardware dump/restore code to use CONTROL-PDL. The previous values are stored in the outgoing control pdl" ;;; make sure it is a control pdl (unless (array::control-pdl-p control-pdl) (trap:illop "This is not a control pdl")) ; control-pdl (save-control-pdl-state) (setq gr:*control-pdl* control-pdl) (load-control-pdl-state)) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; hooks for the debugger ;;; read and modify registers in a frame ;(defun control-pdl-depth (control-pdl) ; "Index of topmost frame of control pdl" ; (floor (- (control-pdl-pointer control-pdl) control-pdl-base) ; control-pdl-frame-size)) ;(defun control-pdl-frame-info (control-pdl frame-number) ;; (declare (values type rpc rdest global-frame)) ; (let ((frame-index (+ control-pdl-base (* control-pdl-frame-size frame-number))) ; word0 word1) ; (when (>= frame-index (control-pdl-pointer control-pdl)) ; (li:error "frame not in control pdl")) ; (setq word0 (array:%vm-read32 control-pdl frame-index)) ; (setq word1 (array:%vm-read32 control-pdl (1+ frame-index))) ; (values (hw:ldb word0 %%cpdl0-type-code 0) ;type ; word1 ;RPC ; (hw:ldb word0 %%cpdl0-rdest 0) ;RDEST ; (hw:ldb word0 %%cpdl0-global-frame 0)))) ;global frame ;(defun control-pdl-frame-examine-register (control-pdl frame-number register-number) ; (let ((frame-index (+ control-pdl-base (* control-pdl-frame-size frame-number))) ; box-bits datum) ; (when (>= frame-index (control-pdl-pointer control-pdl)) ; (li:error "frame not in control pdl")) ; (setq box-bits (hw:ldb (array:%vm-read32 control-pdl frame-index) %%cpdl0-box-bits 0)) ; (setq datum (array:%vm-read32 control-pdl (+ control-pdl-frame-offset-to-registers ; register-number frame-index))) ; (if (hw::32logbitp register-number box-bits) ; (hw:dpb-boxed datum (byte 32 32) (hw:unboxed-constant 0)) ;make boxed ; datum))) ;unboxed ;(defun control-pdl-frame-modify-register (control-pdl frame-number register-number new-value boxed-p) ; (let ((frame-index (+ control-pdl-base (* control-pdl-frame-size frame-number))) ; word0) ; (when (>= frame-index (control-pdl-pointer control-pdl)) ; (li:error "frame not in control pdl")) ; (setq word0 (array:%vm-read32 control-pdl frame-index)) ; (flet ((change-datum () ; (array:%vm-write32 control-pdl (+ control-pdl-frame-offset-to-registers ; register-number frame-index) new-value)) ; (change-box-bit () ; (array:%vm-write32 control-pdl frame-index ; (hw:dpb (hw:dpb (if boxed-p 1 0) ; (byte 1 register-number) ; (hw:ldb word0 %%cpdl0-box-bits 0)) ; %%cpdl0-box-bits ; word0)))) ; (if boxed-p ;try and do this safely ; (progn (change-datum) ; (change-box-bit)) ; (progn (change-box-bit) ; (change-datum))) ))) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;(defun scavenge-control-pdl (control-pdl) ; (macrolet ((scavenge-word (word) ; `(hw:vma-start-read ,word))) ; (SCAVENGE-WORD (control-pdl-stack-group control-pdl)) ; (do ((frame-offset control-pdl-base (+ frame-offset control-pdl-frame-size)) ; (end (control-pdl-pointer control-pdl)) ; frame-box-bits) ; ((>= frame-offset end)) ; (setq frame-box-bits (hw:ldb (array:%vm-read32 control-pdl frame-offset) ; %%cpdl0-box-bits 0)) ; ;;; scavenge the pc also ; (dotimes (register 16) ; (when (hw:32logbitb register frame-box-bits) ; (SCAVENGE-WORD (array:%vm-read32 control-pdl ;do we need to make sure it is boxed ; (+ frame-offset ;in case the transporter refuses to move it? ; control-pdl-frame-offset-to-registers ; register)))) )) )) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; we should maybe use a vanilla global variable for the interlock (defmacro DUMPING-OR-RESTORING-CALL-HARDWARE (doing-it) (let ((interlock 'gr:*ch-dumper-return-pc*)) (if doing-it `(progn (unless (null ,interlock) (trap:illop "call hardware dump or restore entered recursively")) (setq ,interlock t)) `(setq ,interlock nil)))) (defmacro set-rpc-rdest (rpc rdest global-frame) `(let ((rpc-rdest (hw:dpb ,rdest hw:%%ch-rpcd-return-dest ,rpc))) (hw:trap-off) ;;;once Kent fixes the hardware we won't need to do the hack with SPARE-17 any more. (hw:write-processor-control (vinc:dpb-multiple-unboxed ,global-frame hw:%%processor-control-misc 1 hw:%%processor-control-spare-17 (hw:read-processor-control))) (hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:write-return-pc-return-dest rpc-rdest) (hw:nop) (hw:ch-open-call) (hw:write-processor-control (hw:dpb-unboxed 0 hw:%%processor-control-spare-17 (hw:read-processor-control))) (hw:nop) (hw:nop) (hw:write-memory-control (hw:dpb-unboxed hw:$$trap-enable hw:%%memory-control-master-trap-enable (hw:read-memory-control))))) (defmacro FORGE-CATCHER-FRAME () `(set-rpc-rdest (k2:%compiled-function-code (symbol-function 'call-hardware-underflow-catcher)) (vinc::dpb-multiple-unboxed hw:$$i-reg-base-active hw:%%i-reg-base ; return destination A0 0 hw:%%i-reg-offset (hw:unboxed-constant 0)) 0)) ;;; This is what lives at the bottom of the call hardware stack. It is never called. Things return ;;; to it at PC offset 0. The macro FORGE-CATCHER-FRAME knows how to install it. Be sure the call hardware is ;;; empty when you install it otherwise the frames below it will be lost. (defun CALL-HARDWARE-UNDERFLOW-CATCHER (result) ;;; traps are on. This is guaranteed by some hack somewhere. ;;; Forge an open call frame onto the control pdl. ;;; It should look like this: ;;; RPC: either CALL-HARDWARE-UNDERFLOW-RETURN-MULTIPLE-VALUES or CALL-HARDWARE-UNDERFLOW-RETURN-1-VALUE. ;;; RDEST: ignore, return-frame-0. ;;; type: unprotected open-call. ;;; boxed bits: register zero is same as result, all others unboxed. ;;; global frame: doesn't matter. ;;; registers: saved A0 has value of RESULT, all others are unboxed zero. (if (control-pdl-empty-p gr:*control-pdl*) (trap:illop "Control PDL is empty") ; if the control pdl is empty we should loose in some appropriate way (let ((return-function (if (hw:return-code-mv-p) 'call-hardware-underflow-return-multiple-values 'call-hardware-underflow-return-1-value)) (word-1 (vinc:dpb-multiple-unboxed (hw:accumulate-box-bits (hw:unboxed-constant 0) result) %%cpdl0-box-bits $$cpdl0-type-open-call %%cpdl0-type-code (vinc:dpb-multiple-unboxed hw:$$i-reg-base-return hw:%%i-reg-base 0 hw:%%i-reg-offset (hw:unboxed-constant 0)) %%cpdl0-rdest 0 %%cpdl0-global-frame (hw:unboxed-constant 0)))) (macrolet ((control-pdl-write-word (word) `(progn (hw:write-md-unboxed ,word) (hw:vma-start-write-no-gc-trap-unboxed gr:*control-pdl-pointer*) (setq gr:*control-pdl-pointer* (hw:24+ 1 gr:*control-pdl-pointer*))))) (control-pdl-write-word word-1) (control-pdl-write-word (k2:%compiled-function-code (symbol-function return-function))) (control-pdl-write-word result) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0)) (control-pdl-write-word (hw:unboxed-constant 0))) (restore-call-hardware)))) (defun call-hardware-underflow-return-1-value (value) (hw:return value)) (defun call-hardware-underflow-return-multiple-values (value) (hw:return-mv value)) (defun where-to-restore-from-control-pdl (control-pdl) ;;; find a place to start restoring the call hardware from. Must be an unprotected open-call frame (do* ((control-pdl-index (- (control-pdl-pointer control-pdl) control-pdl-frame-size) (- control-pdl-index control-pdl-frame-size)) (number-of-frames 0 (1+ number-of-frames)) open-call-index (open-call-index-number-of-frames 0)) (nil) (cond ((= control-pdl-index control-pdl-base) ;empty control pdl? (return control-pdl-base)) ((>= open-call-index-number-of-frames (floor 256 3)) ;one third of call hardware size? (return open-call-index)) ((< control-pdl-index control-pdl-base) (trap:illop "phase error in control pdl")) ((hw:field= (array::%vm-read32 gr:*control-pdl* control-pdl-index) $$cpdl0-type-open-call %%cpdl0-type-code) (setq open-call-index control-pdl-index open-call-index-number-of-frames number-of-frames))))) ;;; should get called with traps ON! (defafun restore-call-hardware () P_248 (MOVE NOP (REGISTER *CH-DUMPER-RETURN-PC* 7 10) BOXED-RIGHT) (TEST BR-ZERO) (BRANCH B_262 NIL) C_250 (MOVEI O0 (QUOTE 376) BOXED CH-OPEN) (CALL (trap:ILLOP-FUNCTION 1) IGNORE NIL) B_262 (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE T) BOXED) (MOVEI O0 (QUOTE CALL-HARDWARE-UNDERFLOW-CATCHER) BOXED CH-OPEN) (CALL (SYMBOL-FUNCTION 1) (NEW-OPEN 0) NIL) (CALL (k2:%COMPILED-FUNCTION-CODE 1) R2 NIL) (MOVEI R0 16 UNBOXED) (ALU-FIELD FIELD-PASS r8 R0 R2 (QUOTE 1816) PW-II DT-NONE BOXED-RIGHT) (MOVE IGNORE TRAP-OFF) (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS R2 (REGISTER *ONE* 4 1) R2 (QUOTE 273) PW-II DT-NONE UNBOXED) (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 1033) PW-II DT-NONE UNBOXED) (NOP) (NOP) (NOP) (NOP) (MOVE RETURN-PC-RETURN-DEST r8 BOXED-RIGHT) (NOP) (OPEN-CALL (0 0) IGNORE NIL NEXT-PC-PC+1) (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 273) PW-II DT-NONE UNBOXED) (NOP) (NOP) (MOVE R2 MEMORY-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS MEMORY-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 287) PW-II DT-NONE UNBOXED) (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT) (ALU L+R r9 R0 (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT) (ALU L-R R2 (REGISTER *CONTROL-PDL-POINTER* 7 1) (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT) (ALU-FIELD FIELD-PASS (MD BOXED-MD) R2 (REGISTER *ZERO* 4 0) (BYTE 24 0) PW-II DT-NONE BOXED-RIGHT) (MOVE (VMA-START-WRITE BOXED-VMA) r9) (OPEN-CALL (WHERE-TO-RESTORE-FROM-CONTROL-PDL 1) r10 (O0 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT)) (MOVEI R0 (QUOTE 11) BOXED) (ALU-FIELD FIELD-PASS R2 R0 (REGISTER *CONTROL-PDL* 7 0) (QUOTE 1562) PW-II DT-NONE BOXED) (ALU L+R (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) r10 R2 BW-24 BOXED-RIGHT) TAGBODY_353 (MOVE R2 CALL-SP-HP BOXED-RIGHT) (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-BASE-CSP* 7 9) R2 R1 (BYTE 8 0) PW-II DT-NONE BOXED-RIGHT) (MOVE (REGISTER *CH-TEMP-4* 7 8) (REGISTER *CONTROL-PDL-POINTER* 7 1)) (MOVE (REGISTER *CONTROL-PDL-POINTER* 7 1) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) LOOP_357 (ALU L-R NOP (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) (REGISTER *CH-TEMP-4* 7 8) BW-24) (TEST BR-EQUAL) (BRANCH B_1986 NIL) C_363 P_371 (ALU L-R NOP (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) (REGISTER *CH-TEMP-4* 7 8) BW-24) (TEST BR-NOT-GREATER-THAN) (BRANCH B_388 NIL) C_372 (MOVEI O0 (QUOTE 352) BOXED CH-OPEN) (CALL (trap:ILLOP-FUNCTION 1) IGNORE NIL) B_388 (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (MEMORY-WAIT) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) (MOVE (REGISTER *CH-TEMP-1* 7 5) MD) BLOCK_401 (ALU-FIELD FIELD-EXTRACT-R R0 IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 2 0) PW-II UNBOXED) (ALU L+R R1 gr:*TRAP-DTP-CODE-5* TRAP-PC+ BW-32 BOXED) (ALU L+R NOP R0 R1 BW-32 BOXED) (NOP) (NOP NEXT-PC-DISPATCH) (UNCONDITIONAL-BRANCH P_492 NIL) (UNCONDITIONAL-BRANCH P_405 NIL) (UNCONDITIONAL-BRANCH P_505 NIL) (UNCONDITIONAL-BRANCH P_405 NIL) P_402 RESTORE-O-FRAME_526 (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-1* 7 5) (REGISTER *CH-TEMP-1* 7 5) R1 (BYTE 16 -16) PW-II DT-NONE BOXED-RIGHT) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_542 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_552 NIL) C_543 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_574 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_586 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_596 NIL) C_587 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_618 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_630 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_640 NIL) C_631 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_662 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_674 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_684 NIL) C_675 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_706 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_718 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_728 NIL) C_719 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_750 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_762 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_772 NIL) C_763 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_794 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_806 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_816 NIL) C_807 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_838 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_850 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_860 NIL) C_851 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_882 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_894 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_904 NIL) C_895 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_926 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_938 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_948 NIL) C_939 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_970 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_982 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_992 NIL) C_983 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1014 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1026 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1036 NIL) C_1027 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1058 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1070 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1080 NIL) C_1071 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1102 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1114 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1124 NIL) C_1115 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1146 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1158 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1168 NIL) C_1159 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1190 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1202 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1212 NIL) C_1203 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1234 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (UNCONDITIONAL-BRANCH LOOP_357 NIL) C_1212 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1234 NIL) C_1168 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1190 NIL) C_1124 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1146 NIL) C_1080 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1102 NIL) C_1036 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1058 NIL) C_992 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1014 NIL) C_948 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_970 NIL) C_904 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_926 NIL) C_860 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_882 NIL) C_816 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_838 NIL) C_772 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_794 NIL) C_728 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_750 NIL) C_684 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_706 NIL) C_640 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_662 NIL) C_596 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_618 NIL) C_552 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS O0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_574 NIL) P_505 (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) (k:TAIL-OPEN) (UNCONDITIONAL-BRANCH RESTORE-O-FRAME_526 NIL) P_492 (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) (k:OPEN) (UNCONDITIONAL-BRANCH RESTORE-O-FRAME_526 NIL) P_405 (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (MEMORY-WAIT) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-2* 7 6) (REGISTER *CH-TEMP-1* 7 5) R1 (BYTE 7 -2) PW-II DT-NONE BOXED-RIGHT) (MOVE r11 (REGISTER *CH-TEMP-2* 7 6) BOXED-RIGHT) C_428 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-2* 7 6) r11 R2 (QUOTE 1816) PW-II DT-NONE BOXED-RIGHT) (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-3* 7 7) (REGISTER *CH-TEMP-1* 7 5) R1 (BYTE 4 -9) PW-II DT-NONE BOXED-RIGHT) (MOVE IGNORE TRAP-OFF) (MOVE r12 (REGISTER *CH-TEMP-3* 7 7) BOXED-RIGHT) C_449 (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS R2 (REGISTER *ONE* 4 1) R2 (QUOTE 273) PW-II DT-NONE UNBOXED) (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL r12 R2 (QUOTE 1033) PW-II DT-NONE UNBOXED) (NOP) (NOP) (NOP) (NOP) (MOVE RETURN-PC-RETURN-DEST (REGISTER *CH-TEMP-2* 7 6) BOXED-RIGHT) (NOP) (OPEN-CALL (0 0) IGNORE NIL NEXT-PC-PC+1) (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 273) PW-II DT-NONE UNBOXED) (NOP) (NOP) (MOVE R2 MEMORY-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS MEMORY-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 287) PW-II DT-NONE UNBOXED) RESTORE-A-FRAME_1245 (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-1* 7 5) (REGISTER *CH-TEMP-1* 7 5) R1 (BYTE 16 -16) PW-II DT-NONE BOXED-RIGHT) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1261 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1271 NIL) C_1262 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1293 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1305 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1315 NIL) C_1306 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1337 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1349 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1359 NIL) C_1350 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1381 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1393 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1403 NIL) C_1394 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1425 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1437 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1447 NIL) C_1438 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1469 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1481 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1491 NIL) C_1482 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1513 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1525 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1535 NIL) C_1526 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1557 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1569 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1579 NIL) C_1570 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1601 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1613 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1623 NIL) C_1614 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1645 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1657 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1667 NIL) C_1658 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1689 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1701 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1711 NIL) C_1702 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1733 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1745 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1755 NIL) C_1746 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1777 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1789 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1799 NIL) C_1790 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1821 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1833 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1843 NIL) C_1834 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1865 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1877 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1887 NIL) C_1878 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1909 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (MOVE (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) (REGISTER *CH-CONTROL-PDL-INDEX* 7 3)) (ALU R+1 (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) IGNORE (REGISTER *CH-CONTROL-PDL-INDEX* 7 3) BW-24 BOXED-RIGHT) P_1921 (ALU-FIELD EXTRACT-BIT-RIGHT NOP IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 0) PW-II) (TEST BR-ZERO) (BRANCH C_1931 NIL) C_1922 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE BOXED) B_1953 (ALU-FIELD NB-SHIFT-0F-R (REGISTER *CH-TEMP-1* 7 5) IGNORE (REGISTER *CH-TEMP-1* 7 5) (BYTE 0 -1) PW-II) (UNCONDITIONAL-BRANCH LOOP_357 NIL) C_1931 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A15 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1953 NIL) C_1887 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A14 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1909 NIL) C_1843 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A13 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1865 NIL) C_1799 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A12 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1821 NIL) C_1755 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A11 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1777 NIL) C_1711 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A10 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1733 NIL) C_1667 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A9 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1689 NIL) C_1623 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A8 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1645 NIL) C_1579 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A7 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1601 NIL) C_1535 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A6 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1557 NIL) C_1491 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A5 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1513 NIL) C_1447 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A4 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1469 NIL) C_1403 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A3 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1425 NIL) C_1359 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A2 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1381 NIL) C_1315 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A1 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1337 NIL) C_1271 (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS A0 R2 (REGISTER *ZERO* 4 0) (QUOTE 0) PW-II DT-NONE UNBOXED) (UNCONDITIONAL-BRANCH B_1293 NIL) B_1986 (MOVEI O0 "call hardware restored" BOXED CH-OPEN) (CALL (ERROR 1) IGNORE NIL) (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT) (ALU L+R r13 R0 (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT) (ALU L-R r13 (REGISTER *CONTROL-PDL-POINTER* 7 1) (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT) (ALU-FIELD FIELD-PASS (MD BOXED-MD) R2 (REGISTER *ZERO* 4 0) (BYTE 24 0) PW-II DT-NONE BOXED-RIGHT) (MOVE (VMA-START-WRITE BOXED-VMA) r13) (OPEN-CALL (CONTROL-PDL-ASSURE-ROOM 1) (REGISTER *CONTROL-PDL* 7 0) (O0 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT)) (MOVE r14 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT) C_2035 (MOVE R0 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU L+R (VMA-START-READ-NO-TRANSPORT UNBOXED-VMA UNBOXED-MD) R0 (REGISTER *CONTROL-PDL* 7 0)) (MEMORY-WAIT) (MOVE R2 MD BOXED-RIGHT) (ALU-FIELD FIELD-PASS R2 R2 (REGISTER *ZERO* 4 0) (BYTE 21 0) PW-II DT-NONE BOXED-RIGHT) (ALU L+R R2 r14 R2 BW-24 BOXED-RIGHT) (MOVEI R0 (QUOTE 11) BOXED) (ALU-FIELD FIELD-PASS (REGISTER *CONTROL-PDL-LIMIT* 7 2) R0 R2 (QUOTE 1562) PW-II DT-NONE BOXED) (MOVE r15 (REGISTER *CONTROL-PDL* 7 0) BOXED-RIGHT) C_2053 (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT) (ALU L+R (VMA-START-READ BOXED-VMA BOXED-MD) R0 (REGISTER *CONTROL-PDL* 7 0) BW-24 BOXED-RIGHT) (MEMORY-WAIT) (MOVE R2 MD BOXED-RIGHT) (ALU L+R R2 r15 R2 BW-24 BOXED-RIGHT) (MOVEI R0 (QUOTE 11) BOXED) (ALU-FIELD FIELD-PASS (REGISTER *CONTROL-PDL-POINTER* 7 1) R0 R2 (QUOTE 1562) PW-II DT-NONE BOXED) (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE NIL) BOXED) (MOVE RETURN (REGISTER *NIL* 4 5) BOXED-RIGHT CH-RETURN NEXT-PC-RETURN)) ;(defun restore-call-hardware () ;(return-value) ;; (error "about to restore") ; (dumping-or-restoring-call-hardware t) ; (macrolet (;(saved-return-value () 'gr:*ch-temp-0*) ; (frame-first-word () 'gr:*ch-temp-1*) ; (next-rpc-rdest () 'gr:*ch-temp-2*) ; (global-frame () 'gr:*ch-temp-3*) ; (control-pdl-top () 'gr:*ch-temp-4*) ; (restore-register-prep () ; `(setf (frame-first-word) ; (hw:ldb (frame-first-word) %%cpdl0-box-bits (hw:unboxed-constant 0)))) ; (restore-register (register) ; `(progn ; (hw:vma-start-read-no-transport-vma-unboxed-md-unboxed gr:*ch-control-pdl-index* 0) ; (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*)) ; (if (hw:32logbitp 0 (frame-first-word)) ; (setf (,register) (hw:dpb-boxed (hw:read-md) (byte 32. 0) 0)) ; (setf (,register) (hw:dpb-unboxed (hw:read-md) (byte 32. 0) 0))) ; (setf (frame-first-word) (hw:32logical-shift-down (frame-first-word) 1))))) ;; (setf (saved-return-value) return-value) ; (forge-catcher-frame) ; (save-control-pdl-state) ;; (error "catcher frame installed") ; (setq gr:*ch-control-pdl-index* (hw:24+ (where-to-restore-from-control-pdl gr:*control-pdl*) ; (cons:make-pointer vinc:$$dtp-unboxed-locative gr:*control-pdl*))) ; ;;; we should probably flush our frames so they will return to the heap ; (tagbody ;;; WARNING: no locals are allowed. Use of OPEN and ACTIVE frames is prohibited ; (setq gr:*ch-base-csp* (hw:ldb (hw:read-call-sp-hp) ; hw:%%ch-csphp-call-stack-pointer 0)) ; (setf (control-pdl-top) gr:*control-pdl-pointer*) ; (setq gr:*control-pdl-pointer* gr:*ch-control-pdl-index*) ; loop ; (when (hw:24= gr:*ch-control-pdl-index* (control-pdl-top)) ; (go end)) ; (when (hw:24> gr:*ch-control-pdl-index* (control-pdl-top)) ; (trap:illop "frame alignment phase error in control pdl")) ; (hw:vma-start-read-no-transport-vma-unboxed-md-unboxed gr:*ch-control-pdl-index*) ; (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*)) ;point to second word ; (setf (frame-first-word) (hw:read-md)) ; (dispatch %%cpdl0-type-code (frame-first-word) ; (($$cpdl0-type-open-call $$cpdl0-type-protected-open-call) ; (hw:vma-start-read-no-transport-vma-unboxed-md-unboxed ; gr:*ch-control-pdl-index*) ; (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*)) ; (setf (next-rpc-rdest) (hw:ldb (frame-first-word) %%cpdl0-rdest (hw:unboxed-constant 0))) ; (setf (next-rpc-rdest) (hw:dpb (next-rpc-rdest) hw:%%ch-rpcd-return-dest (hw:read-md))) ; (setf (global-frame) (hw:ldb (frame-first-word) %%cpdl0-global-frame (hw:unboxed-constant 0))) ; (hw:trap-off) ; ;;;once Kent fixes the hardware we won't need to do the hack with SPARE-17 any more. ; (hw:write-processor-control ; (vinc:dpb-multiple-unboxed ; (global-frame) hw:%%processor-control-misc ;global frame number ; 1 hw:%%processor-control-spare-17 ; (hw:read-processor-control))) ;read boxed rpc ; (hw:nop) (hw:nop) (hw:nop) (hw:nop) ; (hw:write-return-pc-return-dest (next-rpc-rdest)) ; (hw:nop) ; (hw:ch-open-call) ; (hw:write-processor-control ; (hw:dpb-unboxed 0 hw:%%processor-control-spare-17 ; (hw:read-processor-control))) ; ;(trap:trap-on) ; (hw:nop) (hw:nop) ; (hw:write-memory-control ; (hw:dpb-unboxed hw:$$trap-enable hw:%%memory-control-master-trap-enable ; (hw:read-memory-control))) ; ;;; setup RPC, RDEST and global return destination for next time around: ; (go restore-a-frame)) ; ($$cpdl0-type-open ; ;;; we need only restore the open frame ; (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*)) ;skip RPC ; (hw:open-frame) ; (go restore-o-frame)) ; ($$cpdl0-type-topen ; ;;; we need only restore the active frame ; (setq gr:*ch-control-pdl-index* (hw:24-1+ gr:*ch-control-pdl-index*)) ;skip RPC ; (hw:ch-topen) ; (go restore-o-frame))) ; restore-o-frame ; (progn ; (restore-register-prep) ; (restore-register hw:o0) (restore-register hw:o1) ; (restore-register hw:o2) (restore-register hw:o3) ; (restore-register hw:o4) (restore-register hw:o5) ; (restore-register hw:o6) (restore-register hw:o7) ; (restore-register hw:o8) (restore-register hw:o9) ; (restore-register hw:o10) (restore-register hw:o11) ; (restore-register hw:o12) (restore-register hw:o13) ; (restore-register hw:o14) (restore-register hw:o15) ; (go loop)) ; restore-a-frame ; (progn ; (restore-register-prep) ; (restore-register hw:a0) (restore-register hw:a1) ; (restore-register hw:a2) (restore-register hw:a3) ; (restore-register hw:a4) (restore-register hw:a5) ; (restore-register hw:a6) (restore-register hw:a7) ; (restore-register hw:a8) (restore-register hw:a9) ; (restore-register hw:a10) (restore-register hw:a11) ; (restore-register hw:a12) (restore-register hw:a13) ; (restore-register hw:a14) (restore-register hw:a15) ; (go loop)) ; end) ; (li:error "call hardware restored") ; (save-control-pdl-state) ; (setq gr:*control-pdl* (control-pdl-assure-room gr:*control-pdl*)) ; (load-control-pdl-state) ; (dumping-or-restoring-call-hardware nil) ; )) ;;; when the control pdl and call hardware are scrolled the base of the call hardware ;;; must be an open-call frame so that the underflow catcher can be reached via a return operation. ;;; Since the call hardware dumper and restorer play with traps and can only be invoked while ;;; traps are enabled, this boundary can not fall on an open-call across which traps are disabled. ;;; To prevent the restorer from putting the underflow handler boundary at an open-call across which ;;; traps are disabled, we make the rule that only the trap handler is allowed to disable traps. ;;; We also have the rule that it must reenable traps by the time is goes TRAP-CALL-PROTECTION-COUNT ;;; deep in calls. When the call hardware dumper sees a return pc that is a trap entry (pc < 64) ;;; it protects the next TRAP-CALL-PROTECTION-COUNT open-calls that is sees by recording them ;;; as being control pdl frame type $$CPDL0-TYPE-PROTECTED-OPEN-CALL rather than $$CPDL0-TYPE-OPEN-CALL. ;;; The restorer only looks for $$CPDL0-TYPE-OPEN-CALL when deciding how much to restore but when ;;; it does restore, it treats both type codes the same. (defconstant trap-call-protection-count 2) (defmacro with-dumper-macros (&body body) `(macrolet ((previous-a-frame () 'gr:*ch-temp-0*) (accumulated-box-bits () 'gr:*ch-temp-1*) (saved-csp () 'gr:*ch-temp-2*) (protection-count () 'gr:*ch-temp-3*) (this-rpc () 'gr:*ch-temp-4*) (word-1 () 'gr:*ch-temp-5*) (save-register (register) `(progn (hw:write-md-unboxed (,register)) (hw:vma-start-write-no-gc-trap-unboxed gr:*control-pdl-pointer*) (setq gr:*control-pdl-pointer* (hw:24+ 1 gr:*control-pdl-pointer*)))) (save-box-bit (register) `(setf (accumulated-box-bits) (HW:ACCUMULATE-BOX-BITS (accumulated-box-bits) (,register))))) ,@body)) ;;; CLEAR-R-FRAME, WRITE-OPEN-CALL-FRAME and WRITE-OPEN-FRAME are invoked using the same hack that CONS-REST ;;; is called with. This allows the function to return to its caller (whose pc is stored in ;;; GR:*RETURN-PC-1*). This hack is required so that no call hardware operation is performed ;;; when calling the function or returning from it. This way we can access the same registers ;;; as our caller. (defafun write-open-call-frame () (movei gr:*ch-temp-1* 0) (move (md unboxed-md) a0) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a15 bw-24 carry-1 boxed-right) (move (md unboxed-md) a1) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a14 bw-24 carry-1 boxed-right) (move (md unboxed-md) a2) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a13 bw-24 carry-1 boxed-right) (move (md unboxed-md) a3) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a12 bw-24 carry-1 boxed-right) (move (md unboxed-md) a4) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a11 bw-24 carry-1 boxed-right) (move (md unboxed-md) a5) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a10 bw-24 carry-1 boxed-right) (move (md unboxed-md) a6) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a9 bw-24 carry-1 boxed-right) (move (md unboxed-md) a7) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a8 bw-24 carry-1 boxed-right) (move (md unboxed-md) a8) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a7 bw-24 carry-1 boxed-right) (move (md unboxed-md) a9) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a6 bw-24 carry-1 boxed-right) (move (md unboxed-md) a10) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a5 bw-24 carry-1 boxed-right) (move (md unboxed-md) a11) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a4 bw-24 carry-1 boxed-right) (move (md unboxed-md) a12) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a3 bw-24 carry-1 boxed-right) (move (md unboxed-md) a13) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a2 bw-24 carry-1 boxed-right) (move (md unboxed-md) a14) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a1 bw-24 carry-1 boxed-right) (move (md unboxed-md) a15) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* a0 bw-24 carry-1 boxed-right) ; (save-register hw:a0) (save-box-bit hw:a15) (save-register hw:a1) (save-box-bit hw:a14) ; (save-register hw:a2) (save-box-bit hw:a13) (save-register hw:a3) (save-box-bit hw:a12) ; (save-register hw:a4) (save-box-bit hw:a11) (save-register hw:a5) (save-box-bit hw:a10) ; (save-register hw:a6) (save-box-bit hw:a9) (save-register hw:a7) (save-box-bit hw:a8) ; (save-register hw:a8) (save-box-bit hw:a7) (save-register hw:a9) (save-box-bit hw:a6) ; (save-register hw:a10) (save-box-bit hw:a5) (save-register hw:a11) (save-box-bit hw:a4) ; (save-register hw:a12) (save-box-bit hw:a3) (save-register hw:a13) (save-box-bit hw:a2) ; (save-register hw:a14) (save-box-bit hw:a1) (save-register hw:a15) (save-box-bit hw:a0)) (alu setr nop gr:*ch-temp-3* gr:*ch-temp-3* bw-24 boxed dt-both-fixnum) (test br-not-zero) (branch c_12 nil) (move r2 gr:*one* boxed-right) c_28 (alu-field field-pass gr:*ch-temp-5* r2 gr:*ch-temp-5* (quote 512) pw-II dt-none unboxed) (move r0 gr:*ch-temp-4* boxed-right) (alu-field field-pass r2 r0 gr:*zero* (byte 26 0) pw-II dt-none boxed-right) (movei r1 (quote 64) boxed) (alu l-r nop r2 r1 bw-24 dt-both-fixnum) (test br-not-less-than) (branch b_59 nil) (movei gr:*ch-temp-3* (quote 2) boxed) b_59 (alu-field field-pass (md unboxed-md) gr:*ch-temp-1* gr:*ch-temp-5* (quote 4112) pw-II dt-none unboxed) (movei r0 '-18 boxed) (alu l+r (vma-start-write-no-gc-trap unboxed-vma) r0 gr:*control-pdl-pointer* bw-24 boxed-right) ; (move r0 gr:*one* boxed-right) ; (alu l+r r2 r0 gr:*ch-dumper-return-pc* bw-24 boxed-right) (alu r+1 gr:*ch-dumper-return-pc* gr:*ch-dumper-return-pc* gr:*ch-dumper-return-pc* bw-24 boxed-right) ; (move nop r2 boxed-right) (nop) (nop next-pc-dispatch) (move return gr:*nil* boxed-right ch-return next-pc-return) c_12 (alu r-1 gr:*ch-temp-3* gr:*ch-temp-3* gr:*ch-temp-3* bw-24 boxed dt-both-fixnum-with-overflow) (unconditional-branch c_28 (move r2 gr:*three* boxed-right))) ;(defun foo () ; (setf gr:*ch-temp-5* ; (hw:dpb-unboxed (if (zerop gr:*ch-temp-3*) ; $$cpdl0-type-open-call ; (progn (setf gr:*ch-temp-3* (1- gr:*ch-temp-3*)) ; $$cpdl0-type-protected-open-call)) ; %%cpdl0-type-code ; gr:*ch-temp-5*)) ; (when (< (hw:ldb gr:*ch-temp-4* vinc:%%pointer 0) 64.) ; (setf gr:*ch-temp-3* trap-call-protection-count)) ; (hw:write-md-unboxed (hw:dpb-unboxed gr:*ch-temp-1* %%cpdl0-box-bits gr:*ch-temp-5*)) ; (hw:vma-start-write-no-gc-trap-unboxed ; (hw:24+ (- control-pdl-frame-size) gr:*control-pdl-pointer*)) ; (hw:dispatch (hw:24+ 1 gr:*ch-dumper-return-pc*))) (defafun write-open-frame () (movei gr:*ch-temp-1* 0) (move (md unboxed-md) o0) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o15 bw-24 carry-1 boxed-right) (move (md unboxed-md) o1) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o14 bw-24 carry-1 boxed-right) (move (md unboxed-md) o2) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o13 bw-24 carry-1 boxed-right) (move (md unboxed-md) o3) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o12 bw-24 carry-1 boxed-right) (move (md unboxed-md) o4) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o11 bw-24 carry-1 boxed-right) (move (md unboxed-md) o5) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o10 bw-24 carry-1 boxed-right) (move (md unboxed-md) o6) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o9 bw-24 carry-1 boxed-right) (move (md unboxed-md) o7) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o8 bw-24 carry-1 boxed-right) (move (md unboxed-md) o8) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o7 bw-24 carry-1 boxed-right) (move (md unboxed-md) o9) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o6 bw-24 carry-1 boxed-right) (move (md unboxed-md) o10) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o5 bw-24 carry-1 boxed-right) (move (md unboxed-md) o11) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o4 bw-24 carry-1 boxed-right) (move (md unboxed-md) o12) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o3 bw-24 carry-1 boxed-right) (move (md unboxed-md) o13) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o2 bw-24 carry-1 boxed-right) (move (md unboxed-md) o14) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o1 bw-24 carry-1 boxed-right) (move (md unboxed-md) o15) (move (vma-start-write-no-gc-trap unboxed-vma) (register *control-pdl-pointer* 7 1)) (move r0 (register *one* 4 1) boxed-right) (alu r+1 (register *control-pdl-pointer* 7 1) r0 (register *control-pdl-pointer* 7 1) bw-24 boxed-right) (alu shift-up-lf-l gr:*ch-temp-1* gr:*ch-temp-1* o0 bw-24 carry-1 boxed-right) ; (with-dumper-macros ; (progn ; (save-register hw:o0) (save-box-bit hw:o15) (save-register hw:o1) (save-box-bit hw:o14) ; (save-register hw:o2) (save-box-bit hw:o13) (save-register hw:o3) (save-box-bit hw:o12) ; (save-register hw:o4) (save-box-bit hw:o11) (save-register hw:o5) (save-box-bit hw:o10) ; (save-register hw:o6) (save-box-bit hw:o9) (save-register hw:o7) (save-box-bit hw:o8) ; (save-register hw:o8) (save-box-bit hw:o7) (save-register hw:o9) (save-box-bit hw:o6) ; (save-register hw:o10) (save-box-bit hw:o5) (save-register hw:o11) (save-box-bit hw:o4) ; (save-register hw:o12) (save-box-bit hw:o3) (save-register hw:o13) (save-box-bit hw:o2) ; (save-register hw:o14) (save-box-bit hw:o1) (save-register hw:o15) (save-box-bit hw:o0)) ; (hw:write-md-unboxed (hw:dpb-unboxed gr:*ch-temp-1* %%cpdl0-box-bits gr:*ch-temp-5*)) ; (hw:vma-start-write-no-gc-trap-unboxed ; (hw:24+ (- control-pdl-frame-size) gr:*control-pdl-pointer*)) ; (hw:dispatch (hw:24+ 1 gr:*ch-dumper-return-pc*)) (alu-field field-pass (md unboxed-md) gr:*ch-temp-1* gr:*ch-temp-5* (quote 4112) pw-II dt-none unboxed) (movei r0 '-18 boxed) (alu l+r (vma-start-write-no-gc-trap unboxed-vma) r0 gr:*control-pdl-pointer* bw-24 boxed-right) (move r0 gr:*one* boxed-right) (alu l+r r2 r0 gr:*ch-dumper-return-pc* bw-24 boxed-right) (move nop r2 boxed-right) (nop) (nop next-pc-dispatch) (move return gr:*nil* boxed-right ch-return next-pc-return)) (defun clear-r-frame () (setf (hw:r0) (hw:unboxed-constant 0)) (setf (hw:r1) (hw:unboxed-constant 0)) (setf (hw:r2) (hw:unboxed-constant 0)) (setf (hw:r3) (hw:unboxed-constant 0)) (setf (hw:r4) (hw:unboxed-constant 0)) (setf (hw:r5) (hw:unboxed-constant 0)) (setf (hw:r6) (hw:unboxed-constant 0)) (setf (hw:r7) (hw:unboxed-constant 0)) (setf (hw:r8) (hw:unboxed-constant 0)) (setf (hw:r9) (hw:unboxed-constant 0)) (setf (hw:r10) (hw:unboxed-constant 0)) (setf (hw:r11) (hw:unboxed-constant 0)) (setf (hw:r12) (hw:unboxed-constant 0)) (setf (hw:r13) (hw:unboxed-constant 0)) (setf (hw:r14) (hw:unboxed-constant 0)) (setf (hw:r15) (hw:unboxed-constant 0)) (hw:dispatch (hw:24+ 1 gr:*return-pc-1*))) (defafun Dump-Call-Hardware () P_315 (MOVE NOP (REGISTER *CH-DUMPER-RETURN-PC* 7 10) BOXED-RIGHT) (TEST BR-ZERO) (BRANCH B_329 NIL) C_317 (MOVEI O0 (QUOTE 376) BOXED CH-OPEN) (CALL (trap:ILLOP-FUNCTION 1) IGNORE NIL) B_329 (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE T) BOXED) (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ZERO* 4 0) R2 (QUOTE 274) PW-II DT-NONE BOXED-RIGHT) (MOVEI (REGISTER *CH-TEMP-3* 7 7) (QUOTE 0) BOXED) (MOVEI (REGISTER *CH-TEMP-0* 7 4) (QUOTE 256) BOXED) (MOVE R2 CALL-SP-HP BOXED-RIGHT) (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-2* 7 6) R2 R1 (BYTE 8 0) PW-II DT-NONE BOXED-RIGHT) (MOVE IGNORE TRAP-OFF) LOOP_40 (ALU R+1 (REGISTER *CH-BASE-CSP* 7 9) IGNORE (REGISTER *CH-BASE-CSP* 7 9) BW-8 BOXED-RIGHT) (MOVE r13 (REGISTER *CH-BASE-CSP* 7 9) BOXED-RIGHT) C_48 (MOVE R2 CALL-SP-HP BOXED-RIGHT) (ALU-FIELD FIELD-PASS CALL-SP-HP r13 R2 (QUOTE 2048) PW-II DT-NONE UNBOXED) (NOP) (NOP) (NOP) (NOP) (NOP) (MOVE R2 RETURN-PC-RETURN-DEST BOXED-RIGHT) (MOVE R1 (REGISTER *TRAP-DTP-CODE-5* 0 15) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-4* 7 8) R2 R1 (BYTE 24 0) PW-II DT-NONE BOXED-RIGHT) (MOVEI (REGISTER *CH-TEMP-5* 7 11) 0 UNBOXED) (MOVE R2 RETURN-PC-RETURN-DEST BOXED-RIGHT) (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-6* 7 12) R2 R1 (BYTE 7 -24) PW-II DT-NONE BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) (REGISTER *CH-TEMP-6* 7 12) (REGISTER *CH-TEMP-5* 7 11) (QUOTE 1794) PW-II DT-NONE UNBOXED) (MOVE R2 PROCESSOR-STATUS BOXED-RIGHT) (MOVE R1 (REGISTER *ALL-ZERO* 4 6) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-6* 7 12) R2 R1 (BYTE 4 -9) PW-II DT-NONE BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) (REGISTER *CH-TEMP-6* 7 12) (REGISTER *CH-TEMP-5* 7 11) (QUOTE 1033) PW-II DT-NONE UNBOXED) (NOP CH-RETURN) (NOP) (NOP) (NOP) (NOP) (NOP) (MOVE r14 (REGISTER *CH-TEMP-2* 7 6) BOXED-RIGHT) C_122 (MOVE R2 CALL-SP-HP BOXED-RIGHT) (ALU-FIELD FIELD-PASS CALL-SP-HP r14 R2 (QUOTE 2048) PW-II DT-NONE UNBOXED) (NOP) (NOP) (NOP) (NOP) (NOP) (MOVE R2 MEMORY-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS MEMORY-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 287) PW-II DT-NONE UNBOXED) (NOP) (NOP) (NOP) (NOP) (MOVE (MD UNBOXED-MD) (REGISTER *CH-TEMP-4* 7 8)) (MOVE R0 (REGISTER *ONE* 4 1) BOXED-RIGHT) (ALU L+R (VMA-START-WRITE-NO-GC-TRAP UNBOXED-VMA) R0 (REGISTER *CONTROL-PDL-POINTER* 7 1) BW-24 BOXED-RIGHT) (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT) (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-6* 7 12) R2 R1 (BYTE 8 -8) PW-II DT-NONE BOXED-RIGHT) (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT) (ALU L+R (REGISTER *CONTROL-PDL-POINTER* 7 1) R0 (REGISTER *CONTROL-PDL-POINTER* 7 1) BW-24 BOXED-RIGHT) P_174 (MOVE r15 (REGISTER *CH-TEMP-6* 7 12) BOXED-RIGHT) C_272 (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT) (ALU-FIELD FIELD-PASS R2 R2 (REGISTER *ZERO* 4 0) (BYTE 8 -16) PW-II DT-NONE BOXED-RIGHT) (ALU XOR NOP r15 R2 BW-24 DT-BOTH-FIXNUM) (TEST BR-NOT-EQUAL) (BRANCH C_188 NIL) C_175 (JUMP WRITE-OPEN-CALL-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+)) (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT) (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-0* 7 4) R2 R1 (BYTE 8 -8) PW-II DT-NONE BOXED-RIGHT) (MOVE IGNORE TRAP-OFF) B_298 (ALU XOR NOP (REGISTER *CH-BASE-CSP* 7 9) (REGISTER *CH-TEMP-2* 7 6) BW-24 DT-BOTH-FIXNUM) (TEST BR-NOT-EQUAL) (BRANCH LOOP_40 NIL) END_303 ; (TAIL-CALL (0 0) NIL NEXT-PC-PC+1) (MOVE R2 PROCESSOR-CONTROL BOXED-RIGHT) (ALU-FIELD FIELD-PASS PROCESSOR-CONTROL (REGISTER *ONE* 4 1) R2 (QUOTE 274) PW-II DT-NONE BOXED-RIGHT) (nop) (nop ch-tail-open next-pc-pc+1) (move r0 open-active-return unboxed) (alu-field field-pass r1 r0 gr:*zero* (byte 8 -16) ) (alu-field field-pass open-active-return r1 r0 (byte 8 8) ) (nop) (nop) (nop) (nop) (nop) (OPEN-CALL (trap:TRAP-ON 0) IGNORE NIL) B_361 (MOVEI O0 "dumped" BOXED CH-OPEN) (CALL (ERROR 1) IGNORE NIL) (OPEN-CALL (SELECT-CONTROL-PDL 1) IGNORE (O0 (REGISTER *NEXT-CONTROL-PDL* 7 15) BOXED-RIGHT)) (MOVEI (REGISTER *CH-DUMPER-RETURN-PC* 7 10) (QUOTE NIL) BOXED) (OPEN-TAIL-CALL (RESTORE-CALL-HARDWARE 0) NIL) C_188 (ALU XOR NOP (REGISTER *CH-TEMP-6* 7 12) (REGISTER *CH-TEMP-0* 7 4) BW-24 DT-BOTH-FIXNUM) (TEST BR-NOT-EQUAL) (BRANCH C_218 NIL) C_191 (MOVE R0 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) R0 (REGISTER *CH-TEMP-5* 7 11) (QUOTE 512) PW-II DT-NONE UNBOXED) (JUMP WRITE-OPEN-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+)) (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT) (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-0* 7 4) R2 R1 (BYTE 8 -8) PW-II DT-NONE BOXED-RIGHT) (TAIL-CALL (0 0) (IGNORE TRAP-OFF) NEXT-PC-PC+1) (TAIL-OPEN-CALL (0 0) NIL NEXT-PC-PC+1) (TAIL-OPEN) (UNCONDITIONAL-BRANCH B_298 NIL) C_218 (JUMP WRITE-OPEN-CALL-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+)) (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT) (ALU L+R (REGISTER *CONTROL-PDL-POINTER* 7 1) R0 (REGISTER *CONTROL-PDL-POINTER* 7 1) BW-24 BOXED-RIGHT) (MOVE R0 (REGISTER *TWO* 4 3) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-5* 7 11) R0 (REGISTER *CH-TEMP-5* 7 11) (QUOTE 512) PW-II DT-NONE UNBOXED) (JUMP WRITE-OPEN-FRAME ((REGISTER *CH-DUMPER-RETURN-PC* 7 10) TRAP-PC+)) (MOVE R2 OPEN-ACTIVE-RETURN BOXED-RIGHT) (MOVE R1 (REGISTER *ZERO* 4 0) BOXED-RIGHT) (ALU-FIELD FIELD-PASS (REGISTER *CH-TEMP-0* 7 4) R2 R1 (BYTE 8 -8) PW-II DT-NONE BOXED-RIGHT) (TAIL-CALL (0 0) (IGNORE TRAP-OFF) NEXT-PC-PC+1) (UNCONDITIONAL-BRANCH B_298 NIL)) ;(defun dump-call-hardware () ;; (setq gr:*control-pdl-pointer* (hw:24+ (control-pdl-pointer gr:*control-pdl*) ;; (cons:make-pointer vinc:$$dtp-unboxed-locative gr:*control-pdl*))) ; (with-dumper-macros ; (tagbody ; (dumping-or-restoring-call-hardware t) ; (hw:write-processor-control (hw:dpb hw:$$call-heap-underflow-trap-disable ; hw:%%processor-control-heap-underflow-trap-enable ; (hw:read-processor-control))) ; (setf (protection-count) 0) ; (setf (previous-a-frame) 256) ;nonexistant ; (setf (saved-csp) (hw:ldb (hw:read-call-sp-hp) hw:%%ch-csphp-call-stack-pointer 0)) ; (hw:trap-off) ; loop ; (setq gr:*ch-base-csp* (hw:8-1+ gr:*ch-base-csp*)) ; (hw:write-call-sp-hp (hw:dpb-unboxed gr:*ch-base-csp* ; hw:%%ch-csphp-call-stack-pointer (hw:read-call-sp-hp))) ; (hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:nop) ;how many do we need? ; (setf (this-rpc) (hw:ldb (hw:read-return-pc-return-dest) ; hw:%%ch-rpcd-return-pc gr:*trap-dtp-code-5*)) ; (setf (word-1) (hw:unboxed-constant 0)) ; (setq gr:*ch-temp-6* (hw:ldb (hw:read-return-pc-return-dest) ; hw:%%ch-rpcd-return-dest (hw:unboxed-constant 0))) ; (setf (word-1) (hw:dpb-unboxed gr:*ch-temp-6* %%cpdl0-rdest (word-1))) ; (setq gr:*ch-temp-6* (hw:ldb (hw:read-processor-status) ; hw:%%processor-status-global-return-frame ; (hw:unboxed-constant 0))) ; (setf (word-1) (hw:dpb-unboxed gr:*ch-temp-6* %%cpdl0-global-frame (word-1))) ;; (hw:jump-saving-pc 'clear-r-frame gr:*ch-dumper-return-pc*) ; (hw::ch-return) (hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:nop) ;do we need these NOPs ; (hw:write-call-sp-hp (hw:dpb-unboxed (saved-csp) ; hw:%%ch-csphp-call-stack-pointer (hw:read-call-sp-hp))) ; (hw:nop) (hw:nop) (hw:nop) (hw:nop) (hw:nop) ;; (trap:trap-on) ; (hw:write-memory-control ; (hw:dpb-unboxed hw:$$trap-enable hw:%%memory-control-master-trap-enable ; (hw:read-memory-control))) ; (hw:nop) (hw:nop) (hw:nop) (hw:nop) ; (hw:write-md-unboxed (this-rpc)) ; (hw:vma-start-write-no-gc-trap-unboxed (hw:24+ 1 gr:*control-pdl-pointer*)) ; (setq gr:*ch-temp-6* (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0)) ; (setq gr:*control-pdl-pointer* (hw:24+ control-pdl-frame-offset-to-registers ; gr:*control-pdl-pointer*)) ; (cond ((= gr:*ch-temp-6* ; (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-open 0)) ;OPEN-CALL ; (hw:jump-saving-pc 'write-open-call-frame gr:*ch-dumper-return-pc*) ; (setf (previous-a-frame) (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0)) ; (hw:trap-off)) ; ((= gr:*ch-temp-6* (previous-a-frame)) ;OPEN ; (setf (word-1) (hw:dpb-unboxed $$cpdl0-type-open %%cpdl0-type-code (word-1))) ; (hw:jump-saving-pc 'write-open-frame gr:*ch-dumper-return-pc*) ; (setf (previous-a-frame) (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0)) ; (hw:trap-off) ; (hw:ch-tcall) ; (hw:ch-topen-call) ; (hw:ch-topen)) ; (t ;OPEN-CALL TOPEN ; (hw:jump-saving-pc 'write-open-call-frame gr:*ch-dumper-return-pc*) ; (setq gr:*control-pdl-pointer* (hw:24+ control-pdl-frame-offset-to-registers ; gr:*control-pdl-pointer*)) ; (setf (word-1) (hw:dpb-unboxed $$cpdl0-type-topen %%cpdl0-type-code (word-1))) ; (hw:jump-saving-pc 'write-open-frame gr:*ch-dumper-return-pc*) ; (setf (previous-a-frame) (hw:ldb (hw:read-open-active-return) hw:%%ch-oar-active 0)) ; (hw:trap-off) ; (hw::ch-tcall))) ; (unless (= gr:*ch-base-csp* (saved-csp)) ; (go loop)) ; end ; (hw:ch-tcall) ; (hw:write-processor-control (hw:dpb hw:$$call-heap-underflow-trap-enable ; hw:%%processor-control-heap-underflow-trap-enable ; (hw:read-processor-control))) ; (trap:trap-on)) ; (error "dumped") ; (select-control-pdl gr:*next-control-pdl*) ; (dumping-or-restoring-call-hardware nil) ; (restore-call-hardware)))