Most of the standard system calls you will need to use are either doscalls or iocscalls - this refers to whether the system call is handled by DOS (Human68k DOS, of course), or directly by the BIOS/ROM/IPL functions. Some versions of the C compiler provide a standard C library, including a version of newlib in GCC 4.x, but to do anything other than the basic standard functions you'll need to look at the Sharp-specific calls.

Those functions include things like opening devices, setting screen modes, manipulating graphics memory, reading IO ports etc.

Sadly, most X68000 documentation is in Japanese. To find any information on the available system calls you will need to look up the definitions of those functions in either.

The two main technical manuals for the X68000 are the Inside and Outside series. Inside X68000 deals with mainly software; memory map, system architecture, system calls, IO interfacing etc, and Outside X68000 is mainly hardware interfacing and the electrical side of things.

archive.org, local copy archive.org, local copy

Comprehensive set of programmers reference manuals covering most of the system calls, the use of (very early) GCC and GDB tools and more.

archive.org, local copy archive.org, local copy

archive.org, local copy

• Blue book (#0) covers the install and use of early versions of GCC, HAS assembler and GDB
• Red book (#1) covers the use of the early versions of GCC and the GDB debugger
• Green book (#2) covers function calls available in old versions of GCC and doscalls (including better worded descriptions compared to 'Inside X68000' or the 'PUNI docs')

It's fair to say that #0 has more assembly examples than #2, which is probably the one you want if you are interested in figuring out how to use the various X68000 system calls in doscalls/dos.h.

Do be aware that when the various libc function calls are listed, this is referring to the old version of GCC, and not the new version which comes with newlib and a smaller set of functions.

Although not a programming reference per-se, the technical data book does contain some information that is useful to programmers; it covers a broad spectrum of topics - from CPU registers to a description of the X68000 mouse and its communications protocol.

archive.org, local copy

This is another old book that describes how to use GCC (and period assembler and linker, such as HAS, as listed way down this page) to develop game software on the X68000.

NFG Games, local copy

Source code: archive.org, local copy, files extracted from disk images

To be fair, the best source of material for this one is found in the example source code. Note: Disk 1 is just the old GCC compiler, the examples are found on Disk 2. You can either download the disk images and mount them in a real or emulated X68000, or download the extracted sample files so that you can view them with any normal text editor. Be aware that some of the code uses S-JIS encoded for actual function names!!!

The PUNI docs are another source of system information, a bit clearer than the unwieldy several hundred pages of the Inside X68000 book, but not a lot of supporting information or examples.

Note that all of the files are S-JIS encoded, but should translate well on Google. You'll need a text editor that can understand S-JIS encoding though. I can recommend wxMEdit as a good all-round multi-platform hex and text editor with multiple language support.

Here's the full contents of the PUNI documentation.

There is a wiki on Romhacking that has some of the above files partially translated.

This is a cross-compiler - you run it from Linux and it targets the X68000. So you can use all your modern editors and revision control systems etc. The version of GCC reports as:

human68k-gcc -v
Using built-in specs.
COLLECT_GCC=/opt/toolchains/x68k/bin/human68k-gcc
COLLECT_LTO_WRAPPER=/opt/toolchains/x68k/libexec/gcc/human68k/4.6.2/lto-wrapper
Target: human68k
Configured with: ../gcc-4.6.2-human68k/configure --prefix=/opt/toolchains/x68k --target=human68k --disable-nls --disable-libssp --with-newlib --without-headers --enable-languages=c --disable-werror : (reconfigured) ../gcc-4.6.2-human68k/configure --prefix=/opt/toolchains/x68k --target=human68k --disable-nls --disable-libssp --with-newlib --without-headers --enable-languages=c --disable-werror
Thread model: single
gcc version 4.6.2 (GCC)

The project was originally hosted on Github, but was last updated in June 2013; that's a long time ago, but it's still the latest version of GCC available.

• https://github.com/Lydux/gcc-4.6.2-human68k
• https://github.com/Lydux/binutils-2.22-human68k
• https://github.com/Lydux/newlib-1.19.0-human68k

Pre-built binaries for Linux:

• GCC 4.6.2 +dos.h struct align bugfix (Linux x86_64 host)

If you want to build the tools from source, here's a handy script that patches them with a required fix before install; you must apply the patch, as there is a bug in this version of GCC which will cause a segfault during compilation otherwise:

• build_x68_gcc.zip - Run the included bash script to configure and patch the source from Github

Note as well, that the current distribution includes some C header prototypes that cause bus errors due to struct alignment problems. This is discussed here: https://nfggames.com/forum2/index.php?msg=41392 The pre-compiled bundle above already has the fixes applied to dos.h.

Using the toolchain:

• Download the pre-built binaries above and extract in /, it unpacks to /opt/toolchains/x68k
• X68000 library functions are defined in:
  • /opt/toolchains/x68k/human68k/include/dos.h
  • /opt/toolchains/x68k/human68k/include/iocs.h
• Use the sample makefile below

# Names of the compiler and friends
APP_BASE = /opt/toolchains/x68k/bin/human68k
AS 		= $(APP_BASE)-as
CC 		= $(APP_BASE)-gcc
LD 		= $(APP_BASE)-ld
OBJCOPY 	= $(APP_BASE)-objcopy
STRIP 		= $(APP_BASE)-strip

# libraries and paths
LIBS	 	= -ldos -liocs
INCLUDES 	=          

# Compiler flags
ASM_FLAGS 	= -m68000 --register-prefx-optional
LDFLAGS 	=
CFLAGS 		= -m68000 -std=c99 -fomit-frame-pointer -Wall -Wno-unused-function -Wno-unused-variable -O3
LDSCRIPT 	=
OCFLAGS		= -O xfile

# What our application is named
TARGET	= test
EXE	= $(TARGET).X

all: $(EXE)

OBJFILES = test.o 

$(EXE):  $(OBJFILES)
	$(CC) $(LDFLAGS) $(OBJFILES) $(LIBS) -o $(TARGET)
	$(OBJCOPY) $(OCFLAGS) $(TARGET) $(EXE)

sample.o: sample.c
	$(CC) $(CFLAGS) -c $< -o sample.o
	
clean:
	rm -f *.o $(EXE) $(TARGET)

One of the problems with this toolchain is that you can't use existing library code from earlier compilers. There are possibly some issues with the assembly syntax as well, there are some details documented on the NFG Games forum: https://nfggames.com/forum2/index.php?topic=4850.0

It's the most modern version of GCC currently available on the X68000 and probably the easiest to use, as long as you are not working on any legacy code or libraries.

I haven't tested any of these, but they have been used at some point by others:

A port of GCC 2.95.2 to run natively on the X68000. So you'll need to compile your code on an emulated or real X68000:

• http://retropc.net/x68000/software/develop/c/gcc_2_95_2/
• GCC 2.95.2 Local mirror of the above

This runs on the X68000 itself, so you'll have to compile your source code from within either a real or emulated X68000 environment:

• http://retropc.net/x68000/software/develop/c/gcc_mariko/
• GCC 1.42 local mirror of above

These early versions of GCC rely on a different assembler, so you'll also need:

• http://retropc.net/x68000/software/develop/as/has/
• HAS 309 local mirror of above

Another cross compiler toolchain, but this is built for Windows:

• https://sourceforge.net/projects/gcc-1-30-x68000/files/
• GCC 1.30 local mirror of above

Although this is an old version of GCC, it's a recent package which includes demo source code and some updated documentation put together by users from the NFG Games forum: https://nfggames.com/forum2/index.php?topic=6140.msg42562#msg42562