To help me with my disassembler which has lots of instructions working already, but a few not working, I decided to create this post in order to get help, otherwise I'd go  .

These are my Assembly and Hexadecimal Assembly questions.

QUESTION 1:According to the table here, [22] is:

ld (**),hl
In Assembly I'dd just:

ld (12),hl
But how should I do that in Hexadecimal?

QUESTION 2

ld hl,(**)
The same doubt as above but for [2A].

QUESTION 3

Since I'm coding a Disassembler, how should I handle bytes like [CB], [DD], [ED],[EF]? These link to other tables.



Thanks much for the help!

would say for the link to other tables it would be something like:

Code: [Select]

If (byte==[ab])
{
 then do checks for other table
}


Yeah, I'll probably do that.

But the opcode [CB] is for the BIT Table. How would I know each one IN the other table?

ld (**),hl loads hl into a specific 2 byte address. Generally you would use it like ld (score),hl and that would copy your value in hl into your address with the label score.

$dd (ix) and $fd (iy) always precede $cb (bit) or $ed (ext) if present,  followed by the index offset if needed, followed by the instruction. So first you should always check for a $dd or $fd and you would know that you were dealing with an index.

Tomorrow Ill give you the code for my disassembler and that should help you out a bit.

ret = $c9
ld ($9d95),hl = $22 $95 $9d
ld hl,($9d95) = $2a $95 $9d
sbc hl,bc = $ed $42
lbit 1,a,(ix+3) = $dd $cb $03 $4f           (this is the way I have the mnemonic set up in my table but the opcode is the same.)

For bit instructions you can just multiply the bit by 8 and add it to the regular opcode.

bit 0,a = $cb $47
bit 1,a = $cb $4f ($47+bit*8 )

inc (hl)
$34

inc (ix+3)   
$dd $34 $03

dec (hl)
$35

dec (ix+4)
$dd $35 $04

ld (hl),10
$36 $0a

ld (ix+2),10
$dd $36 $02 $0a
^    ^   ^   ^
|     |    |   value to be loaded
|     |    ix index offset
|     actual opcode
ix identifier

Notice youre basically just putting $dd or $fd in front of the equivalent instruction that uses hl and following the opcode with the index offset.

res 0,(ix+1)
$dd $cb $01 $86
                   ^basically just like the other bit instructions, just use the opcode at 0, multiply the bit by 8 and add it to the opcode.

res 6,(ix+1)
$dd $cb $01 $b6
                   ^$86 + 6 * 8 = $b6



One thing thats really useful in a disassembler is having it automatically label rom calls, ram locations, ports, flags, and restarts. Basically just try to have it match any address to one in a rom call table for instructions that use them and do something similar for the ports, ram locations, flags, and restarts.

This is an example of what mine puts into a text file:

0A3E   LD   A,$06
0A40   OUT  ($04),A   ;Power Mode Port
0A42   LD   A,$11
0A44   OUT  ($03),A   ;Interrupt Mode Port
0A46   RES  3,(IY+$12)   ;?indic,shift flags?
0A4A   RES  3,(IY+$09)   ;?on flags?
0A4E   EX   AF,AF'
0A4F   EXX
0A50   EI
0A51   HALT

It puts the extra info into comments at the end of the instructions. Note that this is part of the ti-84's rom, but I made the disassembler for the ti-86 and I havent updated any of the tables. (Its still pretty close though.)

Woah your assembler even generates comments? This is pretty cool actually. You should make it for the 83+/84+ and post it. :O

You can make comments on mine too

In my program, concerning Assembly and program itself (not GUI and extras), all that's left is add BCALLs:

http://brandonw.net/calcstuff/page0.txt

Any useful advice AssemblyBandit? Your code examples were really good, but I had already figured them out by the time I saw them.

Oh! There's another thing missing: Reading .8xp files data :S

Cool