cc65

cc65 is a complete cross development package for 6502 systems, including a powerful macro assembler, a C compiler, linker, librarian and several other tools. cc65 is based on a C compiler that was originally adapted for the Atari 8bit computers by John R. Dunning.

The original C compiler is a Small C descendant but has several extensions, and some of the limits of the original Small C compiler are gone. The original copyright allows free redistribution including sources, even if it would not qualify as Open Source Software according to the Open Source Definition.

The original Atari compiler is available from http://www.umich.edu/~archive/atari/8bit/Languages/Cc65/. The complete package consists of the compiler, an assembler, a librarian, a linker, and a C library for the Atari. There are some packages on the net that claim to be adapted as a crosscompiler for DOS or Unix, but was not able to get them working correctly.

Because I wanted a C compiler for my CBM machines, I took the Atari compiler and started a rewrite. Until today, I have rewritten large parts of the compiler, all of the library, completely replaced the assembler, the linker and the librarian, and added a frontend to simplify use. All changes have been done with portability in mind, so porting to new 6502 architectures should be quite easy.

The compiler is almost ISO C compatible, so you should be able to translate many sources from other systems.

There may be other target system dependent limitations. One example is file I/O, which is not implemented on all platforms. This is no technical limitation (as with the stuff mentioned above) but does just mean that no one cared enough to write the actual code.

The compiler is only one of the tools available in this package. The assembler suite (assembler, linker, archiver) is a complete development environment for itself, that may be used to write programs for any 6502 machine. C code and assembler code may be used together and may call each other.

The assembler is a one pass macroassembler and is able to output code for the 6502, the 65SC02 and 65SC816. It has a lot of nifty features like include files, conditional assembly, macros, nested lexical levels (that is, local symbols), and more. The assembler creates object files containing relocatable code. These files must be run through a linker to create the final program.

The linker has a flexible output format and is able to support ROMable code (different load and run addresses for data), banked systems (segments may share the same run address), systems with multiple ROMs, unlimited segments, more than one BSS segment and lots of other things.

The archiver is used to create libraries containing objects files. This simplifies code management. The linker will extract only those modules from a library that are actually needed.

To simplifiy use, there is also a frontend to the tools contained in the cc65 package. The frontend is named cl65. It knows how to build binaries from a list of C files, assembler files, object files and libraries. For smaller projects, just one invocation of the cl65 utility is needed to build a binary from several source files and libraries.

Features:

• The compiler allows single line comments that start with //. This feature is disabled in strict ANSI mode.
• The compiler allows unnamed parameters in parameter lists. The compiler will not issue warnings about unused parameters that don't have a name. This feature is disabled in strict ANSI mode.
• The compiler has some additional keywords that are needed for special features. In strict ANSI mode, the additional keywords start with two underscores.
• The volatile modifier has no effect.
• The datatypes float and double are not available.
• The compiler does not support bit fields.
• C functions may not return structs and structs may not be passed as parameters by value. Struct assignment is possible.
• There are some limitation on the size of local variables. Not all operations are available if the size of local variables exceeds 256 bytes.
• Part of the C library is available only with fastcall calling conventions (see below). This means, that you may not mix pointers to those functions with pointers to user written functions.

What is new in this release:

• Some macro issues and problems with incorrect code generated by the C compiler have been fixed.
• This includes converting a function to void pointer and the runtime division routine.
• The assembler also had some macro issues and a problem with alignments greater than 256 bytes.
• There were problems with 80 column mode and conio scrolling in the C128 library.
• The Atari library now has POSIX directory routines.
• There have been several documentation changes, fixes, and improvements.

What is new in version 2.13.0:

• Support for bit-fields has been added.
• This release improves standards compliance, and additional warnings are emitted for dubious code.
• The libraries are tuned for more speed or smaller size.
• The compiler generates faster code in many cases, usually without much of an increase in code size.