popcorn a écrit 75 commentaires

Et continuez comme-ça ! Quelle époque ! Dans laquelle Monsieur et Madame tout le monde peut créer sa propre chaîne de TV. Je ne suis pas inscrit sur Youtube mais vous êtes dans mon carnet en tout cas.

Ah zut, j'ai dévoilé un spoiler sans le vouloir.

Donc, je recommande surtout à ceux dont ce format ennuie en général à regarder la vidéo ;-)

Ce ne sont pas des ouï-dire mais des rapports de personnes qui l'ont connu.

Tiens, en voilà un autre : https://medium.com/@thomas.bushnell/a-reflection-on-the-departure-of-rms-18e6a835fd84

J'ai beaucoup apprécié la vidéo dont cet article ne fait pas justice. Notamment sur les déboires du professeur qui a eut tout le mal du monde à recruter Ken.

Il y avait un réel problème de sexisme au sein du département où travaillait Stallman et celui-ci en a profité aussi. Il n’y a aucune raison de prendre cà avec des pincettes.

Stallman est un gros porc. Voila ma conclusion après mûres reflexions. Désolé.

Me voilà tout deboussolé par toutes ces histoires.

Et j'en rajoute une couche : https://medium.com/@selamie/remove-richard-stallman-fec6ec210794 et l'appendice A : https://medium.com/@selamie/remove-richard-stallman-appendix-a-a7e41e784f88

Je dois encore laisser décanter tout ca.

Je suis attristé par cette nouvelle. J'ai regardé Récré A2 et puis le Club Dorothée jusqu'à l'âge de 13 ans et je dois avouer qu'elle me faisait de l'effet. Certains de mes amis préférai Dorothée mais moi c'était Ariane.

C'était une femme tres belle et talentueuse.

Elle rejoint Corbier, Framboisier, Rene et Cabu.

La reponse etait : 88 46 FE hexa

MOV rm,r et MOV r,rm s'encodent similairement en au moins deux octets : 100010dw binaire, mod/rm, …

Les opcodes 88, 89, 8A et 8B hexa sont frequentes dans un programme.

Donc ici : d=0 (la memoire est la destination) et w=0 (l'instruction opere sur un octet). Le mod/rm est 106 octal donc ce qui differe ici c'est le deuxieme chiffre, 0, qui correspond a AL et non AX puisque w=0.

Et pourquoi une instruction ne pourrait-elle pas depasser la taille du bus de donnees ?

En plus il y a le 8086 avec un bus 16 bits et le 8088, absolument identique en tout point sauf qu'il ne dispose que d'un bus de donnees de 8 bits.

Tu devrais consulter le manuel de l'utilisateur du 8086 : https://ia801302.us.archive.org/2/items/bitsavers_intel80869lyUsersManualOct79_62967963/9800722-03_The_8086_Family_Users_Manual_Oct79.pdf

Je viens d'y penser. Dans ton programme, il existe une situation de concurrence par le fait que tu charges SS et SP separements. Couper les interruptions avec l'instruction CLI ne suffirait pas car ton systeme pourrait aussi recevoir une interruption non-masquable.

Sur mon systeme une NMI peut etre generee par le 8087 ou en cas d'erreur de parite memoire par exemple.

Utilise LSS pour charger SS:SP a la place. L'instruction est atomique et te premunira de ce probleme.

As-tu trouve satisfaction ?

Salut,

Attention dans ton exemple les operandes ont des tailles differentes ce qui est une erreur.

Aussi, ne devrais-tu pas utiliser 'byte ptr' (ou word ptr ici) plutot que 'ptr byte' ? et de toute facon tu pourrais omettre l'indicateur de taille puisqu'il peut etre induit par le premier operande.

Extra car je m'ennuie en ce moment :

L'instruction ADD AX,[BP-2] s'encode en 3 octets: 03 46 FE

Le premier octet est l'opcode. Le second est le mod/rm decrivant les arguments et le troisieme est le deplacement encode sur un octet signe.

L'opcode est au format 000000dw binaire. Donc ici 00000011 binaire, d=1 (le registre est la destination) et w=1 (l'instruction opere sur un mot).

Le mod/rm est 46 hexa ou 106 octal : 1 = l'operande memoire a un deplacement encode sur 8 bits signes. 0 = registre AX (et non AL puisque w=1). 6 = memoire [BP+deplacement].

Je te laisse decouvrir les details.

Question subsidiaire : comment encoderais-tu MOV [BP-2],AL : ?? 46 FE

Je t'en prie !

J'espere que tu trouveras une solution rapidement.

Tu dois demander a l'admin comment envoyer un mail alors.

L'outil mail a besoin d'un MTA pour envoyer un mail.

C'est que tu n'as pas installe ni configure de MTA alors.

Salut,

Pour completer la reponse de Kerro,

Quel message d'erreur obtiens-tu ?

Une idee : il me semble que l'operateur &> ne soit pas supporte par dash, le shell par defaut de Debian.

En plus movq c'est inter registres..

Selon quelle logique ?

Aaah ces machines recelent encore bien des secrets.

Ceci dit, j'etais juste decu de ne pas pouvoir tester mon programme sur une vraie machine, sinon je trouve que le mode 4 couleurs a un certain charme.

J'ai traduit jusque ce qu'il faut du programme C passe en lien par totof2000 en assembleur (https://files.osdev.org/mirrors/geezer/osd/graphics/modes.c) pour passer en mode 13h sans utiliser le BIOS. Seule la fonction write_regs() etait necessaire, ainsi que le tableau g_320x200x256. La palette me semble rudimentaire mais facilement reprogrammable.

Malheureusement mon XT n'a qu'une carte CGA donc j'ai teste ca avec dosemu.

        ...

        ; passe en mode 13h
        mov si,g_320x200x256
        call write_regs

        ; ES = segment de base de la memoire video
        mov ax,0a000h
        mov es,ax

        ; efface l'ecran
        xor di,di
        xor ax,ax
        mov cx,320*200/2
        cld
        rep stosw

        ; pixel en 160,100
        mov byte [es:100*320+160],1

        ...

VGA_AC_INDEX    equ 3c0h
VGA_AC_WRITE    equ 3c0h
VGA_AC_READ     equ 3c1h
VGA_MISC_WRITE  equ 3c2h
VGA_SEQ_INDEX   equ 3c4h
VGA_SEQ_DATA    equ 3c5h
VGA_CRTC_INDEX  equ 3d4h
VGA_CRTC_DATA   equ 3d5h
VGA_GC_INDEX    equ 3ceh
VGA_GC_DATA     equ 3cfh
VGA_INSTAT_READ equ 3dah

VGA_NUM_SEQ_REGS        equ 5
VGA_NUM_CRTC_REGS       equ 25
VGA_NUM_GC_REGS equ 9
VGA_NUM_AC_REGS equ 21

g_320x200x256:

; MISC
        db 63h

; SEQ
        db 03h, 01h, 0Fh, 00h, 0Eh

; CRTC
        db 5Fh, 4Fh, 50h, 82h, 54h, 80h, 0BFh, 1Fh
        db 00h, 41h, 00h, 00h, 00h, 00h, 00h, 00h
        db 9Ch, 0Eh, 8Fh, 28h, 40h, 96h, 0B9h, 0A3h
        db 0FFh

; GC
        db 00h, 00h, 00h, 00h, 00h, 40h, 05h, 0Fh
        db 0FFh

; AC
        db 00h, 01h, 02h, 03h, 04h, 05h, 06h, 07h
        db 08h, 09h, 0Ah, 0Bh, 0Ch, 0Dh, 0Eh, 0Fh
        db 41h, 00h, 0Fh, 00h, 00

;void write_regs(unsigned char *regs)
;{
;       unsigned i;
;
; Entree : DS:SI = tableau g_xxx
write_regs:

        cld

;/* write MISCELLANEOUS reg */
;       outportb(VGA_MISC_WRITE, *regs);
;       regs++;

        mov dx,VGA_MISC_WRITE
        lodsb
        out dx,al

;/* write SEQUENCER regs */
;       for(i = 0; i < VGA_NUM_SEQ_REGS; i++)
;       {
;               outportb(VGA_SEQ_INDEX, i);
;               outportb(VGA_SEQ_DATA, *regs);
;               regs++;
;       }

        xor cl,cl
.l1:
        mov dx,VGA_SEQ_INDEX
        mov al,cl
        out dx,al
        mov dx,VGA_SEQ_DATA
        lodsb
        out dx,al
        inc cl
        cmp cl,VGA_NUM_SEQ_REGS
        jnz .l1

;/* unlock CRTC registers */
;       outportb(VGA_CRTC_INDEX, 0x03);
;       outportb(VGA_CRTC_DATA, inportb(VGA_CRTC_DATA) | 0x80);
;       outportb(VGA_CRTC_INDEX, 0x11);
;       outportb(VGA_CRTC_DATA, inportb(VGA_CRTC_DATA) & ~0x80);

        mov dx,VGA_CRTC_INDEX
        mov al,3
        out dx,al

        mov dx,VGA_CRTC_DATA
        in al,dx
        or al,80h
        out dx,al

        mov dx,VGA_CRTC_INDEX
        mov al,11h
        out dx,al

        mov dx,VGA_CRTC_DATA
        in al,dx
        and al,7fh
        out dx,al

;/* make sure they remain unlocked */
;       regs[0x03] |= 0x80;
;       regs[0x11] &= ~0x80;

        or byte [si+3],80h
        and byte [si+11h],7fh

;/* write CRTC regs */
;       for(i = 0; i < VGA_NUM_CRTC_REGS; i++)
;       {
;               outportb(VGA_CRTC_INDEX, i);
;               outportb(VGA_CRTC_DATA, *regs);
;               regs++;
;       }

        xor cl,cl
.l2:
        mov dx,VGA_CRTC_INDEX
        mov al,cl
        out dx,al

        mov dx,VGA_CRTC_DATA
        lodsb
        out dx,al

        inc cl
        cmp cl,VGA_NUM_CRTC_REGS
        jnz .l2

;/* write GRAPHICS CONTROLLER regs */
;       for(i = 0; i < VGA_NUM_GC_REGS; i++)
;       {
;               outportb(VGA_GC_INDEX, i);
;               outportb(VGA_GC_DATA, *regs);
;               regs++;
;       }

        xor cl,cl
.l3:
        mov dx,VGA_GC_INDEX
        mov al,cl
        out dx,al

        mov dx,VGA_GC_DATA
        lodsb
        out dx,al

        inc cl
        cmp cl,VGA_NUM_GC_REGS
        jnz .l3

;/* write ATTRIBUTE CONTROLLER regs */
;       for(i = 0; i < VGA_NUM_AC_REGS; i++)
;       {
;               (void)inportb(VGA_INSTAT_READ);
;               outportb(VGA_AC_INDEX, i);
;               outportb(VGA_AC_WRITE, *regs);
;               regs++;
;       }

        xor cl,cl
.l4:
        mov dx,VGA_INSTAT_READ
        in al,dx

        mov dx,VGA_AC_INDEX
        mov al,cl
        out dx,al

        mov dx,VGA_AC_WRITE
        lodsb
        out dx,al

        inc cl
        cmp cl,VGA_NUM_AC_REGS
        jnz .l4

;/* lock 16-color palette and unblank display */
;       (void)inportb(VGA_INSTAT_READ);
;       outportb(VGA_AC_INDEX, 0x20);

        mov dx,VGA_INSTAT_READ
        in al,dx

        mov dx,VGA_AC_INDEX
        mov al,20h
        out dx,al

        ret

Et bien voila !

Donc, a priori, pour activer le mode 13h sans passer par le BIOS, il suffirait de reimplementer la fonction write_regs en assembleur, ce qui devrait etre trivial puisque ca ne fait que programmer des ports et lui passer la tableau g_320x200x256.

Une fois le mode 13h active, c'est assez simple en fait, si tout ce que tu veux faire est d'afficher des pixels.

Le segment de base pour ce mode est 0a000h. Les octets aux offsets de 0 a 63999 representent les 64000 (320*200) pixels dans l'ordre horizonal gauche-droite et vertical bas-haut. Donc y*320+x te donne l'offset d'un pixel. Un pixel = un octet representant un index dans la palette. La palette est composee de 256 couleurs sur 262.144 et avec une carte graphique d'epoque du moins, est configurable assez facilement sans passer par le BIOS.

Petit exemple pour afficher un pixel blanc au centre :

mov ah,0 ; selectionne un mode video
mov al,13h
int 10h

mov ax,0a000h
mov es,ax

mov byte [es:100*320+160],15 ; pixel blanc (15 dans la palette par defaut) en x=160 et y=100

Apres si tu avais deja compris tout ca et que tu veux passer en mode 13h sans BIOS, ca sera une autre paire de manches.

Je comprends, tu es parti d'un tuto 32-bit et tu as fait la conversion.

Voici un bout de code effacant l'ecran en mode texte :

     mov ax,0b800h
     mov es,ax

     mov al,32
     mov ah,1fh  ; fond bleu (1), ecriture en blanc (0fh)

     mov cx,80*25
     xor di,di
     cld
     rep stosw

Ca remplit la memoire de caractere ASCII 32 (espace) avec fond bleu et inscription en blanc.
J'utilise 0b800h comme segment de base, ainsi le premier caractere est en 0 plutot que 8000h.

Le chapitre 23 du PDF que je t'ai suggere traite de la memoire video.

La solution de MicP fonctionne pourtant. Utilises-tu bien des guillemets ?

Voici ce qu'il faut corriger dans ton script original, au cas ou tu serais interesse :
- echapper les accents inverses embarques de la premiere ligne
- enlever les espaces entres les signes '=' des deux premieres lignes.
- ajouter un espace avant le signe '+' de la deuxieme ligne.

Salut,

Pour completer les propos de totof2000, dans ton programme, tu assignes ES a 0b000h, qui est le segment de la memoire video du mode MDA mais tu accedes clairement au segment 0b800h du mode CGA ou 0b000h:8000h, ca revient au meme mais bon, ca parait etrange. Quelles ressources as-tu utilisees ?

Aussi, tu assignes BP mais tu ne l'utilises pas. Et ce n'est pas une bonne idee d'assigner SP avec une valeur impaire, car sur le 8086, il y a une penalite en cas d'acces a un mot non aligne.

Et je ne parlerai pas du saut inutile au debut du programme. Ah si.

Je me permets de te conseiller un livre sur la programmation assembleur 8086 sous DOS disponible gratuitement : The Art of Assembly Language : http://www.ic.unicamp.br/~pannain/mc404/aulas/pdfs/Art%20Of%20Intel%20x86%20Assembly.pdf

Il me semble qu'il est lie a une bibliotheque : UCR standard library ou pas loin qui est dans le domaine public.

En tout cas, je te souhaite bon succes dans ton exploration de ce systeme 8086.