Re: Writing Assembler!

jhallen@world.std.com uttered these wise words...


> If you're going to go through the trouble of writing an assembler, write a
> sophisticated generic assembler: use macros to define the instruction set.


This is how Forth assemblers work. Opcodes are Forth words, operands
are also Forth words. "Macros" are simply Forth words that call words
in the assembler (another Forth word) vocabulary.


I also like how you can do the same tricks in Lisp and Prolog, using
symbolic expressions. In Lisp, you could use a special form with
sexprs:


(let ((a (+ 3 4)))
        (asm
                (move a d1)
                (addq #1 d1)
                (andi #ff d1)
                (move d1 a))
        a)


A macro might look like this:


(defmacro fudge (a)
        `(asm
                (move ,a d1)
                (addq #1 d1)
                (andi #ff d1)
                (move d1 ,a)))


And used:


(let ((a (+ 3 4)))
        (fudge a)
        a)


Alternately:


(defmacro fudge (e)
        (let ((a (gensym)))
                `(let ((,a ,e))
                          (asm
                                  (move ,a d1)
                                  (addq #1 d1)
                                  (andi #ff d1)
                                  (move d1 ,a))
                            a)))


If you had to do this often, you could write a macro to give you some
"syntactic sugar", to make this kind of macro more concise:


(defasm-macro fudge (a)
        (move a d1)
        (addq #1 d1)
        (andi #ff d1)
        (move d1 a)
        a)


> At this level of generality, the assembler goes from being a trivial
> program, to an N-pass assembler (if you limit the expressions) or a
> symbolic algebra program (if you have no limits). Of course I'd like
> to see someone implement a completely general assembler :-)


Symbolic algebra is easy to do in Lisp. Forth assemblers are usually
one-pass with backpatching.


> Best of all you only need about 12 pseudo-ops: macro, endm, if, else, elif,
> endif, set, equ, db, dw, dl, include.


Yup. Note that in a Lisp or Forth assembler, you'd need less syntactic
sugar, but the principles are the same.
--
<URL:http://www.wildcard.demon.co.uk/> You can never browse enough
    Martin Rodgers | Programmer and Information Broker | London, UK
                        Please note: my email address is gubbish.
--

Return to the comp.compilers page.
Search the comp.compilers archives again.