> But how is the output of a program containing a lisp macro for example.
I think you have a fundamental confusion about when and where macros are applied. In a compiled CL implementation, macros are expanded prior to compilation. The code will be exactly the same as if there was no macro involved. If you want to see what that might look like take the function body of this simple function:
(defun bar (filename)
(with-open-file (in filename :element-type '(unsigned-byte 16))
(let ((contents (make-array (file-length in) :element-type '(unsigned-byte 16))))
(read-sequence contents in)
contents)))
And run it through `macroexpand` (`with-open-file` is the macro I'm particularly interested in here):
CL-USER> (macroexpand
'(with-open-file (in filename :element-type '(unsigned-byte 16))
(let ((contents (make-array (file-length in) :element-type '(unsigned-byte 16))))
(read-sequence contents in)
contents)))
(LET ((IN (OPEN FILENAME :ELEMENT-TYPE '(UNSIGNED-BYTE 16))) (#:G659 T))
(UNWIND-PROTECT
(MULTIPLE-VALUE-PROG1
(PROGN
(LET ((CONTENTS
(MAKE-ARRAY (FILE-LENGTH IN) :ELEMENT-TYPE
'(UNSIGNED-BYTE 16))))
(READ-SEQUENCE CONTENTS IN)
CONTENTS))
(SETQ #:G659 NIL))
(WHEN IN (CLOSE IN :ABORT #:G659))))
Now take that output and put it in a new function, call it `baz`. Then disassemble both `bar` and `baz` (I've done this and included the output of just one because they have the same instructions):
EDIT: Snipped the excessively long code, here's a link:
https://topaz.github.io/paste/#XQAAAQCODwAAAAAAAAAQYOhAaDnr7... (still long, but at least HN will truncate it)
It doesn't really make sense to talk about disassembling a macro as a macro is not, itself, what gets compiled when it's applied, but rather its output gets compiled (in a compiled Lisp).
> "The logic inside that helps dispatch based on the dynamic types at runtime" is the interpreter part IMHO.
Then every compiled program that uses a tagged union is really an interpreted program (which is a statement you could make a strong argument for, perhaps). The code above is still machine code, though, it's not being interpreted. This is part of the distinction between an interpreter and a runtime. Dynamic dispatch can be applied to statically typed languages as well as dynamically typed languages.
> We need to generate an example of something we can't do in C, something which requires evaluation at runtime.
Strictly speaking, there is no such thing as something that can be done in Lisp that cannot be done in C. It'll just take a lot more effort in C to do some things like compiling a function on the fly, returning it, and then applying it later. You'd at least need to link in a compiler and feed it some structure which it can then compile into a function which gets returned, probably, as a function pointer.