Permalink
Browse files

adding documentation

  • Loading branch information...
1 parent 39eafb7 commit eef2d20059a2312ab40429574b9a9977af4087fa amaury committed Dec 22, 2012
View
Oops, something went wrong.
View
@@ -6,7 +6,7 @@ boot: a
plugin_ctrl: unmapped=1
magic_break: enabled=1
#plugin_ctrl: serial=1
-display_library: sdl #x#, options="gui_debug"
+display_library: x#, options="gui_debug"
port_e9_hack: enabled=1
#com1: enabled=1, mode=term, dev=/dev/ttyS0
#display_library: sdl
Binary file not shown.
Oops, something went wrong.
View
Binary file not shown.
View
Binary file not shown.
View
@@ -0,0 +1,314 @@
+Instructions assembleur avec des op�randes exprim�s en C
+
+Dans une instruction assembleur utilisant 'asm' vous pouvez sp�cifier
+les op�randes d'une instruction en utilisant des expressions en C. Cela
+signifie que vous n'avez pas besoin de deviner quels registres ou emplacements
+m�moire contiendront les donn�es que vous voulez utiliser.
+
+Vous devez sp�cifier un mod�le d'instruction assembleur de la m�me mani�re que
+�a appara�t dans la description d'un processeur, plus une cha�ne de contrainte
+d'op�rande, pour chaque op�rande.
+
+Par exemple, voici comment utiliser l'instruction `fsinx' du 68881:
+
+asm (
+ "fsinx %1,%0"
+ : "=f" (resultat)
+ : "f" (angle)
+);
+
+Ici 'angle' est l'expression C pour l'op�rande d'entr�e tandis que 'resultat'
+est celle de l'op�rande de sortie. Chacune a `"f"' comme contrainte d'op�rande,
+disant qu'un registre flottant est requis. Le '=' dans '=f' indique que l'op�rande
+est une sortie; toute contrainte d'op�rande de sortie doit utiliser '='. Les
+contraintes utilisent le m�me langage utilis� dans la description du processeur.
+(Constraints).
+
+Chaque op�rande est d�crit par une cha�ne de contrainte d'op�rande suivie par
+l'expression C entre parenth�ses. Un deux-points s�pare le mod�le assembleur
+du premier op�rande de sortie, et un autre s�pare le dernier op�rande de sortie
+du premier d'entr�e, si besoin est. Des virgules s�parent les op�randes dans
+chaque groupe. Le nombre total d'op�randes est actuellement limit� � 30; cette
+limitation pourrait �tre lev�e dans une future version de GCC.
+
+S'il n'y a pas d'op�rande de sortie, mais qu'il y a des op�randes d'entr�e, vous
+devez placer deux deux-point cons�cutifs encadrant l'emplacement o� se trouveraient
+les op�randes de sortie.
+
+A partir de GCC version 3.1, il est aussi possible de sp�cifier les op�randes
+d'entr�e et de sortie en utilisant des noms symboliques qui peuvent �tre r�f�renc�s
+dans le code assembleur. Ces noms doivent �tre sp�cifi�s entre crochets pr�c�dant
+la cha�ne de contrainte, et peuvent �tre r�f�renc�s dans le code assembleur en
+utilisant '%[NOM]' au lieu du signe pourcent suivi du num�ro d'op�rande.
+En utilisant des op�randes nomm�s, l'exemple ci-dessus pourrait ressembler � ceci:
+
+asm (
+ "fsinx %[angle],%[sortie]"
+ : [sortie] "=f" (resultat)
+ : [angle] "f" (angle)
+);
+
+Notez que les noms symboliques d'op�randes n'ont aucune relation avec les autres
+identifiants C. Vous pouvez utilisez n'importe quel nom que vous voulez, m�me ceux
+de symboles C existants, mais vous devez vous assurer que deux op�randes dans la
+m�me structure assembleur n'utilisent pas le m�me nom symbolique.
+
+Les expressions des op�randes de sortie doivent �tre des valeurs-l; le compilateur
+peut v�rifier cela. Les op�randes d'entr�e n'ont pas besoin de l'�tre. Le
+compilateur ne peut pas v�rifier si les op�randes ont un type de donn�es qui est
+raisonnable pour l'instruction qui sera execut�e. Il ne parse pas le mod�le
+d'instruction assembleur et ne sait pas ce que �a signifie, o� s'il s'agit
+d'assembleur valide ou non. La caract�ristique d' 'asm' �tendu est plus souvent
+utilis� pour les instructions machine que le compilateur lui-m�me ne connait pas.
+Si l'expression de sortie ne peut pas �tre directement adress�e (par exemple, c'est
+un champ de bits), votre contrainte doit allouer un registre. Dans ce cas, GCC
+utilisera un registre pour la sortie de cet 'asm', et stockera ce registre dans
+la sortie.
+
+Les op�randes ordinaires de sortie doivent �tre en �criture seulement; GCC assumera
+que les valeurs dans ces op�randes avant l'instruction sont morts et n'ont pas
+besoin d'�tre g�n�r�s. L'assembleur �tendu supporte les op�randes d'entr�e-sortie
+ou de lecture-�criture. Utilisez le caract�re de contrainte '+' pour indiquer un
+tel op�rande et le lister dans les op�randes de sortie.
+
+Quand les contraintes pour l'op�rande de lecture-�criture (ou l'op�rande dans
+lequel seuls quelques bits sont chang�s) autorise un registre, vous pouvez, comme
+alternative, logiquement s�parer sa fonction en deux op�randes s�par�s, un op�rande
+d'entr�e et un op�rande de sortie en �criture seule. La connection entre les deux
+est exprim�e par les contraintes disant qu'ils ont besoin de se trouver dans le
+m�me emplacement pendant l'ex�cution de l'instruction. Vous pouvez utiliser la
+m�me expression C pour les deux op�randes, ou des expressions diff�rentes. Par
+exemple, ici nous �crivons l'instruction (fictive) 'combiner' avec 'bar' comme
+op�rande d'entr�e en lecture-seule, et 'foo' en tant que destination en
+lecture-�criture:
+
+asm (
+ "combiner %2,%0"
+ : "=r" (foo)
+ : "0" (foo), "g" (bar)
+);
+
+La contrainte `"0"' pour l'op�rande 1 dit qu'il doit occuper le m�me emplacement
+que l'op�rande 0. Un nombre dans une contrainte n'est autoris� que dans un op�rande
+d'entr�e, et doit se r�f�rer � un op�rande de sortie.
+
+Seul un num�ro dans une contrainte peut garantir qu'un op�rande se trouvera � la
+m�me place qu'un autre. Le fait que 'foo' ait la valeur de deux op�randes n'est pas
+suffisant pour garantir qu'ils seront � la m�me place dans le code assembleur
+g�n�r�. L'exemple suivant ne serait pas fiable:
+
+asm (
+ "combiner %2,%0"
+ : "=r" (foo)
+ : "r" (foo), "g" (bar)
+);
+
+Des optimisations vari�es ou le rechargement pourraient causer les op�randes 0 et 1
+� se trouver dans des registres diff�rents; GCC n'a aucune raison de ne pas le
+faire. Par exemple, le compilateur pourrait trouver une copie de la valeur de 'foo'
+dans un registre diff�rent et l'utiliser pour l'op�rande 1, mais g�n�rer l'op�rande
+de sortie 0 dans un registre diff�rent (le copiant ensuite � la propre adresse de
+'foo'). Bien s�r, puisque le registre pour l'op�rande 1 n'est m�me pas mentionn�
+dans le code assembleur, le r�sultat ne fonctionnera pas, mais GCC ne peux pas
+le dire.
+
+A partir de GCC version 3.1, on peut �crire '[NOM]' au lieu du num�ro d'op�rande
+pour une contrainte correspondante. Par exemple:
+
+asm (
+ "cmoveq %1,%2,%[resultat]"
+ : [resultat] "=r"(resultat)
+ : "r" (test), "r"(nouveau), "[resultat]"(ancien)
+);
+
+Des instructions peuvent polluer des registres sp�cifiques. Pour le d�crire,
+�crivez un troisi�me deux-points apr�s les op�randes d'entr�e, suivi par les noms
+des registres pollu�s (donn�es dans des cha�nes). Voici un exemple r�aliste pour
+le VAX:
+
+asm volatile (
+ "movc3 %0,%1,%2"
+ : /* pas de sortie */
+ : "g" (source), "g" (destination), "g" (quantite)
+ : "r0", "r1", "r2", "r3", "r4", "r5"
+);
+
+Vous ne devriez pas �crire une description de pollution d'une mani�re qui
+passerait sur un op�rande d'entr�e ou de sortie. Par exemple, vous ne devriez pas
+avoir un op�rande d�crivant une classe de registre avec un membre si vous
+mentionnez ce registre dans la liste de pollution. Les variables d�clar�es se
+trouver dans des registres sp�cifiques (Explicit Reg Vars), et utilis�es comme
+op�randes d'entr�es ou de sortie assembleur ne doivent pas �tre mentionn�es dans la
+description de pollution. Il n'y a aucun moyen pour vous de sp�cifier qu'un
+op�rande d'entr�e est modifi� sans le sp�cifier aussi comme op�rande de sortie.
+Notez que si tous les op�randes de sortie que vous sp�cifiez sont pour cet usage
+(et donc inutilis�s), vous aurez aussi besoin de sp�cifier comme 'volatile' la
+structure 'asm', comme d�crit ci-dessus, pour emp�cher GCC, de consid�rer la
+structure enti�re comme inutilis�e, et donc la supprimer.
+
+Si vous r�f�rencez un registre particulier dans le code assembleur, vous aurez
+� le lister apr�s le troisi�me deux-points, pour dire que la valeur de ce registre
+a �t� modifi�e. Dans certains assembleurs, les noms de registre commencent par '%';
+pour produire un '%' dans le code assembleur, vous devez �crire '%%' dans le
+source.
+
+Si votre instruction assembleur peut alt�rer le registre des codes de condition,
+ajouter 'cc' � la liste des registres pollu�s. GCC sur certaines machines
+repr�sente les codes de condition dans un registre sp�cifique; 'cc' sert � nommer
+ce registre. Sur d'autres machines, les codes de condition sont g�r�s diff�remment,
+et sp�cifier 'cc' n'a aucun effet. Mais c'est valide quelque soit la machine.
+
+Si votre instruction assembleur modifie la m�moire de mani�re impr�visible, ajoutez
+'memory' � la liste des registres pollu�s. Ceci forcera GCC � ne pas garder cach�es
+dans des registres des valeurs de la m�moire, apr�s l'ex�cution de l'instruction
+assembleur. Vous voudrez aussi ajouter le mot-cl� 'volatile' si la m�moire affect�e
+n'est pas list�e dans les entr�es et sortie de l' 'asm', car le mot-cl� 'memory'
+ne compte pas comme effet de bord de l' 'asm'.
+
+Vous pouvez mettre plusieurs instructions assembleur ensemble dans un mod�le 'asm',
+s�par�s par les caract�res normalement utilis�s dans le code assembleur pour le
+syst�me. Une combinaison qui fonctionne dans la plupart des cas est une nouvelle
+ligne pour passer � la suivante, plus un caract�re de tabulation pour aller au
+prochain champ d'instruction (�crit comme '\n\t'). Quelquefois, des points-virgule
+peuvent �tre utilis�s, si l'assembleur autorise le point-virgule comme caract�re de
+s�paration des lignes. Notez que certains dialectes assembleurs utilisent le
+point-virgule pour d�marrer un commentaire. Les op�randes d'entr�e sont garantis de
+n'utiliser aucun registre pollu�, de m�me pour les adresses des op�randes de
+sortie, ainsi vous pouvez lire et �crire les registres pollu�s autant de fois que
+vous voulez. Voici un exemple d'instructions multiples dans un mod�le; il assume
+que la sous-routine 'foo' accepte des arguments dans les registres 9 et 10.
+
+asm (
+ "movl %0,r9\n\t" \
+ "movl %1,r10\n\t" \
+ "call _foo"
+ : /* pas de sortie */
+ : "g" (source), "g" (destination)
+ : "r9", "r10"
+);
+
+A moins qu'un op�rande de sortie n'ait la contrainte de modification '&', GCC
+pourrait l'allouer dans le m�me registre que celui d'un op�rande d'entr�e
+ind�pendant, en consid�rant que les entr�es sont consomm�es avant que les sorties
+soit produites. Cette assertion pourrait �tre fausse si le code assembleur consiste
+en plus d'une instruction. Dans un tel cas, utiliser '&' pour que chaque op�rande
+de sortie ne recouvre pas une entr�e. (Modifiers).
+
+Si vous voulez tester les codes de condition produits par une instruction
+assembleur, vous devez inclure un branchement et une �tiquette dans la structure
+'asm', comme suit:
+
+asm (
+ "clr %0\n\t" \
+ "frob %1\n\t" \
+ "beq 0f\n\t" \
+ "mov #1,%0\n" \
+ "0:"
+ : "g" (resultat)
+ : "g" (entree)
+);
+
+Cela consid�re que votre assembleur supporte les �tiquettes locales, comme
+l'assembleur GNU et la plupart des assembleurs Unix font.
+
+En parlant des �tiquettes, les sauts d'un 'asm' � un autre ne sont pas support�s.
+Les optimiseurs du compilateur ne reconnaissent pas ces sauts, et donc ne peuvent
+pas les prendre en compte en d�cidant comment optimiser.
+
+G�n�ralement, la mani�re la plus convenable d'utiliser ces instructions 'asm' est
+de les encapsuler dans des macros qui ressemblent � des fonctions. Par exemple,
+
+#define sin(x) \
+ ({ \
+ double __valeur, __argument = (x); \
+ \
+ asm ( \
+ "fsinx %1,%0" \
+ : "=f" (__valeur) \
+ : "f" (__argument) \
+ ); \
+ __valeur; \
+ })
+
+Ici la variable '__argument' est utilis� pour s'assurer que l'instruction op�re
+r�ellement sur une valeur 'double', et d'accepter seulement les arguments 'x'
+qui peuvent se convertir automatiquement en 'double'.
+
+Un autre moyen d'�tre s�r que l'instruction op�re sur le type de donn�es correct
+est d'utiliser un cast dans l' 'asm'. C'est diff�rent du fait d'utiliser une
+variable '__argument' car il peut convertir plus de types diff�rents. Par exemple,
+si le type d�sir� est 'int', convertir l'argument en 'int' accepterais un pointeur
+sans complainte, alors qu'assigner l'argument vers une variable __argument de type
+'int' avertirait de l'utilisation d'un pointeur � moins que l'appelant l'ait
+explicitement converti.
+
+Si un 'asm' a des op�randes de sortie, GCC consid�re pour l'optimisation que
+l'instruction n'a aucun effet de bord, sauf dans le changement des op�randes de
+sortie. Cela ne signifie pas que les instructions sans effet de bord ne peuvent pas
+�tre utilis�es, mais que vous devez faire attention, parce que le compilateur
+pourrait les �liminer si les op�randes de sortie ne sont pas utilis�s, ou les
+placer en dehors des boucles, ou en remplacer deux par une s'ils ont une
+sous-expression commune. Ainsi, si votre instruction a un effet de bord sur une
+variable qui autrement ne devrait pas changer, l'ancienne valeur de la variable
+peut �tre r�utilis�e plus tard si elle est trouv�e dans un registre.
+
+Vous pouvez emp�cher une instruction 'asm' d'�tre supprim�e, d�plac�e ou combin�e
+en utilisant le mot-cl� 'volatile' apr�s le 'asm'. Par exemple;
+
+#define lire_et_fixer_priorite(nouveau) \
+ ({ \
+ int __ancien; \
+ \
+ asm volatile ( \
+ "lire_et_fixer_priorite %0, %1" \
+ : "=g" (__ancien) \
+ : "g" (nouveau) \
+ ); \
+ __ancien; \
+ })
+
+Si vous �criver une instruction 'asm' sans sorties, GCC saura que l'instruction a
+des effets de bord, et n'effacera pas l'instruction ou ne la d�placera pas en
+dehors des boucles.
+
+Le mot-cl� 'volatile' indique que l'instruction a d'importants effets de bord. GCC
+n'effacera pas un 'asm' volatile s'il est atteignable. (L'instruction pourra �tre
+supprim�e si GCC peut prouver que le flux de contr�le n'atteindra jamais
+l'instruction.) En plus, GCC ne r�ordonnera pas des instructions � travers un
+'asm' volatile. Par exemple:
+
+*(volatile int *)addr = foo;
+asm volatile ("eieio" : : );
+
+Consid�re que 'addr' contient l'adresse du registre d'un p�riph�rique mapp� en
+m�moire. L'instruction PowerPC 'eieio' (Enforce In-order Execution of I/O) dit
+au CPU de s'assurer que le stockage dans le registre de p�riph�rique se produit
+avant qu'il n'effectue d'autres E/S.
+
+Notez que m�me une instruction 'asm' volatile peut �tre d�plac�e de mani�re
+insignifiante par le compilateur, � travers des instructions de saut. Vous ne
+pouvez pas consid�rer qu'une s�quence d'instructions d' 'asm' volatiles se produira
+de mani�re parfaitement cons�cutive. Si vous voulez une sortie cons�cutive,
+utilisez un seul 'asm'. De m�me, GCC effectuera des optimisations � travers une
+instruction 'asm' volatile; GCC n'oublie rien quand il rencontre une instruction
+'asm' volatile de la mani�re que d'autres compilateurs font.
+
+Une instruction 'asm' sans op�randes ou pollution (un 'asm' de vieux style) sera
+trait�e de la m�me fa�on qu'une instruction 'asm' volatile.
+
+C'est une id�e naturelle de chercher un moyen de donner acc�s aux codes de
+condition laiss�es par l'instruction assembleur. Cependant, quand nous avons
+essay� de l'impl�menter, nous n'avons trouv� aucun moyen de le faire de mani�re
+fiable. Le probl�me est que les op�randes de sortie pourraient avoir besoin d'�tre
+recharg�es, ce qui r�sulterait en des instructions 'store' suppl�mentaires. Sur la
+plupart des machines, ces instructions alt�reraient les codes de condition avant
+qu'il soit temps de les tester. Ce probl�me ne se produit pas pour les instructions
+'test' et 'compare' car il n'y a pas d'op�randes de sortie.
+
+Pour des raisons similaires � celles d�crites ci-dessus, il n'est pas possible
+de donner acc�s � une instruction assembleur aux codes de condition laiss�es par
+les instructions pr�c�dentes.
+
+Si vous �crivez un fichier d'ent�te qui pourrait �tre inclus dans des programmes
+ISO C, �crivez `__asm__' au lieu de `asm'. (Alternate Keywords).
+
Binary file not shown.
View
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
View
@@ -46,7 +46,7 @@ void init_idt(void)
//init_idt_desc(0x08, (u32) _asm_irq_4, INTGATE, &kidt[36]); /* serial port com1 */
//init_idt_desc(0x08, (u32) _asm_irq_9, INTGATE, &kidt[40]); /* NIC */
- init_idt_desc(0x08, (u32) _asm_syscalls, TRAPGATE, &kidt[23]); /* apperls systèmes 0x30 */
+ init_idt_desc(0x08, (u32) _asm_syscalls, TRAPGATE, &kidt[23]); /* appels systèmes 0x30 */
View
Binary file not shown.
View
@@ -46,10 +46,8 @@ int main(void)
print("kernel : tr loaded\n");
/* Initialisation de la memoire */
- //init_mm();
- //get_page_directory();
- //get_page_table();
- //print("kernel : paging enable\n");
+ init_mm();
+ print("kernel : paging enable\n");
sti;
print("kernel : interrupts enable\n");
View
Binary file not shown.
View
@@ -4,14 +4,14 @@
u32 kmalloc( u32 size, int align, u32 *phys)
{
- if( align == 1 && ((end) & 0xFFFFF000) != 0x1000){
- end & 0xFFFFF000;
- end += 0x1000;
+ if( align == 1 && ((PD0_ADDR) & 0xFFFFF000) != 0x1000){
+ PD0_ADDR & 0xFFFFF000;
+ PD0_ADDR += 0x1000;
}
if(phys){
- *phys = end;
+ *phys = PD0_ADDR;
}
- u32 tmp = end;
+ u32 tmp = PD0_ADDR;
tmp += size;
return tmp;
}
View
@@ -22,25 +22,4 @@ typedef struct page
} page_entry;
-/* 1024 pages = 1 table entry */
-typedef struct page_table
-{
- page_entry pages[1024];
-
-} page_table_entry;
-
-/* 1024 table_entries = 1 page_directory_entry*/
-typedef struct page_directory
-{
- page_table_entry *tables[1024];
-
- u32 page_table_physical_adress[1024];
-
- u32 directory_physical_adress;
-
-} page_directory_entry;
-
-
-page_directory_entry *current_dir;
-void init_mm(void);
-void switch_mm(page_directory_entry* page_d);
+void init_mm(void);
Oops, something went wrong.

0 comments on commit eef2d20

Please sign in to comment.