Address register indirect with displacement, questions

[deimos]

I'm writing a bunch of code which I want to mix and match with assembler, plain 68K, no 020+ stuff.

I want to allocate a 64K block of memory and use it with (x, Dy, Az) addressing mode. Pretty much, I'm using this as an object pool, linking up hundreds of tiny bits of data using offsets into this pool rather than full addresses.

I understand that the value in Dy is a signed 16 bit value, -32k to 32k-1, $8000 to $7fff, so I need Az to point to the middle of the allocated memory.

But then, I want to also use a zero value in Dy as a "null pointer" equivalent, to terminate my linked up structures.

Is there a smart way to be able to access that whole 64K of data while having Dy = 0 not point to somewhere within that data, which will cause problems as I allocate objects from this pool?

[meynaf]

That depends what you call (x, Dy, Az). There is nothing like that.
But you could mean x(Az,Dy.w). Or, with 020 syntax, (x,Az,Dy.w).
In that case, use x(Az,Dy.l) and you're done. No need to point in the middle of the area. The range for Dy would then be 1-$10000, with 0 being the special value.
And yes, always specify a size where there is one.
However, it's not what's called address register indirect with displacement, which is val(An) or (val,An).

[deimos]

Originally Posted by meynaf

That depends what you call (x, Dy, Az). There is nothing like that.
But you could mean x(Az,Dy.w). Or, with 020 syntax, (x,Az,Dy.w).
In that case, use x(Az,Dy.l) and you're done. No need to point in the middle of the area. The range for Dy would then be 1-$10000, with 0 being the special value.
And yes, always specify a size where there is one.
However, it's not what's called address register indirect with displacement, which is val(An) or (val,An).

Yes, that is what I mean.

Regarding using x(Az,Dy.l) instead of x(Az,Dy.w), assuming I want to store my offsets as 16 bit words, should I just treat them as unsigned and in the assembly code just make sure the top half of Dy is cleared?

[jotd]

Originally Posted by deimos

Yes, that is what I mean.

Regarding using x(Az,Dy.l) instead of x(Az,Dy.w), assuming I want to store my offsets as 16 bit words, should I just treat them as unsigned and in the assembly code just make sure the top half of Dy is cleared?

yes!

[deimos]

Originally Posted by jotd

yes!

Ok, then that is what I shall do.

It would be neat if there was a way to do it without that though, I'd imagined there would be a way to let the numbers wrap around somehow. Nevermind.

[jotd]

works with D0.W until $7FFF. to clear upper word I use

 swap d0
 clr.w  d0
 swap d0

I think it's the fastest way.

[meynaf]

Originally Posted by jotd

I think it's the fastest way.

I don't know for 68000, but for 020+ it's not. Fastest way (in that case) is :

 andi.l #$ffff,d0

But that's when your data is already in the register. As it has to come from somewhere (d1 in the code below), the fastest way is :

 moveq #0,d0
 move.w d1,d0

[jotd]

good to know that AND FFFF is faster. I'll change that in my existing codes.

[a/b]

For that particular purpose I use 64KB aligned tables, for example:

	moveq	#table>>16,d0
	swap	d0
...
	move.w	(a0)+,d0
	move.l	d0,a1
	move.w	(a1),d0

This saves 2 cycles (6 for indexed vs. 4 for reg move).
Does not work with movem (it wipes out the upper half), but with 1-3 registers it's as fast or faster than movem. Also keep in mind that d0 is interpreted as unsigned (0 to 65535, and not as -32768 to 32767).

[JoeJoe]

Originally Posted by meynaf

I don't know for 68000, but for 020+ it's not.

for 68k the swap is faster

swap d0    = 4 cycles
clr.w  d0  = 4 cycles
swap d0    = 4 cycles 

           = 12 cycles

vs.

andi.l #$ffff,d0  = 16 cycles

[deimos]

I'll just assign my UWORD offset to a ULONG and let the compiler sort it out.