Anyone heard of DICE?

Marcel Verdaasdonk wrote:

Anyone heard of DICE?

Yes. Though I don't remember its quality. I had experience with Aztec, Lattice (then SAS), and gcc.

Lots of other Amigatized features.  RTFM :) for more details.

And you can easily call asm functions using a NORMAL calling interface, not that wacked out antifriendly user-hostile gcc abomination.

SASC FTW!

I have here the list of 68k languages:
EXTERNAL LINK 
and here text-editors:
EXTERNAL LINK

So how did 68k compilers fare? what sort of calling conventions did they use exactly ?
As a CISC machine, but nonetheless with quite a healthy register file, how well did they fare with the decisions about what to place on the stack.
with c++ would it keep a 'this' pointer permanently in reg between function calls

I never used C on the amiga, but I do recall seeing some syntax for specific register allocation in ancient listings (perhaps the earliest compilers were purely stack based and you had to hint it)

Back in Amiga times, the gcc back then was really pretty good in optimizing code, often better than the SAS/C. It just didn't fit well into the Amiga architecture such as it used its own object code format (no hunks) its own linker (no ALink or BLink), so the whole toolchain was based on ix and not on Amiga. But the code was fine, really.

ceti 331 wrote:

I always recalled guidelines on using 'leaf' functions in C on the R-series cpu's with their lovely 32 reg file. (under certain conditions, last function call could be done with no memory access)     So how did 68k compilers fare? what sort of calling conventions did they use exactly ?

It was always good to write small compact functions so compilers could keep all locals in the registers. Calling conventions differed, depending on the compiler settings. The early versions used all a stack-based calling convention, then SAS/C in rev.6 changed that offering a convention where the first two integers were passed in d0,d1 and the first two pointers in a0,a1. Return values were always in d0, for MathIEEE floats in d0/d1.

For the later SAS/C, you also had the option to specify the registers where you would want the arguments in, for calling assembly functions.

ceti 331 wrote:

As a CISC machine, but nonetheless with quite a healthy register file, how well did they fare with the decisions about what to place on the stack.   with c++ would it keep a 'this' pointer permanently in reg between function calls.

There was never really a C++ compiler for the Amiga. SAS/C came with some early C++-ish type of dialect that worked entirely on the basis of a C++ to C compiler, and hence the compiler back-end did not know anything about "this". The gcc 2.95 did support some "kind of" C++ as well, with many bugs (but not as many as the SAS/C had), and as far as I remembered, didn't keep "this" special in any way.

It is typically not required, either, to have a fixed-wired convention. Let just the optimizer to the job, it will figure out (hopefully) that "this" is the most-used pointer in the member function and place it in a register accordingly.

ceti 331 wrote:

I never used C on the amiga, but I do recall seeing some syntax for specific register allocation in ancient listings (perhaps the earliest compilers were purely stack based and you had to hint it)

Those were compiler-specific extensions, actually. C doesn't have this, of course.

EXTERNAL LINK 

I don't use "register" variables. Most Amiga compilers do a good job selecting the variables to put in registers until they run out. It does help to create temporary variables in many cases that can be registered (by the compiler) if used several times and a function or loop is not very complex. This is especially helpful with some versions of GCC.