Format Post-fixé

L’assembleur Homade propose une syntaxe simple basée sur la notation post-fixée. Un programme Homade est composé de plusieurs parties et repose sur un sous ensemble du langage Forth. On doit pouvoir réaliser un interpréteur Forth qui émulerait le comportement d'un programme Homade. L’intérêt d'utiliser Forth est double : le processeur Homade est un processeur à pile et donc sont code binaire est basé sur une notation post-fixée, le langage Forth permet d'ajouter des mots clefs dans le dictionnaire dynamiquement et cette propriété sera très utile pour intégrer la reconfiguration dynamique d'IP dans les couches langages dans les versions futures. Forth est fortement utilisé dans le monde des systèmes embarqués, ici on l'utilise aussi comme langage de description de l'assembleur lui même. Vous pouvez lire ce papier pour comprendre comment écrire un compilateur simple passe en Forth. Il nous a fortement inspiré.
.
L'ensemble des compilations ont été validées sur le compilateur GNU Forth. Le fichier de définition des mots Homade est indispensable avant la transformation  un fichier asm vers vhdl. Ce fichier est disponible ici pour la version V1.4. Elle devra être mis à jour en intégrant vos propres définitions de mots en fonction des IPs que vous ajoutez au processeur Homade pour votre propre usage.
Le résultat produit est un code VHDL qui spécifie le contenu le la ROM contenant les  instructions à exécuter par le processeur Homade.

Homade et ses 3 entités de calcul

L'assembleur Homade repose sur trois types de composants de calcul:

  1. composant matériel : il s'agit d'une implémentation matérielle d'une fonctionnalité de calcul( en vhdl et synthétisé par les outils xilinx). Il s'agit soit d'un short_IP soit d'un long_IP. La différence majeur réside dans le temps d'exécution qui est soit d'un cycle, soit d'un nombre de cycle non connu a priori. Ces IP ont une influence directe sur la pile d'exécution, cette influence est explicitement décrite dans le code de l'instruction (XX et YY). ces composants sont sollicités par leur nom dans l'assembleur ou par une valeur hexa de 16 bits suivie de BINARY.
  2. composant logiciel : il s'agit d'un suite d'instructions de contrôle entremêlées de composants matériels. Ils peuvent utiliser de façon hiérarchique des composants logiciels. le temps d’exécution est variable en fonction de l'exécution à proprement parlé. Ils ont une influence sur la pile d'exécution qui dépend de l'exécution du composant lui-même. Ils sont déclenchés par un CALL et déclarés par un bloc FUNCTION... RETURN. Il existe un composant logiciel particulier appelé MAIN qui correspond au programme spécifié entre BEGIN et ENDPROGRAM.
  3. composants virtuels: ce sont des entités de calcul dynamiques qui sont associées durant l'exécution soit à des composants logiciels soit des composants matériels. l'association est obtenue par l'instruction WIM qui lie le code du composant virtuel avec son code effectif et ce pendant l'exéuction d'un composant logiciel. ( le code est limité à trois mots de 16 bits. cf l'exemple 3. Le temps d'excution d'un virtual composant est celui du composant associé plus 2 cycles pour le call et return.

Syntaxe de l'assembleur

<Homadeasm> := 

    <Static_IP_list>

    <VC_ID_list> 
<Func_ID_list> 
Program
 [
 [<VC_decl_list>]
 [<function_decl_list>] begin]

	<instruction_list>
 endprogram

<..._list> := [ <...> ] *

<VC_ID>:=   VARIABLE <id_VC> 

<Func_ID>:=   VARIABLE <id_Function> 

<Static_IP> :=  ':' <my_IP_name> [ <16bits_hexa_value> binary ! <instruction_list> ] ';' 


 	<VC_decl> :=   <id_Function> VC 

<function_decl> :=   <id_Function> FUNCTION 

                                  <instruction_list> 
                                   RETURN

	<instruction> := 	<id_Function> CALL ! 

		<IP_name> !

 		IF <instruction_list>

   			{ELSE <instruction_list>} 

  		ENDIF !

 		REPEAT <instruction_list>
		{AGAIN!UNTIL}! 

		DO <instruction_list>
		     LOOP !

 		<Hexa_constant> BR ! 

		<Hexa_constant> BNZ ! 

		<Hexa_constant> BZ ! 

		<Hexa_constant> BA ! 

		< three_word_homade_program > <id_VC> WIM !

		HLT !

 		NOP ! 

 		<Hexa_constant> LIT


 < three_word_homade_program > : = [ <id_Function> CALL ] ! [ <IP_name> RETRUN NULL ] ! [ <Ip-name >3] ! [ <IP_name>2 RETURN ]  -- not usual

Exemples de code


Exemple 1
	variable read
variable print

program

read function
	f lit
	waitbtn
	switch
	leddup
return

print function
	bufout

return

begin
repeat  
	read call
	read call
	add
	print call
again
hlt
endprogram

Exemple 2

: IPname abcd binary ;

program

IPname
hlt

endprogram
  Exemple 3
   
variable vc1
variable vc2
variable VC3 
variable read
program
vc1 VC
vc2 VC
vc3 VC
read function
    add
return
begin
 read call
 read call vc1 wim
 add return  null   vc2 wim
 1234 binary 5678 binary 9ABC binary vc3 wim  
 vc1 call
endprogram