Arquitetura de computadores

Prévia do material em texto

INSTITUTO FEDERAL DO ESPÍRITO SANTO 
 
 
 
 
BACHARELADO EM SISTEMA DE INFORMAÇÃO 
 
 
JEAN CARLOS PENAS 
ARQUITETURA DE COMPUTADORES 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
SERRA 
2014 
 
JEAN CARLOS PENAS 
ARQUITETURA DE COMPUTADORES 
 
 
 
 
 
 
 
 
Trabalho apresentado no curso de 
Bacharelado em Sistemas De Informação, 
Na disciplina Organização e 
Arquitetura de Computadores no 
Instituto Federal do Espírito Santo 
Professor: Flávio Giraldeli 
 
 
 
 
 
 
 
 
SERRA 
2014 
 
Resumo 
Neste relatório será inferido aspectos entre duas linguagens em função da diferença do 
nível de abstração entre elas. A primeira linguagem é o assembly, depois da binária é a 
linguagem mais próxima da máquina, nela é possível acessar o conteúdo e endereço dos 
registradores, manipular interrupções e portas lógicas, na programação de circuitos. A 
principal característica desta linguagem é uso de instruções simples, isto graças a organização 
ISA, que traz consigo um conjunto de instruções simples com o propósito de facilitar o 
projeto do hardware e a geração do código por parte do compilador. 
A linguagem C é uma linguagem mais abstraída e por este motivo utiliza instruções 
que operam sobre estruturas de dados complexas. Em linguagens com alto nível de abstração 
a compilação de uma sequência de instruções geralmente gera uma sequência maior de 
instruções ISA que funcionam sobre estruturas de dados mais simples, presentes também no 
programa fonte. Segundo o projeto ISA, o objetivo da linguagem de máquina como o 
assembly é dar suporte às linguagens com um nível de abstração superior como a linguagem 
c, permitindo o uso de estruturas de dados como procedimentos, variáveis locais, variáveis 
globais, constantes, operações como alocação e realocação dinâmica, tipos estruturados, 
funções e etc. Então é exatamente em cima das instruções oferecidas pela arquitetura ISA que 
vamos avaliar quantidade de instruções de maior relevância, alguns aspectos entre as duas 
linguagens e mesclar as vantagens de se utilizar linguagens como essas em situações do 
mundo real por meio de um algoritmo de uma calculadora simples. 
 
Abstract 
This report is inferred aspects between two languages depending on the difference in 
the level of abstraction between them. The first language is the assembly, after the binary is 
the closest machine language, it is possible to access the content and address of registers, 
handle interruptions and logic gates in circuit programming. The main feature of this language 
is the use of simple instructions, this thanks to the ISA organization that brings a set of simple 
instructions in order to facilitate the design of hardware and code generation by the compiler. 
The C language is a more abstracted language and for this reason uses instructions that 
operate on complex data structures. In languages with a high level of abstraction to compile a 
sequence of instructions usually generates greater sequence ISA instructions that operate on 
simple data structures, also present in the source program. According to the ISA project, the 
goal of machine language as the assembly is to support languages with a higher level of 
abstraction as the C language, allowing the use of data structures and procedures, local 
variables, global variables, constants, operations like dynamic allocation and reallocation, 
structured types, functions, and so on. So right on top of the instructions offered by ISA 
architecture that we evaluate the amount of instruction more relevant, aspects between the two 
languages and merge the advantages of using languages like those in real-world situations by 
using an algorithm of a calculator simple. 
 
ILUSTRAÇÕES 
 
 
 
Figura 1 – 4 Linhas, Assembly X 7 Linhas, C, para um mesmo resultado. 8 
Figura 2 – Assembly 8 
Figura 3 – Linguagem C 8 
Figura 4 - Definição De Variáveis Em Assembly 9 
Figura 5 - Definição De Variáveis Em C 9 
Figura 6 – Registradores. 9 
Figura 7 – Execução da calculadora em Assembly, Números Grande Positivos. 10 
Figura 8 – Execução Da Calculadora Em assembly, Números Grandes Negativos. 10 
Figura 9 – Interrupções, Assembly 11 
Gráfico 1 - Linhas/Instrução, Código Assembly 11 
Gráfico 2 - Composição dos trechos de código retirados do EMU8086.INC 13 
 
SUMÁRIO 
 
 
 
RESUMO 3 
 
INTRODUÇÃO 7 
 
ASPECTOS ENTRE AS LINGUAGENS 8 
 
QUANTIDADE DE INSTRUÇÕES 11 
 
MACROS E PROCEDIMENTOS 12 
 
O ALGORITMO ASSEMBLY 14 
 
CONCLUSÃO 15 
 
REFERÊNCIAS BIBLIOGRÁFICAS 17 
 
INTRODUÇÃO 
Linguagem, o que seria linguagem? É qualquer sistema ou conjunto de sinais 
convencionais, fonéticos ou visuais, que servem para a expressão dos pensamentos e 
sentimentos, ou conjunto de sons em cuja produção intervém a língua ou articulação, ou ainda 
sistema de representação que os membros de uma comunidade linguística usam como 
principal meio de comunicação, falado ou escrito? Enfim, não existe uma definição específica 
para o termo linguagem, mas no campo da computação ela é tratada como um conjunto de 
símbolos, palavras e regras que expressam comandos que são interpretados pelo processador. 
A linguagem a ser avaliada é exatamente aquela que está relacionada ao computador. 
Na computação existem várias linguagens, cada qual com um nível de abstração específica, 
mas resolveram generalizá-las como baixo, médio e alto nível. Neste relatório vamos avaliar 
duas linguagens, uma com um nível de abstração baixo e a outra com um nível mediano que 
são a linguagem assembly e a C, respectivamente. Para citar os aspectos entre elas seria 
necessário conhecer a arquitetura que está oculta no computador. 
A arquitetura do computador é dividida em seis níveis que são: Nível lógico digital, 
micro arquitetura, arquitetura de instruções, sistema operacional, linguagem assembly, 
linguagens de alto nível. A arquitetura ISA se configura exatamente no terceiro nível que é a 
onde os programadores de baixo nível devem ter total conhecimento em função das instruções 
oferecidas por ela, para que a solução seja construída com eficiência, essas instruções serão 
gerenciadas pelo sistema operacional e este irá oferecer toda uma estrutura para que seja 
possível a implementação da linguagem assembly que por sua vez servirá de suporte para as 
linguagens medianas e de alto nível. 
Programar em uma linguagem como o assembly é complicado, por isto a necessidade 
de criar níveis de organização para facilitar a programação. Como já foi mencionado, o 
terceiro nível de organização é a arquitetura ISA, em outras palavras é tratada como um 
conjunto de instruções que representam a interface entre o software e o hardware. Nesta 
interface, cada nível de organização possui uma linguagem associada e então, à medida que a 
linguagem evolui a favor do usuário, ela vai se tornando mais conveniente para ele. Nesta 
mesma arquitetura o usuário escreve um programa fonte que pode ser escrito tanto em 
linguagem de alto nível quanto em uma linguagem de montagem e então o programa é 
traduzido para um código objeto numa linguagem de máquina e desta forma ele é interpretado 
por um micro programa ou por um hardware. O objetivo final é facilitar o projeto do 
hardware 
 
e tornar a compilação mais eficiente, no entanto, segundo a Universidade Federal Do Rio 
Grande Do Norte em uma das suas pesquisas diz que o projeto de uma linguagem de máquina 
deve dar suporte aos níveis de organização superiores para que seja possível construir 
estruturas de dados como procedimentos, variáveis locais, variáveis globais, constantes e 
dentre outros que por sua vez seriam utilizados numa linguagem de alto nível. 
Então para criar soluções em ambientes onde os detalhes a respeito da arquitetura e da 
organização são fundamentais será necessário um conhecimento eminente de cada aspecto 
como modelo da memória, conjunto de registradores, formato de instruções, modos de 
endereçamento, tipos de instruções e fluxos de controleque são considerados fundamentais 
nesse nível de organização. 
 
ASPECTOS ENTRE AS LINGUAGENS 
Sabe-se que as duas linguagens se diferem na questão do nível de organização da 
arquitetura, então é interessante frisar as consequências da implementação, como por exemplo 
a questão do conjunto de instruções que quanto mais simples, maior serão as linhas 
necessárias para produzir uma mesma solução que em outra linguagem poderia ser escrita em 
pouquíssimas linhas, a Figura 1 avalia exatamente esta propriedade. 
 
Figura 1 – 4 Linhas, Linguagem CX 7 Linhas, Assembly, para um mesmo resultado. 
 
As instruções de movimento, pilha, saltos incondicionais e condicionais e o uso de 
registradores também existem na linguagem C, mas não são acessíveis ao programador, mas 
podem ser notadas. Abaixo há imagens, Figura 2 e Figura 3 que vão mesclar exatamente 
algumas dessas características que uma pessoa desinformada dificilmente conseguiria notar. 
 
Figura 3 – Linguagem C. 
 
Na Figura 2, tem-se comparações seguidas de 
Figura 2 – Assembly. 
 
saltos, pilha, saltos incondicionais, instruções de movimentação de dados, operações 
aritméticas e flags, essas características foram inferidas na linguagem c. Na Figura 3, temos 
uma instrução switch que vai receber o endereço que contém o operador e a partir disso ele 
vai determinar o fluxo por uma série de desvios seguidos de saltos condicionais e 
incondicionais para produzir um resultado que então será armazenado em um endereço e 
impresso na tela. Neste caso temos fatores comuns que são operações de desvios e a utilização 
de labels para determinar o desvio do fluxo, mas porém as operações de pilha e a sinalização 
por flags não estão visíveis na linguagem c. Porém existe toda uma série de cuidados que 
foram obedecidos na Figura 2 e que na Figura 3 não oferece risco de penalização pois não 
está sob o domínio do programador, trata-se das operações que acontecem na pilha, esta 
estrutura é compartilhada pelas instruções ret, call, pop e push que colocam e retiram 
endereços e valores no topo da pilha, neste cenário será necessário apenas uma operação de 
pilha indevida para que toda execução do código seja penalizada. 
 
 
 
 
 
 
 
Figura 4 - Definição De Variáveis Em Assembly. Figura 5 - Definição De Variáveis Em C. 
 
 
 
 
Na Figura 4 é apresentado a forma de como se declarar variáveis no assembly, neste 
caso não haja definição de tipos como inteiro, 
char e real. A única definição possível é do 
tamanho da variável que será criada, ou seja ela 
pode ser de 8 ou 16 bits (DB ou DW, 
respectivamente), já na Figura 5, na linguagem 
c, os aspectos mudam e existe toda uma 
estrutura para que seja possível definir tipos 
Figura 6 – Registradores. 
 
para cada variável. Além disto no assembly qualquer variável é global e na linguagem c esta 
mesma propriedade não é aplicável. O assembly não é case sensitive ou seja a variável VAR1 
= var1=Var1 e assim por diante, já na linguagem c esta característica não foi notada, ou seja 
ele é case sensitive, a variável VAR1 é diferente da variável var1 e assim por diante. 
Outro aspecto que dificilmente seria acessível na linguagem C são os registradores, 
todos eles são de 16 bits, mas cada qual possui um par de registradores de 8 bits e como 
podem ver, a Figura 6 mostra um conjunto finito de registradores cada qual com uma 
propriedade específica, por exemplo os registradores de azul são de endereço, os verdes são 
de propósito geral, os de laranja são registradores de segmento, e o vermelho é composto pelo 
registrador IP usado somente pelo sistema operacional para calcular o endereço de uma 
instrução e outro usado para flags. Especificamente cada registrador possui uma propriedade, 
o registrador AX é usado para cálculos aritméticos; BX é um registrador base para referência 
de posições de memória; CX é utilizado em operações iterativas como contador; DX para 
armazenar parte de um produto de 32 bits em operações de multiplicação e resto em uma 
divisão, além disto é usado para especificar endereço de uma porta de E/S. Os registradores 
de segmento são usados para endereçamento do código de programa, dados e pilha e o 
registrador IP é usado para calcular o endereço da próxima instrução que será executada. 
Outra observação é a quantidade de locais endereçáveis na memória, no caso de uma 
variável de 8 bits é possível endereçar 256 locais de memória e a faixa de valores para que 
seja possível a sua representação é considerando a parte negativa e 
positiva do conjunto, desta forma qualquer número que for armazenado numa posição de 
memória de 8 bits terá que existir na faixa de -128 0 127, se o número for de 16 bits a faixa 
muda para este formato -32768_0_32767. Esta noção de quanto de memória usada em uma 
variável e a faixa de valores usados para representá-la é necessário, pois será uma das 
condições para que determinados tipos de cálculos indevidos ou difíceis de serem tratados 
possam ser evitados, a Figura 8 e a Figura 7 ilustram muito bem esta situação. 
 
Figura 8 – Execução Da Calculadora 
Em assembly, Números Grandes 
Negativos. 
Figura 7 – Execução da calculadora em 
Assembly, Números Grande Positivos. 
Além disto, como podem ver não foi implementado uma validação para evitar 
operações semelhantes a essas ilustradas pelas figuras acima, então se o número for positivo e 
 
muito grande a ponto de ser maior do que (2^(n-1)-1) ele terá outra representação que 
corresponderá ao extremo negativo deslocado em V-(-2^(n-1)) vezes, se for negativo porém 
muito grande ele vai para o extremo positivo (2^(n-1)-1) também deslocado em V-(2^(n-1)-1) 
o mesmo problema também acontece na linguagem c, alguns professores consideram esses 
resultados como corretos e lógicos, serial algo como está errado, mas está certo. 
 
 
 
 
Figura 9 – Interrupções, Assembly. 
Além dos registradores, as 
interrupções não são acessíveis na linguagem 
C, mas estão implícitas. O termo Interrupção 
é definido como o instante em que o 
processador desvia o seu fluxo de execução, 
salvando o ponto em que foi interrompido 
para atender uma solicitação e voltar para o 
ponto onde parou. Na Figura 9 
mostra a interrupção INT executando uma subfunção 10H usada na Macro SALTALINHA 
implementada no algoritmo da calculadora para saltar uma linha na tela do usuário na 
impressão. 
 
 
QUANTIDADE DE INSTRUÇÕES 
Como Previsto foram necessárias 321 linhas de código para desenvolver o algoritmo 
da calculadora simples em assembly, 54% ((176/321) *100) do algoritmo está dentro do 
trecho compreendido entre o ORG e a última instrução ret a ser executada. Os outros 44% 
foram retirados de uma biblioteca chamada emu8086.inc. O tempo de implementação deste 
algoritmo foi relativamente 
rápido. Foram necessários 30 
minutos para implementar os 
procedimentos e as macros que já 
estavam prontas e foram 
necessárias 3 horas para 
implementar o trecho principal 
equivalente ao ORG, no total 
foram 3 horas e meia, então 
Gráfico 1 - Linhas/Instrução, Código 
Assembly. 
tecnicamente foram escritas 176 
linhas de código (Os dados numéricos foram calculados com base no Gráfico 1). Na 
 
linguagem C, o código do mesmo algoritmo corresponde aproximadamente 15% do assembly, 
ou seja foram necessários 51 linhas de código para fazer o mesmo algoritmo em C, além 
disto, somente 12% do tempo de implementação do algoritmo em assembly foi utilizado para 
implementar o mesmo problema na linguagem c, ou seja foram necessários 25 minutos para a 
implementação. 
Os dados numéricos e o Gráfico 1 mostra que ao simplificar as instruções duas linhas 
de raciocínio serão criadas, a primeira é vantajosa para o processador, pois com instruções 
simples precisará de menos ciclos para executá-las e consequentemente isto traz vantagens 
para o compilador, porém a complexidade da implementação e manutenção de soluções feitas 
em linguagens que se baseiamem instruções simples como o assembly aumenta conforme o 
domínio do problema. A segunda vertente é vantajosa para o ser humano pois ao resolver um 
problema em um ambiente com instruções mais complexas e longas e com domínios maiores, 
poucas linhas de código serão necessárias para a sua construção, isto torna o código mais 
legível, fácil de se implementar e de se corrigir. Por outro lado, essas instruções exigirão mais 
ciclos para serem processadas e consequentemente o programa será mais lento. 
 
 
 
 
 
 
 
MACROS E PROCEDIMENTOS 
Como já foi mencionado 44% do algoritmo implementado na linguagem assembly é 
composto pelos trechos de código que foram retirados de um arquivo e estão representados no 
gráfico de pizza, cada trecho recebe uma entrada e produz um resultado que poderá ou não ser 
usado por outro trecho ou então ser impresso na tela, desta forma será descrito cada um deles, 
na sequência em que se encontra na legenda do Gráfico 2, modelo pizza. 
 
 
 
 
Gráfico 2 - Composição dos trechos de código retirados do EMU8086.INC 
 
 
Dos 44% de código retirados do arquivo estão sendo representados no gráfico acima, 
as porcentagens descritas revelam o tamanho da participação de cada um deles no código da 
calculadora. Um exemplo disto é o SCAN_NUM que compõe 60% dos 44% de código que 
foram retirados do arquivo EMU8086.inc. Abaixo foram definidas de forma resumida a 
participação de cada um desses trechos no algoritmo. 
PRINT_NUM_UNS 
É um procedimento para impressão de números positivos, ele recebe um número que 
será gerado pelo PRINT_NUM e por uma série de divisão na base 10 ele vai calculando o 
valor de cada dígito até formar uma cadeia caracteres (Tabela ASCII) que represente 
exatamente o valor dado na entrada. 
PRINT_NUM 
É um procedimento de impressão, ele espera o valor em AX para ser imprimido, 
quando o valor é zero ele simplesmente imprime o caracter zero na tela, quando o número é 
positivo, ele chama o procedimento PRINT_NUN_UNS para impressão de um número 
positivo, caso o número seja negativo, ele faz o complemento de dois para obter o número e 
configura a sua impressão como um número negativo. 
SCAN_NUM 
É um procedimento e a sua função é receber a entrada do usuário e configurá-la para 
que possa ser processada. Ele usa uma instrução para imprimir o caráter dado na entrada e 
 
outra instrução para armazená-lo e em cada iteração ele vai formando a entrada do usuário, 
ele possui a implementação do backspace para deletar o caracter na entrada que é feita através 
de uma operação deslocamento de base 10 para esquerda (Divisão) no fluxo de execução 
através do registrador CS. Quando é escrito um número (caracteres) muito grande ele desloca 
a cadeia de caracteres para direita através de uma multiplicação na base 10. Quando um 
número com sinal é dado na entrada, ele seta o valor dela no fluxo de execução para 1, 
quando o usuário digita Enter, o seu valor é ajustado para zero. O interessante deste 
procedimento é que ele vai formando o valor através de operações de deslocamento e depois 
forma o número através de uma operação de complemento de 2, se necessário. 
 
 
PUTC 
É uma macro que recebe uma entrada cujo tamanho é de 8 bits e sobre ação de uma 
subfunção de impressão e de uma instrução de interrupção ela imprimirá um caracter na tela. 
SALTALINHA 
É uma macro, ela utiliza a mesma instrução e interrupção da macro PUTC para 
impressão de carácter na tecla, com uma diferença são combinados dois caracteres 
que provocaram um salto de linha, ambos estão baseados na tabela ASCII. 
 
O ALGORITMO ASSEMBLY 
Nas operações abaixo não foi implementado a verificação do número em relação a 
faixa de representação, então se o número for positivo é muito grande a ponto de ser maior do 
que (2^(n-1) -1) ele terá outra representação que corresponderá ao extremo negativo 
deslocado em V-(-2^(n-1)) vezes, se for negativo porém muito grande ele vai para o extremo 
positivo (2^(n-1) -1) também deslocado em V-(2^(n-1) -1). 
 
Soma 
O algoritmo da calculadora se inicia recebendo o operador e os operandos na entrada 
pelo usuário, em seguida é feita uma série de comparações seguidas de saltos para determinar 
qual operação será feita. Foram implementadas quatro operações, a primeira delas é a soma, 
nesta operação os operandos salvos na pilha são retirados para não influenciar na resultante 
final, a operação de soma acontece, existe a possibilidade de overflow então é verificada, caso 
aconteça ela é sinalizado com a impressão da frase “OVERFLOW!” e o algoritmo termina, 
 
Caso contrário ele imprime a mensagem “RESULTADO” com um procedimento para 
impressão de caracteres e outro para impressão do valor em AX. 
Subtração 
Na subtração, a operação de subtração acontece, nela é feita uma verificação de 
overflow, caso tenha sucesso o overflow será sinalizado, se o overflow não acontecer o valor 
de saída estará no registrador AX e um procedimento de impressão é utilizado para imprimir a 
mensagem para o usuário e outro para impressão do valor em AX. 
Multiplicação 
Nesta operação foi necessário validar o sinal dos operandos, caso fossem positivos 
uma instrução MUL será utilizada para fazer a operação, caso haja overflow ele é sinalizado, 
do contrário o valor é impresso na mesma configuração dos trechos acima. Para números 
com sinal a multiplicação é feita com a instrução IMUL e os mesmo procedimentos para 
sinalizar o overflow ou o resultado são feitos iguais aos trechos acima. 
Divisão 
Se os valores estiverem dentro da faixa, é verificado se o segundo operando é zero 
para evitar uma divisão por zero, se o número for positivo será utilizada instrução DIV, antes 
da operação o registrador DX é inicializado com zero para para evitar cálculos errados 
provocados por lixo então é verificada a possibilidade de overflow caso aconteça será 
sinalizado do contrário o resultado impressão na mesma configuração dos trecho acima. 
CONCLUSÃO 
Para confirmar a hipótese de que tornando as instruções mais simples, o tempo de 
implementação seria grande, tomamos como exemplo o algoritmo da calculadora em 
assembly, já ousamos criar algoritmos muito mais complicados do que uma calculadora 
simples, mas não se engane o tempo de implementação da calculadora nesta linguagem durou 
3,5 horas. Para confirmar o fato de que tornando as instruções mais complexas mas porém 
com domínios maiores, as soluções se tornam fáceis de se implementar, tomamos como 
exemplo a duração da implementação do mesmo algoritmo na linguagem C, que foi de mais 
ou menos 25 minutos. A complexidade do algoritmo na linguagem assembly aumentou com a 
questão dos sinais, segundo o professor Giraldeli não seria necessária a implementação de um 
procedimento para validar os sinais, logicamente isto foi seguido quando foi percebido que os 
procedimentos SCAN_NUM, SCAN_NUM_UNS, PRINT_NUM eo PRINT_NUM_UNS 
 
fazia tal validação e toda a configuração necessária para facilitar os cálculos. 
Durante a implementação do código no montador assembler foi notado que não seria 
uma tarefa simples, pois o conhecimento sobre quais registradores usar, administração da 
pilha de endereços e de execução que é compartilhada, interrupções e subfunções seriam 
necessários. Este conhecimento está diretamente ligado à arquitetura do computador ou seja 
teria que ser feita perguntas do tipo: Será que o processador possui o conjunto de instruções 
necessário para implementar ou construir tal solução? Um conhecimento mais profundo sobre 
a organização e a arquitetura do computador seria necessário para resolver problemas mais 
complexos. Ocorreu a oportunidade de implementar operações interessantes vistas em sala de 
aula como o complemento de dois que é feita com a instrução NEG. Concluiu-se que cada 
instrução é parte fundamental do código, uma operação errada, toda a execução é penalizada. 
Foi visto que o armazenamento de números muito grandessejam eles positivos ou negativos 
saltavam para o extremo negativo da faixa de representação -2^(n-1) deslocado em A vezes 
ou saltavam para o extremo positivo (2^(n-1) – 1), o primeiro aconteceu quando número é 
positivo porém maior que o limite positivo da faixa de representação, o segundo acontece 
quando o número era negativo porém maior que a faixa negativa de representação. Esses 
aspectos são considerados como errados, mas certos. 
Um dos trechos dos códigos retirados do arquivo EMU8086.INC me chamou a 
atenção, trata-se do SCAN_NUM combinado com o SCAN_NUM_UNS, ele usufrui das 
operações de deslocamento binário para formar o número, tratar sinais e evitar que números 
muito grandes sejam inseridos na entrada, muito interessante esta ideia e é muito utilizada 
pelo processador em determinados tipos de operações com o propósito de ganhar tempo. 
A arquitetura do computador é organizada em 6 níveis começando do mais baixo para 
o mais alto e começa com o nível lógico digital, microarquitetura, conjunto de instrução, 
sistema operacional, linguagem assembly, e finalmente a linguagem de alto nível, como foi 
percebido, o sistema operacional é responsável por oferecer suporte a linguagem assembly 
para que seja possível a implementação da solução do problema. O conjunto de instruções 
tem papel fundamental no suporte ao sistema operacional é nele que é definido se tais 
instruções serão do tipo CISC ou RISC, um exemplo de arquitetura RISC é a ISA que é o 
conjunto instruções simples que visa melhorar a performance do processador e a geração de 
código por parte do compilador se baseando no fato de que instruções simples precisam de 
menos ciclos para serem processadas como consequência processador ganha tempo de 
processamento ao lidar com elas. 
 
 
 
 
 
 
 
REFERÊNCIAS BIBLIOGRÁFICAS 
 
 
USP. Compiladores. 
Disponível em: 
http://www.icmc.usp.br/pessoas/delamaro/SlidesCompiladores/Aula1- Cap1.pdf 
Acesso em 25 de Júlio, 2014. 
 
UFU. Linguagem De Programação. 
Disponível em: 
http://www.daniel.prof.ufu.br/apostilas/linguaProgram.pdf Acesso em 25 
de Júlio, 2014. 
 
UFU. Linguagem De Programação. 
Disponível em: 
http://www.ime.usp.br/~song/mac412/oc-risc.pdf Acesso em 26 
de Júlio, 2014. 
 
UFMG. Arquitetura. 
Disponível em: 
http://www.verlab.dcc.ufmg.br/_media/cursos/arquitetura/2007- 
1/transparencias/aula04-prig.pdf 
Acesso em 27 de Júlio, 2014. 
UFRN. Nível ISA. 
Disponível em: 
http://www.dca.ufrn.br/~pablo/FTP/arq_de_comp/apostilha/capitulo3.pdf 
Acesso em 3 de Agosto, 2014. 
 
Projeto Lógico De Computadores. ISA. 
Disponível em: http://walderson.com/2012-2/plc/aula3-plc-nisa.pdf 
Acesso em 4 de Agosto, 2014. 
http://www.icmc.usp.br/pessoas/delamaro/SlidesCompiladores/Aula1-Cap1.pdf
http://www.icmc.usp.br/pessoas/delamaro/SlidesCompiladores/Aula1-Cap1.pdf
http://www.daniel.prof.ufu.br/apostilas/linguaProgram.pdf
http://www.ime.usp.br/~song/mac412/oc-risc.pdf
http://www.verlab.dcc.ufmg.br/_media/cursos/arquitetura/2007-1/transparencias/aula04-prig.pdf
http://www.verlab.dcc.ufmg.br/_media/cursos/arquitetura/2007-1/transparencias/aula04-prig.pdf
http://www.dca.ufrn.br/~pablo/FTP/arq_de_comp/apostilha/capitulo3.pdf
http://walderson.com/2012-2/plc/aula3-plc-nisa.pdf
	ARQUITETURA DE COMPUTADORES 
	SERRA 2014 
	SERRA 2014 
	Abstract 
	ILUSTRAÇÕES 
	INTRODUÇÃO 
	ASPECTOS ENTRE AS LINGUAGENS 
	QUANTIDADE DE INSTRUÇÕES 
	MACROS E PROCEDIMENTOS 
	PRINT_NUM_UNS 
	PRINT_NUM 
	SCAN_NUM 
	PUTC 
	SALTALINHA 
	O ALGORITMO ASSEMBLY 
	Soma 
	Subtração 
	Multiplicação 
	Divisão 
	CONCLUSÃO 
	REFERÊNCIAS BIBLIOGRÁFICAS