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.

• Inside X68000: archive.org, local copy
• Outside X68000: archive.org, local copy

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 X68000 cross compiler (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

Using the toolchain:

• Download the archive 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