Building for custom 68k or ColdFire board without OS?

[Toralf Lund <toralf at procaptura dot com>]

I'm looking for a new way to build the software running on a custom I/O 
board we are producing, which is based on the MC68010. The board has no 
separate OS; our software calls some very simple routines built into the 
"Bug ROM" on the unit, but is otherwise fully self-contained. The 
software is traditionally compiled and linked on another 68k-based board 
running the OS-9 operating system. Some more details:

   * Source code mainly in K&R C (not ANSI C), with some routines
     written in 68k assembler.
   * The code is generally closely linked to the hardware; it accesses
     registers via hard-coded addresses, uses interrupt routines a lot,
     and also relies on "register" directives etc.
   * Built using Microware C Assembler and linker (not the newer Ultra
     C) under OS-9
   * The assembler routines are sometimes stored in separate files,
     sometimes inlined via #asm directives. The compiler-generated code
     will pass parameters to subroutines (functions) via d0, d1, ...,
     and extract return value from d0. The assembler routines rely on
     this fact.
   * The actual program code is linked with clibn.l, sys.l, math.l from
     OS-9, as well as a custom "cstart" routine, to make up a
     self-contained unit.
     clibn.l is a version of the C-lib which has no floating point
     support, while math.l provides *stand-alone* floating point support.
   * The software uses some floating point operations, and there is no
     math co-processor.
   * Format of the executable file is "OS9/68K module".
   * Code is currently loaded by another board via the VME bus. The
     load software ensures the module is written to a well-known memory
     address, then starts the execution by initiating a jump to that
     address + an "execution offset" extracted from the module header.
   * The software may be PROM'ed and/or transferred via S-records in
     the future.

What I want to do is to set up a build system under Linux (Red Hat 9 
ix86) for the software. Also, we are about to design a new generation of 
the board, which will be based on a 683xx or ColdFire processor, and I 
need the build environment to support that, too.

Would CrossGCC be suitable for this task? What would it take to get it 
up and running? To what extent would the code need to be ported to suit 
the new compiler? (That one might be hard to answer. I'll provide some 
example code later if necessary.) Is ColdFire supported at all?

- Toralf



------
Want more information?  See the CrossGCC FAQ, http://www.objsw.com/CrossGCC/
Want to unsubscribe? Send a note to crossgcc-unsubscribe@sources.redhat.com