\documentclass[10pt]{letter}

\usepackage{portuges}
\usepackage{isolatin1}

\pagestyle{empty}

\date{}

\textheight 9in
\topmargin -0.7in

\newcommand{\section}[1]{\vspace{3mm}{\emph{#1}}\vspace{2mm}}

\begin{document}
\pagestyle{empty}

\begin{center}
  \LARGE
  MAC-221 --- Construção de Montadores \\
  MAC-222 --- Sistemas de Programação \\[1cm]
  \large
  1998 ---   Especificação da segunda fase do Montador p/ MIPS
\end{center}

\vspace{2mm}


\section{Idéias gerais}

Na segunda fase do montador para o processador RISC MIPS R2000 deve-se
implementar um analisador sintático.  Não haverá preocupação em montar os
`opcodes' das instruções (que deverá ser feito numa terceira fase).
Como idéia geral, desejamos ser capazes de reconhecer como sintaticamente
correto, qualquer arquivo assembly gerado pelo ``cross-compiler'' como será
descrito oportunamente.


\section{O analisador léxico}

Nesta segunda fase deverá ser utilizado o analisador léxico gerado na primeira
fase.  Poucas alterações poderão ser necessárias.  Os módulos já definidos,
incluindo-se aquele gerado pelo flex e que implementa a função
\texttt{yylex()} e o módulo necessário à manipulação da tabela de hashing
serão usados como antes.  O módulo \texttt{testlex} será omitido no analisador
sintático, mas pode ser utilizado nalgum outro executável de forma a se obter
uma listagem dos ítens léxicos que estão sendo sucessivamente remetidos ao
analisador sintático.


\section{Recuperação e relatório de erros}

O programa deve ser capaz de se recuperar de um erro sintático, prosseguindo a
análise sintática nas linhas subsequentes.  Quanto à
função \texttt{yyerror()} deve dar informações sobre onde ocorreu o erro
sintático.  Ao menos o número da linha em que foi detectado o erro (basta que
\texttt{yylex()} conte os caracteres de mudança de linha) e o valor de
\texttt{yytext} do último token lido deve ser impresso.

De fato, o arquivo fornecido
\texttt{testsint.c} já possui uma implementação de uma tal função
\texttt{yyerror()} e também tem uma função 
\texttt{main()} que inicializa a tabela de símbolos, lê os parâmetros da linha
de comando e chama \texttt{yyparse()}.  Este arquivo, como todos os demais que
foram fornecidos, pode ser alterado.


\section{Arquivos fornecidos}

O diretórios (que são idênticos no momento)
\begin{quote}
  \texttt{<http://www.ime.usp.br/\~{ }alair/mac221-98/SegundaFase/>}\\
  \texttt{<http://www.ime.usp.br/\~{ }alair/mac222-98/SegundaFase/>}
\end{quote}
contêm a especificação da segunda fase e arquivos auxiliares à confecção do
analisador sintático.  Um arquivo com todo o conteúdo do diretório pode ser
encontrado em  
\begin{quote}
  \texttt{<http://www.ime.usp.br/\~{ }alair/mac221-98/SegundaFase.tar.gz>}\\
  \texttt{<http://www.ime.usp.br/\~{ }alair/mac222-98/SegundaFase.tar.gz>}\\
\end{quote}
Para ser extraído, basta usar o comando
\begin{quote}
  \texttt{tar xvzf SegundaFase.tar.gz}
\end{quote}
no linux\footnote{Quem usa o \texttt{DJGPP} pode fazer o mesmo já que o
  \texttt{DJGPP} possui o \texttt{tar} e o \texttt{gzip}.}.

Nesses diretórios são fornecidos os arquivos:
\begin{itemize}
\item \texttt{Tokens-2.5} com a especificação dos tokens;
\item \texttt{Observacoes.txt} com várias observações\footnote{Algumas
    destas observações serão mais úteis quando for feita a geração de
    código, na terceira fase.} sobre o projeto.
\end{itemize}
Estes dois arquivos \emph{fazem parte da especificação do projeto} e poderão
ser alterados de forma a dar mais esclarecimentos porventura necessários.

São fornecidos ainda vários arquivos que \emph{podem} ser usados na implementação
do projeto:
\begin{itemize}
\item \texttt{symrec.h} com a especificação de uma tabela de símbolos;
\item \texttt{symrechash.c} com uma implementação da tabela de símbolos
  através de uma tabela de hashing (com uma função de hashing simples);
\item \texttt{initsymrec.c} com uma função que inicializa a tabela de hashing;
\item \texttt{token2hash} um script AWK que processa o arquivo
  \texttt{Tokens-2.5} e gera um vetor de inicialização com as palavras
  reservadas a serem inseridas inicialmente na tabela de Hashing;
\item \texttt{testsint.c} com a função \texttt{yyerror()} e a função
  \texttt{main()};
\item \texttt{token2bison} um script AWK que processa o arquivo
  \texttt{Tokens-2.5} e gera definições como \texttt{\%token} e
  \texttt{\%union} para o bison;
\item \texttt{Makefile} um arquivo descritor das dependências entre os
  diferentes arquivos do projeto;
\item outros arquivos/scripts AWK relacionados à primeira fase do projeto;
\item \texttt{exemplos} um diretório que será comentado mais tarde. 
\end{itemize}
  


\section{A análise sintática}

Todas as \emph{instruções}, \emph{pseudoinstruções} e \emph{diretivas} deverão
ser reconhecidas corretamente.

No caso das instruções, o reconhecimento
sintático deve ser \emph{estrito}, ou seja, todas as possíveis combinações de
operandos devem ser reconhecíveis e nenhuma a mais.  Todas as diretivas
\texttt{.text}, \texttt{.data}, \texttt{.sdata}, \texttt{.rdata},
\texttt{.bss}, \texttt{.sbbs}, \texttt{.comm}, \texttt{.lcomm},
\texttt{.word}, \texttt{.byte}, \texttt{.half}, \texttt{.double},
\texttt{.ascii} e \texttt{.asciiz} também devem ter reconhecimento sintático
\emph{estrito}, bem como as pseudo-instruções \texttt{la} (load address),
\texttt{li} (load immediate) e \texttt{move}.

Todas as demais pseudoinstruções e diretivas podem ter um reconhecimento
sintático \emph{relaxado}, ou seja, todas as combinações corretas de operandos
devem ser reconhecíveis mas pode-se reconhecer como sintaticamente corretos
operandos que de fato não o são.  Na terceira fase, isto não trará problemas
para estas pseudoinstruções e diretivas pois não serão implementadas a
princípio.


\section{Instruções com duas sintaxes possíveis}

Várias instruções dos tipos \texttt{R3} e \texttt{J} podem ter uma segunda
sintaxe.  Alguns montadores MIPS admitem que um nome de instrução como
\texttt{add} admita duas sintaxes possíveis.  Isto inclui o montador GNU as.
\begin{verbatim}
     add reg,reg,reg  
     add reg,reg,imm
\end{verbatim}
No primeiro caso a instrução seria montada com um opcode (correspondente a
\texttt{ADD\_OP}) e na segunda com outro opcode (correspondente a \texttt{ADDI\_OP}).

Num montador mais simples, estas instruções como \texttt{add} poderiam aceitar somente a
primeira sintaxe e caso se quizesse a segunda sintaxe, deveríamos
explicitamente escrever
\begin{verbatim}
     addi reg,reg,imm
\end{verbatim}
     
Neste projeto, para que se possa reconhecer como sintaticamente corretos
quaisquer arquivos assembly gerados pelo cross-compiler, estas segundas
sintaxes devem ser reconhecidas como corretas.  Isto pode complicar um pouco a
maneira de se fazer a análise sintática de instruções dos tipos \texttt{R3} e
\texttt{J}.  Mais detalhes devem ser vistos no ítem $3$ do arquivo
\texttt{Observacoes.txt}.


\section{Documentação fornecida}

Está à disposição no Xerox o apêndice A da primeira edição do excelente livro
``Computer Organization \& Design: The Hardware / Software Interface'' de
autoria de Patterson \& Hennessy.  Este apêndice contém os `opcodes' das
instruções do MIPS 2000 bem como sua sintaxe e \emph{DEVE} ser consultado.  Há
alguns erros no apêndice e o arquivo \texttt{Observacoes.txt} e
\texttt{Tokens-2.5} têm informações mais confiáveis quando houver
discrepância.  Uma terceira fonte de informação é o manual do SPIM que também
está no xerox.  Já no apêndice A há alguma informação referente ao SPIM.


\section{Usando os arquivos fornecidos}

Com os arquivos fornecidos, basta escrever os arquivos \texttt{analex.l},
\texttt{anasintdef.y} e \texttt{anasintregras.y} compatíveis.  Rodando
\texttt{make}, o \texttt{Makefile} fornecido é analisado e é gerado o
executável \texttt{./testaanasint}.  Se só estes arquivos forem implementados,
basta entregar um arquivo-pacote \texttt{.tar}\footnote{Um comando \texttt{tar
    cvzf meutar.tgz analex.l anasintdef.y anasintregras.y} monta o pacote.}
(ou um \texttt{.zip}) dos três arquivos.  Se os arquivos fornecidos forem
alterados ou outros arquivos forem acrescentados, todos estes arquivos devem
ser entregues neste pacote.  Com o pacote entregue e extraído sobre um
diretório contendo previamente os mesmos arquivos entregues na especificação
da SegundaFase, deve-se ser capaz de gerar o executável, de nome
\texttt{testaanasint} simplesmente rodando \texttt{make}.


\section{Diretório \texttt{exemplos}}

Este diretório possui vários arquivos assembly (\texttt{.s}) para o MIPS.  Possui também
alguns arquivos C (\texttt{.c}) que podem ser cross-compilados de forma que se gerem
os correspondentes arquivos \texttt{.s}.  O arquivo \texttt{Makefile} presente
neste diretório oferece regras de como fazer esta cross-compilação.

O ``cross-compiler'', disponível apenas em linux, pode ser encontrado em
\begin{quote}
  \texttt{<ftp://ftp.linux.ime.usp.br/pub/alair/>}
\end{quote}
juntamente com o simulador \texttt{spim}. (Já estão instalados na rede linux
do IME.)  Há também uma versão do simulador \texttt{spim} que roda em DOS.

\section{Entrega}

A entrega deste pacote deve ser feita de forma eletrônica em 
  \begin{quote}
    \texttt{<http://panda.ime.usp.br>}
  \end{quote}
até o dia 19 de outubro.

\pagestyle{empty}
\end{document}
