Курсовой проект / Cursov / TrdAsm

unit TrdAsm;
{ !!! Зависит от целевой вычислительной системы !!! }

interface
{ Модуль распределения регистров и построения ассемблерного
  кода по списку триад }

uses Classes, TrdType, Triads;

const
{ Префикс наименования временных переменных }
  TEMP_VARNAME = '_Tmp';
{ Количество доступных регистров процессора }
  NUM_PROCREG = 6;

{ Функция распределения регистров и временных переменных
  для хранения промежуточных результатов триад }
function MakeRegisters(listTriad: TTriadList): integer;
{ Функция построения ассемблерного кода по списку триад }
function MakeAsmCode(listTriad: TTriadList;
                     listCode: TStrings;
                     flagOpt: Boolean): integer;

implementation

uses SysUtils;

function MakeRegisters(listTriad: TTriadList): integer;
{ Функция распределения регистров и временных переменных
  для хранения промежуточных результатов триад.
  Результат: количество необходимых временных переменных }
var
  { Счетчики и переменные циклов }
  i,j,iR,iCnt,iNum : integer;
  { Динамический массив для запоминания занятых регистров }
  listReg: TList;
begin
  Result := 0;
  { Создаем массив для хранения занятых регистров }
  listReg := TList.Create;
  if listReg <> nil then
  try
    { Обнуляем информационное поле у всех триад }
    for i:=listTriad.Count-1 downto 0 do
      listTriad[i].Info := 0;
    { Цикл по всем триадам. Обязательно с конца списка! }
    for i:=listTriad.Count-1 downto 0 do
    { Цикл по всем (2) операндам }
    for j:=1 to 2 do
    { Если триада - линейная операция, или "IF"
      (первый операнд), или прсвоение (второй операнд) }
    if ((listTriad[i].TrdType in TriadLineSet)
     or (listTriad[i].TrdType = TRD_IF) and (j = 1)
     or (listTriad[i].TrdType = TRD_ASSIGN) and (j = 2))
     { и при этом операндом является ссылка
       на другую триаду }
     and (listTriad[i][j].OpType = OP_LINK) then
    begin
      { Запорминаем номер триады, на которую ссылка }
      iNum := listTriad[i][j].TriadNum;
      { Если этой триаде еще не назначен регистр, и если
        это не предыдущая триада,
        то надо ей назначить регистр }
      if (listTriad[iNum].Info = 0) and (iNum <> i-1) then
      begin
        { Количество назначенных регистров
          в массиве регистров }
        iCnt := listReg.Count-1;
        { Цикл по всему массиву назначенных регистров }
        for iR:=0 to iCnt do
        begin
          { Если область действия регистра за пределами
            текущей триады, то этот регистр свободен и
            можно его использовать }
          if longint(listReg[iR]) >= i then
          begin
            { Запоминаем новую область действия регистра
              (iNum) }
            listReg[iR] := TObject(iNum);
            { Назначаем регистр триаде с номером iNum }
            listTriad[iNum].Info := iR+1;
            { Прерываем цикл по массиву регистров }
            Break;
          end;
        end;
        { Если не один из использованных регистров
          не был назначен, надо брать новый регистр }
        if listTriad[iNum].Info = 0 then
        begin
          { Добавляем запись в массив регистров, указываем
            ей область действия iNum }
          listReg.Add(TObject(iNum));
          { Назначаем новый регистр триаде с номером iNum }
          listTriad[iNum].Info := listReg.Count;
        end;
      end;
    end;
    { Результат функции:
      количество записей в массиве регистров - 1,
      за вычетом количества доступных регистрв процессора }
    Result := listReg.Count - (NUM_PROCREG-1);
    finally listReg.Free;
  end;
end;

function GetRegName(iInfo: integer): string;
{ Функция наименования регистров процессора }
begin
  case iInfo of
    0: Result := 'eax';
    1: Result := 'ebx';
    2: Result := 'ecx';
    3: Result := 'edx';
    4: Result := 'esi';
    5: Result := 'edi';
    { Если это не один из регистров - значит,
      даем имя временной переменной }
    else Result :=
           Format('%s%d',[TEMP_VARNAME,iInfo-NUM_PROCREG]);
  end{case};
end;

function GetOpName(i: integer; listTriad: TTriadList;
                   iOp: integer): string;
{ Функция наименования операнда триады
  i - номер триады в списке;
  listTriad - список триад;
  iOp - номер операнда триады }
var
  iNum: integer; {номенр триады по ссылке}
  Triad: TTriad; {текущая триада}
begin
  { Запоминаем текущую триаду }
  Triad := listTriad[i];
  { Выборка наименования операнда в зависимости от типа }
  case Triad[iOp].OpType of
    { Если константа - значение константы }
    OP_CONST: Result := IntToStr(Triad[iOp].ConstVal);
    { Если переменная - ее имя из таблицы идентификаторов }
    OP_VAR:
      begin
        Result := Triad[iOp].VarLink.VarName;
        { Если имя совпадает с именем функции,
          заменяем его на Result функции }
        if Result = NAME_FUNCT then Result := NAME_RESULT;
      end;
    { Иначе - это регистр для временного хранения
      результатов триады }
    else
      begin
        { Запоминаем номер триады }
        iNum := Triad[iOp].TriadNum;
        { Если это предыдущая триада, то операнд не нужен }
        if iNum = i-1 then Result := ''
        else
        begin
          { Берем номер регистра, связанного с триадой }
          iNum := listTriad[iNum].Info;
          { Если регистра нет, то операнд не нужен }
          if iNum = 0 then Result := ''
          { Иначе имя операнда - это имя регистра }
          else Result := GetRegName(iNum);
        end;
      end;
  end{case};
end;

function MakeMove(const sReg,{имя регистра}
               sPrev,{предыдущая команда}
               sVal{предыдущая величина в eax}: string;
               flagOpt: Boolean{флаг оптимизации}): string;
{ Функция, генерящая код занесения значения в регистр EAX }
begin
  { Если операнд был только что выгружен из eax,
    или необходимое значение уже есть в аккумуляторе,
    нет необходимости записывать его туда снова }
  if (Pos(Format(#9'mov'#9'%s,eax',[sReg]),sPrev) = 1)
  or (sVal = sReg) then
  begin
    Result := '';
    Exit;
  end;
  if flagOpt then
  { Если оптимизация команд включена }
  begin
    { Если значение = 0, то заносим его с помощью XOR }
    if sReg = '0' then
    begin
      if sVal = '-1' then
       Result := #9'inc'#9'eax'
      else
      if sVal = '1' then
       Result := #9'dec'#9'eax'
      else
       Result := #9'xor'#9'eax,eax'
    end
    else
    { Если = 1 - двумя командами: XOR и INC }
    if sReg = '1' then
    begin
      if sVal = '-1' then
       Result := #9'neg'#9'eax'
      else
      if sVal = '0' then
       Result := #9'inc'#9'eax'
      else
       Result := #9'xor'#9'eax,eax'#13#10#9'inc'#9'eax';
    end
    else
    { Если = -1 - двумя командами: XOR и DEC }
    if sReg = '-1' then
    begin
      if sVal = '1' then
       Result := #9'neg'#9'eax'
      else
      if sVal = '0' then
       Result := #9'dec'#9'eax'
      else
       Result := #9'xor'#9'eax,eax'#13#10#9'dec'#9'eax';
    end
    { Иначе заполняем EAX командой MOV }
    else Result := Format(#9'mov'#9'eax,%s',[sReg]);
  end
  { Если оптимизация команд выключена,
    всегда заполняем EAX командой MOV }
  else Result := Format(#9'mov'#9'eax,%s',[sReg]);
end;

function MakeOpcode(i: integer;{номер текущей триады}
          listTriad: TTriadList;{список триад}
          const sOp,sReg,{код операции и операнд}
                sPrev,{предыдущая команда}
                sVal{предыдущая величина в eax}: string;
          flagOpt: Boolean{флаг оптимизации}): string;
{ Функция, генерящая код линейных операций над EAX }
var Triad: TTriad;{текущая триада}
begin
  { Запоминаем текущую триаду }
  Triad := listTriad[i];
  { Если оптимизация команд включена }
  if flagOpt then
  begin
    { Если операнд = 0 }
    if sReg = '0' then
    begin
      case Triad.TrdType of
        { Для команды AND результат всегда = 0 }
        TRD_AND:
          Result := MakeMove('0',sPrev,sVal,flagOpt);
        { Для OR, "+" и "-" ничего не надо делать }
        TRD_OR,TRD_ADD,TRD_SUB: Result := #9#9;
        { Иначе генерим код выполняемой операции }
        else Result := Format(#9'%s'#9'eax,%s',[sOp,sReg]);
      end{case};
    end
    else
    { Если операнд = 1 }
    if sReg = '1' then
    begin
      case Triad.TrdType of
        { Для команды OR результат всегда = 1 }
        TRD_OR:
          Result := MakeMove('1',sPrev,sVal,flagOpt);
        { Для AND ничего не надо делать }
        TRD_AND: Result := #9#9;
        { Для "+" генерим операцию INC }
        TRD_ADD: Result := #9'inc'#9'eax';
        { Для "-" генерим операцию DEC }
        TRD_SUB: Result := #9'dec'#9'eax';
        { Иначе генерим код выполняемой операции }
        else Result := Format(#9'%s'#9'eax,%s',[sOp,sReg]);
      end{case};
    end
    else
    { Если операнд = -1 }
    if sReg = '-1' then
    begin
      case Triad.TrdType of
        { Для "+" генерим операцию DEC }
        TRD_ADD: Result := #9'dec'#9'eax';
        { Для "-" генерим операцию INC }
        TRD_SUB: Result := #9'inc'#9'eax';
        { Иначе генерим код выполняемой операции }
        else Result := Format(#9'%s'#9'eax,%s',[sOp,sReg]);
      end{case};
    end
    { Иначе генерим код выполняемой операции }
    else Result := Format(#9'%s'#9'eax,%s',[sOp,sReg]);
  end
  { Если оптимизация команд выключена,
    всегда генерим код выполняемой операции }
  else Result := Format(#9'%s'#9'eax,%s',[sOp,sReg]);
  { Добавляем к результату информацию о триаде
    в качестве комментария }
  Result := Result + Format(#9'{ %s }',
                            [Triad.MakeString(i)]);
end;

function MakeAsmCode(
  listTriad: TTriadList;{входной список триад}
  listCode: TStrings;{список строк рез. кода}
  flagOpt: Boolean{флаг оптимизации}): integer;
{ Функция построения ассемблерного кода по списку триад }
var
  i,iCnt: integer;{счетчик и переменная цикла}
  sR: string;{строка для имени регистра}
  sPrev,sVal: string;
  {строки для хранения предыдущей команды и значения eax}
procedure TakePrevAsm;
{ Процедура, выделяющая предыдущую команду и значение eax
  из списка результирующих команд }
var j: integer;
begin
  j := listCode.Count;
  if j > 0 then
  begin
    sPrev := listCode[j-1];
    sVal := StrPas(PChar(listCode.Objects[j-1]));
  end
  else
  begin
    sPrev := '';
    sVal := '';
  end;
end;
procedure MakeOper1(const sOp,{код операции}
               sAddOp: string;{код доп. операции}
               iOp: integer{номер операнда в триаде});
{ Функция генерации кода для унарных операций }
var sReg{строка для имени регистра}: string;
begin
  { Берем предыдущую команду и значение из eax }
  TakePrevAsm;
  { Запоминаем имя операнда }
  sReg := GetOpName(i,listTriad,iOp);
  { Если имя пустое, операнд уже есть в регистре EAX
    от выполнения предыдущей триады, иначе его нужно
    занести в EAX - вызываем функцию генерации кода }
  if sReg <> '' then
  begin
    sReg := MakeMove(sReg,sPrev,sVal,flagOpt);
    if sReg <> '' then listCode.Add(sReg);
  end;
  { Генерим непосредственно код операции }
  listCode.Add(Format(#9'%s'#9'eax'#9'{ %s }',
                      [sOp,listTriad[i].MakeString(i)]));
  { Если есть доп. операция, генерим ее код }
  if sAddOp <> '' then
   listCode.Add(Format(#9'%s'#9'eax,1',[sAddOp]));
  { Если триада связана с регистром, запоминаем результат в
    этом регистре }
  if listTriad[i].Info <> 0 then
  begin
    sReg := GetRegName(listTriad[i].Info);
    { При этом запоминаем, что сейчас находится в eax }
    listCode.AddObject(Format(#9'mov'#9'%s,eax',[sReg]),
                       TObject(PChar(sReg)));
  end;
end;
procedure MakeOper2(const sOp,{код операции}
               sAddOp: string{код доп. операции});
{ Функция генерации кода для бинарных арифметических
  и логических операций }
var sReg1,sReg2{строки для имен регистров}: string;
begin
  { Берем предыдущую команду и значение из eax }
  TakePrevAsm;
  { Запоминаем имя 1 операнда }
  sReg1 := GetOpName(i,listTriad,1);
  { Запоминаем имя 2 операнда }
  sReg2 := GetOpName(i,listTriad,2);
  { Если имя первого операнда пустое, значит он уже
    есть в регистре EAX от выполнения предыдущей триады -
    вызываем функцию генерации кода для второго операнда }
  if (sReg1 = '') or (sReg1 = sVal) then
   listCode.Add(MakeOpCode(i,listTriad,sOp,sReg2,
                           sPrev,sVal,flagOpt))
  else
  { Если имя второго операнда пустое, значит он уже
    есть в регистре EAX от выполнения предыдущей триады -
    вызываем функцию генерации кода для первого операнда }
  if (sReg2 = '') or (sReg2 = sVal) then
  begin
    listCode.Add(MakeOpCode(i,listTriad,sOp,sReg1,
                            sPrev,sVal,flagOpt));
    { Если есть доп. операция, генерим ее код
      (когда операция несимметричная - например "-") }
    if sAddOp <> '' then
     listCode.Add(Format(#9'%s'#9'eax',[sAddOp]));
  end
  else
  { Если оба операнда не пустые, то надо:
    - сначала загрузить в EAX первый операнд;
    - сгенерить код для обработки второго операнда. }
  begin
    sReg1 := MakeMove(sReg1,sPrev,sVal,flagOpt);
    if sReg1 <> '' then listCode.Add(sReg1);
    listCode.Add(MakeOpCode(i,listTriad,sOp,sReg2,
                            sPrev,sVal,flagOpt));
  end;
  { Если триада связана с регистром, запоминаем результат в
    этом регистре }
  if listTriad[i].Info <> 0 then
  begin
    sReg1 := GetRegName(listTriad[i].Info);
    { При этом запоминаем, что сейчас находится в eax }
    listCode.AddObject(Format(#9'mov'#9'%s,eax',[sReg1]),
                       TObject(PChar(sReg1)));
  end;
end;
procedure MakeCompare(const sOp: string
                     {флаг операции сравнения});
{ Функция генерации кода для операций сравнения }
var sReg1,sReg2{строки для имен регистров}: string;
begin
  { Берем предыдущую команду и значение из eax }
  TakePrevAsm;
  { Запоминаем имя 1 операнда }
  sReg1 := GetOpName(i,listTriad,1);
  { Запоминаем имя 2 операнда }
  sReg2 := GetOpName(i,listTriad,2);
  { Если имя первого операнда пустое, значит он уже
    есть в регистре EAX от выполнения предыдущей триады -
    сравниваем EAX со вторым операндом }
  if sReg1 = '' then
   listCode.Add(Format(#9'cmp'#9'eax,%s'#9'{ %s }',
                       [sReg2,listTriad[i].MakeString(i)]))
  else
  { Если имя второго операнда пустое, значит он уже
    есть в регистре EAX от выполнения предыдущей триады -
    сравниваем EAX с первым операндом в обратном порядке }
  if sReg2 = '' then
   listCode.Add(Format(#9'cmp'#9'%s,eax'#9'{ %s }',
                       [sReg1,listTriad[i].MakeString(i)]))
  else
  { Если оба операнда не пустые, то надо:
    - сначала загрузить в EAX первый операнд;
    - сравнить EAX со вторым операндом. }
  begin
    sReg1 := MakeMove(sReg1,sPrev,sVal,flagOpt);
    if sReg1 <> '' then listCode.Add(sReg1);
    listCode.Add(Format(#9'cmp'#9'eax,%s'#9'{ %s }',
                      [sReg2,listTriad[i].MakeString(i)]));
  end;
  { Загружаем в младший байт EAX 1 или 0
    в зависимости от флага сравнения }
  listCode.Add(Format(#9'set%s'#9'al',[sOp]));
  (* Один из вариантов кода:
  { Преобразуем 8 младших бит в 16 бит }
  listCode.Add(#9'cbw');
  { Преобразуем 16 младших бит в 32 бита }
  listCode.Add(#9'cwde'); *)
  (* Другой вариант: *)
  listCode.Add(#9'and'#9'eax,1');
  { Если триада связана с регистром, запоминаем результат в
    этом регистре }
  if listTriad[i].Info <> 0 then
  begin
    sReg1 := GetRegName(listTriad[i].Info);
    { При этом запоминаем, что сейчас находится в eax }
    listCode.AddObject(Format(#9'mov'#9'%s,eax',[sReg1]),
                       TObject(PChar(sReg1)));
  end;
end;
{ Тело основной функции }
begin
  { Берем количество триад в списке }
  iCnt := listTriad.Count-1;
  { Цикл по всем триадам от начала списка }
  for i:=0 to iCnt do
  begin
    { Если триада помечена, создаем локальную метку
      в списке команд ассемблера }
    if listTriad[i].IsLinked then
     listCode.Add(Format('@M%d:',[i+1]));
    { Генерация кода в зависимости от типа триады }
    case listTriad[i].TrdType of
      { Код для триады IF }
      TRD_IF:
        begin
          { Если операнд - констата (это возможно
            в результате оптимизации) }
          if listTriad[i][1].OpType = OP_CONST then
          begin
            { Условный переход превращается в безусловный,
              если константа = 0, }
            if listTriad[i][1].ConstVal = 0 then
             listCode.Add(Format(#9'jmp'#9'@M%d'#9'{ %s }',
                            [listTriad[i][2].TriadNum+1,
                             listTriad[i].MakeString(i)]));
            { а иначе вообще генерить код не нужно. }
          end
          else
          { Если операнд не константа }
          begin
            { Берем имя первого операнда }
            sR := GetOpName(i,listTriad,1);
            { Если имя первого операнда пустое,
              значит он уже есть в регистре EAX
              от выполнения предыдущей триады }
            if sR = '' then
             { тогда надо выставить флаг "Z", сравнив EAX
               сам с собой, но учитывая, что предыдущая
               триада для IF - это либо сравнение, либо
               логическая операция, это можно опустить}
             (* listCode.Add(#9'test'#9'eax,eax') *)
            else
             { иначе надо сравнить EAX с операндом }
             listCode.Add(Format(#9'cmp'#9'%s,0',[sR]));
            { Переход по обратному условию "NOT Z"
              на ближайшую метку }
            listCode.Add(Format(#9'jnz'#9'@F%d'#9'{ %s }',
                          [i,listTriad[i].MakeString(i)]));
            { Переход по прямому условию на дальнюю метку }
            listCode.Add(Format(#9'jmp'#9'@M%d',
                            [listTriad[i][2].TriadNum+1]));
            { Метка для ближнего перехода }
            listCode.Add(Format('@F%d:',[i]));
          end;
        end;
      { Код для бинарных логических операций }
      TRD_OR:     MakeOper2('or','');
      TRD_XOR:    MakeOper2('xor','');
      TRD_AND:    MakeOper2('and','');
      { Код для операции NOT (т.к. NOT(0)=FFFFFFFF,
        то нужна еще операция: AND EAX,1 }
      TRD_NOT:    MakeOper1('not','and',1);
      { Код для операций сравнения по их флагам }
      TRD_LT:     MakeCompare('l');
      TRD_GT:     MakeCompare('g');
      TRD_EQ:     MakeCompare('e');
      TRD_NEQ:    MakeCompare('ne');
      { Код для бинарных арифметических операций }
      TRD_ADD:    MakeOper2('add','');
      TRD_SUB:    MakeOper2('sub','neg');
      { Код для унарного минуса }
      TRD_UMIN:   MakeOper1('neg','',2);
      { Код для операции присвоения }
      TRD_ASSIGN:
        begin
          { Берем предыдущую команду и значение из eax }
          TakePrevAsm;
          { Берем имя второго операнда }
          sR := GetOpName(i,listTriad,2);
          { Если имя первого операнда пустое,
            значит он уже есть в регистре EAX
            от выполнения предыдущей триады }
          if sR <> '' then
          begin
            { иначе генерим код загрузки операнда в EAX }
            sVal := MakeMove(sR,sPrev,sVal,flagOpt);
            if sVal <> '' then listCode.Add(sVal);
          end;
          { Из EAX записываем результат в переменную
            с именем первого операнда }
          sVal := listTriad[i][1].VarLink.VarName;
          if sVal = NAME_FUNCT then sVal := NAME_RESULT;
          sVal := Format(#9'mov'#9'%s,eax'#9'{ %s }',
                        [sVal,listTriad[i].MakeString(i)]);
          { При этом запоминаем, что было в eax }            
          listCode.AddObject(sVal,TObject(PChar(sR)));
        end;
      { Код для операции безусловного перехода }
      TRD_JMP: listCode.Add(
                 Format(#9'jmp'#9'@M%d'#9'{ %s }',                      
                        [listTriad[i][2].TriadNum+1,
                         listTriad[i].MakeString(i)]));
      { Код для операции NOP }
      TRD_NOP: listCode.Add(Format(#9'nop'#9#9'{ %s }',
                            [listTriad[i].MakeString(i)]));
    end{case};
  end{for};
  Result := listCode.Count;
end;

end.