Intermediate forms (again?): worthwhile?

As a language designer/developer, I feel like I'm in between the
proverbial rock and hard place. I'm A-OK with doing the "front end" of
the compiler, but the "back end" is "kinda scary" for me. To "spill", my
path is, currently, compiling to assembly language (am I naive?). I mean,
it's "simple", right? What can go wrong, having full control (ignore
multi-platform compatibility, for it is NOT in my requirement now)?


My question is, or is in the area of, intermediate representations and
backends and code generation. Optimization is NOT AT ALL my concern
(read, I don't do compilers, I do my language, and "ain't it great that
computers are so fast now!").


Clarification: I got to here from disenchantment/unenamorment with
existing HLLs (yep, every one of them). I like the freedom afforded by
writing to the hardware level for my language's
initial/prototype/reference output. I have looked at (well, "you know
me", cursory inspection) LLVM and GCC, but get the feeling it throws me
back from where I started.


Am I making any sense? Almost (S/N, get off the sauce and be on-topic in
MY thread) all replies are welcome.
[If you don't plan to do much optimization, you don't need a complex
internal form. For a really simple compiler, you can often just make a
tree for each statement, then walk the tree to generate the code and
throw the tree away. Or if you're clever enough, emit the code directly
from the parser. -John]

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