[Asm] Progettare una architettura di processore

[Z80Fan]

Stavo anche ponderando sull'utilità di ADC (add con carry): è ancora utile ora che abbiamo registri a 64 bit?

Edit: ed è utile avere la somma/sottrazione che lavorano su 3 registri (Ra=Rb+Rc)? Perchè nel mergesort MIPS lo ho usato solo una volta (per fare center = left+right )

[Tesinevb]

Originariamente inviato da Z80Fan

...Ultima cosa: come pensi di far riconoscere al processore istruzioni a 16 o a 32 bit? Queste ultime sono solo normali 32 bit ma con un prefisso, o usi un bit dell'istruzione per dire "questa è a 32, carica anche l'altra word" ?

Campo Opcode
Contenuto x x x x x x d w
Posizi. bit 7 6 5 4 3 2 1 0

Se w=0, gli operandi sono a 8 bit; se, invece, w=1, gli operandi sono a 16 bit se invece w=2sono a 32bit ecosì via...

[Z80Fan]

Originariamente inviato da Tesinevb

Campo Opcode
Contenuto x x x x x x d w
Posizi. bit 7 6 5 4 3 2 1 0

Se w=0, gli operandi sono a 8 bit; se, invece, w=1, gli operandi sono a 16 bit se invece w=2sono a 32bit ecosì via...

Ok, quello lo avevo capito. Mi chiedevo come il processore fa a capire se (durante il fetch) si trova davanti un'istruzione con opcode lungo 16 bit o 32 bit, perchè (se non ho capito male), Cesare ha una tabella con opcode lunghi 16 bit, e un'altra con opcode lunghi 32 bit. Quindi il processore si carica una word dalla memoria: come fa a capire se quella word gli basta (perchè è un'istruzione a 16 bit), oppure deve caricare un'altra word che continene il resto dell'istruzione (perchè è un'istruzione a 32 bit) ?

[MaxArt]

Originariamente inviato da Z80Fan

Ok, quello lo avevo capito. Mi chiedevo come il processore fa a capire se (durante il fetch) si trova davanti un'istruzione con opcode lungo 16 bit o 32 bit, perchè (se non ho capito male), Cesare ha una tabella con opcode lunghi 16 bit, e un'altra con opcode lunghi 32 bit. Quindi il processore si carica una word dalla memoria: come fa a capire se quella word gli basta (perchè è un'istruzione a 16 bit), oppure deve caricare un'altra word che continene il resto dell'istruzione (perchè è un'istruzione a 32 bit) ?

La butto lì: forse perché in realtà gli opcode non sono a 16 e 32 bit ma in sostanza a 15 e 31?

[Z80Fan]

Originariamente inviato da MaxArt

La butto lì: forse perché in realtà gli opcode non sono a 16 e 32 bit ma in sostanza a 15 e 31?

Si, quello che avevo pensato io (cioè il discorso di Tesinevb però applicato alle istruzioni): il uP carica la prima word, e controlla subito un bit; se quel bit è attivo, intende dire "hey, uP, carica un'altra word perchè sennò sono incompleto!".

[MaxArt]

Vedo che ci siamo capiti

[cdimauro]

Originariamente inviato da Z80Fan

Ok, tu vuoi fare in modo che sia il uP a decidere come disporre lo stack in modo da adattarsi ai suoi bisogni e velocizzare l'operazione.

Sì. Ho specificato, infatti, un apposito campo per regolare il funzionamento dello stack.

Si potrebbe unire l'utilità del link e dello stack in questo modo: la call mette l'indirizzo nello stack e nel link, se poi la funzione non richiama altre cose, può ritornare mediante un'istruzione che semplicemente usa il link per ripristinare il pc, e decrementa lo sp di tot (in modo da simulare il pop).

Per me non ha senso, perché la push del registro c'è comunque; per una POP in meno non vedo questo gran vantaggio.

E se invece di aggiungere registri specifici, e istruzioni adatte per gestirli, si potrebbe riservare un altro bit per selezionare il registro indirizzi, in modo da espanderli a 16, e usare i trucchi "risc-eschi" per risparmiare sulle altre istruzioni (e usare pseudo-istruzioni).

Lo sai che non mi piacciono i RISC.

Ad esempio, A15 è PC, A14 è SP, la call sarà un'istruzione discreta, ma push, pop, carica immediato, ret, salto incondizionato possono essere tranquillamente semplificate in
mov r, [++SP]
mov [SP--],r
mov r, [PC++]
mov PC, [SP--]
mov PC, [PC++]
Si semplificherebbe il tutto, mantenendo ortogonalità e lasciando al programmatore possibilità di abbinare le istruzioni per far venire fuori qualche altro "trucchetto".

I trucchetti lasciamoli perdere quando si ha a che fare con PC e SP.

Comunque col 68000 e per SP funziona già così.

In ogni caso ci sono 2 considerazioni da fare. La prima è che stai usando 2 registri, per cui te ne rimarranno 14 "general purpose".

La seconda è che con questi trucchetti usando il PC rischi di limitare la scalabilità del processore, visto che il PC è l'elemento che cambia più spesso, ed è determinante per proseguire col flusso delle istruzioni.

Possiamo cmq usare 2 alu per operare sugli stessi registri: se ad esempio abbiamo una istruzione tipo

add R1, [R2+R3]

R2 e R3 verranno prelevati dall'AGU, e il valore prelevato andrà sommato con R1 nell'alu normale; oppure

add R1, [R2++]

R2 viene prelevato dall'AGU, che manda il suo valore in uscita e salva pure il valore aggiornato, e R1 viene prelevato dall'ALU.

Mumble. Non ho capito questi due esempi in base al contesto di cui stavamo discutendo.

Ultima cosa: come pensi di far riconoscere al processore istruzioni a 16 o a 32 bit? Queste ultime sono solo normali 32 bit ma con un prefisso, o usi un bit dell'istruzione per dire "questa è a 32, carica anche l'altra word" ?

Rispondo dopo.

Originariamente inviato da Z80Fan

Stavo anche ponderando sull'utilità di ADC (add con carry): è ancora utile ora che abbiamo registri a 64 bit?

Sì, perché si possono fare operazioni a 128 o più bit.

Comunque al momento non l'ho aggiunta. Lo farò nella tabella degli opcode a 32 bit, perché si tratta di un'istruzione più rara.

Edit: ed è utile avere la somma/sottrazione che lavorano su 3 registri (Ra=Rb+Rc)? Perchè nel mergesort MIPS lo ho usato solo una volta (per fare center = left+right )

Avendo un buon numero di registri e la possibilità di fare accessi in memoria diventa meno utile.

Diciamo che se c'è spazio nella tabella degli opcode, si può pensare di aggiungere questo tipo di struzioni.

Originariamente inviato da Z80Fan

Ok, quello lo avevo capito. Mi chiedevo come il processore fa a capire se (durante il fetch) si trova davanti un'istruzione con opcode lungo 16 bit o 32 bit, perchè (se non ho capito male), Cesare ha una tabella con opcode lunghi 16 bit, e un'altra con opcode lunghi 32 bit. Quindi il processore si carica una word dalla memoria: come fa a capire se quella word gli basta (perchè è un'istruzione a 16 bit), oppure deve caricare un'altra word che continene il resto dell'istruzione (perchè è un'istruzione a 32 bit) ?

Originariamente inviato da MaxArt

La butto lì: forse perché in realtà gli opcode non sono a 16 e 32 bit ma in sostanza a 15 e 31?

No.

Originariamente inviato da Z80Fan

Si, quello che avevo pensato io (cioè il discorso di Tesinevb però applicato alle istruzioni): il uP carica la prima word, e controlla subito un bit; se quel bit è attivo, intende dire "hey, uP, carica un'altra word perchè sennò sono incompleto!".

Sì, ci siamo quasi.

Innanzitutto il processore può benissimo caricare entrambe le word e comporre, quindi, un opcode sempre a 32 bit che andrà poi a decodificare.

Questo sistema è utile per semplificare il decoder, che non dove prendere prima una word, controllarla, e poi eventualmente aggiungere l'altra. Al limite non userà la seconda word.

L'idea è quella di "intercettare" i 4 bit alti dell'opcode a 16 bit. Se sono tutti a 1, allora l'opcode è in realtà a 32 bit, altrimenti è a 16 bit (e verrà semplicemente ignorata la seconda word in fase di decodifica).

E' chiaro che in questo modo i 4 bit alti di un opcode a 32 bit sono sempre a 1111 e, quindi, inutilizzabili per mappare qualche campo. Di fatto gli opcode a 32 bit in realtà sono a 28 bit (che sono i bit utilizzabili a tutti gli effetti).

Di seguito scrivo 3 messaggi con una descrizione dell'ISA, la tabella degli opcode a 16 bit, e quella degli opcode a 32 bit (quest'ultima è ancora in lavorazione, per cui i bit pattern usati sono sballati e da sistemare, e mancano ancora diverse istruzioni).

[cdimauro]

64K (64000) ISA

8 64 bits data registers: D0..D7
8 64 bits address registers: A0..A7
1 64 bits Program Counter: PC
1 64 bits Stack Pointer: SP
1 64 bits Frame Pointer: FP
1 64 bits Status Register: SR

All not specified bits are RESERVED (SHOULD BE ZERO; SBZ).

****************************************************************
SR format (showed as a byte mask)

 7   6   5  4   3   2   1   0
SET|SBZ|SBZ|IF|FR3|FR2|FR1|FR0

FR0 = Current Flags
FR1 = Previous Flags
FR2 = Pre-Previous Flags
FR3 = Pre-Pre-Previous Flags
IF = IF Skip Mask
SET = Settings
SBZ = Should Be Zero (RESERVED)

Flags byte:
7    6    5    4    3    2    1    0
               X    N    Z    V    C
C -> Carry
V -> Overflow
Z -> Zero
N -> Negative
X -> Extended (sometimes carry is copied on, other times is user defined)

Every time that an instruction changes the flags,
FR3 is discarded and FR2, FR1 and FR0 are moved to the left
(FR0 is now free to get the new flags).

IF byte holds a 4 bits mask which reports the skip flag for each instruction:
7    6    5    4    3    2    1    0
                   |Sk.3|Sk.2|Sk.1|Sk.0|
Every time that an instruction is executed, Sk.0 is checked to see if it must be skipped.
If true, the instruction is skipped, otherwise, it will be executed normally.
After that, Sk.0 is discarded, and Sk.3, Sk.2, Sk.1 are moved to the right,
so that Sk.1 is now Sk.0, and Sk.3 is 0 (no skip: the instruction will be executed).

SET byte:
7    6    5    4    3    2    1    0
EAZ |AA  |BE                 |MSA   |
EAZ -> Exception on Address Zero
If a memory location is referenced through an address register,
an exception is raised if it was zero (null pointer)
AA  -> Aligned Address
An exception is raised if the referenced memory location
wasn't properly aligned (word to 16 bits, longs to 32 bits,
and quads to 64 bits).
BE  -> Big Endian
Datas are read and written are big endian (little endian if not set) 
MSA -> Minimum Stack Alignament defines as a Size field
(1, 2, 4 or 8 bytes pushed AT LEAST for each data)

[cdimauro]

Size fields are defined by 2 bits:
00 (B) -> Byte
01 (W) -> Word (16 bits)
10 (L) -> Long (32 bits)
11 (Q) -> Quad (64 bits)

****************************************************************
Condition Code:
0000 XC -> X Clear
0001 XS -> X Set 
0010 HI -> High (> for unsigned integers)
0011 LS -> Low or Same (<= for unsigned integers)
0100 CC -> Carry Clear (>= for unsigned integers)
0101 CS -> Carry Set (< for unsigned integers) 
0110 NE -> Not Equal (!= 0)
0111 EQ -> Equal (== 0)  
1000 VC -> Overflow Clear
1001 VS -> Overflow Set 
1010 PL -> Plus (Not negative) 
1011 MI -> Minus (Negative) 
1100 GE -> Greather or Equal (>= for unsigned integers)
1101 LT -> Less Than (< for unsigned integers)
1110 GT -> Greather Than (> for unsigned integers)
1111 LE -> Less or Equal (<= for unsigned integers)

****************************************************************
Scale factor fields are defined by 2 bits:
00 -> 1
01 -> 2
10 -> 4
11 -> 8

****************************************************************
Addressing Modes (3 bits mode)

Mode | Register | Syntax
 000 |  Reg. no | Dn                           | Data register
 001 |  Reg. no | An                           | Address register
 010 |  Reg. no | [An]                         | Indirect address
 011 |  Reg. no | [An, SInt16]                 | Indirect address with signed 16 bits offset
 100 |  Reg. no | [An]+                        | Indirect address with postincrement
 101 |  Reg. no | -[An]                        | Indirect address with predecrement
 110 |  Reg. no | [An, Xn.Size * Scale, SInt8] | Indirect address with sign-extended scaled index and signed 8 bits offset
 111 |      000 | [PC, SInt16]                 | Indirect PC with signed 16 bits offset
 111 |      001 | [PC, Xn.Size * Scale, SInt8] | Indirect PC with sign-extended scaled index and signed 8 bits offset
 111 |      010 | [SP, UInt16]                 | Indirect SP with unsigned 16 bits offset
 111 |      011 | [SP, Xn.Size * Scale, UInt8] | Indirect SP with zero-extended scaled index and unsigned 8 bits offset
 111 |      100 | [FP, UInt16]                 | Indirect FP with unsigned 16 bits offset
 111 |      101 | Value                        | Immediate
 111 |      110 | [SP]+                        | Indirect SP with postincrement
 111 |      111 | -[SP]                        | Indirect SP with predecrement
Xn = Dn or An

Extension word (for scaled index addressing modes):

15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
D/A |Register      |Size      |Scale    | 8 bits offset                      |
D/A -> 0 = Data, 1 = Address

****************************************************************
16 bits Opcode Table

MOVE.Size Source EA, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    0   | Size    |Dest. Mode     |Dest. Register|Source Mode   |Source Reg.|

ADD.Size Source EA, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    0    0    0   |Dn             |Size     |Source Mode   |Source Reg.|

ADD.Size Dn, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    0    0    1   |Dn             |Size     |Dest. Mode    |Dest. Reg. |

SUB.Size Source EA, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    0    1    0   |Dn             |Size     |Source Mode   |Source Reg.|

SUB.Size Dn, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    0    1    1   |Dn             |Size     |Dest. Mode    |Dest. Reg. |

CMP.Size Source EA, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    1    0    0   |Dn             |Size     |Source Mode   |Source Reg.|

QMOVEU UInt8, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    1    0    1   |Dn             |UInt8                               |
# Dn.Q = Zero-extended UInt8  

AND.Size Source EA, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    1    1    0   |Dn             |Size     |Source Mode   |Source Reg.|

AND.Size Dn, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0    1    1    1    1   |Dn             |Size     |Dest. Mode    |Dest. Reg. |

OR.Size Source EA, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    0    0   |Dn             |Size     |Source Mode   |Source Reg.|

OR.Size Dn, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    0    1   |Dn             |Size     |Dest. Mode    |Dest. Reg. |

XOR.Size Source EA, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    1    0   |Dn             |Size     |Source Mode   |Source Reg.|

XOR.Size Dn, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    1    1   |Dn             |Size     |Dest. Mode    |Dest. Reg. |

QShift.Size UInt3, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    1   |Shift    |UInt3          |Size     |Dest. Mode    |Dest. Reg. |
Shift = LSL (Logical Shift Left), LSR (Logical Shift Right),
ASL (Aritmetic Shift Left), ASR (Aritmetic Shift Right)
UInt3 = 1..7, 0 -> 8.
# QASR gives 0 if Value / (2 ^ Shift) is zero

Bcc SInt8 (* 2)
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    0    0   | Condition Code     |SInt8                               |
# Branch on Condition Code.
# If CC, PC = PC + SInt8 * 2; otherwise PC = PC + 2

QADD.Size UInt3, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    0    1    0   |UInt3          |Size     |Dest. Mode    |Dest. Reg. |
UInt3 = 1..7, 0 -> 8.

QSUB.Size UInt3, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    0    1    1   |UInt3          |Size     |Dest. Mode    |Dest. Reg. |
UInt3 = 1..7, 0 -> 8.

QCMP.Size SInt2, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    0    0    |SInt2    |Size     |Dest. Mode    |Dest. Reg. |
SInt2 = 0..2, 3 -> -1.

LEA Source EA, An
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    0    1     0   |An            |Source. Mode  |Sour. Reg. |
# Load Effective Address (calculates the EA address and saves it into An)

XXX Source EA, An   *** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    0    1     1   |An            |Source. Mode  |Sour. Reg. |

NEG.Size Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    0     0    0   |Size     |Dest. Mode    |Dest. Reg. |
# NEGate. [EA] = - [EA]

NOT.Size Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    0     0    1   |Size     |Dest. Mode    |Dest. Reg. |

XXX.Size Source EA  *** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    0     1    0   |Size     |Source. Mode  |Sour. Reg. |

XXX.Size Source EA  *** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    0     1    1   |Size     |Source. Mode  |Sour. Reg. |

BRA SInt8 (* 2)
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     0    0   |SInt8                               |
#PC = PC + SInt8 * 2

JMP Source EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     0    1    0    0   |Source. Mode  |Sour. Reg. |
# JuMP to EA

JSR Source EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     0    1    0    1   |Source. Mode  |Sour. Reg. |
# Jump to SubRoutine. Pushes next instruction address on stack. Jump to EA 

PEA Source EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     0    1    1    0   |Source. Mode  |Sour. Reg. |
# Push Effective Address. Pushes EA address on stack

XXX Source EA  *** RESERVED! ***

15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     0    1    1    1   |Source. Mode  |Sour. Reg. |

IFcc ConditionMask

15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    0    0   |Cond. Mask |Condition Code     |
Cond. Mask:
000 -> 3 instructions, TFF
001 -> 3 instructions, TFT
010 -> 3 instructions, TTF
011 -> 3 instructions, TTT
100 -> 2 instructions, TF
101 -> 2 instructions, TT
110 -> 1 instruction,  T
111 -> 4 instructions, TTTT
# Conditional executes up to 4 instructions, based upon the condition.
# The condition is evaluated and IF mask on SR is loaded based on
# the Condition Mask.
# So a T flag means that the corrisponding instruction will be executed,
# while an F flag means that it will be skipped.
# 1 instruction: the condition is forced to True,
# so it will be executed only if the condition is true.
# Example:
# IFEQ T -> for the next instruction the EQ condition must match
# 2 instructions: for the first instruction the condition must be true,
# the second can be True or false.
# Examples:
# IFEQ TF
# IFEQ TT
# 3 instructions: for the first instruction the condition must be true,
# the second and third can be True or false.
# Examples:
# IFEQ TFF
# IFEQ TFT
# IFEQ TTF
# IFEQ TTT
# 4 instructions: for all 4 instructions the condition must be true.
# Example:
# IFEQ TTTT
  
XCHG Dx, Dy
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    0    1    0   |Dx            |Dy         |

XCHG Ax, Ay
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    0    1    1   |Ax            |Ay         |

QMOVES SInt3, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    0    0   |Dn            |SInt3      |
SInt3
# Dn.Q = Sign-extended SInt3  

MOVE.Size SR, Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    0    1    0   |Size     |Dn         |

MOVE.Size Dn, SR
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    0    1    1   |Size     |Dn         |

SWAP.Size Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    0    0   |Size|Dn         |
Size: 0 -> Long, 1 = Quad
# SWAPs the two words for the (lower) Long, or the two longs for the Quad

BSWAP.Size Dn

15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    0    1   |Size|Dn         |
Size: 0 -> Long, 1 = Quad
# Byte SWAP. Swaps the bytes for the Long, or the Quad
# For Long: B3 B2 B1 B0 -> B0 B1 B2 B3
# For Quad: B7 B6 B5 B4 B3 B2 B1 B0 -> B0 B1 B2 B3 B4 B5 B6 B7

TRAPcc
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    1    0   |Condition Code  |
# Calls the trap vector if the Condition code is satisfied

MOVE FP, An
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    1    1    0   |An         |

MOVE An, FP
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    1    1    1   |An         |

BSWAP.W Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    0    0    0   |Dn         |
# Byte SWAP. Swaps the bytes for the Word: B1 B0 -> B0 B1

EXT.B Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    0    0    1   |Dn         |
# Sign-extend the Byte in Dn to the Quad

EXT.W Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    0    1    0   |Dn         |
# Sign-extend the Word in Dn to the Quad

EXT.L Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    0    1    1   |Dn         |
# Sign-extend the Long in Dn to the Quad

PUSH SR
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    0    0   |Size  |

POP SR
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    0    1   |Size  |

PUSH FP
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    0    1    0    0

POP FP
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    0    1    0    1

RTS
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    0    1    1    0
# ReTurn from Subroutine

RTR
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    0    1    1    1
# ReTurn from subroutine, restoring SR

ILLEGAL
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    1    0    0    0
# Calls the ILLEGAL vector

NOP
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    1    0    0    1

UNLINK
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    1    0    1    0
# Unlinks the stack (freeing allocated stack space for locals). The steps are:
# 1) SP = FP
# 2) POP FP (restores the old FP from stack, removing it from stack)

BKPT
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    1    0    1    1
# Calls the BreaKPoinT vector

SETFR FRn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    0    1    1   |FRn   |
# Sets the Flags Register. FR0 = FRn

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    1    0    *    *    *

RESET
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    1    1    0    0    0

STOP
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    1    1    0    0    1
# Stops execution until interrupt

RTE
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    1    1    0    1    0
# ReTurn from Exception 

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    1    1    0    1    1

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    1    1    1    1    1    *    *

[cdimauro]

Scale(3) factor fields are defined by 3 bits:
000 -> 1
001 -> 2
010 -> 4
011 -> 8
100 -> 16
101 -> 32
110 -> 64
111 -> 128

****************************************************************
Addressing Modes (4 bits mode)

Mode | Register | Syntax
0000 |  Reg. no | Dn                              | Data register
0001 |  Reg. no | An                              | Address register
0010 |  Reg. no | [An]                            | Indirect address
0011 |  Reg. no | [An, SInt16]                    | Indirect address with signed 16 bits offset
0100 |  Reg. no | [An]+                           | Indirect address with postincrement
0101 |  Reg. no | -[An]                           | Indirect address with predecrement
0110 |  Reg. no | [An, Xn.Size * Scale, SInt8]    | Indirect address with sign-extended scaled index and signed 8 bits offset
0111 |      000 | [PC, UInt16]                    | Indirect PC with signed 16 bits offset
0111 |      001 | [PC, Xn.Size * Scale, SInt8]    | Indirect PC with sign-extended scaled index and signed 8 bits offset
0111 |      010 | [SP, UInt16]                    | Indirect SP with unsigned 16 bits offset
0111 |      011 | [SP, Xn.Size * Scale, UInt8]    | Indirect SP with zero-extended scaled index and unsigned 8 bits offset
0111 |      100 | [FP, UInt16]                    | Indirect FP with unsigned 16 bits offset
0111 |      101 | Int8*/16/32/64                  | Immediate
0111 |      110 | [SP]+                           | Indirect SP with postincrement
0111 |      111 | -[SP]                           | Indirect SP with predecrement
1000 |  Reg. no | [An, Xn.Size * Scale, SInt8]+   | Indirect address with sign-extended scaled index and signed 8 bits offset
1001 |  Reg. no | [An, Xn.Size * Scale3, SInt23]+ | Indirect address with sign-extended scaled3 index and signed 23 bits offset
1010 |  Reg. no | [An, SInt32]+                   | Indirect address with signed 32 bits offset
1011 |  Reg. no | [An, SInt32]                    | Indirect address with signed 32 bits offset
1100 |  Reg. no | [An]-                           | Indirect address with postdecrement
1101 |  Reg. no | +[An]                           | Indirect address with preincrement
1110 |  Reg. no | [An, Xn.Size * Scale3, SInt23]  | Indirect address with sign-extended scaled3 index and signed 23 bits offset
1111 |      000 | [PC, SInt32]                    | Indirect PC with signed 32 bits offset
1111 |      001 | [PC, Xn.Size * Scale3, SInt23]  | Indirect PC with sign-extended scaled3 index and signed 23 bits offset
1111 |      010 | [SP, UInt32]                    | Indirect SP with unsigned 32 bits offset
1111 |      011 | [SP, Xn.Size * Scale3, UInt23]  | Indirect SP with zero-extended scaled3 index and unsigned 8 bits offset
1111 |      100 | [FP, UInt32]                    | Indirect FP with unsigned 32 bits offset
1111 |      101 |                                 | RESERVED
0111 |      110 | [UInt32]                        | Absolute unsigned int 32 bits
0111 |      111 | [UInt64]                        | Absolute unsigned int 64 bits
Xn = Dn or An
*Int8 is always stored as word (16 bits), with the upper byte that SBZ.
Addressing modes 1000, 1001 and 1010 update the An register with the EA. For example:
[An, Xn.Size * Scale, SInt8]+ -> An = An + Xn.Size * Scale + SInt8

Extension word (for scaled index addressing modes):

15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
D/A |Register      |Size      |Scale3        |7 high bits offset             |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
16 low bits offset
D/A -> 0 = Data, 1 = Address

****************************************************************
32 bits Opcode Table

BINOP1[S|Z] Dn, Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    0    0    |Dn            |Dest. Mode         |D. Register|
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Binary Operation 1 |Dest. Size|Src. Size|Source Mode        |Source Reg.|
Src. Size: Source Size
Dest. Size: Destination Size
SExt: 0 -> Zero extend operand; 1 -> Sign extend operand
Binary Operation 1:
0000 SUB
0001 SUBX
0010 RSUB
0011 RSUBX
0100 DIV # SExt is used to calculate signed or unsigned division
0101 RDIV # SExt is used to calculate signed or unsigned division
0110 MOD # SExt is used to calculate signed or unsigned modulo
0111 RMOD # SExt is used to calculate signed or unsigned modulo
1000 AND
1001 NAND
1010 OR
1011 XOR
1100 ADD
1101 ADDX
1110 MUL # SExt is used to calculate signed or unsigned multiplication
1111 BOOLMUL # "Boolean" multiplication. Returns 0 if Dn is 0, Source EA otherwise
# Example: RSUBS D0, [A0, D1.Q * 128, $7F0123]+.W, -[SP].L
# Takes the word (.W) at address A0 + D1.Q * 128 + $7F0123,
# saves the target address in A0 ([]+ address mode),
# sign extend (S instruction suffix) the word to long (.L)
# subtract Dn.L (destination .L is shared with Dn) to the long
# and pushes the result into the stack (-[SP])
# If the stack granularity is quad, a quad word is pushed instead
# (the high 32 bits will be zeroed).   

BINOP2[S|Z] Dn, Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    0    1    |Dn            |Dest. Mode         |D. Register|
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Binary Operation 2 |Dest. Size|Src. Size|Source Mode        |Source Reg.|
Src. Size: Source Size
Dest. Size: Destination Size
SExt: 0 -> Zero extend operand; 1 -> Sign extend operand
Binary Operation 2:
0000 LSL
0001 LSR
0010 ASL
0011 ASR
0100 ROL
0101 ROR
0110 ROLX
0111 RORX
1000 MIN
1001 MAX
1010 
1011 
1100 
1101 
1110 
1111 

QBINOP1[S|Z] Dn, Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    0    |Dn            |0   |SInt6                     |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Binary Operation 1 |Dest. Size|Src. Size|Source Mode        |Source Reg.|
# "Quick" version of BINOP1.
# SInt6: -4..59

QBINOP2[S|Z] Dn, Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    0    |Dn            |1   |SInt6                     |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Binary Operation 2 |Dest. Size|Src. Size|Source Mode        |Source Reg.|
# "Quick" version of BINOP2.
# SInt6: -4..59

UNOP[S|Z] Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    0   |Dest. Mode         |Dest. Reg. |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Unary Operation    |Dest. Size|Src. Size|Source Mode        |Source Reg.|
Src. Size: Source Size
Dest. Size: Destination Size
SExt: 0 -> Zero extend operand; 1 -> Sign extend operand
Un. Operation:
0000 MOVE
0001 NOT
0010 BOOL # Returns 0 if the value is 0, 1 otherwise
0011 MASK # Returns 0 if the value is 0, -1 otherwise
0100 SIGN # Returns -1, 0, or 1 based on the source value
0101 ABS
0110 NEG
0111 NEGX # - Source EA - XFlag
1000 POPCNT # Number of bits set.
1001 LZCNT # Number of leading zero bits
1010 
1011
1100
1101  
1110 
1111 

CMPOP[S|Z] Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    0   |Dest. Reg. |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Compare Operation  |Dest. Size|Src. Size|Source Mode        |Source Reg.|
Src. Size: Source Size
Dest. Size: Destination Size
SExt: 0 -> Zero extend operand; 1 -> Sign extend operand
Compare Operation:
0000 CHK # Checks if 0 <= Source EA < Dn; sets carry and X if not in bounds 
0001 TRAPCHK # Sames as CHK, but calls the check vector if outbounds
0010 CMP
0011 TESTMASK # Destination register Binary And Source EA
0100 
0101 
0110 
0111 
1000 
1001 
1010 
1011
1100
1101  
1110 
1111 

LINK UInt16
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    0    0
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
UInt16
# Links the FP to the stack, adding space for locals. The steps are:
# 1) PUSH FP (saves old FP)
# 2) SP = FP
# 3) SP = SP - UInt16 * MSA (allocates space for locals)

RTD UInt16
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    0    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
UInt16
# ReTurn from subroutine and Deallocate (space). The steps are:
# PC = [SP]+
# SP = SP + UInt16 * MSA

SYSCALL UInt16
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    0
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
UInt16
# SYStem CALL entry point UInt16

BITOPI UInt6, Source EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
0   |UInt6                         |Bit Op.  |Dest Mode          |Dest. Reg. |
Bit Op.:
00 BTST # Bit TeST
01 BCHG # Bit CHanGe
10 BCLR # Bit CLeaR
11 BSET # Bit SET

BITOP Dn, Source EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    0   |Dn             |Bit Op.  |Dest Mode          |Dest. Reg. |
Bit Op.:
00 BTST # Bit TeST
01 BCHG # Bit CHanGe
10 BCLR # Bit CLeaR
11 BSET # Bit SET

SMOVE Register, Sn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    1    0   |D/A  |Register      |                               |
# Move Register to Supervisor register (0..127)
D/A -> 0 = Data, 1 = Address

SMOVE Sn, Rn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    0    1    1   |D/A  |Register      |                               |
# Move Supervisor register (0..127) to Register
D/A -> 0 = Data, 1 = Address

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    0    1    *

SETcc.Size Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    0   |Condition Code      |Dest.Size|Dest Mode          |Dest. Reg. |
# SETs Destination EA to 1 if condition matches, to 0 otherwise

XCHG.Size Register, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    0    1    1
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1   |D/A |Register       |Dest.Size|Dest Mode          |Dest. Reg. |
# eXCHange Register with Destination EA
D/A -> 0 = Data, 1 = Address

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    0    1    1    *    *
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0

DBcc.Size Dn, UInt10 (* 2)
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    1    0   |Register   |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
Size     |Condition Code      |UInt10                                        |
#Decrement Dn and branch if Dn != 0 or Condition Code matches.
#PC = PC + UInt10 * 2 if branch taken

DBRA.Size Dn, UInt14 (* 2)
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    0    1    1   |Register   |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
Size     |UInt14                                                             |
#Decrement Dn and branch if Dn != 0.
#PC = PC + UInt14 * 2 if branch taken

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    0    1    *    *    *    *    *
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0

QCMPOP[S|Z] Source EA.Size, Destination EA.Size
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    0    1    1   |SInt6                     |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
SExt|Compare Operation  |Dest. Size|Src. Size|Source Mode        |Source Reg.|
# "Quick" version of CMPOP.
# SInt6: -4..59

MOVEM Register List, Destination EA
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    1    0    |Dest. Mode        |Dest. Reg. |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
Register List = 16 bits mask
# MOVE Multiple registers to Destination EA

MOVEM Source EA, Register List
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     0    1    1    |Source. Mode      |Sour. Reg. |
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
Register List = 16 bits mask
# MOVE Multiple registers from Source EA

*** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     1    0    *    *    *    *    *    *    *    *
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0

*** COPROCESSOR INTERFACE ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    1    1    1     1    1    *    *    *    *    *    *    *    *
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0

[MaxArt]

Scusa, ma... in inglese?

[cdimauro]

Beh, è la lingua franca dell'informatica. Anche nei miei sorgenti i commenti sono quasi sempre in inglese (al limite con qualche frase in siciliano stretto ).

E' un problema (a parte gli orrori grammaticali)?

[MaxArt]

No, non è un problema ma non so nemmeno da dove cominciare a fare le domande...

[cdimauro]

In genere si parte dall'ISA, ma... domani, perché sto cascando dal sonno.

'Notte a tutti.

[cionci]

Prima di discutere su registri e funzionalità dei registri, non sarebbe meglio discutere delle modalità di indirizzamento e del conseguente formato degli opcode. La definizione dei registri sarà creata di conseguenza.

Ad esempio: esisteranno opcode con operatori a 16, 32 e 64 bit ?

[Z80Fan]

Wow, un set di istruzioni veramente impressionante!

Originariamente inviato da cdimauro

Lo sai che non mi piacciono i RISC.

Io ci provo

Originariamente inviato da cdimauro

In ogni caso ci sono 2 considerazioni da fare. La prima è che stai usando 2 registri, per cui te ne rimarranno 14 "general purpose".

Sono sempre più di 8

Originariamente inviato da cdimauro

La seconda è che con questi trucchetti usando il PC rischi di limitare la scalabilità del processore, visto che il PC è l'elemento che cambia più spesso, ed è determinante per proseguire col flusso delle istruzioni.

Hai assolutamente ragione. Mi hai convinto a separare i registri

Originariamente inviato da cdimauro

Mumble. Non ho capito questi due esempi in base al contesto di cui stavamo discutendo.

Intendevo dire che anche se abbiamo 2 alu separate (una per indirizzi e una per dati), possiamo cmq dargli in pasto qualsiasi registro, non serve per forza dividerli in 2 gruppi dati-indirizzi.

Originariamente inviato da cdimauro

L'idea è quella di "intercettare" i 4 bit alti dell'opcode a 16 bit. Se sono tutti a 1, allora l'opcode è in realtà a 32 bit, altrimenti è a 16 bit (e verrà semplicemente ignorata la seconda word in fase di decodifica).

E' chiaro che in questo modo i 4 bit alti di un opcode a 32 bit sono sempre a 1111 e, quindi, inutilizzabili per mappare qualche campo. Di fatto gli opcode a 32 bit in realtà sono a 28 bit (che sono i bit utilizzabili a tutti gli effetti).

Ah bene, un po' come avevo pensato io per la mia codifica simil-risc a 16 bit:

Formato 16 bit:
(Ra, Rb, Rc = registri operandi)
Tipo 0:
+---------+---------+
|      opcode       |
+---------+---------+
Tipo 1:
+---------+----+----+
|    opcode    | Ra |
+---------+----+----+
Tipo 2:
+---------+----+----+
| opcode  | Rb | Ra |
+---------+----+----+
Tipo 3:
+----+----+----+----+
| op | Rc | Rb | Ra |
+----+----+----+----+

Nota:
Gli opcode 1111, 1110, 1101 del tipo 3 sono riservati, per scegliere gli altri 3 tipi di modalità:
1111 -> opcode tipo 0
1110 -> opcode tipo 1
1101 -> opcode tipo 2

Volevo cercare di identificare dei blocchetti fissi (in questo caso 4 bit), in modo da semplificare la decodifica, ma mi sono imbattuto negli ovvi limiti di spazio

Originariamente inviato da cionci

Prima di discutere su registri e funzionalità dei registri, non sarebbe meglio discutere delle modalità di indirizzamento e del conseguente formato degli opcode. La definizione dei registri sarà creata di conseguenza.

Ad esempio: esisteranno opcode con operatori a 16, 32 e 64 bit ?

E' una buona idea, ma visto che Cesare aveva già fatto abbastanza roba, volevo prima vedere cosa aveva già fatto.
Cmq, si, esistono opcode con dati anche da 8 bit, e se c'è spazio, anche singoli bit



Ora comincio a scrivere le molteplici domande sulle istruzioni

[Z80Fan]

64K (64000) ISA

Guarda, non si capisce proprio da dove hai preso ispirazione

FR0 = Current Flags
FR1 = Previous Flags
FR2 = Pre-Previous Flags
FR3 = Pre-Pre-Previous Flags

Accidenti, io volevo i flag di cinque istruzioni fa

Extension word (for scaled index addressing modes):
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
D/A |Register      |Size      |Scale    | 8 bits offset                      |
D/A -> 0 = Data, 1 = Address

L'estensione viene messa subito dopo l'opcode ma subito prima di altri immediati? Quindi praticamente è come un opcode a 32 bit?

Bcc SInt8 (* 2)
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    0    0   | Condition Code     |SInt8                               |
# Branch on Condition Code.
# If CC, PC = PC + SInt8 * 2; otherwise PC = PC + 2

E se qualcuno deve saltare ad un indirizzo ad un offset dispari?
Cioè (è un esempio stupido):

            <codice>
1000        BEQ    etich
1002        MOV.B 5, D0
1005        MOV.W 47, D1
1009        MOV.W 136, D2
1013        MOV.W 234, D3
1017        MOV.W 262, D4
1021 etich: <codice>

In questo caso l'etichetta è a 21 byte dal branch. Oppure il MOV.B deve essere cmq seguito da un'intera word di dati, di cui solo 8 bit sono presi?

000 -> 3 instructions, TFF
001 -> 3 instructions, TFT
010 -> 3 instructions, TTF
011 -> 3 instructions, TTT
100 -> 2 instructions, TF
101 -> 2 instructions, TT
110 -> 1 instruction,  T
111 -> 4 instructions, TTTT

C'è un ragionamento sotto questa disposizione? Perchè io metterei

000 -> 4 instructions, TTTT
001 -> 1 instruction,  T
010 -> 2 instructions, TF
011 -> 2 instructions, TT
100 -> 3 instructions, TFF
101 -> 3 instructions, TFT
110 -> 3 instructions, TTF
111 -> 3 instructions, TTT

I bit così rappresentano meglio la verità/falsità delle istruzioni (secondo me)

BSWAP.Size Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    0    1   |Size|Dn         |
Size: 0 -> Long, 1 = Quad
# Byte SWAP. Swaps the bytes for the Long, or the Quad
# For Long: B3 B2 B1 B0 -> B0 B1 B2 B3
# For Quad: B7 B6 B5 B4 B3 B2 B1 B0 -> B0 B1 B2 B3 B4 B5 B6 B7

Che istruzione curiosa, in cosa potrebbe essere utile?

MOVEM
PUSHM
POPM

Sono istruzioni veramente complesse. Bisognerebbe implementare dei cicli all'interno del microcodice e, in caso di pipeline, bisognerebbe bloccarla nello stadio di scrittura/lettura memoria. Della loro comodità ovviamente non si discute.

Mi puoi anche chiarire il significato dei BTST, BCHG, BCLR, BSET che usano Dn come parametro? sopratutto, cosa contiene Dn?

[Z80Fan]

non riesco a far stare le istruzioni nella mia codifica a 16 bit!
(almeno ho fatto una MOV veramente potente )

[cdimauro]

Originariamente inviato da cionci

Prima di discutere su registri e funzionalità dei registri, non sarebbe meglio discutere delle modalità di indirizzamento e del conseguente formato degli opcode. La definizione dei registri sarà creata di conseguenza.

Io già fatto tutto.

Ad esempio: esisteranno opcode con operatori a 16, 32 e 64 bit ?

Nella mia ISA sì: puoi manipolare dati del "taglio" che ti serve. Quindi non esclusivamente a 64 bit.

Originariamente inviato da Z80Fan

Wow, un set di istruzioni veramente impressionante!

Sarà più impressionante la tabella degli opcode a 32 bit, quando sarà finita.

Io ci provo

Ma con le idee che hai realizzerai un CISC, e non un RISC.

CISC = opcode a lunghezza variabile. RISC = opcode a lunghezza fissa. Non si scappa.

Sono sempre più di 8

Quello era scontato, ma a mio avviso 20 registri, di cui 16 ortogonali due a due, è un ottimo compromesso (32 registri sarebbero troppi).

Intendevo dire che anche se abbiamo 2 alu separate (una per indirizzi e una per dati), possiamo cmq dargli in pasto qualsiasi registro, non serve per forza dividerli in 2 gruppi dati-indirizzi.

Questo è ovvio. Le ALU ricevono di dati da elaborare, ma non conoscono la fonte.

Ah bene, un po' come avevo pensato io per la mia codifica simil-risc a 16 bit:

Formato 16 bit:
(Ra, Rb, Rc = registri operandi)
Tipo 0:
+---------+---------+
|      opcode       |
+---------+---------+
Tipo 1:
+---------+----+----+
|    opcode    | Ra |
+---------+----+----+
Tipo 2:
+---------+----+----+
| opcode  | Rb | Ra |
+---------+----+----+
Tipo 3:
+----+----+----+----+
| op | Rc | Rb | Ra |
+----+----+----+----+

Nota:
Gli opcode 1111, 1110, 1101 del tipo 3 sono riservati, per scegliere gli altri 3 tipi di modalità:
1111 -> opcode tipo 0
1110 -> opcode tipo 1
1101 -> opcode tipo 2

Volevo cercare di identificare dei blocchetti fissi (in questo caso 4 bit), in modo da semplificare la decodifica, ma mi sono imbattuto negli ovvi limiti di spazio

Tranquillo: si fa sempre così. Altrimenti si impazzirebbe.

E' una buona idea, ma visto che Cesare aveva già fatto abbastanza roba, volevo prima vedere cosa aveva già fatto.
Cmq, si, esistono opcode con dati anche da 8 bit, e se c'è spazio, anche singoli bit

Le istruzioni BTST, BCHG, BSET e BCLR manipolano singoli bit, infatti (Motorola docet).

Ora comincio a scrivere le molteplici domande sulle istruzioni

GLOM. :|

Originariamente inviato da Z80Fan

Guarda, non si capisce proprio da dove hai preso ispirazione

FR0 = Current Flags
FR1 = Previous Flags
FR2 = Pre-Previous Flags
FR3 = Pre-Pre-Previous Flags

Aggiungi un byte al registro SR allora.

Extension word (for scaled index addressing modes):
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
D/A |Register      |Size      |Scale    | 8 bits offset                      |
D/A -> 0 = Data, 1 = Address

L'estensione viene messa subito dopo l'opcode ma subito prima di altri immediati? Quindi praticamente è come un opcode a 32 bit?

L'estensione (estensioni nel caso della MOVE, perché supporta un EA sorgente e un EA destinazione) viene aggiunta subito dopo l'opcode; nel caso di due EA, prima viene l'estensione sorgente e poi quella destinazione.

Bcc SInt8 (* 2)
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    0    0   | Condition Code     |SInt8                               |
# Branch on Condition Code.
# If CC, PC = PC + SInt8 * 2; otherwise PC = PC + 2

E se qualcuno deve saltare ad un indirizzo ad un offset dispari?
Cioè (è un esempio stupido):

            <codice>
1000        BEQ    etich
1002        MOV.B 5, D0
1005        MOV.W 47, D1
1009        MOV.W 136, D2
1013        MOV.W 234, D3
1017        MOV.W 262, D4
1021 etich: <codice>

In questo caso l'etichetta è a 21 byte dal branch. Oppure il MOV.B deve essere cmq seguito da un'intera word di dati, di cui solo 8 bit sono presi?

Esatto. Gli opcode sono multipli di 16 bit, quindi le istruzioni sono sempre allineate a 2 byte (anche qui, Motorola docet).

Solo che, a differenza di Motorola, io sfrutto quest'informazione per amplicare il range dell'offset (qui, invece, è wpython docet ).

000 -> 3 instructions, TFF
001 -> 3 instructions, TFT
010 -> 3 instructions, TTF
011 -> 3 instructions, TTT
100 -> 2 instructions, TF
101 -> 2 instructions, TT
110 -> 1 instruction,  T
111 -> 4 instructions, TTTT

C'è un ragionamento sotto questa disposizione?

Sì: ho applicato un algoritmo gready.

Perchè io metterei

000 -> 4 instructions, TTTT
001 -> 1 instruction,  T
010 -> 2 instructions, TF
011 -> 2 instructions, TT
100 -> 3 instructions, TFF
101 -> 3 instructions, TFT
110 -> 3 instructions, TTF
111 -> 3 instructions, TTT

I bit così rappresentano meglio la verità/falsità delle istruzioni (secondo me)

A me sembra uguale. Perché tanto quello che fa saltare l'omogeneità è il caso delle 4 istruzioni tutte True.

Comunque stamattina m'è venuto in mente un altro modo, molto più efficiente, di implementare quest'istruzione (che rimane esattamente la stessa come opcode; cambia l'apposita porzione del registro SR e come la si usa).

BSWAP.Size Dn
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     1    1    1    0    0    1   |Size|Dn         |
Size: 0 -> Long, 1 = Quad
# Byte SWAP. Swaps the bytes for the Long, or the Quad
# For Long: B3 B2 B1 B0 -> B0 B1 B2 B3
# For Quad: B7 B6 B5 B4 B3 B2 B1 B0 -> B0 B1 B2 B3 B4 B5 B6 B7

Che istruzione curiosa, in cosa potrebbe essere utile?

Per convertire un valore da big endian a little endian, o viceversa. Ad esempio, se stai lavorando in little endian ma devi leggere dati memorizzati in big endian.

MOVEM
PUSHM
POPM

Sono istruzioni veramente complesse. Bisognerebbe implementare dei cicli all'interno del microcodice e, in caso di pipeline, bisognerebbe bloccarla nello stadio di scrittura/lettura memoria. Della loro comodità ovviamente non si discute.

Sì, la pipeline in questi casi viene bloccata (non svuotata, che è quello che interessa di più), ma perché c'è un vantaggio notevole nell'usarle.

Non credere, comunque, che si tratti di roba esclusiva CISC: le MOVEM sono presenti in tutti i PowerPC e in tutti gli ARM.

Mi puoi anche chiarire il significato dei BTST, BCHG, BCLR, BSET che usano Dn come parametro? sopratutto, cosa contiene Dn?

Dn contiene il numero del bit da testare o modificare.

Originariamente inviato da Z80Fan

non riesco a far stare le istruzioni nella mia codifica a 16 bit!
(almeno ho fatto una MOV veramente potente )

Addio RISC...

[Z80Fan]

Originariamente inviato da cdimauro

Ma con le idee che hai realizzerai un CISC, e non un RISC.

CISC = opcode a lunghezza variabile. RISC = opcode a lunghezza fissa. Non si scappa.

Non sono un estremista, mi basta che "opcode a lunghezza fissa" significhi "pochi o meglio nessun byte di prefisso o suffisso" (fatta eccezione per i dati immediati). E' per questo che il tuo set mi è piaciuto subito
(Poi, tecnicamente, non è detto che un RISC debba avere istruzioni della stessa lunghezza, basta che ogni istruzione sia breve e veloce nell'esecuzione, no?)

Originariamente inviato da cdimauro

Esatto. Gli opcode sono multipli di 16 bit, quindi le istruzioni sono sempre allineate a 2 byte (anche qui, Motorola docet).

Solo che, a differenza di Motorola, io sfrutto quest'informazione per amplicare il range dell'offset (qui, invece, è wpython docet ).

Molto bene.

Originariamente inviato da cdimauro

A me sembra uguale. Perché tanto quello che fa saltare l'omogeneità è il caso delle 4 istruzioni tutte True.

Ma per quello basta una AND a 3 ingressi: se l' and dice di no, allora si possono sparare direttamente i bit nell' opcode direttamente in quelli dello SR, senza bisogno di decodificarli.

Originariamente inviato da cdimauro

Comunque stamattina m'è venuto in mente un altro modo, molto più efficiente, di implementare quest'istruzione (che rimane esattamente la stessa come opcode; cambia l'apposita porzione del registro SR e come la si usa).

Aspetto con pazienza

Originariamente inviato da cdimauro

Non credere, comunque, che si tratti di roba esclusiva CISC: le MOVEM sono presenti in tutti i PowerPC e in tutti gli ARM.

No no, non mi preoccupavo della religione dell'architettura (), mi preoccupavo come effettivamente implementarla.

Originariamente inviato da cdimauro

Addio RISC...

Veramente ho preso ispirazione dalle tue modalità (ops, volevo dire, dalle modalità Motorola ), solo estendendo i campi registro ad un bit in più, in modo da eliminare la distinzione D/A

Edit:
Ops, ho visto ora un'istruzione che mi era sfuggita:

XXX Source EA  *** RESERVED! ***
15   14   13   12   11   10    9    8    7    6    5    4    3    2    1    0
1    1    1    0    1    1     0    1    1    1   |Source. Mode  |Sour. Reg. |

Bella un'istruzione con solo la sorgente e non la destinazione

Edit2: Altra domanda: non si può usare un cmp solo? Basterebbe solo dopo modificare l'eventuale salto in modo da rispecchiare la differenza degli elementi. A meno che non ci sia qualche codice dove usi un cmp per modificare i flag in modo da variare successive istruzioni (che non siano salti), ma al momento non mi viene in mente nulla.