SETHI7 (Материалы к контрольным работам)

8.6. Распределение регистров при вычислении арифметических выражений

Одной из важнейших задач при генерации кода является распределение регистров. Рассмотрим хорошо известную технику распределения регистров при трансляции арифметических выражений, называемую алгоритмом Сети-Ульмана.

Пусть система команд машины имеет неограниченное число универсальных регистров, в которых выполняются арифметические команды. Рассмотрим, как можно сгенерировать код, используя для данного арифметического выражения минимальное число регистров.

R1

R2

Rn

LR


L R

Рис. 8.13

Предположим сначала, что распределение регистров осуществляется по простейшей схеме слева-направо, как изображено на рис. 8.13. Тогда к моменту генерации кода для поддерева LR занято n регистров. Пусть поддерево L требует n_l регистров, а поддерево R - n_r регистров. Если n_l=n_r, то при вычислении L будет использовано n_l регистров и под результат будет занят n+1-й регистр. Еще n_r (=n_l) регистров будет использовано при вычислении R. Таким образом, общее число использованных регистров будет равно n+n_l+1.

Если n_l>n_r, то при вычислении L будет использовано n_l регистров. При вычислении R будет использовано n_r<n_l регистров, и всего будет использовано не более чем n+n_l регистров.

Если n_l<n_r, то после вычисления L под результат будет занят один регистр (предположим n+1-й) и n_r регистров будет использовано для вычисления R. Всего будет использовано n+n_r+1 регистров.

Видно, что для деревьев, совпадающих с точностью до порядка потомков каждой вершины, минимальное число регистров при распределении их слева-направо достигается на дереве, у которого в каждой вершине слева расположено более "сложное" поддерево, требующее большего числа регистров.

Таким образом, если дерево таково, что в каждой внутренней вершине правое поддерево требует меньшего числа регистров, чем левое, то, обходя дерево слева направо, можно оптимально распределить регистры.

Без перестройки дерева это означает, что если в некоторой вершине дерева справа расположено более сложное поддерево, то сначала сгенерируем код для него, а затем уже для левого поддерева.

Алгоритм работает следующим образом. Сначала осуществляется разметка синтаксического дерева по следующим правилам.

Правила разметки:

1) если вершина - правый лист или дерево состоит из единственной вершины, помечаем эту вершину числом 1, если вершина - левый лист, помечаем ее 0 (рис. 8.14).

R (l_l) R (l_r) R (l_l+1)

l_l l_r l_l l_r
0 1
R+1 R R R+1 R R+1

а) б) а) l_l<l_r б) l_l>l_r в)l_l=l_r

Рис. 8.14 Рис. 8.15

2) если вершина имеет прямых потомков с метками l₁ и l₂, то в качестве метки этой вершины выбираем большее из чисел l₁ или l₂ либо число l₁+1, если l₁=l₂ (рис. 8.15).

Эта разметка позволяет определить, какое из поддеревьев требует большего количества регистров для своего вычисления.

Затем осуществляется распределение регистров для результатов операций.

Правила распределения регистров.

1) Корню назначается первый регистр.

2) Если метка левого потомка меньше метки правого, то левому потомку назначается регистр на единицу больший, чем предку, а правому - с тем же номером (сначала вычисляется правое поддерево и его результат помещается в регистр R), так что регистры занимаются последовательно. Если же метка левого потомка больше или равна метке правого потомка, то наоборот, сначала вычисляется левое поддерево и его результат помещается в регистр R (рис. 8.15), а правому потомку – R+1. После этого формируется код по следующим правилам.

Правила генерации кода:

1) если вершина - правый лист с меткой 1, то ей соответствует код LOAD X,R, где R - регистр, назначенный этой вершине, а X - адрес переменной, связанной с вершиной (рис. 8.16.б);

2) если вершина внутренняя и ее левый потомок - лист с меткой 0, то ей соответствует код (рис. 8.16а)

Код правого поддерева
Op X,R

где снова R - регистр, назначенный этой вершине, X - адрес переменной, связанной с вершиной, а Op - операция, примененная в вершине (рис. 8.16.а);

3) если непосредственные потомки вершины не листья и метка правой вершины больше метки левой, то вершине соответствует код

Код правого поддерева
Код левого поддерева
Op R+1,R

где R - регистр, назначенный внутренней вершине, и операция Op, вообще говоря, не коммутативная (рис. 8.17 б)).

R R R R


R R R R+1 R+1 R
X X

(0) (1)
а) б) а) б)

Рис. 8.16 Рис. 8.17

Если метка правой вершины меньше или равна метке левой вершины, то вершине соответствует код

Код левого поддерева
Код правого поддерева
Op R,R+1
MOVE R+1,R

Последняя команда генерируется для того, чтобы получить результат в нужном регистре (в случае коммутативной операции операнды операции можно поменять местами и избежать дополнительной пересылки)(рис. 8.17 а)).

Рассмотрим атрибутную грамматику, реализующую эти правила генерации кода. В этой атрибутной грамматике генерация кода происходит не непосредственно в процессе обхода дерева, как раньше, а из-за необходимости переставлять поддеревья код строится в виде текста с помощью операции конкатенации. Практически, конечно, это нецелесообразно: разумнее управлять обходом дерева непосредственно, однако для простоты мы будем пользоваться конкатенацией.

RULE
Expr ::= IntExpr
SEMANTICS
Reg<1>=1; Left<1>=true.

RULE
IntExpr ::= IntExpr Op IntExpr
SEMANTICS
Left<1>=true; Left<3>=false;
Label<0>=(Label<1>==Label<3>)
? Label<1>+1
: Max(Label<1>,Label<3>);
Reg<1>=(Label<1> < Label<3>)
? Reg<0>+1
: Reg<0>;
Reg<3>=(Label<1> < Label<3>)
? Reg<0>
: Reg<0>+1;
Code<0>= (Label<1>==0)
? Code<3> + Code<2>
+ Reg<3> + "," + Reg<0>
: (Label<1> < Label<3>)

? Code<3> + Code<1> + Code<2> +
(Reg<0>+1)+ "," + Reg<0>
: Code<1> + Code<3> + Code<2> +
Reg<0> + ","+(Reg<0>+1)+
+ "MOVE" + (Reg<0>+1)
RULE
IntExpr ::= Ident
SEMANTICS
Label<0>=(Left<0>) ? 0 : 1;
Code<0>=(!Left<0>)
? "LOAD" + Reg<0> + "," + Val<1>
: Val<1>.

RULE
Op ::= '+'
SEMANTICS
Code<0>="ADD".

RULE
Op ::= '-'
Code<0>="SUB".

RULE
Op ::= '*'
SEMANTICS
Code<0>="MUL".

RULE
Op ::= '/'
SEMANTICS
Code<0>="DIV".

Атрибутированное дерево для выражения A*B+C*(D+E) приведено на рис. 8.18. При этом будет сгенерирован следующий код:

LOAD E,R1
ADD D,R1
MUL C,R1
LOAD B,R2
MUL A,R2
ADD R2,R1

Expr
|
IntExpr
Left=false
Label=2
Reg=1
Term AddOp IntExpr
Left=true Left=false
Label=1 Label=2
Reg=2
+
Factor MultOp Term Factor MultOp Term
Left=true Left=false Left=true Left=false
Label=0 Label=1 Label=0 Label=1
Reg=2 Reg=3 Reg=1 * Reg=1
Ident * Factor Ident Factor
A Left=false C Left=false
Label=1 Label=1
Reg=3 Reg=1
Ident
B
( IntExpr )
Left=false
Label=1
Reg=1
Term AddOp IntExpr
Left=true Left=false
Label=0 + Label=1
Reg=2 Reg=1
Factor Term
Left=true Left=false
Label=0 Label=1
Reg=2 Reg=1
Ident Factor
D Left=false
Label=1
Reg=1
Ident
E

Рис. 8.18.

Приведенная атрибутная схема требует двух проходов по дереву выражения. Рассмотрим теперь другую атрибутную схему, в которой достаточно одного обхода для генерация программы для выражений с оптимальным распределением регистров [9].

Пусть мы произвели разметку дерева разбора так же, как и в предыдущем алгоритме. Назначение регистров будем производить в соответствии со схемой рис. 8.19.

Левому потомку всегда назначается регистр, равный его метке, а правому - его метке, если она не равна метке его левого брата, и метке +1, если метки равны. Поскольку более сложное поддерево всегда вычисляется раньше более простого, его регистр результата имеет больший номер, чем любой регистр, используемый при вычислении более простого поддерева, что гарантирует правильность использования регистров.

Label



Left=0 Label Left
Reg<0>= ((Left<0>==Label<0>)
&&(Left<0>!=0))
? Label<0>+1
: Label<0>


Рис. 8.19.

Приведенные соображения реализуются следующей атрибутной схемой:

RULE
Expr ::= IntExpr
SEMANTICS
Code<0>=Code<1>; Left<1>=true.
RULE
IntExpr ::= IntExpr Op IntExpr
SEMANTICS
Left<1>=true; Left<3>=false;
Label<0>=(Label<1>==Label<3>)
? Label<1>+1
: Max(Label<1>,Label<3>);
Code<0>=(Label<3> > Label<1>)
? (Label<1>==0)
? Code<3> + Code<2> + Code<1>
+ "," + Label<3>
: Code<3> + Code<1> + Code<2> +
Label<1> + "," + Label<3>
: (Label<3> < Label<1>)
? Code<1> + Code<3> + Code<2> +
Label<1> + "," + Label<3> +
"MOVE" + Label<3> + "," +
Label<1>

: //Label<3>==Label<1>
Code<3> + "MOVE" + Label<3> +
"," + Label<3>+1 + Code<1> +
Code<2> + Label<1> + "," +
Label<1>+1.

RULE
IntExpr ::= Ident
SEMANTICS
Label<0>=(Left<0>) ? 0 : 1;
Code<0>=(Left<0>) ? Val<1>
: "LOAD" + Val<1> + "R1".

RULE
Op ::= '+'
SEMANTICS
Code<0>="ADD".

RULE
Op ::= '-'
SEMANTICS
Code<0>="SUB".