.TITLE	CRASH
	.IDENT	/04/
;
;
; COPYRIGHT (C) 1977
; DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS.
;
;
; THIS  SOFTWARE  IS  FURNISHED  UNDER A LICENSE FOR USE ONLY ON A
; SINGLE COMPUTER SYSTEM AND MAY BE COPIED ONLY WITH THE INCLUSION
; OF  THE  ABOVE COPYRIGHT  NOTICE.  THIS SOFTWARE, OR  ANY  OTHER
; COPIES THEREOF, MAY NOT BE PROVIDED OR OTHERWISE  MADE AVAILABLE
; TO  ANY  OTHER PERSON  EXCEPT  FOR USE ON SUCH SYSTEM AND TO ONE
; WHO AGREES TO THESE LICENSE TERMS.  TITLE  TO  AND  OWNERSHIP OF
; THE SOFTWARE SHALL AT ALL TIMES REMAIN IN DIGITAL.
;
; THE  INFORMATION  IN THIS DOCUMENT IS SUBJECT  TO CHANGE WITHOUT
; NOTICE AND SHOULD NOT BE CONSTRUED AS A  COMMITMENT  BY  DIGITAL
; EQUIPMENT CORPORATION.
;
; DIGITAL ASSUMES NO  RESPONSIBILITY FOR THE USE OR RELIABILITY OF
; ITS SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
;
;
; VERSION 04
;
; J. MASSE / P. J. BEZEREDI  24-OCT-77
;
;
; CRASH DUMP ROUTINES
;


	.IF DF	C$$RSH

;
; MACRO LIBRARY CALLS
;
	.MCALL	HWDDF$
	HWDDF$

;
; LOCAL DATA
;

;
;
$CRUPC::.WORD	0		; USER PC IS STORED HERE
$CRUST::.WORD	0		; USER PS IS STORED HERE

	.IF DF	C$$CDA

CRSMSG:	.ASCII	<15><12><12>/CRASH -- CONT WITH SCRATCH MEDIA ON /

.IIF EQ C$$CDA-1,	.ASCII	/DT/
.IIF EQ C$$CDA-2,	.ASCII	/DK/
.IIF EQ C$$CDA-3,	.ASCII	/MT/
.IIF EQ C$$CDA-4,	.ASCII	/MM/

UNIT:	.ASCIZ	/0/<15><12><12>
	.EVEN

	.ENDC


	.IF DF	C$$TTY

MSG1:	.ASCIZ	<15><12><12>/SYSTEM CRASH AT LOCATION /
MSG2:	.ASCII	<15><12><12>/REGISTERS/<15><12><12>
	.ASCIZ	/ R0=/
MSG3:	.ASCIZ	/R1=/
MSG4:	.ASCIZ	/R2=/
MSG5:	.ASCIZ	/R3=/
MSG6:	.ASCIZ	<15><12><12>/ R4=/
MSG7:	.ASCIZ	/R5=/
MSG8:	.ASCIZ	/SP=/
MSG9:	.ASCIZ	/PS=/<0>
MSG10:	.ASCII	<15><12><12>/SYSTEM STACK DUMP/
	.ASCIZ	<15><12><12>/ LOCATION CONTENTS/<15><12><12>
	.EVEN

	.ENDC


				; *** THE FOLLOWING MUST BE ADJACENT
$CRPBF::.BLKW	4		;STACK AREA FOR SUBROUTINE CALLS
$CRSBF::.BLKW	14.		;INTERNAL CRASH STACK ...
$CRPST::			;TOP OF PANIC STACK


	.IF DF	M$$MGE

	.BLKW	159.		;... MAPPED STACK IS THIS LARGE

	.ENDC


$CRSST==.-2			;TOP OF CRASH STACK
				; *** ABOVE MUST BE ADJACENT


	.IF DF	C$$CDA

$CRSBN::.WORD	PBNH,PBNL	;STARTING DEVICE ADDRESS
$CRSCS::.WORD	PBNH+PBNL	;CHECKSUM OF DEVICE ADDRESS

;
; LOCAL MACROS
;
	.MACRO	PUSH	ARG
	SUB	#2,SP
	MOV	ARG,(SP)
	.ENDM	PUSH

	.ENDC


	.ENDC


;+
; **-$CRASH-SYSTEM CRASH DUMP ROUTINE
;
; THIS ROUTINE IS ENTERED VIA A JUMP WHENEVER A FATAL SYSTEM ERROR
; (IOT) IS DETECTED.
;
; THIS ROUTINE PERFORMS A MEMORY DUMP THAT CAN BE DIRECTED TO A
; HARD COPY DEVICE, DECTAPE, RK05, TU10 OR TU16.  THE DUMP GENERATED
; WILL HAVE A SPECIAL BLOCK AS THE FIRST BLOCK OF THE DUMP, WHICH WILL
; CONTAIN INFORMATION CONCERNING THE STATE OF THE SYSTEM AT THE TIME
; THE CRASH OCCURRED.  ONCE THE DUMP IS FINSIHED THE SYSTEM MAY BE
; RE-BOOTED OR ANOTHER DUMP MAY BE TAKEN.  IF THE DUMP IS DIRECTED
; TO A HARD COPY DEVICE THE DUMP WILL CONTAIN ONLY THE REGISTER
; CONTENTS AND THE SYSTEM STACK.
;
; INPUTS:
;
;	02(SP)=PS WORD AT CRASH.
;	00(SP)=PC WORD AT CRASH.
;
; OUTPUTS:
;
;	THE INTERNAL CRASH STACK AND A CORE IMAGE OF THE SYSTEM,
;	UP TO 128K, ARE DUMPED ONTO THE MASS STORAGE CRASH DUMP DEVICE.
;	THE REGISTER CONTENTS AND THE SYSTEM STACK ARE DUMPED IF A
;	HARD COPY DUMP IS REGUESTED.
;-

$CRASH::			;CRASH DUMP ROUTINE


	.IF DF	C$$RSH
;
	MOV	(SP)+,$CRUPC	; SAVE USER PC FROM THE STACK
	MOV	(SP)+,$CRUST	; SAVE USER PS FROM THE STACK
$CRALT::
;


	.IF DF	C$$TTY

	MOV	(SP)+,$CRPBF	;SAVE LOCATION OF CRASH
	MOV	R0,$CRPBF+2	;SAVE R0
	MOV	#$CRPBF+4,R0	;SET UP SAVE AREA
	MOV	R1,(R0)+	;SAVE R1 THRU R5
	MOV	R2,(R0)+	;
	MOV	R3,(R0)+	;
	MOV	R4,(R0)+	;
	MOV	R5,(R0)+	;
	MOV	(SP)+,2(R0)	;SAVE PS
	MOV	SP,(R0)		;SAVE SP
	MOV	#$CRPST,SP	;SETUP TEMPORARY STACK
	MOV	#C$$TTY,R5	;SPECIFY OUTPUT DEVICE CSR
	MOV	#$CRPBF,R1	;POINT TO DATA VECTOR
	MOV	#MSG1,R4	;POINT TO MESSAGE TEXT
1$:	MOVB	(R4)+,R2	;GET A BYTE OF MESSAGE
	BEQ	5$		;IF EQ AT MESSAGE BREAK
	BR	3$		;ELSE ALREADY HAVE A BYTE
2$:	MOVB	(R4)+,R2	;GET A BYTE OF MESSAGE
	BEQ	4$		;IF EQ END OF THIS MESSAGE
3$:	CALL	$OUT		;OUTPUT THIS CHARACTER
	BR	2$		;GO AGAIN
4$:	MOV	(R1)+,R3	;GET DATA WORD
	CALL	$EDIT		;PRINT IN PLACE
	BR	1$		;GET NEXT MESSAGE
5$:	MOVB	(R4)+,R2	;GET NEXT CHARACTER TO OUTPUT
	BEQ	6$		;IF EQ END OF STRING
	CALL	$OUT		;OUTPUT CHARACTER
	BR	5$		;GO AGAIN
6$:	MOV	$CRPBF+16,R1	;POINT TO BOTTOM OF SYSTEM STACK
7$:	MOV	R1,R3		;SET ADDRESS OF LOCATION TO EDIT
	CALL	8$		;EDIT ADDRESS
	MOV	(R1)+,R3	;GET CONTENTS OF LOCATION
	CALL	8$		;EDIT CONTENTS
	CALL	$CRLF		;ISSUE CARRIAGE RETURN, LINE FEED
	CMP	R1,#$STACK	;END OF SYSTEM STACK?
	BLO	7$		;IF LO NO
	MOV	#$CRPBF+16,R0	;POINT TO SAVED STACK POINTER
	MOV	(R0),SP		;RESTORE SP
	MOV	-(R0),R5	;RESTORE R5 THRU R0
	MOV	-(R0),R4	;
	MOV	-(R0),R3	;
	MOV	-(R0),R2	;
	MOV	-(R0),R1	;
	MOV	-(R0),R0	;
	BR	9$		;BR AROUND SUBROUTINE
8$:	CALL	$OUTB		;OUTPUT TWO BLANKS
	CALL	$OUTB		;
	CALLR	$EDIT		;PRINT CONTENTS OF R3 AND RETURN
9$:				;REF LABEL

	.ENDC


	.IF DF	C$$CDA

	MOV	#6,@#4		;SETUP TO IGNORE NON-EXISTANT MEMORY
	MOV	#2,@#6		;PUT RTI INSTRUCTION IN LOCATION 6


	.IF DF	L$$SI1

	CLR	$CRSST		;CLEAR PS STORAGE WORD
	MFPS	$CRSST		;STORE LOW BYTE OF PS
	MTPS	#PR7		;LOCK OUT INTERRUPTS

	.IFF

	MOV	PS,$CRSST	;STORE FULL PS
	MOVB	#PR7,PS		;LOCK OUT INTERRUPTS

	.ENDC


	MOV	SP,$CRSST-2	;;;SAVE SP
	MOV	$CRUPC,$CRSST-4	;;;SAVE PC BEFORE IOT CRASH
	MOV	$CRUST,$CRSST-6	;;;SAVE PS BEFORE IOT CRASH
	MOV	#$CRSST-6,SP	;;;RESET SP TO INTERNAL STACK


	.IF DF	M$$MGE

	MFPI	SP		;;;SAVE USER'S SP

	.IFF

	CLR	-(SP)		;;;NO USER SP IF UNMAPPED

	.IFTF

	MOV	R0,-(SP)	;;;SAVE REGISTER SET 1
	MOV	R1,-(SP)	;;;
	MOV	R2,-(SP)	;;;
	MOV	R3,-(SP)	;;;
	MOV	R4,-(SP)	;;;
	MOV	R5,-(SP)	;;;

	.IFT

	PUSH	SR0		;;;SAVE MEMORY MANAGEMENT REGISTERS
	PUSH	SR0+2		;;;
	PUSH	SR0+4		;;;
	PUSH	SR3		;;;
	BIC	#67,SR3		;;;DISABLE UNIBUS MAP AND D-SPACE
	MOV	#UISDR0,R0	;;;SETUP TO SAVE FIRST SET OF APR'S
	MOV	#32.,R1		;;;
10$:	PUSH	(R0)		;;;SAVE APR
	ADD	#2,R0		;;;MOVE TO NEXT ONE
	DEC	R1		;;;DONE YET?
	BNE	10$		;;;IF NE NO
	MOV	#SISDR0,R0	;;;SETUP TO SAVE SECOND SET OF APR'S
	MOV	#64.,R1		;;;
20$:	PUSH	(R0)		;;;SAVE APR
	ADD	#2,R0		;;;MOVE TO NEXT ONE
	DEC	R1		;;;DONE YET?
	BNE	20$		;;;IF NE NO
	MOV	#UBMPR,R0	;;;GET ADDRESS OF FIRST UMR
	MOV	#62.,R1		;;;NUMBER OF UMR'S TO SAVE
30$:	PUSH	(R0)		;;;SAVE A UMR
	ADD	#2,R0		;;;MOVE TO NEXT ONE
	DEC	R1		;;;DONE YET?
	BNE	30$		;;;IF NE NO

	.ENDC


;
; TYPE MESSAGE AND WAIT FOR USER
;

AGAIN:	MOV	$CRSUN,R0	;;;GET CRASH UNIT NUMBER
	ADD	#'0,R0		;;;ADD ASCII BIAS
	MOVB	R0,UNIT		;;;MOVE IT INTO TEXT STRING
	MOV	#CRSMSG,R1	;;;TYPE USER MESSAGE
	MOV	#C$$RSH,R5	;;;GET CSR ADDRESS OF PRINT DEVICE
10$:	MOVB	(R1)+,R2	;;;GET CHARACTER
	BEQ	$CRSHT		;;;IF EQ MESSAGE PRINTED
	CALL	$OUT		;;;OUTPUT THE CHARACTER
	BR	10$		;;;LOOP FOR MORE
$CRSHT::HALT			;;;WAIT FOR THE USER
	BR	DUMP		;;;GO DO THE DUMP

;
; FOR CONVENIENCE THE CRASH DEVICE UNIT NUMBER IS STORED
; HERE SO THAT THE CONSOLE DISPLAY +2 WILL GIVE THE
; ADDRESS OF THE NEXT WORD, THUS ALLOWING THE USER TO PATCH
; A DIFFERENT UNIT NUMBER (IGNORING THE PRINTOUT).
;

$CRSUN::.WORD	C$$RUN		;;;CRASH UNIT NUMBER (DEFAULT=0)


;+
; **-CKSUM-VERIFY CHECKSUM OF DEVICE ADDRESS
;
; THIS ROUTINE WILL VERIFY THAT THE DEVICE ADDRESS FOR THE RK11
; AND TC11 HAS NOT BEEN CORRUPTED BY THE CRASH.
;-

CKSUM:	MOV	$CRSBN,-(SP)	;;;GET HIGH ORDER BITS
	ADD	$CRSBN+2,(SP)	;;;ADD LOW ORDER BITS
	CMP	(SP)+,$CRSCS	;;;COMPARE WITH CHECKSUM
	BEQ	10$		;;;IF EQ OK
	HALT			;;;WAIT FOR USER
	BR	CKSUM		;;;TRY AGAIN
10$:	RETURN			;;;

;+
; **-DUMP-DUMP THE SYSTEM IMAGE
;
; THIS ROUTINE IS USED TO DUMP THE INTERNAL CRASH STACK
; AND THE SYSTEM IMAGE ONTO A SCTATCH DUMP MEDIA.  WHEN THE DUMP
; IS FINISHED THE SYSTEM IS EITHER RE-BOOTED OR THE USER IS ASKED
; IF HE WANTS TO DUMP ANOTHER COPY OF THE IMAGE.
; 
; INPUTS:
;	NONE.
;
; OUTUTS:
;	IMAGE DUMPED.
;-

DUMP:				;;;DUMP IMAGE ONTO MEDIA
	MOV	#C$$CSR,R0	;;;GET CSR ADDRESS OF DUMP DEVICE
	MOV	$CRSUN,R3	;;;GET UNIT NUMBER


	.IF EQ	C$$CDA-1

PBNH=	0			;HIGH ORDER TC11 BLOCK NUMBER
PBNL=	100			;LOW ORDER TC11 BLOCK NUMBER

	CALL	CKSUM		;;;CHECK BLOCK NUMBER AGAINST CHECKSUM
	SWAB	R3		;;;POSITION UNIT BITS
	MOV	R3,R1		;;;COPY
	BIS	#4003,R1	;;;SET FOR READ LBN IN REVERSE
	MOV	R1,(R0)		;;;START THE TAPE
10$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BEQ	10$		;;;IF EQ NO
	BPL	DUMP		;;;IF PL MOVE UNTIL ENDZONE
20$:	MOV	R3,R1		;;;RETREIVE UNIT BITS
	BIS	#3,R1		;;;SET TO READ LBN FORWARD
	MOV	R1,(R0)		;;;START THE TAPE
30$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BMI	DUMP		;;;IF MI ERROR, RESTART
	BEQ	30$		;;;IF EQ WAIT
	SUB	$CRSBN+2,6(R0)	;;;ARE WE AT THE BLOCK WE WANT?
	BNE	20$		;;;IF NE NO
	MOV	#-256.,2(R0)	;;;WORD COUNT FOR INTERNAL STACK
	MOV	#$CRSBF,4(R0)	;;;SET INTERNAL STACK ADDRESS
	MOV	R3,R1		;;;RETREIVE UNIT BITS
	BIS	#15,R1		;;;SET TO WRITE DATA FORWARD
	MOV	R1,(R0)		;;;WRITE THE BLOCK
40$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BEQ	40$		;;;IF EQ NO
	BMI	DUMP		;;;IF MI ERROR, RESTART
	CLR	2(R0)		;;;SET TO WRITE ALL MEMORY
	CLR	4(R0)		;;;
	MOV	R3,R1		;;;RETREIVE UNIT BITS
	BIS	#15,R1		;;;SET TO WRITE DATA FORWARD
	MOV	R1,(R0)		;;;WRITE ALL MEMORY
50$:	CLR	2(R0)		;;;KEEP WRITING
	TST	(R0)		;;;ANY ERRORS?
	BPL	50$		;;;IF PL NO
	BIT	#400,-2(R0)	;;;NON-EXISTANT MEMORY?
	BEQ	DUMP		;;;IF EQ NO, RESTART
	BIS	#1,R3		;;;SET TO STOP TAPE
	MOV	R3,(R0)		;;;STOP TAPE

	.ENDC


	.IF EQ	C$$CDA-2

PBNH=	0			;HIGH PART OF RK11 DISK ADDRESS
PBNL=	124			; LOW PART OF RK11 DISK ADDRESS

	CALL	CKSUM		;;;CHECK DISK ADDRESS AGAINST CHECKSUM
	CLC			;;;SET TO POSITION UNIT BITS
	ROR	R3		;;;
	ROR	R3		;;;
	ROR	R3		;;;
	ROR	R3		;;;
	MOV	#401,(R0)	;;;RESET RK11 CONTROLLER
	BIS	$CRSBN+2,R3	;;;SET STARTING DISK ADDRESS
	MOV	R3,6(R0)	;;;SET DISK ADDRESS
	MOV	#$CRSBF,4(R0)	;;;SET ADDRESS OF INTERNAL STACK
	MOV	#-256.,2(R0)	;;;SET TO WRITE ONE BLOCK
	MOV	#403,(R0)	;;;WRITE THE FIRST BLOCK
10$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BEQ	10$		;;;IF EQ NO
	BMI	DUMP		;;;IF MI ERROR, RESTART
	CLR	4(R0)		;;;SETUP TO WRITE ALL MEMORY
	CLR	2(R0)		;;;
	MOV	#403,(R0)	;;;START THE WRITE
20$:	CLR	2(R0)		;;;KEEP WRITING
	TST	(R0)		;;;ANY ERROR BITS SET?
	BPL	20$		;;;IF PL NO
	BIT	#2000,-2(R0)	;;;NON-EXISTANT MEMORY?
	BEQ	DUMP		;;;IF EQ NO, RESTART

	.ENDC


	.IF EQ	C$$CDA-3

PBNH=	0			;BLOCK NUMBER IGNORED FOR TM11
PBNL=	0			;

	SWAB	R3		;;;POSITION UNIT SELECT BITS
	BIS	#60001,R3	;;;MERGE DENSITY AND GO BITS
	MOV	R3,R2		;;;COPY
	BIS	#16,R2		;;;SET REWIND FUNCTION
	MOV	R2,(R0)		;;;START THE REWIND
10$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BMI	DUMP		;;;IF MI ERROR, RESTART
	BEQ	10$		;;;IF EQ NO
	MOV	#$CRSBF,4(R0)	;;;SET ADDRESS OF INTERNAL STACK
	MOV	R3,R2		;;;RETREIVE MTC BITS
	BIS	#4,R2		;;;SET WRITE DATA FUNCTION
	MOV	#-512.,2(R0)	;;;SET 512. BYTE RECORD
	MOV	R2,(R0)		;;;START THE WRITE
20$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BMI	DUMP		;;;IF MI ERROR, RESTART
	BEQ	20$		;;;IF EQ NO
	CLR	(R0)		;;;CLEAR MTC REGISTER
	CLR	4(R0)		;;;START TO WRITE ALL MEMORY
	BIC	#1,R2		;;;CLEAR GO BIT
	MOV	R2,(R0)		;;;LOAD MTC REGISTER
30$:	MOV	#-500,R1	;;;WAIT FOR TAPE TO SETTLE DOWN
35$:	DEC	R1		;;;WAIT
	BNE	35$		;;;IF NE LOOP
	MOV	#-512.,2(R0)	;;;SET 512. BYTE RECORDS
	BIS	#1,(R0)		;;;START THE WRITE
40$:	BIT	#100200,(R0)	;;;ERROR OR READY?
	BEQ	40$		;;;IF EQ NO
	BPL	30$		;;;IF PL WRITE FINISHED
	TSTB	-2(R0)		;;;NON-EXISTANT MEMORY?
	BPL	DUMP		;;;IF PL NO, RESTART
	MOV	R3,R2		;;;RETREIVE MTC BITS
	BIS	#10000,R2	;;;SET CLEAR FUNCTION
	MOV	R2,(R0)		;;;LOAD FUNCTION
50$:	TSTB	(R0)		;;;READY?
	BPL	50$		;;;IF PL NO
	BIS	#6,R3		;;;SET WRITE EOF FUNCTION
	MOV	R3,(R0)		;;;DO THE WRITE EOF
60$:	TSTB	(R0)		;;;READY?
	BPL	60$		;;;IF PL NO
	CLR	(R0)		;;;CLEAR MTC REGISTER

	.ENDC


	.IF EQ	C$$CDA-4

PBNH=	0			;BLOCK NUMBER IGNORED FOR TJU16
PBNL=	0			;

	BIS	(PC)+,R3	;;;SET MODE AND DENSITY
$DNSTY::.WORD	1300		;;;DEFAULT TO 800 BPI, NORMAL MODE
	BIS	#40,10(R0)	;;;RESET CONTROLLER
10$:	TSTB	12(R0)		;;;IS THE TAPE DRIVE READY?
	BPL	10$		;;;IF PL NO
	MOV	R3,32(R0)	;;;SET FORMAT BITS
	MOV	#7,(R0)		;;;START THE TAPE REWINDING
20$:	BIT	#20000,12(R0)	;;;POSITIONING STILL IN PROGRESS?
	BNE	20$		;;;IF NE YES
	TSTB	12(R0)		;;;DRIVE READY?
	BPL	20$		;;;IF PL NO
	MOV	#$CRSBF,4(R0)	;;;SET ADDRESS OF INTERNAL STACK
	MOV	#-256.,2(R0)	;;;SET WORD COUNT
	MOV	#-512.,6(R0)	;;;SET FRAME COUNT
	MOV	#61,(R0)	;;;START THE WRITE
30$:	TSTB	12(R0)		;;;DRIVE READY?
	BPL	30$		;;;IF PL NO
	BIT	#40000,(R0)	;;;TRANSFER ERROR?
	BNE	DUMP		;;;IF NE YES, RESTART
	CLR	4(R0)		;;;SET TO WRITE ALL OF MEMORY
40$:	MOV	#-256.,2(R0)	;;;SET WORD COUNT
	MOV	#-512.,6(R0)	;;;SET FRAME COUNT
	BIS	#1,(R0)		;;;START TO WRITE ALL OF MEMORY
50$:	TSTB	12(R0)		;;;DRIVE READY?
	BPL	50$		;;;IF PL NO
	BIT	#40000,(R0)	;;;TRANSFER ERRORS?
	BEQ	40$		;;;IF EQ NO
	BIT	#4000,10(R0)	;;;NON-EXISTANT MEMORY?
	BEQ	DUMP		;;;IF EQ NO
	BIS	#40,10(R0)	;;;RESET CONTROLLER
60$:	TSTB	12(R0)		;;;DRIVE READY?
	BPL	60$		;;;IF PL NO
	MOV	R3,32(R0)	;;;RESET FORMAT BITS
	MOV	#27,(R0)	;;;WRITE EOF ON TAPE
70$:	TSTB	12(R0)		;;;IS DRIVE READY?
	BPL	70$		;;;IF PL NO
	CLR	(R0)		;;;CLEAR CONTROLLER REGISTER

	.ENDC

	.ENDC


	.IFF

	JMP	$PANIC		;;;JUMP TO PANIC DUMP ROUTINE


	.ENDC


;+
; IF B$$OOT IS DEFINED, RE-BOOT THE SYSTEM BY JUMPING TO THE
; BOOTSTRAP ROM ADDRESS SPECIFIED BY B$$OOT.  ELSE, RE-ISSUE
; THE CRASH MESSAGE IF THE USER WISHES ANOTHER DUMP.  IF NO
; CRASH DUMP WAS CONFIGURED, SIMPLY RE-BOOT OR HALT FOREVER.
;-

$BTSTP::			;;;RE-BOOT THE SYSTEM


	.IF DF	B$$OOT

	HALT			;;;WAIT FOR THE USER BEFORE BOOTING
	RESET			;;;RESET THE WORLD
	JMP	@#B$$OOT	;RE-BOOT THE SYSTEM

	.IFF

	HALT			;;;WAIT FOR THE USER


	.IF DF	C$$RSH


	.IF DF	C$$CDA

	JMP	AGAIN		;;;DO IT ALL OVER AGAIN

	.ENDC


	.IFF

	BR	.-2		;;;LOOP FOREVER

	.ENDC


	.ENDC


	.END