Thread: Compilers.. assemblers.. linkers..

http://www.bloodshed.net/compilers/index.html
Should keep you busy for a while...

I very much doubt that it's Tabu to talk about compilers and compiler technology. It is very complicated, and my guess would be that there are less than 10 people who are active in the next week on this forum that has actually worked in the source code of a REAL "industrial quality" compiler (most likely candidate here is gcc).

On top of that, there's usually little NEED to write your own compiler, assembler or linker, as there is almost always a compiler available that you can get for free - commonly gcc (it supports several different processor architectures, C, C++, Java, Fortran and some other less common languages).

This is FAR more than can be covered even in 100 posts, never mind one.

The frist step is to parse the code into some internal representation of the symbols, e.g:

Code:

// inside a functiokn of some sort.
int x;
x = 2;

would be translated to

Code:

variable: name="x", type "auto", location="stack";
assignment: target=variable("x"), source = constant(int, 2);

The compiler will then do take the complete list of such internal representation and produce the machine-code from that. Of course, it's quite likely that there will be one or more other intermediate steps, and for "industrial quality", a good optimizer will be necessary to produce good quality code (look at the differences between gcc with -O0 and -O1, -O2 and -O3).

Writing an assembler is a whole lot easier (at least if you only have one processor architecture to worry about - gas which supports a few dozen different processor types is quite complex, because everything needs to be able to cope with lots of different options). It's essentially just two parts:
1. Translate op-code into machine code.
2. Deal with symbols (labels, external symbols, exported symbols and some trivial math).

A linker is not very difficult either, from a generic perspective. It's basicly just dealing with symbols and resolving external symbols in one module by finding the corresponding symbol in a different module.


If you go to a university that has a computer oriented program (e.g. Computer Science or Software Engineering), there will probably be some compiler oriented course in the corriculum - it may not be part of any particular program, but rather an optional course, but I'm pretty sure you will find one.

One of the more commonly recomended books on the subject is:
http://en.wikipedia.org/wiki/Princip...ompiler_Design

However, there are several others, including free ones.

However, going from the level of "being able to write a simple compiler" to producing "industrial quality" is a huge difference. A small, simple compiler is probably in the order of a few tens of thousands of lines of code. A industrial strength compiler will be several hundred thousand lines of code.

--
Mats