Re: [Announce] AVR-Ada V0.1 released

[Christopher Fairbairn <ckf13@student.canterbury.ac.nz>]

Hi,

Jeff C, wrote:
> That would be a strange thing to presume. While there are Ada compilers
> that take that approach I would
> assume that since this is based on the Ada front end of GCC with a GNAT
> heritage that it produces
> code just like every other (well nearly every other) GCC/GNAT compiler.

GCC vss GCC :-)

Some people I know of are not aware of the true meaning to GCC. To them 
(mostly people doing embedded development work, using windows based 
development hosts) GCC stands for the "GNU C compiler" and not a lot more, 
they are not fully aware of it's origins or how it internally is 
architectured. They might know of other GNU compilers for languages such as 
Pascal, Ada or Fortran etc but they are not totally aware of how they are 
related with GCC.

However, explaining GCC as the "GNU Compiler Collection" helps clarify 
things up quite a lot.

GCC is made up of two major "components". Front-ends which parse languages 
such as C, C++, Fortran and Ada etc into an intermediate form and a series 
of back-ends which take the intermediate form and end up generating machine 
code for a particular architecture.

Some things are shareable between the particular targets, for example there 
is a whole range of optomisations which can be done on the intermediate 
form which is not backend (target) specific and hence is shared across the 
different compilers. On the other hand there are optomisations which are 
exteremly architecture dependant and hence belong in code developed 
specifically for that port.

A compiler built as part of the GNU Compiler collection is obviously the 
combination of a selected front end intergrated with a selected backend. 
The avr-gcc executable on my box is obvioulsy the combination of the avr 
backend and the C front end, while m68k-palmos-gcc is the same front end 
married to a different backend.

Hopefully I havn't messed up that simplified description too much...

There has been a backend for the AVR architecture for a while now, however 
the original developers (as far as I can remember off the top of my head) 
only worried about getting the C front end working reasonably well.

As the original poster commented, there are various aspects of all languages 
which mean work before a "raw" backend code generator for that architecture 
can be utilised. Things such as how language constructs such as exceptions 
should map to architecture capabilities and any runtime library support 
required. In the case of a C compiler choices include things such as what 
size a long or short int should be etc etc.

Hopefully I've clarified things slightly for those interested, and hopefully 
I havn't mucked up my simpilified description too much.

Hope it helps,
Christopher Fairbairn.