This code can be both inlined and unrolled at the same time.

What's more useful depends on what's needed and how the function is called.

True. But...

o Inlining helps more with short strings and unrolling more with long strings. Strings tend to be short thus unrolling may be unnecessary.

o Inlining generally gives smaller code than the push/bsr/rts/pop of the AT&T ABI function call so is faster and smaller. Unrolling gives more code which can be bad for ICache usage and wastes memory. Inlining unrolled loops could result in substantially larger program sizes.

o String processing is rarely the bottleneck anyway (unless the compiler does an awful job of optimizing string handling :banghead).

True again, but it is not so simple for compilers to figure out what is needed. Compilers generally need intrinsic and profiling information or they are ignorant but most programmers ignore this and expect them to figure out what they meant. Of course this is a separate problem than compilers not being able to do basic backend code generation right :sad.

Admittedly OT here, but some folks in this thread appear to be the right ones to ask...so.. :)

I've been writing code in C for a long time. However, I'm completely unfamiliar with the assembly it compiles into. Can someone recommend a good online class or reading material to help me learn this? A friend mentioned taking a class at some point whereby they actually wrote a C compiler in assembly, but he did it at his university and as such it isn't available to me. I'd be curious to do something like that. Thanks!

Very true, which is why you should be able to specify what you want per function call when needed, or use a default setting when it doesn't matter.

This isn't up to the compiler. A good example is when you want a string copy that returns a pointer to the end of string character of the copy, which is useful for string concatenation. You either write the function, or see if there's one in the standard library.

There is this https://godbolt.org/g/aa9FDd

On how a compiler works this might be of help http://compilers.iecc.com/crenshaw/

Many of the "free" compiler design texts are rather old but can be fine for learning the basics. The Basics of Compiler Design is fairly modern and in depth.

Basics of Compiler Design
http://www.diku.dk/hjemmesider/ansat...sics_lulu2.pdf

It is always good to look at and play with some code too. The vbcc compiler source is fairly modern, advanced, has few dependencies (it compiles on my Amiga) and is written in C. The vbcc source, documentation and binaries are at the following link.

http://sun.hasenbraten.de/vbcc/

The GCC C source is available but a complex mess and full of dependencies. Clang/LLVM is written in C++ and has no official or finished 68k backend. The Amiga DICE source is in C and available but it is old and rather basic.

It is probably necessary to learn some basic assembly language and study the compiler output to fully understand the process. Various debuggers and disassemblers are available to disassemble compiled programs (ask if needed). The M68000PRM is the basic guide for the 68k ISA (now with spiffy NXP text).

http://www.nxp.com/assets/documents/.../M68000PRM.pdf

Thanks matthey!

Ok, I took the sources from the chess engine TSCP ( http://www.tckerrigan.com/Chess/TSCP/ )
and compiled them with sas/c, gcc and vbcc.

Tscp has an embedded benchmark. I lowered the 'max_depth' from 5 to 3, cause you know....amiga. And run the three executables produced from the three compilers.

gcc-3.4.0 19 secs
sas/c 25secs
vbcc 35secs.

gcc: m68k-amigaos-gcc -m68020 -O3 -fomit-frame-pointer -noixemul -o tscpgcc *.c
vbcc: vc +aos68k -O4 -o tscpvbcc *.c -I/usr/local/amiga/m68k-amigaos/sys-include/ -lmieee -cpu=68020
sas: see scoptions inside archive

All the above were run in fs-uae inside a vm so the absolute numbers probably shouldn't mean a thing, still the ratios should be good.

Included is the archive of sources, if you want to play with it. You run the executable, type 'bench' and wait. When it's finished type 'bye' to exit.

the toolchains is now able to build the libnix library.

The examples hello-ks13 and hello-ks20 do compile and run.

Bebbo


PS and gcc 6 / binutils 2.14 are the default setting now

Awesome news! =)

Right now it compiles with gcc6, but links only if multiple symbols are suppressed

and crashes :-(


Bebbo

Don't expect to much. But I'm still on it.

Bebbo

Ummm, as in you can actually run the exe on amiga 500 with kickstart1.3???!!!!

Btw, thanks for your work.

What symbols it complains about? Possible to attach the log?

Bebbo, I am still having issues compiling under macOS Sierra. I filed an issue for some common bits I overcame but I'm now getting this:

Any ideas?

I managed to hack thru that error (manually hacked a generated makefile), but then I got a different error later in the build so I gave up.

Since I don't own a Mac, I can't reproduce (I could get a VM with OSX, but then I'd also need XCode, which requires an account).

I'm not sure, but it looks like the target does match your system:

Does it work, if you build with gcc 2.9.3?

Bebbo

Fixed the register usage.
without -mregparm=2 the parameters are passed via stack (again):

And yes, the code could be better.

Bebbo

Why is it so hard to get compilers to produce proper code for simple stuff like this? It absolutely boggles the mind :confused

Because 68k is poorly and Amiga is not supported?

GCC performs the code generation and optimization with abstract instructions. A meta description/som code describes which operations are available, how they perform and how the assembly syntax looks like.

If that's not complete or the performance information is bogus, the optimal code can't be found.

If the code was still officially supported there were test cases and those bugs were found and fixed.

Now: Find and fix it yourself. You are part of the community.

Bebbo