the vast majority of lisp compilers and interpreters written in the 60s-80s were written in assembly.

PS: on the contrary, someone try assembler on lisp ;^)
http://lasm.sourceforge.net/ (look cvs)

"How might I make a procedure at runtime, and then call it?"

The aim was to provide a framework for generating assembly programs in Common Lisp. I think that they would have been better off using FASM as a backend instead of generating raw binary.

;;;; carrot.lisp (don't ask me why this name... the file just needed any name)
;;;; Using CommonLisp as a macro preprocessor for an assembler
;;;; Written for and used with CLISP (version 2.34 or newer)

;; check command line argument count
(unless (= (length ext:*args*) 1)
  (format t "clisp carrot.lisp <LASM>.lasm ; processes Lisp-Assembly file and produces an .asm file.~%")
  (ext:bye))

;; check that the LASM file exists
(unless (probe-file (first ext:*args*))
  (format t "Specified LASM file does not exist.~%"))

;; compute the name of the output file
(defvar *output-file*
  (concatenate 'string (subseq (first ext:*args*)
    0 (position #\. (first ext:*args*) :from-end t)) ".asm"))

;; a list of generated lines of code
(defvar *asm* ())

(defun asm (&rest s)
  (setf *asm* (append *asm* (list
    (apply #'concatenate (cons 'string (mapcar #'princ-to-string s)))))))

;; syntax extensions:
;; % mov eax, edx % ; generates the specified block of assembly code
;; \\ ; generates a newline (only usable inside a block of assembly code)
(set-macro-character #\%
  #'(lambda (s c)
    (let ((str "") char)
      (loop until (char= #\% (setf char (read-char s)))
        do (if (char= #\# char)
            (setf str (concatenate 'string str (princ-to-string (eval (read-preserving-whitespace s))) " "))
            (setf str (concatenate 'string str (string char)))))
      (read-char s)
      `(setf *asm* (append *asm* ',(regexp:regexp-split "\\\\\\\\" str))))))

;; processes the LASM file
(load (first ext:*args*))

;; write the generated code into the output file
(with-open-file
    (s *output-file* :direction :output :if-exists :supersede)
  (dolist (i *asm*)
    (princ i s)
    (terpri s)))

;; attempt assembling the file
(ext:execute "/usr/bin/fasm" *output-file*)
    

(defvar *_prev* 0)

(defun _entry (name body)
  (let ((here (gensym)))
    (asm here ":")
    (asm "dd " *_prev*)
    (asm "dd " name)
    (asm "db 0")
    (asm "cstr '" name "'")
    (setf *_prev* here)
    (asm name ":")
    (asm body)))
    

%use32%
(_entry "foo"
"mov eax, esi
xor esi, esi")
(_entry "foo2"
"mov eax, esi
xor esi, esi")
    

G4091:
dd 0
dd foo
db 0
cstr 'foo'
foo:
mov eax, esi
xor esi, esi
G4092:
dd G4091
dd foo2
db 0
cstr 'foo2'
foo2:
mov eax, esi
xor esi, esi