(setf (search-list "viceme:") '("/afs/cs/user/chiles/"))
(setf (search-list "port:") '("viceme:rt-port/"))
(setf (search-list "alf:") '("/afs/cs/project/clisp/new-compiler/"))
(setf (search-list "target:") '("alf:rt_mach/1/"))

;(compile-file "port:setup" :error-file nil)
(load "port:compiler/tools/setup.pmaxf")



COMPILING COMPILER BACKEND:

(setq c:*target-backend* (c::make-backend))
; (push :afpa *features*)

;;; Do NOT use this, unless you intend to compile just a few files.
(setf *comrtcom-load* t)

(setf *compile-all* t)
(load "port:compiler/tools/comrtcom.lisp")



COMPILING CODE:

(load "port:compiler/tools/loadrtcom.lisp")
(setf c:*backend* c:*target-backend*)

If trying to load kernelcom.lisp, do the following too:

(setf *interactive* nil)

;;;
;;; FUCK:
;;;  You must delete the compile-lisp.log file and all fasls to get this to do
;;; anything.
;;;
(load "target:kernelcom.lisp")

;COMPILE-FILE compiles for Rt.
;Compile and COMPILE-FROM-STREAM use pmax backend.



BUILDING A CORE:

(load "port:compiler/tools/loadrtcom.lisp")
(setf c:*backend* c:*target-backend*)

(setf lisp::*genesis-core-name* "port:compiler/ldb/kernel.core")
(setf lisp::*genesis-c-header-name* "port:compiler/ldb/lisp.h")
(setf lisp::*genesis-map-name* "port:compiler/ldb/lisp.map")
(setf lisp::*genesis-symbol-table* "port:compiler/ldb/ldb.map")

<create and compile some file>
;;; Type in additional file names to include necessary assembly material.
(lisp::genesis '("port:compiler/hack/fuck-me.rtf"))


Then in a shell

cd $port/ldb
cp kernel.core /tmp/
ldb -core /tmp/kernel.core -monitor



DEBUGGING:

;;; What file defines a VOP?
(describe (c::vop-info-generator-function
	   (c::template-or-lose 'RT::CALL-NAMED)))



RCS:

;;; Optionally on this command add "< /dev/null" to prevent repeated prompting
;;; for a log message.  -u says to leave the working file alone; that is, do
;;; not delete it.
;;;
cd into directory.
rcsci -u *lisp

;;; To find the change log for a file, use:
;;;
cd into directory with file.
rlog <file>

;;; To find the actual source text changes between two revisions, do:
;;;
cd into directory.
rcsdiff -r<version 1> -r<version 2> <file>
;;;
;;; For example, to find the changes corresponding to this revision:
;;;   revision 1.17        
;;;   date: 90/11/26 19:21:39;  author: wlott;  state: Exp;  lines added/del: 1/1
;;;   Don't assume the size of sigcontext, use c-sizeof.
;;; Do:
;;;
rcsdiff -r1.16 -r1.17 debug-int.lisp

;;; To find who has what locked.
;;;
find . -follow -name '*,v' -print | rlog -i -
;;;
;;; The following invokes rlog many times (for each file), but it works when
;;; the directory has so many files it chokes the previous expression.
;;;
find . -follow -name '*,v' -exec rlog -i {} \;

;;; Who has which locks.
;;;
rlog -i RCS/*,v
;;;
;;; or
;;;
ls -l *lisp | grep w-



ADB:

;;; print contents of R9 in hex.
;;;
<r9=X

;;; print 8 words in hex starting at -7 from R9 (subtract other pointer tag).
;;;
<r9-7/8X

;;; Given an address (such as the second to last word of a symbol which is its
;;; print name) skip the other pointer 7 bytes plus one more to skip the eight
;;; bytes of a string header and print that as a string.
;;;
0x0600030f+1/s

;;; print named function to get its start addr (raw fun addr).
;;; set breakpoint.
;;; run code, hit breakpoint, and look at instructions.
;;;
<addr>:b
:c 0		;0 restarts with no signal in case we interrupted to do this.
<iar/i		;/i says interpret memory as instruction.
<return>...	;returns continues with what you were doing stepping through mem.

;;; dump some memory
;;; address: 32bits-hex 16bits-hex 16bits-hex 8bits 8bits 8bits 8bits four-chars
;;; can follow addr with number of words to print
;;;
d $N