Hacker News Reader

Comment by korethr | Hacker News Reader

It would be cool if 68k support landed in LLVM. I've been wanting to do a 68k-based retrocomputer project for a while. If I ever get started on such a project, being able to use a modern compiler would be nice.

View on HN

I have recently built a simple 8085 computer on a breadboard and finding a working and open-source C compiler was a huge challenge. Finally I found this one: https://github.com/ncb85/SmallC-85 but it supports ancient K&R C syntax, without such goodies like subscript operator or character literals. Still I prefer ancient C than ancient assembly language.

On the other hand there is Small Device C Compiler (SDCC) project that provides a decent compiler for Z80 CPU. There is also cc65 for 6502 CPUs.

The strangest thing is that Free Pascal seems to support 68k out of the box (https://www.freepascal.org/) and also AVR and bunch of other archs.

Free Pascal has shockingly broad platform support:) One of the things I always found cool about it.

> but it supports ancient K&R C syntax, without such goodies like subscript operator or character literals. Still I prefer ancient C than ancient assembly language

A thought occurs to me: would it be possible to use that compiler to bootstrap your way to a modern C dialect? At one point, there were no C89 compilers. So, one would have to write a C89 compiler in K&R. Or am I failing to appreciate just how much work it would be?

You need to write a bridge compiler in C89 that can compile newer variants of C, and then feed another compiler's source code into it. These are implicitly written whenever new C features are added to compilers (can't depend on features that don't exist yet) but will be destroyed fairly quickly (why not dogfood our own features?). Furthermore, the compilers most people are going to want are either GCC or LLVM/clang, both of which have non-standard extensions which you'll likely also need to support.

However, a much more efficient approach would be to add support for older architectures to a modern compiler. Then you can build binaries via cross-compilation, or cross-compile the compiler itself to get a modern self-compiler on an old system.

> A thought occurs to me: would it be possible to use that compiler to bootstrap your way to a modern C dialect?

You don't need to. SmallC is a cross-compiler, not a self-hosting compiler; it runs on a modern computer, not an 8085. If you wanted to modify SmallC to accept modern C syntax, you can do that without "bootstrapping" anything.

You could probably write some macros or some other kind of text processing job to convert modern C constructs into K&R and feed it into SmallC.

These folks are working on bootstrapping from a small amount of machine code for multiple arches all the way to the Linux kernel.

https://bootstrappable.org/

I vaguely recall trying to write fixed point math functions using sdcc for a gameboy homebrew project a long time ago. I’d compile and run via an emulator. Good times!

So, use gcc, which is what the BSD ports supporting m86k use. See also

https://www.phoronix.com/scan.php?page=news_item&px=GCC-11-m...

I know about GCC. In fact, I'm the one who created the Bountysource campaign to convert the m68k backend in GCC to MODE_CC.

There are languages that LLVM supports that GCC doesn't.

Fair enough.

One annoying thing is that nobody makes new 68k CPUs anymore. The only real source appears to be scavenged chips from China.

If you want to limit your retrocomputer design to only parts that are still manufactured, like I do: The only cpu choices appear to be: Z80, 68c02 and 68c816

In 2014, Rochester Electronics has re-established manufacturing capability for the 68020 microprocessor and it is still available today.

(https://en.wikipedia.org/wiki/Motorola_68020)

Reminds me I used the 68332 68k based MCU 25 years ago. I just checked, can still buy them from digikey. Some packages are listed as not for new designs. But a couple are listed as active.

Which is a shame. Just from high level descriptions of the 68k architecture, compared to my own (albeit very limited) experience with x86 assembly, the 68k seems a much more elegant and easier to program architecture.

Someone else in this thread has pointed out you can still buy the 68SEC000 from digikey.

But it's not recommended for new designs.

NXP USA Inc. MC68SEC000AA16

$19.39 for one

https://www.digikey.com/en/products/detail/nxp-usa-inc/MC68S...

You are correct. I also seem to recall recently reading news that someone had started fabbing 68020s again, but can't find the source at the moment.

Wikipedia says Rochester Electronics, and I did find it here on their site: https://www.rocelec.com/part/REIMC68020EH33E

At $100 for '020 and $300 for '040 I don't see many hobbyists rushing for those. You can get pretty damn nice FPGA for that sort of money, even if I understand it's not quite the same.

https://www.rocelec.com/part/REIMC68040RC25A

You can run a 68k emulator on a 64-bit x86 if you wish to program as a hobby. Or is this about professional 68k programming, or perhaps nostalgia?

There is the Vampire 68080 which features new instructions.

See: http://apollo-core.com/index.htm?page=products

Looks like NXP is still making M68k CPUs, but I don't know about dev boards.

https://www.nxp.com/products/processors-and-microcontrollers...

you know that GCC had support for 68k and it's a modern compiler, not ?

Yes, but GCC cannot be used as a backend for other languages like Rust. My primary goal is to get Rust support for m68k.

You probably don't want to hear this but you could go the LLVM->Wasm->Wasm2C->GCC route.

The Julia folks had resurrected the C backend to LLVM at least once, it is also a possibility.

Reply on news.ycombinator.com