Move documentation ; add template for report on CPU.

7 files changed, 495 insertions, 0 deletions

diff --git a/doc/minijazz.pdf b/doc/minijazz.pdf
new file mode 100644
index 0000000..06b90c6
--- /dev/null
+++ b/doc/minijazz.pdf
diff --git a/doc/plan_micro.pdf b/doc/plan_micro.pdf
new file mode 100644
index 0000000..d1e0dcc
--- /dev/null
+++ b/doc/plan_micro.pdf
diff --git a/doc/plan_micro.tm b/doc/plan_micro.tm
new file mode 100644
index 0000000..158ffb5
--- /dev/null
+++ b/doc/plan_micro.tm
@@ -0,0 +1,256 @@
+<TeXmacs|1.0.7.19>
+
+<style|generic>
+
+<\body>
+  <doc-data|<doc-title|Spécification processeur>|<doc-subtitle|Projet Système
+  Digital 2013>|<doc-author|<author-data|<author-name|A.Auvolat, E.Enguehard,
+  J.Laurent>>>>
+
+  Nous proposons ici une spécification pour un processeur minimaliste 16 bit
+  RISC.
+
+  <section|Registres>
+
+  La machine dispose de 8 registres \S généraux \T, tous de taille 16 bits :
+
+  \;
+
+  <\itemize>
+    <item>0. Registre <verbatim|Z> ou zéro (valant tout le temps 0...)
+
+    <item>1. Registre <verbatim|A>
+
+    <item>2. Registre <verbatim|B>
+
+    <item>3. Registre <verbatim|C>
+
+    <item>4. Registre <verbatim|D>
+
+    <item>5. Registre <verbatim|E>, écrit par certaines instructions
+    (multiplication, division...) et utilisé préférentiellement comme
+    registre temporaire pour certaines instructions composées
+
+    <item>6. Registre <verbatim|F>, ou <verbatim|RA> (return adresse), écrit
+    par l'instruction <verbatim|jal>
+
+    <item>7. Registre <verbatim|G>, ou <verbatim|SP> (stack pointer), utilisé
+    par les instructions <verbatim|pop> et <verbatim|push>
+  </itemize>
+
+  Ces 8 registres sont tous manipulables par les instructions prenant un
+  registre comme argument. De plus, le processeur dispose d'un registre
+  manipulable uniquement par certaines instructions spécifiques, le registre
+  <verbatim|PC> (program counter : contient l'adresse de l'instruction
+  courante).
+
+  Les numéros de registres sont donc codés sur 3 bits.
+
+  <section|Mémoire>
+
+  La mémoire est adressée sur 16 bits et les mots mémoire font 8 bits, il y a
+  donc 64ko disponnibles.
+
+  Le CPU est little-endian (le mot 0x1234 est codé 34 puis 12)
+
+  On définit plusieurs zones de mémoire :
+
+  <big-table|<tabular*|<tformat|<table|<row|<cell|0x0000 - 0x3FFF>|<cell|ROM
+  pour programme utilisateur>>|<row|<cell|0x4000 - 0x7FFF>|<cell|MMIO (seuls
+  quelques octets sont utilisés)>>|<row|<cell|0x8000 - 0xFFFF>|<cell|RAM pour
+  programme utilisateur>>>>>|Memory map>
+
+  Les bits suivants sont utilisés pour la MMIO :
+
+  <big-table|<tabular*|<tformat|<table|<row|<cell|>>>>><tabular*|<tformat|<table|<row|<cell|byte
+  at 0x4000>|<cell|Clock ticker (incremented every tick, reset on
+  read)>>|<row|<cell|byte at 0x4100>|<cell|Serial input (set when byte
+  received, reset on read)>>|<row|<cell|byte at 0x4102>|<cell|Serial output
+  (sends byte immediately on write)>>>>>|Addresses MMIO>
+
+  <section|Jeu d'instruction>
+
+  Les instructions sont codées sur 16 bits. Les tableaux suivants montrent
+  les instructions avec les bits de poids forts à gauche et les bits de poids
+  faibles à droite (convention contraire à celle exprimée dans le
+  <verbatim|README>).
+
+  <subsection|Types d'instructions>
+
+  <paragraph|Format de base><tabular*|<tformat|<cwith|2|2|1|-1|cell-lborder|1px>|<cwith|2|2|1|-1|cell-bborder|1px>|<cwith|2|2|1|-1|cell-tborder|1px>|<cwith|2|2|3|3|cell-rborder|1px>|<table|<row|<cell|5
+  bits>|<cell|3 bits>|<cell|8 bits>>|<row|<cell|<math|I>>|<cell|<math|R>>|<cell|<math|\<ldots\>>>>|<row|<cell|poids
+  forts>|<cell|>|<cell|poids faibles>>>>>
+
+  <paragraph|Format <math|R>><tabular*|<tformat|<cwith|2|2|1|-1|cell-lborder|1px>|<cwith|2|2|1|-1|cell-bborder|1px>|<cwith|2|2|1|-1|cell-tborder|1px>|<cwith|2|2|3|3|cell-rborder|1px>|<cwith|2|2|5|5|cell-rborder|1px>|<table|<row|<cell|5
+  bits>|<cell|3 bits>|<cell|3 bits>|<cell|3 bits>|<cell|2
+  bits>>|<row|<cell|<math|I>>|<cell|<math|R>>|<cell|<math|R<rsub|A>>>|<cell|<math|R<rsub|B>>>|<cell|<math|f>>>>>>
+
+  <paragraph|Format <math|I>><tabular*|<tformat|<cwith|2|2|1|-1|cell-lborder|1px>|<cwith|2|2|1|-1|cell-bborder|1px>|<cwith|2|2|1|-1|cell-tborder|1px>|<cwith|2|2|3|3|cell-rborder|1px>|<table|<row|<cell|5
+  bits>|<cell|3 bits>|<cell|8 bits>>|<row|<cell|<math|I>>|<cell|<math|R>>|<cell|<math|d>>>>>>
+
+  <paragraph|Format K><tabular*|<tformat|<cwith|2|2|1|-1|cell-lborder|1px>|<cwith|2|2|1|-1|cell-bborder|1px>|<cwith|2|2|1|-1|cell-tborder|1px>|<cwith|2|2|3|3|cell-rborder|1px>|<cwith|2|2|4|4|cell-rborder|1px>|<table|<row|<cell|5
+  bits>|<cell|3 bits>|<cell|3 bits>|<cell|5
+  bits>>|<row|<cell|<math|I>>|<cell|<math|R>>|<cell|<math|R<rprime|'>>>|<cell|<math|d>>>>>>
+
+  <paragraph|Format <math|J>><tabular|<tformat|<cwith|2|2|1|2|cell-lborder|1px>|<cwith|2|2|1|2|cell-bborder|1px>|<cwith|2|2|1|2|cell-tborder|1px>|<cwith|2|2|2|2|cell-rborder|1px>|<cwith|2|2|1|-1|cell-halign|c>|<table|<row|<cell|5
+  bits>|<cell|11 bits>>|<row|<cell|<math|I>>|<cell|<math|d>>>>>>
+
+  <section|Tableau d'instructions>
+
+  Certain noms d'instuctions sont en <em|italique>, il s'agit de signifier
+  qu'il s'agit d'un alias (optionnel) pour une autre instruction.
+
+  <big-table|<tabular*|<tformat|<cwith|1|1|1|-1|cell-bborder|1px>|<table|<row|<cell|<strong|<math|I>>>|<cell|<strong|format>>|<cell|<strong|<math|f>>>|<cell|<strong|description>>|<cell|<strong|action>>|<cell|<strong|valeurs
+  signés ?>>>|<row|<cell|00000>|<cell|R>|<cell|0>|<cell|add>|<cell|<math|R\<leftarrow\>R<rsub|A>+R<rsub|B>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|1>|<cell|sub>|<cell|<math|R\<leftarrow\>R<rsub|A>-R<rsub|B>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|2>|<cell|mul>|<cell|<math|R\<leftarrow\>lo<around*|(|R<rsub|A>\<times\>R<rsub|B>|)>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|>|<cell|>|<cell|<math|E\<leftarrow\>hi<around*|(|R<rsub|A>\<times\>R<rsub|B>|)>>
+  si <math|E\<neq\>R>>|<cell|>>|<row|<cell|>|<cell|>|<cell|3>|<cell|div>|<cell|<math|R\<leftarrow\>q<around*|(|R<rsub|A>,R<rsub|B>|)>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|>|<cell|>|<cell|<math|E\<leftarrow\>r<around*|(|R<rsub|A>,R<rsub|B>|)>>
+  si <math|E\<neq\>R>>|<cell|>>|<row|<cell|00001>|<cell|R>|<cell|0>|<cell|addu>|<cell|idem
+  add>|<cell|non signé>>|<row|<cell|>|<cell|>|<cell|1>|<cell|subu>|<cell|idem
+  sub>|<cell|non signé>>|<row|<cell|>|<cell|>|<cell|2>|<cell|mulu>|<cell|idem
+  mul>|<cell|non signé>>|<row|<cell|>|<cell|>|<cell|3>|<cell|divu>|<cell|idem
+  div>|<cell|non signé>>|<row|<cell|00010>|<cell|R>|<cell|0>|<cell|or>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<vee\>R<rsub|B>|)>>>|<cell|>>|<row|<cell|>|<cell|>|<cell|1>|<cell|and>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<wedge\>R<rsub|B>|)>>>|<cell|>>|<row|<cell|>|<cell|>|<cell|2>|<cell|xor>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<oplus\>R<rsub|B>|)>>>|<cell|>>|<row|<cell|>|<cell|>|<cell|3>|<cell|nor>|<cell|<math|R\<leftarrow\>not
+  <around*|(|R<rsub|A>\<vee\>R<rsub|B>|)>>>|<cell|>>|<row|<cell|00011>|<cell|R>|<cell|0>|<cell|lsl>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<ll\>R<rsub|B>|)>>>|<cell|>>|<row|<cell|>|<cell|>|<cell|1>|<cell|<em|lsl>>|<cell|>|<cell|>>|<row|<cell|>|<cell|>|<cell|2>|<cell|lsr>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<gg\>R<rsub|B>|)>>
+  (logical)>|<cell|(non signé)>>|<row|<cell|>|<cell|>|<cell|3>|<cell|asr>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<gg\>R<rsub|B>|)>>
+  (arith)>|<cell|(signé)>>|<row|<cell|00100>|<cell|R>|<cell|0>|<cell|<em|se>>|<cell|>|<cell|>>|<row|<cell|>|<cell|>|<cell|1>|<cell|<em|sne>>|<cell|>|<cell|>>|<row|<cell|>|<cell|>|<cell|2>|<cell|se>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>=R<rsub|B>?1:0|)>>>|<cell|>>|<row|<cell|>|<cell|>|<cell|3>|<cell|sne>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<neq\>R<rsub|B>?1:0|)>>>|<cell|>>|<row|<cell|00101>|<cell|R>|<cell|0>|<cell|slt>|<cell|<math|R<rsub|>\<leftarrow\><around*|(|R<rsub|A>\<less\>R<rsub|B>?1:0|)>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|1>|<cell|sle>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<leqslant\>R<rsub|B>?1:0|)>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|2>|<cell|sltu>|<cell|<math|R<rsub|>\<leftarrow\><around*|(|R<rsub|A>\<less\>R<rsub|B>?1:0|)>>>|<cell|non
+  signé>>|<row|<cell|>|<cell|>|<cell|3>|<cell|sleu>|<cell|<math|R\<leftarrow\><around*|(|R<rsub|A>\<leqslant\>R<rsub|B>?1:0|)>>>|<cell|non
+  signé>>|<row|<cell|00110>|<cell|I>|<cell|>|<cell|incri>|<cell|<math|R\<leftarrow\><around*|(|R+d|)>>>|<cell|<math|d>
+  signé>>|<row|<cell|00111>|<cell|I>|<cell|>|<cell|shi>|<cell|<math|R\<leftarrow\><around*|(|R\<ll\>d|)>>>|<cell|<math|d>
+  signé>>|<row|<cell|01000>|<cell|J>|<cell|>|<cell|j>|<cell|<math|PC\<leftarrow\>PC+d>>|<cell|>>|<row|<cell|01001>|<cell|J>|<cell|>|<cell|jal>|<cell|<math|F\<leftarrow\><around*|(|PC+2|)>
+  ; PC\<leftarrow\>PC+d>>|<cell|>>|<row|<cell|01010>|<cell|R<math|>>|<cell|0>|<cell|jr>|<cell|<math|PC\<leftarrow\>R>>|<cell|>>|<row|<cell|>|<cell|<math|>>|<cell|1>|<cell|jalr>|<cell|<math|><math|F\<leftarrow\><around*|(|PC+2|)>
+  ; PC\<leftarrow\>R>>|<cell|>>|<row|<cell|>|<cell|>|<cell|2>|<cell|jer>|<cell|if
+  <math|R<rsub|A>=R<rsub|B>> then <math|PC\<leftarrow\>R<rsub|>>>|<cell|>>|<row|<cell|>|<cell|>|<cell|3>|<cell|jner>|<cell|if
+  <math|R<rsub|A>\<neq\>R<rsub|B>> then <math|PC\<leftarrow\>R<rsub|>>>|<cell|>>|<row|<cell|01011>|<cell|R>|<cell|0>|<cell|jltr>|<cell|if
+  <math|R<rsub|A>\<less\>R<rsub|B>> then <math|PC\<leftarrow\>R<rsub|>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|1>|<cell|jler>|<cell|if
+  <math|R<rsub|A>\<leqslant\>R<rsub|B>> then
+  <math|PC\<leftarrow\>R<rsub|>>>|<cell|signé>>|<row|<cell|>|<cell|>|<cell|2>|<cell|jltru>|<cell|if
+  <math|R<rsub|A>\<less\>R<rsub|B>> then <math|PC\<leftarrow\>R<rsub|>>>|<cell|non
+  signé>>|<row|<cell|>|<cell|>|<cell|3>|<cell|jleru>|<cell|if
+  <math|R<rsub|A>\<leqslant\>R<rsub|B>> then
+  <math|PC\<leftarrow\>R<rsub|>>>|<cell|non
+  signé>>|<row|<cell|01100>|<cell|J>|<cell|>|<cell|lra>|<cell|<math|E\<leftarrow\>PC+d>>|<cell|<math|d>
+  signé>>|<row|<cell|01101>|<cell|>|<cell|>|<cell|<em|nop>>|<cell|>|<cell|>>|<row|<cell|01110>|<cell|>|<cell|>|<cell|<em|nop>>|<cell|>|<cell|>>|<row|<cell|01111>|<cell|>|<cell|>|<cell|hlt>|<cell|halt
+  microprocessor (infinite loop)>|<cell|>>|<row|<cell|10000>|<cell|K>|<cell|>|<cell|lw>|<cell|<math|R\<leftarrow\>mem<around*|(|R<rprime|'>+d|)>>
+  (16 bits)>|<cell|>>|<row|<cell|10001>|<cell|K>|<cell|>|<cell|sw>|<cell|<math|mem<around*|(|R<rprime|'>+d|)>\<leftarrow\>R>
+  (16 bits)>|<cell|>>|<row|<cell|10010>|<cell|K>|<cell|>|<cell|lb>|<cell|<math|R<rsub|lo>\<leftarrow\>mem<around*|(|R<rprime|'>+d|)>
+  ; R<rsub|hi>\<leftarrow\>0> (8 bits)>|<cell|>>|<row|<cell|10011>|<cell|K>|<cell|>|<cell|sb>|<cell|<math|mem<around*|(|R<rprime|'>+d|)>\<leftarrow\>R<rsub|lo>>
+  (8 bits)>|<cell|>>|<row|<cell|10100>|<cell|R>|<cell|*>|<cell|lwr>|<cell|<math|R\<leftarrow\>mem<around*|(|R<rsub|A>+R<rsub|B>|)>>
+  (16 bits)>|<cell|>>|<row|<cell|10101>|<cell|R>|<cell|*>|<cell|swr>|<cell|<math|mem<around*|(|R<rsub|A>+R<rsub|B>|)>\<leftarrow\>R>
+  (16 bits)>|<cell|>>|<row|<cell|10110>|<cell|R>|<cell|*>|<cell|lbr>|<cell|<math|R<rsub|lo>\<leftarrow\>mem<around*|(|R<rsub|A>+R<rsub|B>|)>
+  ; R<rsub|hi>\<leftarrow\>0> (8 bits)>|<cell|>>|<row|<cell|10111>|<cell|R>|<cell|*>|<cell|sbr>|<cell|<math|mem<around*|(|R<rsub|A>+R<rsub|B>|)>\<leftarrow\>R<rsub|lo><rsup|>>
+  (8 bits)>|<cell|>>|<row|<cell|11000>|<cell|I>|<cell|>|<cell|lil>|<cell|<math|R<rsub|lo>\<leftarrow\>d>>|<cell|>>|<row|<cell|11001>|<cell|I>|<cell|>|<cell|lilz>|<cell|<math|R<rsub|lo>\<leftarrow\>d
+  ; R<rsub|hi>\<leftarrow\>0>>|<cell|(<math|d> non
+  signé)>>|<row|<cell|11010>|<cell|I>|<cell|>|<cell|liu>|<cell|<math|R<rsub|hi>\<leftarrow\>d>>|<cell|>>|<row|<cell|11011>|<cell|I>|<cell|>|<cell|liuz>|<cell|<math|R<rsub|hi>\<leftarrow\>d
+  ; R<rsub|lo>\<leftarrow\>0>>|<cell|>>|<row|<cell|11100>|<cell|I>|<cell|<em|>>|<cell|lie>|<cell|<math|R\<leftarrow\>sign_extend<rsub|8><rsup|16><around*|(|d|)>>>|<cell|(<math|d>
+  signé)>>|<row|<cell|11101>|<cell|>|<cell|>|<cell|<em|nop>>|<cell|>|<cell|>>|<row|<cell|11110>|<cell|>|<cell|>|<cell|<em|nop>>|<cell|>|<cell|>>|<row|<cell|11111>|<cell|>|<cell|>|<cell|nop<samp|>>|<cell|<math|\<varnothing\>>>|<cell|>>>>>|Instructions
+  reconnues par le microproceseur>
+
+  L'assembleur propose également quelques instructions \S étendues \T
+  permettant de faciliter la programmation :
+
+  <big-table|<tabular|<tformat|<cwith|1|1|1|-1|cell-bborder|1px>|<table|<row|<cell|<strong|Nom>>|<cell|<strong|Action>>|<cell|<strong|Code
+  assembleur de base équivalent>>>|<row|<cell|push
+  <math|R>>|<cell|<math|G\<leftarrow\>G-2 ;mem<around*|(|G|)>\<leftarrow\>R
+  >>|<cell|incri <math|G,-2>>>|<row|<cell|>|<cell|>|<cell|sw
+  <math|R\<nocomma\>>, <math|G>>>|<row|<cell|pop
+  <math|R>>|<cell|<math|R\<leftarrow\>mem<around*|(|G|)> ;
+  G\<leftarrow\>G+2>>|<cell|lw <math|R>, <math|G>>>|<row|<cell|>|<cell|>|<cell|incri
+  <math|G>, 2>>|<row|<cell|move <math|R,R<rsub|A>>>|<cell|<math|R\<leftarrow\>R<rsub|A>>>|<cell|add
+  <math|R>, <math|R<rsub|A>>, <math|Z>>>|<row|<cell|addi, subi,
+  ...>|<cell|<math|R\<leftarrow\>R<rsub|A>+d>>|<cell|(utilise E comme
+  registre temporaire)>>|<row|<cell|not <math|R,R<rsub|A>>>|<cell|<math|R\<leftarrow\>not
+  R<rsub|A>>>|<cell|<math|nor R,R<rsub|A>,Z>>>|<row|<cell|jz <math|R>,
+  addr>|<cell|if <math|R=0> then <math|PC\<leftarrow\>addr>>|<cell|lil E,
+  lo(addr) ; liu E, hi(addr) OU lilz E, addr>>|<row|<cell|>|<cell|>|<cell|jer
+  R, E, Z>>|<row|<cell|jnz <math|R>, addr>|<cell|if <math|R\<neq\>0> then
+  <math|PC\<leftarrow\>addr>>|<cell|lil E, lo(addr) ; liu E, hi(addr) OU lilz
+  E, addr>>|<row|<cell|>|<cell|>|<cell|jner R, E, Z>>>>>|Instructions
+  supplémentaires (produites par l'assembleur)>
+
+  \ 
+</body>
+
+<\initial>
+  <\collection>
+    <associate|language|french>
+    <associate|page-medium|paper>
+    <associate|page-screen-margin|false>
+  </collection>
+</initial>
+
+<\references>
+  <\collection>
+    <associate|auto-1|<tuple|1|1>>
+    <associate|auto-10|<tuple|4|2>>
+    <associate|auto-11|<tuple|5|2>>
+    <associate|auto-12|<tuple|4|2>>
+    <associate|auto-13|<tuple|3|3>>
+    <associate|auto-14|<tuple|4|4>>
+    <associate|auto-15|<tuple|5|?>>
+    <associate|auto-16|<tuple|4|?>>
+    <associate|auto-17|<tuple|5|?>>
+    <associate|auto-2|<tuple|2|1>>
+    <associate|auto-3|<tuple|1|2>>
+    <associate|auto-4|<tuple|2|2>>
+    <associate|auto-5|<tuple|3|2>>
+    <associate|auto-6|<tuple|3.1|2>>
+    <associate|auto-7|<tuple|1|2>>
+    <associate|auto-8|<tuple|2|2>>
+    <associate|auto-9|<tuple|3|2>>
+  </collection>
+</references>
+
+<\auxiliary>
+  <\collection>
+    <\associate|table>
+      <tuple|normal|Memory map|<pageref|auto-3>>
+
+      <tuple|normal|Addresses MMIO|<pageref|auto-4>>
+
+      <tuple|normal|Instructions reconnues par le
+      microproceseur|<pageref|auto-13>>
+
+      <tuple|normal|Instructions supplémentaires (produites par
+      l'assembleur)|<pageref|auto-14>>
+    </associate>
+    <\associate|toc>
+      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Registres>
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-1><vspace|0.5fn>
+
+      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Mémoire>
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-2><vspace|0.5fn>
+
+      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Jeu
+      d'instruction> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-5><vspace|0.5fn>
+
+      <with|par-left|<quote|1.5fn>|Types d'instructions
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-6>>
+
+      <with|par-left|<quote|6fn>|Format de base
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-7><vspace|0.15fn>>
+
+      <with|par-left|<quote|6fn>|Format <with|mode|<quote|math>|R>
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-8><vspace|0.15fn>>
+
+      <with|par-left|<quote|6fn>|Format <with|mode|<quote|math>|I>
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-9><vspace|0.15fn>>
+
+      <with|par-left|<quote|6fn>|Format K
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-10><vspace|0.15fn>>
+
+      <with|par-left|<quote|6fn>|Format <with|mode|<quote|math>|J>
+      <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-11><vspace|0.15fn>>
+
+      <vspace*|1fn><with|font-series|<quote|bold>|math-font-series|<quote|bold>|Tableau
+      d'instructions> <datoms|<macro|x|<repeat|<arg|x>|<with|font-series|medium|<with|font-size|1|<space|0.2fn>.<space|0.2fn>>>>>|<htab|5mm>>
+      <no-break><pageref|auto-12><vspace|0.5fn>
+    </associate>
+  </collection>
+</auxiliary>
\ No newline at end of file
diff --git a/doc/projet13.pdf b/doc/projet13.pdf
new file mode 100644
index 0000000..c603cfc
--- /dev/null
+++ b/doc/projet13.pdf
diff --git a/doc/rapport_cpu.tex b/doc/rapport_cpu.tex
new file mode 100644
index 0000000..d7901db
--- /dev/null
+++ b/doc/rapport_cpu.tex
@@ -0,0 +1,120 @@
+\documentclass[11pt, a4paper]{article}
+
+\usepackage[utf8]{inputenc}
+
+\usepackage[margin=1.0in]{geometry}
+\usepackage[french]{babel} 
+
+\newcommand{\prog}[1]{{\tt#1}}
+\newcommand{\underscore}{$\_\,$}
+
+\begin{document}
+
+
+
+\title{Programmation d'un simulateur de net-lists \\ \normalsize{\textsc{Projet de Système digital}}}
+\author{Jonathan Laurent}
+\maketitle
+
+
+Le programme \prog{netsim} permet de simuler un circuit digital synchrone représenté par une net-list. Il propose notamment les fonctionnalités suivantes :
+
+\begin{itemize}
+\item Un \textit{mode interactif} suffisament riche pour permettre un déboguage efficace des net-lists
+\item Le maintien d'un \textit{historique} des états de la machine permettant d'annuler certaines actions
+\item La \textit{vérification} de la cohérence des net-lists passées en entrée
+\end{itemize}
+
+\section{Guide d'utilisation}
+\subsection{Commande et options}
+
+Le programme se lance avec la commande 
+
+\begin{center}\prog{./netsim NETLIST\underscore{}FILE [--rom ROM\underscore{}FILE] [-f INPUT\underscore{}FILE] }\end{center}
+
+où \prog{NETLIST\underscore{}FILE} désigne un fichier contenant le circuit à simuler, \prog{ROM\underscore{}FILE} contient le contenu des mémoires \textsc{rom}s et \prog{INPUT\underscore{}FILE} contient une suite de directives à executer avant le démarrage du \textit{mode interactif}.
+
+\medskip
+
+Dans la suite de ce document :
+\begin{itemize}
+\item \prog{val} désigne une valeur, c'est à dire l'état d'une nappe de fils où les bits sont présentés dans l'ordre \emph{décroissant}
+\item \prog{addr} représente une valeur codant pour une adresse
+\item \prog{id} désigne l'identifiant d'une variable présente dans le fichier net-list courant
+\item \prog{cell} désigne une variable ou un emplacement \textsc{ram} de la forme \prog{id : addr} où \prog{addr} est une valeur codant pour une adresse
+
+\end{itemize}
+
+\subsection{Format des fichiers ROM}
+
+Un fichier \textsc{rom} est composé d'une suite de blocs. Un bloc est composé d'un entête de la forme suivante
+\begin{center}\prog{ROM id ADDRSIZE n$_1$ WORDSIZE n$_2$ }\end{center}
+où les deux arguments numériques sont fournis en écriture décimale. Le contenu de la mémoire correspondant à un entête est décrit par une suite de valeurs ordonnées dans le sens des adresses croissantes. Il est possible de sauter directement à une adresse spécifiée avec la directive 
+\begin{center}\prog{ADDR addr :}\end{center}
+Un exemple est fourni dans le dossier \prog{samples} du programme.
+
+\subsection{Le language de scripts d'interaction}
+
+\medskip
+
+Après affichage de l'invite de commande \prog{>}, l'utilisateur peut saisir plusieurs directives, séparées par des points ou des sauts de lignes. La directive la plus simple consiste à entrer une séquence de valeurs \prog{val} séparées par des espaces, et correspondant à chaque entrée du circuit, dans l'ordre de leur déclaration au sein du fichier net-list. Le logiciel exécute alors un cycle machine à partir de ces entrées et affiche les nouvelles valeurs des sorties. Il est également possible de saisir une liste d'affectations suivant l'exemple suivant :
+\begin{center}
+\prog{a = 0, b = 0110, c = 10}
+\end{center}
+Les entrées su circuit qui n'auront pas été mentionnées dans la liste garderont leur valeur précédente. Il est également possible d'utiliser une des directives suivantes :
+
+\medskip
+\begin{center}
+\begin{itemize}
+   \item \prog{\%inputs id$_1$ ... id$_n$} spécifie une nouvelle liste ordonnée des entrées du circuit
+   \item \prog{\%outputs cell$_1$ ... cell$_n$} spécifie la liste des sorties du circuit
+   \item \prog{\%show cell$_1$ ... cell$_n$} affiche la valeur des variables et emplacements \textsc{ram} indiqués. En l'absence d'arguments, la valeur des sorties est affichée
+   \item \prog{\%run n}  exécute $n$ cycles machine
+   \item \prog{\%echo off} désactive l'affichage  automatique des sorties après exécution d'un cycle. Pour réactiver cette fonctionnalité, remplacer \prog{off} par \prog{on}
+   \item \prog{\%echo on} active l'affichage des sorties
+   \item \prog{\%undo n}  annule les $n$ dernières commandes ayant eu pour effet d'exécuter des cycles machine. Si l'argument n'est pas spécifié, $n=1$
+   \item \prog{\%redo n} annule un appel anterieur de \prog{\%undo n}, si aucune opération d'écriture n'a été excutée d'ici là
+   \item \prog{\%history n} redéfinit la valeur de la capacité de l'historique permettant d'effectuer des \prog{undo}
+   
+\end{itemize}
+\end{center}
+
+Des exemples sont disponnibles dans le dossier \prog{samples} du programme.
+\section{Carcatéristiques techniques}
+
+Une exécution du programme se déroule schématiquement de la manière suivante :
+
+\paragraph{Au chargement d'un fichier net-list :}
+\begin{itemize}
+\item Les équations sont triées dans l'ordre topologique et tout cycle d'exécution est signalé
+\item Une vérification de la cohérence des types est effectuée
+\item La liste d'équations est précompilée (voire suite)
+\end{itemize}
+
+\paragraph{A chaque cycle :}
+\begin{itemize}
+\item Les valeurs des mémoires \textsc{ram} sont mises à jour en fonction de l'état de la machine à la fin du cycle \emph{précédent}. Le membre gauche d'une équation de type \textsc{ram} ne dépend ainsi dans l'ordre topologique que du paramètre de l'adresse de lecture.
+\item Chaque équation modifie l'état courant sur la base de l'état de la machine à la fin du cycle précédent (calcul des valeurs des registres) et de l'état obtenu après exécution des équations antérieures (par rapport à l'ordre topologique)
+\end{itemize}
+
+\medskip
+
+Pour plus de détails, le lecteur est invité à consulter le fichier \emph{netlist\underscore{}simulator.ml}.
+
+\subsection{Optimisations}
+Afin de rendre le programme raisonnablement efficace, deux optimisations ont été principalement mises en oeuvre :
+
+\begin{itemize}
+\item Chaque variable se voit affecter un identifiant numérique et l'état de toutes les variables de la machine est stockée dans un tableau. Cependant, le type \prog{state} exporté par \prog{Netlist\underscore{}simulator} est persistent (le tableau est recopié à la fin de toutes les fonctions exportées par la signature du module), ce qui permet de gérer plutôt simplement un historique.
+\item La liste des équations est précompilée en une liste de fonctions du type \prog{state -> state -> state} de manière à ce que la structure de ses éléments ne soit pas réexplorée à chaque cycle. Pour plus d'explications, consulter \emph{netlist\underscore{}simulator.ml}.
+\end{itemize}
+
+\medskip
+
+Ces deux améliorations représentent un gain de temps d'un facteur 12 environ environ. A titre indicatif, la simulation de $84000$ cycles du circuit à $300$ variables \prog{clockHMS} prend $3s$.
+
+\subsection{Améliorations possibles}
+
+Le système actuel génère des erreurs très imprécises et ne vérifie pas la sémantique des fichiers de \textsc{rom} et des directives d'entrées.
+
+\end{document}
\ No newline at end of file
diff --git a/doc/rapport_simulateur.tm b/doc/rapport_simulateur.tm
new file mode 100644
index 0000000..a7352cf
--- /dev/null
+++ b/doc/rapport_simulateur.tm
@@ -0,0 +1,119 @@
+<TeXmacs|1.0.7.19>
+
+<style|generic>
+
+<\body>
+  <doc-data|<doc-title|Rapport : simulateur de
+  circuit>|<doc-author|<author-data|<author-name|Alex
+  AUVOLAT>>>|<doc-date|2013-11-12 09h00>>
+
+  Dans le cadre du cours <em|Système Digital : de l'algorithme au circuit> de
+  <name|J.Vuillemin>, j'ai écrit un simulateur de circuit capable de faire
+  fonctionner un circuit préalablement compilé dans le langage MiniJazz.
+
+  Le simulateur que j'ai écrit est codé en C (essentiellement pour la
+  rapidité d'exécution), et nécessite un pré-traîtement des données par un
+  programme en Caml. Le simulateur en C ne lit pas directement les netlist
+  produites par MiniJazz, mais un fichier <verbatim|.dumb> qui est produit
+  par le pré-processeur.
+
+  Contenu de l'archive ci-jointe :
+
+  <\verbatim-code>
+    README
+
+    \ Diverses documentations. À lire.
+
+    \;
+
+    sched/
+
+    \ Dans ce répertoire se trouve le pré-processeur, qui effectue les
+    opérations suivantes :
+
+    \ - lecture d'une netlist
+
+    \ - tri topologique
+
+    \ - diverses optimisations
+
+    \ - écriture d'un fichier .net et d'un fichier .dumb contenant le
+    résultat.
+
+    Pour compiler le pré-processeur :
+
+    $ cd sched/
+
+    $ ocamlbuild main.byte
+
+    \;
+
+    csim/
+
+    \ Dans ce répertoire se trouve le simulateur en C.
+
+    Pour le compiler :
+
+    $ cd csim/
+
+    $ make
+
+    Les options du simulateur sont décrites lors de l'invocation de celui-ci
+    sans arguments.
+
+    \;
+
+    tests/
+
+    \ Ce répertoire contient un certain nombre de fichiers de test au format
+    minijazz. Le Makefile permet d'effectuer les appels au compilateur, au
+    pré-processeur et au simulateur avec la syntaxe suivante :
+
+    $ cd tests/
+
+    $ make nadder.sim \ \ \ \ # nadder.mj -\<gtr\> nadder.net -\<gtr\>
+    nadder.dumb -\<gtr\> csim
+  </verbatim-code>
+
+  Les points importants à souligner dans mon travail sont :
+
+  <\itemize>
+    <item>Définition d'un format de données intermédiaire pour les Netlist,
+    permettant l'écriture d'un simulateur en C. Définition conjointe de ce
+    format et de la structure du simulateur, afin d'écrire un simulateur le
+    mieux optimisé possible.
+
+    <item>Écriture d'un optimiseur de Netlist, qui est capable d'effectuer
+    plusieurs simplifications, dont :
+
+    <\itemize>
+      <item>propagation des constantes ;
+
+      <item>détection de variables au contenu identique ;
+
+      <item>suppression de variables inutiles ;
+
+      <item>suppression d'opérations arithmétiques inutiles.
+    </itemize>
+
+    L'application de ces passes d'optimisation réduit généralement la taille
+    d'une Netlist d'environ 30%.
+  </itemize>
+
+  Les efforts d'optimisation ont été faits dans l'idée que le simulateur
+  devra faire fonctionner un processeur MIPS à une fréquence raisonnable
+  (idéalement, plusieurs centaines, voire milliers, de cycle par seconde). Le
+  résultat de ce travail se voit sur les programmes <verbatim|clockHMS.mj> et
+  <verbatim|clock2.mj> qui définissent deux horloges qui comptent modulo 60
+  puis 60 puis 24 (donc qui comptent sur une journée, à un cycle par
+  seconde). Avec mon simulateur optimisé, les deux horloges sont capables de
+  simuler une journée entière de comptage, c'est-à-dire 86400 cycles, en 0.4
+  secondes pour le premier et 0.9 secondes pour le second, sur un ordinateur
+  moderne.
+</body>
+
+<\initial>
+  <\collection>
+    <associate|language|french>
+  </collection>
+</initial>
\ No newline at end of file
diff --git a/doc/tp1_simulateur.pdf b/doc/tp1_simulateur.pdf
new file mode 100644
index 0000000..0b7a29e
--- /dev/null
+++ b/doc/tp1_simulateur.pdf