[TASM] problème de syntaxe

[Paul TOTH]

Bonjour,

J'ai écris un secteur boot qui charge un programme à l'adresse réelle 0000:0500

ce programme passe en mode protégé et reviens en mode réel selon le modèle déjà évoqué.

mais pour aller un peu plus loin j'utilise un FAR JMP afin de passer en adressage 32bits (merci à ce site qui m'a fait comprendre l'importance du bit D_BIG).

J'ai donc une portion de mon code qui s’exécute avec un adressage 32bits...pour cela je suis passé de cette syntaxe

Code :

1
2
3
4
5
6
7
 
.MODEL TINY
.386P
ORG 500h
start:
 ...
END start

à celle-ci

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
.MODEL TINY
.386P
ORG 500h
start:
 
CODE16 SEGMENT USE16
 ASSUME CS:CODE16, DS:CODE16
 
; init PM
; FAR JMP 1
 
CODE16 ENDS
 
CODE32 SEGMENT USE32
 ASSUME CS:CODE32, DS:CODE32
 
; code après le FAR JMP 1
; passage en adressage 16bits
; FAR JMP 2
CODE32 ENDS
 
CODE16 SEGMENT USE16
 ASSUME CS:CODE16, DS:CODE16
 
; code après le FAR JMP 2
; retour en mode réel
CODE16 ENDS
 
END start

sauf que dans le premier cas le code 32 est encodé en adressage 16bits
et dans le second les offset ne tiennent pas compte du ORG 500h

si je place ORG dans le segment, je me retrouve avec un padding...c'est pas ce que je veux moi !


alors comment mixer USE16 et USE32 dans un fichier binaire sans entête ?

[bifur]

je ne suis pas vraiment connaisseur de tasm (je suis sous fasm) mais je pense que l'on peut mettre use16 et use32 plusieur fois dans le programme, comme la directive orgXXXh qui peut etre placé plusieurs fois, juste avant la partie du programme concerné 'en tout cas c'est possible sous fasm)

[Paul TOTH]

Envoyé par bifur

je ne suis pas vraiment connaisseur de tasm (je suis sous fasm) mais je pense que l'on peut mettre use16 et use32 plusieur fois dans le programme, comme la directive orgXXXh qui peut etre placé plusieurs fois, juste avant la partie du programme concerné 'en tout cas c'est possible sous fasm)

je pensais aussi, mais quand je place un ORG 500h après la déclaration du premier segment, je me retrouve avec 0x500 fois 00 en début de fichier !

[Paul TOTH]

j'ai trouvé...bien que je n'en comprend pas la logique

au lieu d'écrire ceci

Code :

1
2
3
4
5
6
7
8
9
10
 
.MODEL TINY
.386P
ORG 500h
start:
CODE16 SEGMENT USE16
 ASSUME CS:CODE16, DS:CODE16
....
CODE16 ENDS
END start

j'écris ceci

Code :

1
2
3
4
5
6
7
8
9
10
 
.MODEL TINY
.386P
CODE16 SEGMENT USE16
 ASSUME CS:CODE16, DS:CODE16
ORG 500h
start:
....
CODE16 ENDS
END start

[Paul TOTH]

Nouveau problème que je poursuis ici

je pensais que le code généré suivait l'ordre du source...or visiblement les portions notées CODE16 sont regroupées et la portion CODE32 est mise à la fin

or mon FAR JMP était sous la forme

Code :

1
2
3
4
 
  DB 0EAh   ; FAR JMP
  DW $ + 4 ; juste après
  DW 08h   ; Selecteur 8

et je plaçais mon CODE32 à la suite

j'ai placé un label en début de CODE32 et en début du second CODE16 et remplacé le "DW $ +4 " par un "DW label"

bizarrement cela fonctionne dans la portion CODE32, mais l'offset en CODE16 est nul ?!

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
CODE16 SEGMENT USE16
; init PM
  ...
  DB 0EAh
  DW label1 ; me donne 0 !
  DB 08h ; adressage 32bits
CODE16 ENDS
CODE32 SEGMENT USE32
label1:
  DB 66h
  DB 0EAh
  DW label2 ; OK
  DB 10h ; adressage 16bits
CODE32 ENDS
CODE16 SEGMENT USE16
label2:
; retour RM
  ...
CODE16 ENDS

alors je peux toujours coller mon label1 en fin de code16 mais je trouve cela risqué car je ne fais que supposer l'alignement des données.

quelle est la bonne syntaxe ?

existe-il une autre manière de basculer l'adressage en 16/32bits sans déclarer des SEGMENT ? je pensais pouvoir faire un peu ce que je veux en assembleur, mais le compilateur m'impose des règles

[bifur]

alors il faut changer de compilateur!

pour l'assembleur il y en a plein: masm, nasm, et fasm (mon préféré)
tasm est peut être plus adapté a la compilation d'executable pour les système d'exploitation standard et pas vraiment indiqué pour les bidouillage

je te conseillerait bien fasm mais c'est un peut parce que je ne connait (et n'uttilise) que celui la et je n'ai pas non plus expérimenté le mélange code 16bits et 32bits

[Paul TOTH]

Hello,

en effet, suite à ton premier message j'ai pris FASM qui s'avère bien plus adapté à mon projet

voici mon secteur boot en mode protégé avec passage en adressage 32bits

je ne trouve pas de doc claire sur le multitâche LTR, TTS & Cie...quelqu'un connait un article qui me permettrait de mettre cela en place à la suite de ce secteur boot ?

je précise de suite que je veux juste m'amuser et pas créer un nouvel OS révolutionnaire

donc je cherche à savoir comment on met ça en place indépendamment de tout OS, c'est ce qu'il se passe au niveau processeur qui m'intéresse.

La question principale étant : qu'est-ce qui provoque la bascule d'une tâche à une autre - en mode préemptif évidement

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
 
 
; BOOT 0.1, passage en mode protégé et retour au monde réel :)
; (c) 2010 by Paul TOTH <tothpaul@free.fr>
 
; à compiler sous FASM
 
; adresse de chargement du secteur BOOT par le BIOS
ORG $7C00
 
  PUSH CS
  POP  DS
 
; Configuration des selecteurs
  MOV  BX,GDT
  LGDT [BX]
 
; sauvegarde des segments 16bits
  PUSH DS
  PUSH CS
 
; basculer en mode protégé
  MOV EAX,CR0
  OR  AL,1
  MOV CR0,EAX
 
; ATTENTION ici les valeurs des registres de segments sont invalides.
; on hérite cependant des attributs du mode réel et le programme 
; continue à fonctionner. Mais il faut dorénavant leur donner des offset
; dans la GDT et non plus des segments du mode réel !
 
; passer CS sur un description 32bits
  JMP FAR $08:CODE32  ; $08 est un offset dans la GDT (GDT_08)
  CODE32:
  USE32   ; préciser à FASM que l'adressage a changé
 
; faire pointer ES et DS sur DATA32
  MOV AX,$10 ; $10 est un offset dans la GDT (GDT_10)
  MOV ES,AX
  MOV DS,AX
 
; afficher un message en adressage linéaire 32bits
  MOV ESI, msg1
  MOV EDI, $B8000 ; mémoire vidéo
  MOV AH,$70      ; attribut noir sur blanc (en fait gris)
  MOV CX, msg1_length
 Next32:
  LODSB  ; AL = [DS:ESI++]
  STOSW  ; [ES:EDI] = AX; EDI += 2
  LOOP Next32
 
; revenir à un adressage 16bits
  JMP FAR $18:CODE16 ; $18 est un offset dans la GDT (GDT_18)
  CODE16:
  USE16  ; préciser à FASM que l'on est de nouveau en adressage 16bits
 
; retour en mode réel
  MOV EAX,CR0
  AND AL,254
  MOV CR0,EAX
 
; restaurer CS (qui est sur la pile) avec sa valeur initiale (et non $18)
  PUSH SetCS
  RETF
 SetCS:
; restaurer DS (qui est sur la pile)
  POP  DS
 
; appel au BIOS, preuve du fonctionnement en mode réel
  MOV SI,msg2
  MOV CX,msg2_length
 Next2:
  LODSB
  MOV AH,$0E
  MOV BX,$70
  INT $10    ; on fait appel au BIOS et non au DOS qui n'est pas chargé !!!
 LOOP Next2
 
; boucle éternelle
  JMP $
 
; notre message
 msg1 DB 'Hello World !'
; sa longueur
 msg1_length = $ - msg1
 
; Configuration de la GDT (Global Descriptor Table)
 
; attributs
 SIZE_4K  = 10000000b ; indique que la taille est exprimée en pages de 4K, sinon ce sont des octets
 CODE_32  = 01000000b ; l'adressage se fait en mode 32bits, sinon en 16bits (cf préfix DB 66h)
 EXT_SIZE = 00001111b ; bits qui complète la taille pour atteindre 4Gb
 
; accès
 PRESENT    = 10000000b ; l'adresse est valide
 APP_DESC   = 00010000b ; utilisé par un programme
 READ_WRITE = 00000010b ; accessible en écriture (DATA)
                        ; accessible en lecture (CODE)
 EXEC       = 00001000b ; execution autorisée
 
 GDT_00 DW 0
        DW 0
        DB 0
        DB 0
        DB 0
        DB 0
; CODE32, 4Gb
 GDT_08 DW $FFFF  ; Taille
        DW 0      ; Adresse de base
        DB 0      ; Adresse partie haute
        DB PRESENT + APP_DESC + READ_WRITE + EXEC ; Attributs
        DB SIZE_4K + CODE_32 + EXT_SIZE ; Mode d'accès
        DB 0      ; Adresse de base étendue
; DATA32, 4Gb
 GDT_10 DW $FFFF  ; Taille
        DW 0      ; Adresse de base
        DB 0      ; Adresse partie haute
        DB PRESENT + APP_DESC + READ_WRITE  ; Attributs
        DB SIZE_4K + CODE_32 + EXT_SIZE ; Mode d'accès
        DB 0      ; Adresse de base étendue
; CODE16, 4Gb
 GDT_18 DW $FFFF  ; Taille
        DW 0      ; Adresse de base
        DB 0      ; Adresse partie haute
        DB PRESENT + APP_DESC + READ_WRITE + EXEC ; Attributs
        DB SIZE_4K + EXT_SIZE;  Mode d'accès
        DB 0      ; Adresse de base étendue
 
 GDT DW $ - GDT_00
     DW GDT_00
     DW 0
 
 msg2 DB 'Back to real world !'
 msg2_length = $ - msg2
 
; compléter le secteur 0
 DB 510 - ($ - $$) DUP(0)
 
; secteur bootable
 DW $AA55

[bifur]

concernant le tss et le multitache j'avait déja lancé un sujet la dessus:

http://www.developpez.net/forums/d84...on-multitache/

par contre on a pas approfondit le sujet sur le(s) tss

[Paul TOTH]

Envoyé par bifur

concernant le tss et le multitache j'avait déja lancé un sujet la dessus:

http://www.developpez.net/forums/d84...on-multitache/

par contre on a pas approfondit le sujet sur le(s) tss

en effet

pour l'instant je n'ai que les sources de MenuetOS (sous FASM) qui ont l'air assez clairement rédigés, mais une bête mise en place de deux tâches en // auraient été plus simple pour démarrer

d'après ce que j'ai lu sur ton post, le multitâche est mis en place par l'OS avec l'IRQ0...le(s) TSS ne sont qu'une façon de sauvegarder l'état de la tâche en cours...ce n'est pas très excitant finalement

je vais plutôt regarder la gestion des interruptions matériel car mon secteur boot ne permet pas même une lecture clavier

[bifur]

si tu veux mettre en place la lecture clavier il va te falloire plus d'un secteur de boot, donc il faudrat d'abord un programme qui chargeras la suite du programme

j'ai commencé aussi a faire un petit os (seulement monotache) donc j'ai dût faire un bootloader pour disquette (qui a l'avantage de ne pas pourrir le système de fichier fat12), le programme de boot charge seulement un fichier dans un emplacement mémoire et lui passe la main
la source du programme est dans le zip MRT12 (téléchargeable ici , dans le sous dossier "util" et le programme en question est "amorc.com", il est en fait constitué de deux partie:
- le secteur de boot
- le programme qui est chargé de l'écrire sur la disquette sans détruire le système de fichier
bon par contre je suis pas vraiment champion du commentaire

[Paul TOTH]

Envoyé par bifur

si tu veux mettre en place la lecture clavier il va te falloire plus d'un secteur de boot, donc il faudrat d'abord un programme qui chargeras la suite du programme

j'ai commencé aussi a faire un petit os (seulement monotache) donc j'ai dût faire un bootloader pour disquette (qui a l'avantage de ne pas pourrir le système de fichier fat12), le programme de boot charge seulement un fichier dans un emplacement mémoire et lui passe la main
la source du programme est dans le zip MRT12 (téléchargeable ici , dans le sous dossier "util" et le programme en question est "amorc.com", il est en fait constitué de deux partie:
- le secteur de boot
- le programme qui est chargé de l'écrire sur la disquette sans détruire le système de fichier
bon par contre je suis pas vraiment champion du commentaire

oui oui ça je sais faire

au départ j'avais un secteur boot 16bits qui chargeait un binaire 16bits KERNEL.BIN depuis une disquette 1.44 en FAT12...mais pour mes tests un secteur boot suffisait alors j'ai allégé la chose

d'ailleurs dans un premier temps je me contenterais d'un système sur disquette non formatée, c'est à dire quel a suite du noyau sera dans les secteurs 1, 2 ... et le secteur 0 se chargera simplement de monter tout cela en mémoire.

par contre ta page me renvoie une erreur 403

[bifur]

erreur 403? hélas mon site pourri est sous olympe network, un hébergeur gratuit qui est pas vraiment fiable