World: r3wp

anyway that is not the problem, i just said, that handling 16bits 
registers in 16 bits values instead to have 2 register of 8 bits 
is much slower when we have to read/write into memory

plus lost of time due to the syncronization between 16 and 8 bits 
registers

finally i'm not sure that it's a good idea to separate them

Well, I would have to read more of that document to agree with you 
or not :(

but we would have a gain when performing operations between 16 bits 
registers

quite balanced

in C it will not be a problem, 8 bits registers and 16 bits registers 
will share the same space adressing.

it's missing in rebol

Do you mean union types?

yesp, that's what i mean

that will be the solution

definitivly

Ah, according to the docs, Z80 is not strictly load/store.

but the instructions which operate directly in memory are rarely 
used, because they consume more time.

More time than the combination of a load to a register and an add 
from that register?

yes

depending what operations follows , but right the most time

Wow. It's the same amount of work, in fewer instructions, and it 
takes more time. How does that happen? Microcode?

the reason is that most register operations use one opcode ob one 
byte length

*of one byte length

operation into memory use an opcode of 3 to 6  byte length

so in 1 operation into memory , we can perform several operation 
with registers

*so during 1 operation

How many bytes in a load from memory? I suppose on the addressing 
mode...

3

*it depends on the addressing mode

yep, you're right

3 is the minimum

one for the operation opcode and 2 for the address on 16 bits

but in fact it can be occured in one opcode of  length 1, if the 
adress is already contained in one 16 bit register .

that's mostly the case

so, the correct answer is: 1

What happens if you EXT8 a value that already has data in the higher 
bytes? I'm guessing it will just overwrite that data...

wrong

What happens? I don't have rebcode here to test.

I'm going off docs and memory here.

ext8 (128 + 65536) = -128 instead of 128

fooooollll

no it works

ext 128 = -128

I'm thinking that you may be able to efficiently store your 8-bit 
registers in your 16-bit registers and break them out when you need 
them.

Internally, they would really be 32-bit registers, of course.

Is the accumulator internally 8 or 16-bit?

8

it is A

_a in my source

What do 16-bit arithmetic instructions use for an accumulator?

HL

but most of instructions act on A

Is 8-bit or 16-bit code more common?