nesdev.org

If you ever need to write some code for SNES APU, you'll need one. Unfortunately, there is very few assemblers, and they aren't easy to find. I've spent a day searching available options, and here is the results, to save your time if you'd need this.

First, there are official tools, because the CPU core in SNES APU is just a part of a large MCU series (named SPC700). As an individual enthusiast, you can't have the tools, they probably cost a lot, but anyway, just as an interesting fact - there is Sony's assembler named WASM700II (virtually not mentioned in the internet), and Gaio Technology's toolset that includes an assembler, linker, C compiler, and IDE. You can find a lot of details on the MCU series and overview of the software in this PDF, and overview of Gaio's tools on their website.

For common people, less impressive options are available:

wladx-spc700 - unlike support of other processors, SPC700 support seems bad. There are reports from people who attempted to use it that it generates wrong code and has other bugs. There are sources, though, so maybe you will be able to fix the assembler (would be cool).

Telmark Cross Assembler (TASM) - is does not have native SPC700 support, but it is table-driven. You need to use this table created by GAU and revised by eKid. It was used to compile 5000+ lines of xmsnes, so it is tested well. There are downsides, though - this assembler is just old, and it is shareware. It costs $25, according to docs 'prolonged use without registration is unethical'.

spcas - very simple assembler specifically designed for SPC700, made by byuu, author of the bsnes. Reports are that it works well, but lacks many features, so may be not suitable for large projects.


If you are an hero, there are two extra options.

First, you can use an existing macro assembler and make macros for all the opcodes. If will work, and will give you nice set of features, but syntax will be unusual, because macro assemblers usually don't like spaces and special symbols in macro names, and error messages could be confusing.

Second, you can write your own assembler. It is a large project by itself, and in short time starting from scratch you can only make something comparable with spcas. However, if you already made an assembler, adapting it to SPC700 could take not that much time and effort.

Or a way that doesn't require one to be suicidal: write a preprocessor in Perl or Python that outputs .byt statements, and have ca65 assemble that. This is like the macro way, but with the advantage of having more sophisticated syntax thanks to the regular expression facilities in such languages. It's also like the write-your-own-assembler way, but with the advantage that ca65 and ld65 handle all the label processing for you.

Agree, it could be a nice compromise between using macros and writing own assembler.

bass (successor to xkas) supports SPC700 syntax in Sony's format, and in an infinitely more logical 65xx style syntax. Your choice.

Has full define+macro+relocation support, among other things. Only thing it doesn't do is produce objects, but with a 16-bit processor and 64K RAM max, you really, really don't need that. Really.

Temporary link:
http://byuu.org/temp/bass_v00r06.tar.bz2

You'll have to compile it yourself (very easy, install TDM/GCC and run a batch file), or wait another day or two for v01 to be posted.

New syntax example: Again: old, ugly syntax is fully supported as well.

byuu, that's great. I almost decided to make my own assembler, and this will save me a lot of time.

Edit: Unfortunately it turned out that my bass build is broken to completely unusable state, including not working defines, macros, comments, etc. spcas also does not work for me, I haven't found anything like equ, and it does not report about problems, in simplest test it ends up in 7 bytes of generated code instead of expected 11 without any warning or errors. Together with lack of debuggers it makes work on code next to impossible.

Binaries and GPLv2 source included.

I can assure you that defines/macros work just fine, see example code under test/ :D

Tried this version. Defines seems working, but the same problem with macro:
Results in 'unknown command:macro length()'.

Other problem is that none of possible combinations of org and base allow to create a file assembled to, say, $0200, but without $200 zeroes in beginning of the file.

Sorry, namespace.asm wasn't updated yet.
Defines and macros were merged, ala test.asm. They work like this now:

Other problem is that none of possible combinations of org and base allow to create a file assembled to, say, $0200, but without $200 zeroes in beginning of the file.

Right, org is the location in the file, base is the location the code sees.

Use org 0; base $200 for what you want.

Ok, thanks. Now the last problem: comments with ; aren't work:
Results in 'unknown command:test'. The same happens with any ;comment, does not matter if it is on a new line, with or without space after opcode.

Comments use //
Block separators use ;
It's like C++-style, but you don't need one for the last block on a line.

I know people like ; for comments, but ; is the most logical block separator.

Eg:
lda #$07; sta $2100 //set screen brightness to half intensity

If it bothers you that greatly, you can edit the source to change it, but please give it a chance =)

It bothers me because I use many different assemblers where a lot of things are different, and this is one extra thing. It is very uncomfortable to remember and relearn set of rules for every assembler.

Examples are # or $ for hex, @ or . or _ for local labels, : after labels in some assemblers, etc.

In many other assemblers block separator is : (and labels without : ). In 99% of assemblers ; is for comments.

I can change it in the source, of course, but what will do people who would like to use my code? Change source too, or replace ; with //? It is kinda unconvenient.

Gnu Assembler uses @ for comments, and that's just wrong on so many levels. But that's what it uses.

Well, I think I can solve this problem seamlesly with a very simple preprocessor that will replace all the ; with // before compilation, and publish preprocessed files only. Still not very convinient, but as it is seemingly the best free SPC700 assembler available (and with active author, which is important), it is tolerable.

Byuu's Macro technique is similar to TASM's Define/Macro technique,

That sounds like a decent thing.

I found it not so decent. Simplest thing from wla like
turns into
In this case amount of additional symbols makes macros not helpful, because they are there to make code more readable, not more complex. Also, try to forget to use {} somewhere if you want to have a lot of fun searching what is wrong.

This system is probably works well for more complex uses, but not for this one.