RISOLTO Istruzione MUL blocca il programma

[Matteo34]

Scusate ho un problema(strano eh -_-), ho cercato un po su internet, ho provato a fare un paio di prove ma niente non ne esco.
Quando viene eseguita l'istruzione "MUL word" il programma si blocca, sono sicuro al 100% sia quell'istruzione,poiché escludendo le altre istruzioni che potrebbero causare overflow o generare eccezioni fila tutto liscio come l'olio.
Avevo finito questo programma un mesetto fa, ho deciso di riprenderlo e aggiungervi due cose, giusto per visualizzare l'output, vi metto solo la macro che fa ciò, i registri non vengono modificati al di fuori della macro quindi escludo cambiamenti esterni involuti, o meglio vengono modificati ma azzerati prima dell'estensione della macro(tutti attranne il registro bx, la quale viene preso come parametro dalla macro):

output_add  MACRO register
        LOCAL search_lenght, continue, mult, output
        push    ax
        push    cx
        push    dx
        mov     store_in, 10
        mov     ax, register
        search_lenght: cmp    ax, 0
                       jne    continue
                       dec    cx
                       mov    store_in, 1
                       mov    ax, 10
                       xor    dx, dx
                       jmp    output
                       continue: xor   dx, dx
                                 mov   ax, ax
                                 div   store_in
                                 inc    cx
                                 jmp   search_lenght
    
        mult: mul  store_in ;in questa riga avviene il fatto secondo me
          
              mov   store_in, ax
              xor   dx, dx
              loop  mult
              mov   ax, register
    
        output: mov   ax, ax
                xor   dx, dx
                div   store_in
                push  ax
                push  dx
                mov   ah, 02h
                add   al, 48
                xor   dx, dx
                mov   dl ,al
                int   21h
                pop   dx
                pop   ax
                mov   ax, dx
                push  ax
                mov   ax, store_in
                xor   dx, dx
                mov   cx, 10
                div   cx
                mov   store_in, ax
                pop   ax
            
                cmp   store_in, 0
                je    stop
                jmp   output
    
        pop     dx
        pop     cx
        pop     ax
ENDM

Non voglio sapere con preciso se la mia supposizione è corretta o su quale riga avviene ciò, vorrei sapere cosa può generare eccezioni in questo frammento di codice, ho controllato i manuali e le guide online ma non trovo nessuno problema in quell'istruzione MUL, può darsi abbia letto male qualcosa o mi sia fatto sfuggire altrettanto.

comunque l'algoritmo consiste nel scovare la lunghezza del numero, moltiplicare la lunghezza per 10 per "lunghezza-1" volte e quindi poi dividere il numero per il risultato della moltiplicazione, stampare il contenuto del registro ax+48, memorizzare in ax il registro ax, e ripetere ciò finche il numero(che ogni volta viene divisio per "lunghezza-1*10" 10 volte, il divisore viene diviso a sua volta per 10) sia pari a 0, o meglio il quoziente dell'ultima divisione sia 0.


EDIT: è incredibile come delle cavolate possano diventare relativamente complesse per chi non abbia mai programmato in tale linguaggio, mentre le cose più complesse come sovrascrivere la RAM video siano facili(si parla in relazione di righe di codice : risultato)

 

[DispatchCode]

Ciao, pubblicalo completo, così da avere una visione d'insieme e poterlo assemblare.

 

[Matteo34]

Eccolo:

input_int MACRO register

        LOCAL input, stop_input

        push    ax
        push    cx

        xor     register, register

        mov     cx, 5

        input:  mov   ah, 01h
                int   21h
                xor   ah, ah

                cmp   al, 13
                je   stop_input

                cmp   al, 48
                jb    stop
        
                cmp   al, 57
                ja    stop

                sub   al, 48
                mov   store_in, ax
                mov   ax, 10
                mul   register
                add   store_in, ax
                mov   register, store_in

                loop  input
                pop   cx
                pop   ax
        
        stop_input: pop   cx
                    pop   ax
                    push  dx
                    mov  ah, 02h
                    mov  dl, 13
                    int  21h
                    mov  dl, 10
                    int  21h
                    pop  dx
ENDM

output_add  MACRO register

        LOCAL search_lenght, continue, mult, output

        push    ax
        push    cx
        push    dx

        mov     store_in, 10
        mov     ax, register

        search_lenght: cmp    ax, 0
                       jne    continue
                       dec    cx
                       mov    store_in, 1
                       mov    ax, 10
                       xor    dx, dx
                       jmp    output

                       continue: xor   dx, dx
                                 mov   ax, ax
                                 div   store_in

                                 inc    cx
                                 jmp   search_lenght
        
        mult: mul  store_in
              
              mov   store_in, ax
              xor   dx, dx

              loop  mult
              mov   ax, register
        
        output: mov   ax, ax
                xor   dx, dx
                div   store_in

                push  ax
                push  dx
                mov   ah, 02h
                add   al, 48
                xor   dx, dx
                mov   dl ,al
                int   21h
                pop   dx
                pop   ax

                mov   ax, dx

                push  ax
                mov   ax, store_in
                xor   dx, dx
                mov   cx, 10
                div   cx

                mov   store_in, ax
                pop   ax
                
                cmp   store_in, 0
                je    stop
                jmp   output
        
        pop     dx
        pop     cx
        pop     ax
ENDM

stack SEGMENT PARA STACK 
        
        db      ?

stack ENDS

data SEGMENT PARA PUBLIC

        msg1    db      "Primo numero:$"
        msg2    db      "Secondo numero:$"
        msg3    db      "Risultato:$"
        store_in    dw     ?
        
data ENDS

code SEGMENT PARA PUBLIC        

        ASSUME ss: stack, ds: data, cs: code

_start:
        ;load the DS
        mov     ax, data
        mov     ds, ax

        ;ouput msg1
        mov     ah, 09h
        mov     dx, OFFSET msg1
        int     21h

        ;input 1
        input_int  bx

        ;output msg2
        mov   ah, 09h
        mov   dx, OFFSET msg2
        int   21h 
        
        ;input 2
        input_int  dx

        ;add the number in bx
        add     bx, dx

        ;output msg2
        mov     ah, 09h
        mov     dx, OFFSET msg3
        int     21h

        output_add  bx

        ;return the control at ms-dos
        stop: mov   ah, 04ch
              mov   al, 1
              int   21h

code ENDS       
        END _start

 

[DispatchCode]

Il programma termina correttamente, ma la stampa è sbagliata.

Qualche consiglio:

• indenta usando 2 o 4 spazi, così è più leggibile
• non abusare delle MACRO, esistono le procedure per svolgere compiti

Il primo errore che mi salta all'occhio è in output_add:

        push    ax
        push    cx
        push    dx

        mov     store_in, 10
        mov     ax, register

        search_lenght: cmp    ax, 0
                       jne    continue
                       dec    cx

quel CX è sporco molto probabilmente. Il valore che contiene deriva da altre operazioni.
Un altro problema è sicuramente qui:

                       continue: xor   dx, dx
                                 mov   ax, ax
                                 div   store_in

                                 inc    cx
                                 jmp   search_lenght

quel mov ax, ax.

Per contare le cifre del risultato puoi usare un contatore che moltiplichi per 10 ad ogni numero. Così facendo il contatore lo potrai utilizzare per stampare le cifre del numero partendo dall'ultima cifra.

Per spiegarmi:
Contatore inizializzato a 1, se hai un risultato N = 123, farai 123/10 = 12, Contatore *= 10.
Poi 12/10 = 1, Contatore *=10
Poi 1/10 = 0.

A questo punto avrai il Contatore = 100.
Ti sarà sufficiente fare 123 / 100 = 1, e stamparlo. Il resto della divisione sarà il nuovo numero, quindi N = 23.
N / 10 = 2, resto 3. Stampi 2 e fai N = 3 / 1 = 3.
Ad ogni ciclo dovrai anche dividere il contatore per 10.

 

[Matteo34]

Non capisco che cosa intendi quando dici che CX è "sporco" se "ax ≠ 0" incremento CX per poi doverlo decrementare visto che mi uscirebbe un numero con una cifra in più.
Esempio=

AX= 12
store_in = 10
AX/store_in = 1,2 => AX = 1 DX= 2 CX++
AX/store_in = 0,1 => SX = 0 DX = 1 CX++

CX--

CX*10 = 10

In questo modo non ottengo 100 ma dieci.
Cosa c'è di "sporco" in CX?

Il programma termina correttamente, ma la stampa è sbagliata.

Qualche consiglio:

• indenta usando 2 o 4 spazi, così è più leggibile
• non abusare delle MACRO, esistono le procedure per svolgere compiti

Il primo errore che mi salta all'occhio è in output_add:

push ax
push cx
push dx

mov store_in, 10
mov ax, register

search_lenght: cmp ax, 0
jne continue
dec cx

quel CX è sporco molto probabilmente. Il valore che contiene deriva da altre operazioni.
Un altro problema è sicuramente qui:

continue: xor dx, dx
mov ax, ax
div store_in

inc cx
jmp search_lenght

quel mov ax, ax.

Per contare le cifre del risultato puoi usare un contatore che moltiplichi per 10 ad ogni numero. Così facendo il contatore lo potrai utilizzare per stampare le cifre del numero partendo dall'ultima cifra.

Per spiegarmi:
Contatore inizializzato a 1, se hai un risultato N = 123, farai 123/10 = 12, Contatore *= 10.
Poi 12/10 = 1, Contatore *=10
Poi 1/10 = 0.

A questo punto avrai il Contatore = 100.
Ti sarà sufficiente fare 123 / 100 = 1, e stamparlo. Il resto della divisione sarà il nuovo numero, quindi N = 23.
N / 10 = 2, resto 3. Stampi 2 e fai N = 3 / 1 = 3.
Ad ogni ciclo dovrai anche dividere il contatore per 10.

Inviato da MI 8 tramite App ufficiale di Tom\'s Hardware Italia Forum

 

[Matteo34]

Inoltre com'è che a te non si blocca il programma mentre a me si? Che assemblatore hai usato(non credo cambi qualcosa, alla fine alla fine il codice il linguaggio macchina e lo stesso)soprattutto per quale architettura hai assemblato. A me non va proprio arriva a quella istruzioni le "mul" e muore

Il programma termina correttamente, ma la stampa è sbagliata.

Qualche consiglio:

• indenta usando 2 o 4 spazi, così è più leggibile
• non abusare delle MACRO, esistono le procedure per svolgere compiti

Il primo errore che mi salta all'occhio è in output_add:

push ax
push cx
push dx

mov store_in, 10
mov ax, register

search_lenght: cmp ax, 0
jne continue
dec cx

quel CX è sporco molto probabilmente. Il valore che contiene deriva da altre operazioni.
Un altro problema è sicuramente qui:

continue: xor dx, dx
mov ax, ax
div store_in

inc cx
jmp search_lenght

quel mov ax, ax.

Per contare le cifre del risultato puoi usare un contatore che moltiplichi per 10 ad ogni numero. Così facendo il contatore lo potrai utilizzare per stampare le cifre del numero partendo dall'ultima cifra.

Per spiegarmi:
Contatore inizializzato a 1, se hai un risultato N = 123, farai 123/10 = 12, Contatore *= 10.
Poi 12/10 = 1, Contatore *=10
Poi 1/10 = 0.

A questo punto avrai il Contatore = 100.
Ti sarà sufficiente fare 123 / 100 = 1, e stamparlo. Il resto della divisione sarà il nuovo numero, quindi N = 23.
N / 10 = 2, resto 3. Stampi 2 e fai N = 3 / 1 = 3.
Ad ogni ciclo dovrai anche dividere il contatore per 10.

Inviato da MI 8 tramite App ufficiale di Tom\'s Hardware Italia Forum

 

[DispatchCode]

Non capisco che cosa intendi quando dici che CX è "sporco" se "ax ≠ 0" incremento CX per poi doverlo decrementare visto che mi uscirebbe un numero con una cifra in più.
Esempio=

AX= 12
store_in = 10
AX/store_in = 1,2 => AX = 1 DX= 2 CX++
AX/store_in = 0,1 => SX = 0 DX = 1 CX++

CX--

CX*10 = 10

In questo modo non ottengo 100 ma dieci.
Cosa c'è di "sporco" in CX?




Inviato da MI 8 tramite App ufficiale di Tom\'s Hardware Italia Forum

CX non viene inizializzato, che valore contiene? Nell'input lo usi, ma fai PUSH/POP in entrata e in uscita, quindi hai ancora il valore iniziale che non penso proprio sia quello che ti aspetti.
Nella MACRO dell'output fai ancora il medesimo push, ma operi poi direttamente sul valore di CX:

output_add  MACRO register

        LOCAL search_lenght, continue, mult, output

        push    ax
        push    cx
        push    dx

        mov     store_in, 10
        mov     ax, register

        search_lenght: cmp    ax, 0
                       jne    continue
                       dec    cx
                       mov    store_in, 1
                       mov    ax, 10
                       xor    dx, dx
                       jmp    output

                       continue: xor   dx, dx
                                 mov   ax, ax
                                 div   store_in

                                 inc    cx
                                 jmp   search_lenght

In pratica se CX contiene 140h, tu vai incrementarlo portandolo a 141h.

E' giusto fare anche in un altro modo: ovvero contare le cifre, ad esempio 3, e poi moltiplicare il numero 1 per il numero 10 "tre" (in questo caso) volte.

Ma il valore sul quale operi inizialmente è errato.

Inoltre com'è che a te non si blocca il programma mentre a me si? Che assemblatore hai usato(non credo cambi qualcosa, alla fine alla fine il codice il linguaggio macchina e lo stesso)soprattutto per quale architettura hai assemblato. A me non va proprio arriva a quella istruzioni le "mul" e muore

Inviato da MI 8 tramite App ufficiale di Tom\'s Hardware Italia Forum

Io sto usando sempre il solito assemblatore, Microsoft (R) Macro Assembler Version 6.14.8444 e come linker (ilnk16.exe) ovviamente Microsoft (R) Segmented Executable Linker Version 5.60.339 Dec 5 1994.

Io ho provato ad assemblare e viene eseguito su Emu8086 e anche su DOSBox. Il risultato non viene stampato, ma termina correttamente.

 

[Matteo34]

CX non viene inizializzato, che valore contiene? Nell'input lo usi, ma fai PUSH/POP in entrata e in uscita, quindi hai ancora il valore iniziale che non penso proprio sia quello che ti aspetti.
Nella MACRO dell'output fai ancora il medesimo push, ma operi poi direttamente sul valore di CX:

output_add  MACRO register

        LOCAL search_lenght, continue, mult, output

        push    ax
        push    cx
        push    dx

        mov     store_in, 10
        mov     ax, register

        search_lenght: cmp    ax, 0
                       jne    continue
                       dec    cx
                       mov    store_in, 1
                       mov    ax, 10
                       xor    dx, dx
                       jmp    output

                       continue: xor   dx, dx
                                 mov   ax, ax
                                 div   store_in

                                 inc    cx
                                 jmp   search_lenght

In pratica se CX contiene 140h, tu vai incrementarlo portandolo a 141h.

E' giusto fare anche in un altro modo: ovvero contare le cifre, ad esempio 3, e poi moltiplicare il numero 1 per il numero 10 "tre" (in questo caso) volte.

Ma il valore sul quale operi inizialmente è errato.


Io sto usando sempre il solito assemblatore, Microsoft (R) Macro Assembler Version 6.14.8444 e come linker (ilnk16.exe) ovviamente Microsoft (R) Segmented Executable Linker Version 5.60.339 Dec 5 1994.

Io ho provato ad assemblare e viene eseguito su Emu8086 e anche su DOSBox. Il risultato non viene stampato, ma termina correttamente.

L'ho ri-assemblato è inizzializato CX a 0 e adesso va tutto liscio, l'output è giusto e non si blocca più, non so cosa sia capitato prima, forse come dici tu CX conteneva un valore che non mi aspettavo che forse causava qualcosa, forse veniva eseguita la moltiplicazione un numero sbagliato di volte e quindi il risultato non diventava non rappresentabile nella coppia di registri DX : AX, quindi generava qualche eccezione, probabile.

 

[DispatchCode]

Ottimo, quello era sicuro fosse un errore, già solo guardandolo (non avevo fatto modifiche).
Considera anche che CX è l'operando di default se usi ad esempio LOOP, quindi è anche possibile che questa parte provocasse un loop (CX viene decrementato in automatico):

      mult: mul  store_in
              
              mov   store_in, ax
              xor   dx, dx

              loop  mult

Puoi correggere anche quel mov ax, ax che è inutile; per il resto se funziona, puoi lasciarlo così.

Ti consiglio però di dare uno sguardo alle procedure, in quanto l'utilizzo di macro in quel modo ti complica ulteriormente il debug (che già di per sè non è facilissimo). Le Macro usale solo per piccole operazioni che magari devi ripetere più volte, e non ha senso fare una procedura.

 

[Matteo34]

Ottimo, quello era sicuro fosse un errore, già solo guardandolo (non avevo fatto modifiche).
Considera anche che CX è l'operando di default se usi ad esempio LOOP, quindi è anche possibile che questa parte provocasse un loop (CX viene decrementato in automatico):

      mult: mul  store_in
            
              mov   store_in, ax
              xor   dx, dx

              loop  mult

Puoi correggere anche quel mov ax, ax che è inutile; per il resto se funziona, puoi lasciarlo così.

Ti consiglio però di dare uno sguardo alle procedure, in quanto l'utilizzo di macro in quel modo ti complica ulteriormente il debug (che già di per sè non è facilissimo). Le Macro usale solo per piccole operazioni che magari devi ripetere più volte, e non ha senso fare una procedura.

Hai ragione, ho usato le macro per prenderci un pò la mano, e anche perchè queste verranno estese con le istruzioni identificate dalla macro e mi sarei evitato rogne come il passaggio di parametri etc... che ancora non ho ben studiato.

 

[DispatchCode]

Hai ragione, ho usato le macro per prenderci un pò la mano, e anche perchè queste verranno estese con le istruzioni identificate dalla macro e mi sarei evitato rogne come il passaggio di parametri etc... che ancora non ho ben studiato.

Ci sono diverse convenzioni per il passaggio dei parametri. Come tappa intermedia puoi usare anche FASTCALL, che è di fatto il passaggio dei parametri nei registri (viene usata anche in IA32). Poi usando asm hai più "libertà d'azione"; se non ricordo male in 8086 i registri usati per fastcall erano AX e CX, ma varia anche in base al compilatore (potrebbero venir usati anche AX, BX, DX ad esempio).
Qui usi asm, quindi se tu a stabilire che convenzione usare e rispettare nel tuo programma.
Devi solo stare attento se usi delle funzioni in librerie che ti crei, poichè se la funzione usa CDECL e il chiamante non pulisce lo stack... è un problema.