UFSCAR (UNIVERSIDADE FEDERAL DE SÃO CARLOS)

LINGUAGEM INTERMEDIÁRIA

SOROCABA

2011
 RENAN TADEU DA SILVA 408638

LUCAS SANTOS DE ALMEIDA RA 408190

CELIO SOARES DE SOUZA RA 408107

GRUPO 12

LINGUAGEM INTERMEDIÁRIA

Pesquisa acadêmica realizada sobre linguagem intermediária

para computadores para da disciplina de algoritmo

do primeiro semestre do curso de ciência da computação

da UFscar( universidade federal de São Carlos )

Professor Dr. Siovani Cintra Felipossi

 SUMÁRIO

INTRODUÇÃO- ------------------------------------------------------------------------------------------4

1 - LINGUAGEM INTERMEDIARIA --------------------------------------------------------5

1.1 - DEFINIÇÃO................................................................................................................5
1.2 ASSEMBLY..................................................................................................................6
1.2.1 - AMBIENTES DE USO................................................................................................6
1.2.2 - LINGUAGEM C........................................................................................................6
1.2.3 - LINGUAGEM JAVA..................................................................................................7
1.2.4 – PLATAFORMA .NET................................................................................................7

Explicando as camadas e sua utilidade......................................................................11

1.2.5 STANDARD ML........................................................................................................13
TIPOS SINÔNIMOS............................................................................................................15
1.2.6 - OUTROS AMBIENTES.............................................................................................16

2 - RESUMO SOBRE COMPILADOR E INTERPRETADOR-----------------------16

3 - GERAÇÃO DO CÓDIGO INTERMEDIÁRIO----------------------------------------16

4 - OTIMIZAÇÃO DE CÓDIGO-------------------------------------------------------------17

CONCLUSÃO-----------------------------------------------------------------------------------19

BIBLIOGRAFIA---------------------------------------------------------------------------------20
INTRODUÇÃO

Existe uma relação simbiótica entre as linguagens de programação

usadas atualmente. Nomear qualquer uma que seja exclusivamente
intermediaria tornou-se tarefa dificil

As linguagens usadas pelos desenvolvedores – desde o FORTRAN –

são definidas como linguagens de alto nível, na grande maioria das
bibliografias.

A pesquisa realizada e descrita neste documento encontrou fontes que

“definiram” linguagem intermediaria de maneira abrangente, ou seja, uma
linguagem que faz o “caminho” entre linguagem de alto nível e linguagem de
alto nível. Em outros termos, é possível dizer que a linguagem intermediária
“traduz” a linguagem do homem para a linguagem da máquina.

As denominadas linguagens da terceira geração – C, Cobol, Pascal,

entre outras – assumem a função de linguagem intermediária, dentro de seus
respectivos compiladores, para que os programas construídos funcionem.

Apontou, ainda, a pesquisa a plataforma .NET como uma grande

“usuária” de linguagem intermediária. Segue também a Standard ML que
mostrou-se outra linguagem eficaz.
1 - LINGUAGEM INTERMEDIARIA

1.1 - Definição

T
rata-se de um termo não aceito por todos. Esta linguagem de
computador é usada na programação como um estágio intermediário
entre a linguagem-fonte de origem (geralmente uma linguagem de alto
nível) e a linguagem de destino (geralmente o código de máquina). Muitos
compiladores de alto nível usam a linguagem assembly como uma linguagem
intermediária.

Em ciência da computação , uma linguagem intermediária é a língua de

uma máquina abstrata projetada para auxiliar na análise dos programas de
computador . O termo vem do seu uso em compiladores , onde um primeiro
compilador traduz o código fonte de um programa em uma forma mais
adequada para melhorar o código de transformações, como uma etapa
intermediária antes de gerar objeto ou máquina de código para uma máquina
de destino. A concepção de uma linguagem intermediária normalmente é
diferente da prática de uma linguagem de máquina de três maneiras
fundamentais:

Cada instrução representa exatamente uma operação fundamental, por

exemplo "shift-add" modos de endereçamento comum
em microprocessadores não estão presentes.

Controle de fluxo de informação não pode ser incluído no conjunto de

instruções.

O número de registros disponíveis pode ser grande, mesmo sem limites.

Um formato popular para as línguas intermediário é código de três

endereços .

A variação do significado deste termo é para referir as línguas utilizadas

como uma linguagem intermediária por alguns de alto nível de
programação línguas que não objeto de saída ou código de máquina, mas a
linguagem intermediária única saída, se submeter a um compilador para essa
linguagem , que então saídas objeto acabado ou código de máquina. Isso
geralmente é feito para ganhar otimização quanto tratadas acima,
ou portabilidade , utilizando uma linguagem intermediária que tem muitos
compiladores para processadores e sistemas operacionais , tais
como C . Línguas utilizadas para essa queda de complexidade entre
linguagens de alto nível e baixo nível de línguas, como línguas de montagem .

As linguagens de programação evoluíram ao longo do tempo tornando

assim, cada vez mais complexas as sua definições.
 Essa evolução das linguagens de programação pode ser dividida em
cinco etapas ou gerações.

 Primeira geração: Linguagem máquina.

 Segunda geração: Criaram-se as primeiras linguagens assembler.

 Terceira geração: Criam-se as primeiras linguagens de alto nível. Ex: C,

Pascal, Cobol…

 Quarta geração: São linguagens capazes de gerar código por si só, são
os chamados RAD, com o qual pode-se realizar aplicações sem ser um
expert na linguagem. Aqui também se encontram as linguagens
orientadas a objetos, tornando possível a reutilização de partes do
código para outros programas. Ex: Visual, Natural Adabes…

 Quinta geração: Aqui se encontram as linguagens orientadas à

inteligência artificial. Estas linguagens ainda estão pouco desenvolvidas.
Ex: LISP

1.2 Assembly
Assembly ou linguagem de montagem é uma notação legível por
humanos para o código de máquina que uma arquitetura de
computador específica usa. A linguagem de máquina, que é um mero padrão
de bits, torna-se legível pela substituição dos valores em bruto por símbolos
chamados mnemónicos.

1.2.1 - Ambientes de uso

1.2.2 - Linguagem C
C é usado como língua intermediária por muitas linguagens de programação,
incluindo Eiffel , Sather , Esterel,alguns dialetos de Lisp ( Lush , Gambit ), Hask
ell ( Glasgow Haskell Compiler ), Squeak's-subconjunto C calão, Cython , entre
outros. Variantes de C foram concebidos para fornecer recursos de C como um
jogador portátil de linguagem assembly , incluindo uma das duas línguas
chamado C - , a C Intermediate Language e o baixo nível da máquina virtual .
 1.2.3 - Linguagem Java
Sun Microsystem bytecode Java é a linguagem intermediária usada por todos
os compiladores visando o Java Virtual Machine . A JVM pode então fazer -em-
tempo de compilação apenas para obter o código de máquina executável para
melhorar as performances. Da mesma forma, da Microsoft Common
Intermediate Language é uma linguagem intermediária projetada para ser
compartilhada por todos os compiladores para o . NET Framework , antes ou
dinâmico compilação estática de código de máquina.

O GNU Compiler Collection (GCC) usa internamente várias linguagens

intermediárias para simplificar a portabilidade e compilação cruzada. Entre
essas linguagens são:

 histórico Register Transfer Language (RTL)

 a linguagem árvore GENERIC

 o SSA baseado GIMPLE .

1.2.4 – Plataforma .NET

De maneira mais robusta, a plataforma .NET mostra de maneira mais
clara a função e utilização da linguagem intermediaria. O excerto extraído do
sitio Linha de código aborda de maneira significativa essa aplicação: “a
plataforma .NET tem independência na linguagem de programação: com ela é
possível trabalhar com várias linguagens diferentes no mesmo projeto e
interagir entre elas. Isso é possível por termos uma IL (Intermediate
Language), ou seja, linguagem intermediária onde todos os fontes compilados
pelo CLR (comentado mais a frente) resultam em uma só linguagem.

Os sistemas desenvolvidos em. NET são auto-explicativos: cada

programa compilado contém em si informações necessárias em METATAGS
que faz com que o runtime não precise procurar as informações no registro do
Windows. Por exemplo quando criamos um sistema, o mesmo pode ser
executado em qualquer máquina (que suporte a .NET) sem necessidade da
instalação. Todas as informações necessárias para que o sistema seja
executado são encontrados dentro nas METATAGS dentro dele mesmo. Com
isso temos um sistema auto-explicativo, pois as informações necessárias estão
armazenadas dentro dele e não no registro do sistema operacional.”

Ainda dentro da plataforma .NET encontra-se algumas linguagens de

médio nivel; são estes exemplos:

 MSIL(Microsoft Intermediate Language)

MSIL ou IL é a linguagem intermediária dita até agora.

Independentemente da linguagem que você escrever seu programa
 quando compilado será gerado a IL. Mas repare que não é qualquer
linguagem que pode ser compilada em .NET. Ela deve aderir as
especificações da CLS e CTS (comentadas mais a frente) e só então e
linguagem pode ser "nomeada" como XYZ.NET, assim como
Python.NET, Cobol.NET etc.

 CLR (Common Language Runtime)

É o ambiente de execução das aplicações .NET. O CLR cuidará do

gerenciamento de memória através do GC (visto mais a frente). Este
gerenciamento de memória torna o programa menos propício a erros.
Outro item muito interessantes da .NET é a conversão da sua
linguagem, por exemplo COBOL, para IL e é neste estágio entra o
compilador JIT (Just-in-Timer) um componente da CLR que interpreta a
IL e gera a linguagem de máquina na arquitetura do processador.

 CTS (Common Type System)

É a definição de tipos de dados onde tudo é um objeto e deriva da

classe System.Object, que é o núcleo do sistema de tipos.
Pensando que tudo é um objeto, logo tudo deriva da classe
System.Object e, por isso, os projetistas da .NET organizaram o sistema
de tipos de dados de duas formas:
Tipos Valor: variáveis deste tipo são alocadas na pilha e têm como
classe base System.ValueType, que por sua vez deriva da
System.Object.
Tipos Referência: variáveis deste tipo são alocadas na memória heap e
têm a classe System.Object como classe base.

Essa é a melhor maneira de como se estruturam tipos com esta separação:

-- System.Object
---- Tipos valor
------ Estruturas
------ Tipos Enumerados
---- Tipo Referência
------ Objeto
------ Interface
------ Ponteiros

O que aconteceria se não fosse assim?

Seria da seguinte forma:

-- System.Object
---- Estruturas
---- Tipos Enumerados
---- Objeto
---- Interface
---- Ponteiros
Não teria a diferença entre Tipo valor e Tipo referência.

 CLS (Common Language Specification - Especificação comum de

dados)

Define um conjunto de regras que as linguagens que implementam a

.NET devem seguir para que a CLR possa gerar a IL.
Esse é um dos motivos de podermos criar sistemas em diferentes
linguagens e interagir entre elas dentro da .NET. No momento da
compilação é gerado um código único intermediário (IL) e todas essas
linguagens suportadas pela .NET seguem as regras da CLS, para que
depois de gerado a IL, ela seja interpretada corretamente pela CLR,
como já dito acima.

BCL (Base Classe Library - Biblioteca de Classe Base)

Como o próprio nome diz, na biblioteca de classe base você encontra

sistema de janelas, biblioteca de entrada/saída de dados, sockets,
gerenciamento de memória, etc.
Esta biblioteca é organizada em uma estrutura conhecida como
namespace, ou seja, imagine que você precise atribuir um nome ao seu
componente para que o mesmo possa ser referenciado a partir de outro
programa. Abaixo seguem alguns namespaces da .NET

System

Contém algumas classes de baixo nível usadas para trabalhar com tipos
primitivos, operações matemáticas, gerenciamento de memória etc.

System.Collections

Contém pilhas, filhas e listas encadeadas.

System.Data, System.Data.Common, System.Data.OleDb,

System.Data.SqlClient

Acesso a base de dados. Aqui também se encontra o ADO.NET

System.Diagnostics
Log de Event, medição de performance, gerenciamento de processos,
depuração etc.

System.Drawing e namespace derivados:

A .NET oferece uma biblioteca de componentes para trabalhar com gráficos,
chamadas GDI+, que se encontra neste namespace.

System.IO

Biblioteca para lidar com entrada e saída, gerenciamento de arquivos etc.

System.NET

Bibliotecas para programação de redes, sockets etc.

System.Reflection

Biblioteca necessária para gerar código em tempo de execução, descobrir tipo

de variáveis etc.

System.RuntimeInteropServices e System.Runtime.Remoting

Fornece bibliotecas para interagir com código não-gerenciado.

System.Security

Criptografia, permissão e todo o suporte referente à segurança.

System.Threading

Biblioteca para aplicações multithread

System.Web
Biblioteca sobre tudo relacionado a Web, como Webservices, ASP.NET etc.

System.Windows.Forms
Bibliotecas para o desenvolvimento de aplicações Windows tradicionais.
System.XML
Biblioteca que permite a interação com documentos XML.

Estrutura da arquitetura .NET em camadas:

Primeira: Linguagem de programação preferida e aceita pela especificação da
CLS e CTS.
Segunda: BCL (Base Class Library)
Terceira: CLR (Common Language Runtime)
Quarta: CTS (Common Type System) e CLS (Common Language
Specification)

Explicando as camadas e sua utilidade

Primeira camada

O desenvolvedor usará sua linguagem de programação preferida e que

seja suportada pela .NET (primeira camada) e então criar seus sistemas. E,
para criá-los, o desenvolvedor acessará as classes da BCL, já que tudo é
objeto em .NET.

Segunda camada

Feito isso, o programa deverá ser compilado e então gerado a IL que, por sua
vez, será interpretada pela CLR (terceira camada), que deverá passar pelas
especificações da CTS e CLS (quarta camada).

Toda aplicação .NET, quando compilada, é armazenada fisicamente

numa unidades de código denominada assembly. Uma aplicação pode ser
composta de um ou mais assemblies, os quais são representados no sistema
de arquivos de sistema operacional host na forma de arquivos executáveis, de
extensão .EXE, ou de uma biblioteca de ligação dinâmica melhor conhecida
como DLL, de extensão .DLL.

PE (Portable Executable - Executável Portável)

Isto significa que o fonte gerado poderá ser interpretado (executado) em

qualquer plataforma que tenha suporte .NET, sem necessidade de
recompilação do fonte.

Compilação JIT (Just in Time)

O compilador JIT, também conhecido como JITTER, converte as

instruções da IL para instruções específicas da arquitetura do processador
onde a aplicação .NET esta sendo executada.
Temos três tipos de JITTER:

 Pre-JIT: Compila de uma só vez todo o código da aplicação .NET que

esta sendo executada e o armazena no cache para uso posterior.

 Econo-JIT: Utilizado em Hand-Helds onde a memória é um recurso

precioso. Sendo assim, o código é compilado sob demanda e a memória
alocada que não esta em uso é liberada quando o dispositivo assim o
requer.

 Normal-JIT: Compila o código sob demanda e joga o código resultante

em cache, de forma que esse código não precise ser recompilado
quando houver uma nova invocação do mesmo método.

VES (Virtual Execution System - Sistema de execução virtual)

É um processo de compilação e é aqui onde o JITTER é ativado quando

uma aplicação .NET é chamada. O windows identifica que esta é uma
aplicação .NET e uma runtime Win32 passa o controle para a runtime do .NET.
Neste momento a compilação do PE é efetuada e só então o código assembly
próprio da arquitetura do processador é gerado para que a aplicação possa ser
executada.

Estes são os processo em suas etapas em camadas:

Primeira: Sua linguagem de programação

Segunda: IL
Terceira: CLR (Compilador JIT - Código nativo gerenciado - Execução
do código)
Quarto: Dispositivo de saída: PentiumX, Mobile etc.

Em outras palavras as camadas e sua utilidade ficariam da seguinte

forma:

o desenvolvimento do aplicativo (primeira camada); compila gerando a IL

(segunda camada). Após isto a CLR interpreta (quando o aplicativo for
executado) e compila com o JIT, gerando o código nativo da arquitetura do
processador e o executa (terceira camada). De acordo com o dispositivo de
saída é gerado um código nativo da arquitetura do processador diferente
(quarta camada).

GC (Garbage Collector - Coletor de Lixo)

 Gerenciar memória não deve ser uma preocupação de quem
desenvolve sistemas para tratar sobre regras de negócio e com .NET; não é
necessário se preocupar com o gerenciamento de memória porque o GC faz
isso.

Quando uma área de memória não esta mais em uso, o GC trata de

liberá-la. E quando necessário a utilização de um novo espaço o GC também
faz isso. Mesmo não utilizando C/C++, em .NET também é psossivel gerenciar
memória o que torna o desempenho maior. Em contrapartida é considerado um
método inseguro, conhecido como "unsafe code".

1.2.5 Standard ML
O sitio Wikipedia ainda mostra que uma outra linguagem pode ser considerada
intermediaria:

“Standard ML (SML) é uma linguagem de programação funcional de

propósito geral modular com verificação e inferência de tipos em tempo de
compilação. É popular entre pesquisadores de linguagem de programação
e compiladores. Detém algumas características impuras.

Softwares escritos em Standard ML consistem de expressões a serem

avaliadas, ao contrário de declarações ou comandos, apesar de algumas
expressões de retorno de uma unidade de "trivial" valor e apenas são
avaliados por seus efeitos colaterais.

SML é um descendente moderno da ML (linguagem de

programação) utilizado em lógica de funções computáveis (LCF). Distingue-se
entre as linguagens utiliada devido sua característica funcional e devido sua
especificação formal, dado como escrever regras e semântica operacional na
definição da Standard ML.”

Essa é a exemplicação mis clara do uso dessa linguagem

Como toda linguagem de programação funcional, uma característica

fundamental do Sntadard ML é função, que é usada para a captação. Por
exemplo, a função fatorial pode ser expresso como:

fun factorial n =

if n = 0 then 1 else n * factorial (n-1)

Um compilador Stardard ML é requirido para inferir o tipo estático int ->

int desta função fornecida pelo usuário, sem anotação de tipo. Ou seja, tem a
deduzir que n"" só é usado com expressões inteiro, e deve, portanto, por si só,
um número inteiro, e que todas expressões produzem expressões com funções
retornando inteiros.
A mesma função pode ser expressa com as definições em que as
condicionaisif-then-else são substituídas por uma seqüência de "templates" da
função fatorial avaliados para valores específicos, separados por "|", que são
avaliados um por um na ordem escrita até que seja encontrada uma
correspondência:”

fun factorial 0 = 1
| factorial n = n * factorial (n - 1)

Isto pode ser reescrito usando uma instrução, num caso similar como este:

val rec factorial =

fn n => case n of 0 => 1
| n => n * factorial (n - 1)

ou como uma função lambda:

val rec factorial = fn 0 => 1 | n => n * factorial(n -1)

Aqui, a palavra-chave val introduz uma ligação de um identificador para um

valor, fn apresenta a definiação de uma função função anônima,
e case introduz uma seqüência de padrões e expressões correspondentes.

Usando uma função local, esta função pode ser reescrita de forma mais
eficiente de estilo tail recursive.

fun factorial n = let

fun lp (0, acc) = acc
| lp (m, acc) = lp (m-1, m*acc)
in
lp (n, 1)
end

(O valor de uma expressãolet é o da expressão entre in e end.) O

encapsulamento de uma invariante preservando cauda-do-loop apertado
recursivamente com um ou mais parâmetros acumuladores dentro de uma
função externa invariável-livre, como pode ser visto aqui, é uma expressão
comum em Standard ML, e aparece com grande freqüência no código SML.
 Tipos Sinônimos
O tipo sinônimo é definido com the palavra reservada type. Aqui é um tipo
sinônimo para pontos no plano, e as funções de computação das distâncias
entre dois pontos e a área de um triângulo com cantos dada pela fórmula de
Heron.”

type loc = real * real (* x and y *)

(* dist : loc * loc -> real *)
fun dist ((x0, y0), (x1, y1)) = let
val dx = x1 - x0
val dy = y1 - y0
in
Math.sqrt (dx * dx + dy * dy)
end
(* heron : loc * loc * loc -> real *)
fun heron (a, b, c) = let
val ab = dist (a, b)
val bc = dist (b, c)
val ac = dist (a, c)
val perim = ab + bc + ac
val s = perim / 2.0
in
Math.sqrt (s * (s - ab) * (s - bc) * (s - ac))
end

Implementações

Existem muitas implementações SML, es5as são algumas delas:

 MLton é uma implemantação com um compilador que produz código

muito rápido comparado a outras implementações ML
 Standard ML of New Jersey (abreviado SML/NJ) é um compilador
completo, com bibliotecas associadas, ferramentas, shell interativo e
documentação.
 Moscow ML é uma implementação de peso, baseado no CAML
Light runtime engine. Esta implementa a linguagem SML completa.
Incluindo módulos SML e muitas bibliotecas SML básicas.
  Poly/ML é uma implementação completa do Standard ML que produz
um código muito rápido e que suporte hardware multicore (via Pthreads)
 TILT é um compilador para certificação completa do SML. Ele é usado
digitando línguas intermediárias para otimizar o código e assegurar a
regularidade, e pode compilar paralinguagem Assembly.
 HaMLet é um interpretador SML que pretende ser uma implementação
de referência precisa e acessível do padrão SML.
 ML Kit implementações que comporta um garbage collector (que pode
ser desativado) visando aplicações de tempo real.
 SML.NET permite compilação para o Microsoft CLR e tem extensões
para linkagem com outro código .NET.

1.2.6 - Outros ambientes

A maioria das linguagens intermediárias são projetados para suportar
linguagens com tipagem estática, a representação intermediária Parrot foi
concebido para suportar linguagens com tipagem dinâmica, inicialmente, Perl e
Python.

A linguagem intermediária ILOC é usado em aulas de desenho do

compilador como um idioma alvo simples.

2 - Resumo sobre compilador e interpretador

O compilador uni todo o programa em um arquivo EXE em formato

binário, que em seguida será executado pelo computador. O processo de
compilação é feito uma única vez, o que torna o processo de leitura do
programa, muito rápido. Linguagens compiladas geralmente são usadas em
jogos, robótica, automação industrial, pois são áreas em que a velocidade de
execução do programa precisa ser rápida.

Um interpretador nada mais é que um intermediário entre, o código-fonte

a ser executado, e o computador, ou seja, o interpretador “entrega” o código-
fonte ao computador em uma linguagem de baixo nível sempre que o programa
é executado

3 - Geração do Código Intermediário

 Nesta citação encontrada no sitio Wikipedia, fica claro como se dá o
processo de geração de código intermediário. Tendo como ponto de partida a
sintaxe da linguagem usada, seguem-se estes passos: “na fase de geração de
código intermediário, ocorre a transformação da árvore sintática em uma
representação intermediária do código fonte. Um tipo popular de linguagem
intermediária é conhecido como código de três endereços. Neste tipo de
código uma sentença típica tem a forma X := A op B, onde X,A e B são
operandos e op uma operação qualquer.

Uma forma prática de representar sentenças de três endereços é

através do uso de quádruplas (operador, argumento-1, argumento-2 e
resultado). Este esquema de representação de código intermediário é preferido
por diversos compiladores, principalmente aqueles que executam extensivas
otimizações de código, uma vez que o código intermediário pode ser
rearranjado de uma maneira conveniente com facilidade.”

Tomando um compilador como um modelo de análise-e-síntese,

podemos considerar que seus módulos iniciais traduzem um programa fonte
em uma representação (linguagem) intermediária, a partir da qual seus
módulos finais geram o código objeto final.

Embora um programa fonte possa ser traduzido diretamente para a

linguagem objeto, o uso de uma representação intermediária, independente de
máquina, tem as seguintes vantagens:

 reaproveitamento de código, facilitando o transporte de um compilador

para

 diversas plataformas de hardware; somente os módulos finais precisam

ser refeitos a cada transporte.

 Um otimizador de código independente de máquina pode ser usado no

código intermediário.

Existem várias formas de representação de código intermediário. Duas

das mais comuns são árvores de sintaxe e triplas de código intermediário (ou
instruções de 3 endereços)

4 - Otimização de Código

A otimização de código é a estratégia de examinar o código

intermediário, produzido durante a fase de geração de código com objetivo de
produzir, através de algumas técnicas, um código que execute com bastante
eficiência. O nome optimizador deve sempre ser encarado com cuidado, pois
não se pode criar um programa que leia um programa P e gere um programa P
´ equivalente sendo melhor possível segundo o critério adotado.

Várias técnicas e várias tarefas se reúnem sob o nome de Optimização.

Estas técnicas consistem em detectar padrões dentro do código produzido e
substituí-los por códigos mais eficientes. Entre as técnicas usadas estão a
substituição de expressões que podem ser avaliadas durante o tempo de
compilação pelos seus valores calculados, eliminação de sub-expressões
redundantes, desmembramento de laços, substituição de operações
(multiplicação por shifts), entre outras.

Uma das técnicas de otimização mais eficazes e independente de

máquina é a otimização de laços, pois laços internos são bons candidatos para
melhorias. Por exemplo, em caso de computações fixas dentro de laços, é
possível mover estas computações para fora dos mesmos reduzindo
processamento.
Conclusão

O termo linguagem intermediária diz – aos desenvolvedores e

estudiosos - muito mais do que a aparente limitação do material pesquisado e
o conteúdo produzido em relação a este termo.

Enquanto a “linguagem do homem” necessitar se comunicar com a

“linguagem de máquina” – tendo em mente que isso será perpetrado durante
longa data – pois ainda os estudos em computação e afins não indicam para
outro caminho, toda e qualquer linguagem antiga ou atual necessitará de
processo intermediário.

Portanto, criam-se novas linguagens, novos métodos, mas a estrutura

dos compiladores e a capacidade dos computadores – esta pesquisa nos
indicou – ainda não poderão se abstrair da linguagem de médio nível; ou, como
aqui chamada, linguagem intermediária.
BIBLIOGRAFIA

http://www.netpedia.com.br/MostraTermo.php?TermID=3515 ( CONTEÚDO ACESSADO EM

21/04/2011)

http://en.wikipedia.org/wiki/Intermediate_language (CONTEÚDO ACESSADO EM

21/04/2011)

http://www.criarprogramas.com/2011/03/18/o-que-sao-interpretadores-e-compiladores-qual-a-
diferenca/ (CONTEÚDO ACESSADO EM 21/04/2011)

http://www.linhadecodigo.com.br/artigo/120/Arquitetura-NET-MSIL-CLR-CTS-CLS-BLC-
JIT.aspx (CONTEÚDO ACESSADO EM 21/04/2011)

http://pt.wikipedia.org/wiki/Assembly (CONTEÚDO ACESSADO EM 21/04/2011)

http://pt.wikipedia.org/wiki/Compilador (CONTEÚDO ACESSADO EM 21/04/2011)

http://www.criarweb.com/artigos/685.php (CONTEÚDO ACESSADO EM 21/04/2011)

http://www.dsc.ufcg.edu.br/~peter/cursos/cc/material/p6-gercod-2p.pdf (CONTEÚDO
ACESSADO EM 21/04/2011)