6502.org

Hi,

Which assembler are you using, and why?

If you have some specific likes about your assembler or dislikes about others you've used, please list them.

I'd like to hear from as many of you as possible.

Thanks,
Mike

Mike:

I actually use TASM version 3.01 mostly and TASS 1.31 occasionally. I like TASM because it also has 8085, 8080 and Z80 targets which I use for my Altair emulation project. They are roughly equal in capabilities but the preprocessor syntax is different so code is not transferable without some search-and-replace.

Rich

PC Assembler: Universal Cross-Assemblers C32

Reason: Not only was it less expensive than others ($199 IIRC), but you only have to buy one for all your processors. Even if a new processor comes out, you can make your own tables if you don't want to buy the update. I know there are some assemblers that are free for the downloading now, but I got this one when the web hardly existed. I don't know how the flexibility and capabilities, the speed, and the bugs would compare. I seem to find plenty of bugs in a lot of software that people swear is solid. It's not that I try-- I guess I'm just an extra-intensive user of some types of software (assemblers, compilers, and CAD), doing things that the average user doesn't do.

Bug: It does have a bug: If you have a comma in a quoted string in a macro parameter list, the assembler thinks the comma is the delimiter to the next parameter, instead of ignoring commas that come before the closing quotation mark.

I used the 2500 AD assembler from 1986 to 1993. It was nice, but I didn't like the fact that you couldn't bitwise-OR constants together before putting them in an operand.

For smaller assembly portions (up to a few hundred instructions max) which may only be a part of a program that's mostly Forth, I'll use my 6502 Forth's built-in assembler instead of assembling on the PC and then trasferring. Advantages to doing it this way for these short portions include quicker turnaround time, the 6502 computer can assemble and integrate it on the fly while doing other things at the same time, you can put several instructions on a line if you wish, and you can mix assembly portions and high-level Forth (again without necessarily interrupting other processes going on in the target computer).

I was using Frank Vorstenbosch's AS65 (see http://www.kingswood-consulting.co.uk/assemblers/ but the Windows XP patch SP2 removed compatibility for 16-bit DOS applications.

I've been writing my own relocating 6501/6502/65C02/65SC02/65816 macro assembler assembler in Java to replace it. The code is split between a base framework and a processor specific portion so you can construct new assemblers quite quickly. It should work on any Java supporting platform. The object and library format is compressed XML!

The assembler is working but missing a few details (like macros and listings). My attention is currently going to the linker and libarian. I should have a good beta in a few weeks.

I wrote my own 6502 assembler waaay back in about 1983, on a Prime minicomputer running Primos and Software Tools. I wrote it in the preferred language of that environment, Ratfor (which is pre-processed into FORTRAN and then compiled). I subsequently translated the assembler into C on MS-DOS, and then ported it to Linux (although I must have run it on the Atari ST at some point). I still use it, although I need to go back and add the CMOS 6502 instructions and addressing modes.

Did anybody else write their own?

Hi Garth,

Just an update on the price. C32 is now just $99, and comes with a DOS
& Windows version ( plus all the docs )
It may be found @ http://www.datasynceng.com/c32doc.htm

- Wally

For general 6502 use I used to use TASS but now use Michal Kowalski's 6502 assembler & simulator because it does all I need, for now, in the one package.

Lee.

I wrote my own also, using MS Quick BASIC. It supported some of the CMOS instructions. I switched to TASS after Lee Davison used it for EhBASIC.

I also wrote a mini-assembler for my SBC OS.

Daryl

Cross-32 due to recommendation from Garth, and I've been VERY pleased with it as an assembler.

ACME cross-assembler. I use it under Win32, but it's available for several platforms. I've also written a word file for UltraEdit so I get syntax highlighting (The word file is available from here).

ACME was the first cross-assembler I tried. I thought it worked great and could do everything I wanted it to do and then some, plus it's fairly well documented and it's free.

If I were to choose a freeware text editor instead of UltraEdit, with syntax highlighting and the possiblity to invoke external programs (like assemblers) from within the text editor, I'd probably go for PSPad or SourceEdit.

I also use ACME. I use it because it's one of the few 65816 assemblers for Linux that actually works. Most other assemblers for Linux that claim to support the 65816 have obtuse runtime requirements, or have so many bugs with respect to the 65816 instruction set that it's worthless to even try.

Also, ACME produces Commodore PRG-format executables, which are very simple to load. The disadvantage is that there is no relocation information, so it's not possible to use ACME to produce O65-format programs. But for coding up a ROM image or OS kernel, it's perfect.

Note that ACME was specifically designed to support Super Nintendo programming, so ROM generation was its highest priority, and is therefore optimized for that. So, for me (who is still working at the lowest possible levels with the Kestrel), it's ideal.

Maybe later, I'll research A65 and LD65 to produce relocatable images, once I get the Kestrel to recognize more than 64K of address space and have at least 128K of RAM installed, with an OS image to suitably handle such dynamic loading of programs.

I use cc65 (http://www.cc65.org/). But, I've never used the C compiler (I don't know how to, honestly heheh), only the assembler and linker. I like being able to use the segments and linker config, being able to reserve bytes of RAM/ROM right next to the code that uses it, stuff like that.

It's still being developed, so I guess that's both good and bad. Some bugs showed up due to changes, but it was fixed after I compiled a newer version.

For 65816, I used x816. I really liked it's local label style and it was generally easy to use. But it doesn't even work in windows anymore, so I have to run it in the dosbox emulator if I need to assemble the SNES program I wrote with it.

For software written by others, I will usually stick with the assembler that the author used, as long as it is easily available and can be unobtrusively installed on my computer. For example, I use TASS for assembling EhBASIC, but not for anything else.

Believe it or not, since most of my 6502 programs are fairly short (only a few k of object code), I still use Merlin (a popular commercial assembler back in the day) on an Apple! (How's that for living in the 20th century?) I like it because I can have the assembler, editor, source code, and object code all in memory at once, and I don't have to save source code before reassembling, so the edit-assemble-test cycle is pretty quick. I prefer to run on actual hardware as much as possible (even when working with other processors), so along with the built-in monitor on the Apple, it makes a great interactive debugging environment. I also wrote a short program to transfer source code via RS-232 to a PC so it can be e-mailed or posted on the forum. These days there are other options in terms of assemblers that run on 6502-based systems, but Merlin is what I have and was already using, and it's good enough for most of my purposes.

Garth mentioned Forth assemblers, and I've used them also, but in that case its been assembly routines that have Forth specifically in mind, rather than general-purpose 6502 routines (which could be done, but I haven't done it). One additional advantage of a Forth assembler is that it's very easy to write one (even a cross assembler) for the 6502 even when there isn't one already built-in.

Anyway, some things I like about Merlin are: decent macro capability, looping constructs which are useful for calculating tables, useful assembler directives for strings, zero page or absolute addressing (or long addressing on the 65816) can be forced, and a symbolic disassembler is included.

I'm strongly considering writing my own assembler, though. My original intent was to come up with a way of compressing/tokenizing the source code that would be suitable for a processor like the 6502 with a 16-bit address space. The idea was that I could keep larger source code files in memory, and as a bonus it would assemble faster since you wouldn't have to parse an opcode like CLC every time you assembled the file (twice for a two-pass assembler). This has sort of grown into a list of ideas for an assembler.

Originally I was going to write the assembler first, then use that to write my 6502 ANS Forth, but now I'm thinking I'll write the Forth system first, and write the assembler in Forth at least initially. It's difficult to estimate the typical source code length to object code length ratio or the speed of the assembler, but there appears to be several options avaiable for making the assembler extremely fast. An unintended benefit of using Forth is that it might be usable as a cross assembler on non-6502 systems using GForth or some other ANS Forth.

I am also an UltraEdit user. Thanks for the wordfile!

Regards,
Mike

Mike Naberezny wrote:
You're welcome! From what I hear, this wordfile will soon be part of the ACME distribution for DOS/Windows.

Regards,

Fredrik