Etwas ist in Übersetzerbau seit Einsatz der Alpha als Plattform im wesentlichen immer gleich geblieben: die Hilfsregister! Angenehmer Weise gehen sich unsere Berechnungen alle in den zur Verfügung stehenden Registern aus, wir bräuchten uns diesbezüglich also eigentlich keinerlei Gedanken machen.

Doch hier wäre ein erster Ansatzpunkt, Instruktionen einzusparen.

Man braucht nicht für jedes Ergebnis ein neues Register. Ganz im Gegenteil, meistens kann man Register recyclen. Ich möchte hier kurz eine Mini-Bibliothek zur Registerverwaltung anbringen, sie basiert im wesentlichen auf einer Idee von Wolti:

16 /*              private register handling
17 
18 */
19 
20 
21 int free_registers[]=           { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 };
22 const int register_nr[]=        { 1, 2, 3, 4, 5, 6, 7, 8,22,23,24,25 };
23 const int register_amount=      12;
24 
25 
26 is_work_reg(int regnr) {
27         int i;
28 
29         for(i=0; i
30                 if(register_nr==regnr)
31                         return(1);
32 
33         return(0);
34 }
35 
36 
37 alloc_register() {
38         int i;
39 
40         for(i=0; i
41                 if(free_registers) {
42                         free_registers=0;
43 
44                         return(register_nr);
45                 }
46 }
47 
48 
49 free_register(int regnr) {
50         int i;
51 
52         for(i=0; i
53                 if(register_nr==regnr) {
54                         free_registers=1;
55                         return;
56                 }
57 
58 }
59 
60 free_register_2(int a, int b) {
61 
62         free_register(a);
63 
64         if(a!=b)
65                 free_register(b);
66 
67 }

Ich hoffe, die Funktionsweise ist nicht allzu schwer zu durchschauen. Wir haben einen Pool von Registern (register_nr[]) und merken uns, ob diese noch zur Verfügung stehen, oder nicht (free_registers[]).

is_work_reg() sagt uns, ob ein gegebenes Register ein Arbeitsregister ist und somit frei recyclet werden kann. Die hier nicht aufgezählten Register sind Tabu (Übergabeparameter, heap, etc.) und dürfen nicht verändert werden.

alloc_register() stellt uns ein Arbeitsregister zur Verfügung, mit free_register() kann man es wieder freigeben. Da C kein Overloading überstützt, oft genug aber die Freigabe mehrerer Register erwünscht ist, gibt's auch noch free_register_2().