[Assembler] Numeri negativi

[andrea0032]

Ciao a tutti. Devo fare un codice assembler dove ho un vettore di numeri positivi e negativi. Devo memorizzare in una variabile la somma dei numeri positivi e in un'altra la somma di quelli negativi. IL problema però è che l'istruzione CMP, che uso per fare il confronto di un numero con 0, mi crea problemi.
Ad esempio il numero 30000 me lo considera positivo, mentre 40000 lo considera negativo.
I numeri sono considerati in complemento a due su 16 bit????
Illuminatemi pls.

[variabilepippo]

Mostra il codice utilizzato...

[andrea0032]

Mi sono dimenticato di die che il vettore è di elementi su 32 bit.

VETT DD 10000, 38000, -4, .....

LEA SI, VETT
....
MOV AX, [SI]
CMP AX, 0
JGE positivo
JMP negativo

...

positivo:

.....

negativo:


Ad esempio se ho 32767 va in positivo, se metto 32768 va in negativo

[cionci]

I numeri sono considerati in complemento a due su 16 bit????
Se un numero è considerato o meno in complemento a 2 dipende esclusivamente dalle istruzioni che usi. CMP setta i flag sia interpretando i numero con segno che senza segno. A te sta utilizzare un salto condizionato che sia adatto a quello che cerchi: esistono salti condizionati signed e unsigned.
http://unixwiz.net/techtips/x86-jumps.html

[andrea0032]

Ma infatti uso il salto JGE che salta dopo il confronto tra numeri con segno.

CMP 32768, 0 Risulta negativo

CMP 32767, 0 risultao positivo.

Uso JGE perchè ho numeri con segno.
Dove sbaglio?

Ho provato pure con JS e JNS se che controlla il SIGN FLAG, ma stessa cosa...

[cionci]

32768 non è rappresentabile su un numero a 16 bit in complemento a due ;)
32768 corrisponde alla rappresentazione unsigned:

1000 0000 0000 0000

che è identica alla rappresentazione in complemento a 2 di -32768 ;)

[andrea0032]

In conclusione cosa dovrei modificare al mio codice? Nessuno vieta al programmatore di poter inserire il 32768 o 40000.

[cionci]

In conclusione cosa dovrei modificare al mio codice? Nessuno vieta al programmatore di poter inserire il 32768 o 40000.
Certo che non lo vieta, vengono semplicemente tradotti in binario, di fatto 32768 e 40000 sono numeri corretti a 16 bit la cui rappresentazione senza segno corrisponde a quella di un numero negativo in complemento a 2.
Sei tu a dover sapere che non puoi mettere interi maggiori di 32767 in un intero con segno a 16 bit.

Nel codice non devi modificare niente, il codice è sostanzialmente corretto. L'unico errore è concettuale nel programmatore per aver inserito interi unsigned in un vettore di interi signed, pratica che poi potrebbe anche essere volontaria.

[andrea0032]

Tra l'altro il vettore è di elementi da 32 bit, come faccio il confronto che siano positivi o negativi??? Nella CMP non posso mettere variabili da 32.

[cionci]

In effetti non pensavo a DD che è a 32 bit.
Utilizzi un assemblatore a 16 o a 32 bit ? Davo per scontato tu utilizzassi un assemblatore a 16 bit visto che facevi un LEA su un registro a 16 bit. Se il tuo indirizzamento di memoria è 32 bit ovviamente è errato caricare un indirizzo su un registro a 16 bit.

[andrea0032]

Sto usando l'assembler 8086

[andrea0032]

16 bit

[cionci]

16 bit
E allora non puoi usare i registri a 32 bit, quindi il codice va bene a patto di incrementare SI di 4 byte.
Se invece usi DW al posto di DD sono semplici interi a 16 bit. Quindi devi incrementare SI di 2 byte.
In alternativa puoi usare un indirizzamento composto con SI usato come contatore. In tal caso basta incrementare il contatore di 1.

LEA BX, VETT
...
MOV AX, [BX + SI]

In ogni caso NON puoi usare interi con segno maggiori di 32767

[andrea0032]

Allora ho un vettore di elementi positivi o negativi a 32 bit. Devo sommare tutti gli elementi positivi e tutti quelli negativi e metterli in due variabili distinte da 32 bit ciascuna.
Devo gestire l'overflow ovvero se ho overflow devo settare il risultato della soma a 0.
Avendo numeri su 32 bit in complemento a due, se non sbaglio posso rappresentare da -2 miliardi etc.. a +2 miliardi etc. (da -2^31 a 2^(31)-1).
Come mi consigliatre di procedere??
Io avevo pensato di tenermi due variabili per gli overflow, una relativi ai numeri negativi e l'altra per i positivi. La setto ad 1 se ho overflow altrimenti a 0.
QUando ho terminato l'operazione controllo le variabili e vedo se c'è overflow e azzero oppure no la variabile risultato.

[cionci]

Ma sempre con assembly a 16 bit ?

[andrea0032]

SI sempre 16 bit, uso l'assembler 8086.

[wlog]

perchè uno dovrebbe voler usare l'assembler?


Credevo di essere già abbastanza un nerd a programmare in C ....

[cionci]

perchè uno dovrebbe voler usare l'assembler?
Magari perché sta seguendo un corso o per pura curiosità personale.

Con l'assembler a 16 bit devi farti tutte le operazioni su interi a 32 bit suddividendoli in interi a 16 bit.

Supponendo che la locazione con etichette dato contenga un intero a 32 bit, il byte meno significativo sarà nella cella dato+3, il byte più significativo nella cella di indirizzo dato.
Per sommare dato e dato1:

XOR AX, AX
XOR CX, CX
LEA BX, dato
LEA SI, dato1
LEA DI, risultato
MOV AX, [BX + 1] #prendo i due byte meno significativi
ADD AX, [SI + 1] #sommo i due byte meno significativi
JNC nocarry
INC CX
nocarry: MOV [DI + 1], AX
MOV AX, CX #aggiungo il carry se c'è stato
ADD AX, [BX] #sommo i due byte più significativi
ADD AX, [SI] #sommo i due byte più significativi
MOV [DI], AX #metto il risultato nella locazione di risultato

Ora se il mio assembler non è arrugginito, in realtà lo è, per sommare due interi a 32 byte suddividendoli in interi a 16 bit puoi fare così.
Ovviamente per le altre operazioni devi ragionare anche qui in modulo 16.