Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.

--- prog:guia-de-estudo-c [2026/02/28 04:16] – [Compiladores] detalhamento de compiladores na seção respectiva hrcerq
+++ prog:guia-de-estudo-c [2026/03/02 01:49] (atual) – [Compiladores] palavra repetida removida hrcerq
@@ Linha 193: / Linha 193: @@
   - [[prog:guia-de-estudo-c#montagem|Montagem]]
   - [[prog:guia-de-estudo-c#ligacao|Ligação]]
+Portanto, o mínimo necessário para compilar programas C são um
+pré-processador, um compilador, um montador e um ligador, além
+da biblioteca C (que será explicada mais adiante).
 As ferramentas que desempenham essas funções podem ou não estar
-agrupadas em uma mesma coleção (compiladores mais conhecidos, como GCC e
+agrupadas em uma mesma coleção. Duas coleções particularmente
-Clang, por exemplo, fazem esse agrupamento de funções).
+notórias são:
+  * [[https://gcc.gnu.org/|GCC]] + [[https://www.gnu.org/software/binutils/|Binutils]] (do projeto GNU)
+  * [[https://clang.llvm.org/|Clang]] + [[https://llvm.org/|LLVM]]
+Outra um pouco menos conhecida é a do //Tiny C Compiler// (TCC):
+  * [[https://bellard.org/tcc/|TCC]]
+E ainda outra é a do //Simple C Compiler// (SCC):
+  * [[https://www.simple-cc.org/|SCC]]
 === Pré-processamento ===
@@ Linha 225: / Linha 240: @@
   * [[https://pt.wikipedia.org/wiki/Pr%C3%A9-processador|Pré-processador]]
+  * [[https://wiki.inf.ufpr.br/maziero/doku.php?id=c:o_preprocessador_c|O preprocessador C]]
   * [[https://dca.fee.unicamp.br/cursos/EA876/apostila/HTML/node150.html|O pré-processador C]]
+  * [[https://www.ime.usp.br/~pf/algoritmos/apend/preprocessor.html|Pré-processamento]]
   * //[[https://en.wikipedia.org/wiki/C_preprocessor|C preprocessor]]// (inglês)
@@ Linha 238: / Linha 255: @@
   * [[http://mcpp.sourceforge.net|mcpp]]
   * [[https://github.com/lpsantil/ucpp|ucpp]]
+  * [[https://www.simple-cc.org/|SCC]] (pré-processador [[https://git.simple-cc.org/scc/file/src/cmd/scc-cc/cc1/cpp.c.html|embutido]] no compilador ''scc-cc'')
 === Compilação ===
@@ Linha 265: / Linha 283: @@
   * //Otimização//: Otimizações podem ocorrer ao longo de etapas anteriores, mas a maior parte só é possível após a conversão para uma representação intermediária, com o uso de uma análise heurística sobre o código gerado.
+  * //Geração de código de montagem//: emitir o código //assembly// específico da arquitetura alvo.
 Enfim, depois de todo esse processo, temos o código Assembly gerado.
@@ Linha 289: / Linha 309: @@
   * //[[https://en.wikipedia.org/wiki/List_of_compilers#C_compilers|C compilers]]// (inglês)
-Dois compiladores de grande destaque são o [[https://gcc.gnu.org/|GCC]],
+Dois compiladores de grande destaque são:
-do projeto GNU, e o [[https://clang.llvm.org/|Clang]], que faz parte da
-infraestrutura de compilação [[https://llvm.org/|LLVM]].
+  * [[https://gcc.gnu.org/|GCC]] (do projeto GNU)
+  * [[https://clang.llvm.org/|Clang]] (relacionado à infraestrutura de compilação [[https://llvm.org/|LLVM]])
 Conhecer ao menos esses dois já será suficiente para compreender as
 funções centrais desse tipo de ferramenta.
@@ Linha 315: / Linha 337: @@
 No caso do compilador Clang, é a máquina virtual LLVM que se encarrega
 de ler a representação intermediária, fazer as otimizações e gerar
-o código de montagem.
+o código de montagem. O GCC já possui internamente seu próprio
+//back-end//.
+Uma outra opção de infraestrutura de compilação (entenda-se o
+//back-end//) é o QBE:
+  * [[https://c9x.me/compile/|QBE]]
+Diferente do GCC e do LLVM, sua prioridade é a simplicidade
+e capacidade de inspecionar e estudar o processo de compilação,
+ainda que sob pena de realizar menos otimizações sobre o código.
+Alguns compiladores (mais especificamente, //front-ends//) que
+visam gerar código intermediário para o QBE são:
+  * [[https://sr.ht/~mcf/cproc/|cproc]]
+  * [[https://www.simple-cc.org/|SCC]] (''scc-cc'')
+Por fim, existem compiladores que não utilizam uma representação
+intermediária. Um exemplo interessante é o Tiny C Compiler (TCC):
+  * [[https://bellard.org/tcc/|TCC]]
+Sua principal vantagem é uma compilação mais rápida, ainda que
+o programa resultante não tenha o mesmo desempenho que o
+equivalente gerado por GCC e Clang, geralmente.
 === Montagem ===
+Diferentemente de um processo de compilação, que dá ênfase à
+intenção do programador quanto //ao quê// deve ser feito pelo programa,
+a montagem é um processo mais linear, que enfatiza //como// deve ser
+feito. Portanto, a montagem é uma tradução mais literal de expressões
+mnemônicas para equivalentes binários que podem ser compreendidos pelo
+processador alvo.
+Um código-fonte C pode passar por várias transformações e ainda assim
+manter seu sentido original, não importanto para o programador quais
+otimizações precisaram ser aplicadas, desde que o comportamento se
+mantenha consistente. Já o código de montagem (//assembly//) é mais
+diretamente equivalente ao resultado (binário).
+Embora a estrutura geral da linguagem //assembly// possua semelhanças
+entre diferentes arquiteturas de processamento, existem diferenças
+suficientes para que se possa considerar como código não portável.
+O código //assembly// escrito para uma máquina terá de ser reescrito
+para outra, se esta utilizar uma arquitetura diferente.
+Para compreender melhor como ocorre esse processo, você pode ler os
+seguintes documentos:
+  * [[https://pt.wikipedia.org/wiki/Assembly|Linguagem assembly]]
+  * [[https://dca.fee.unicamp.br/cursos/EA876/apostila/HTML/node79.html|Montadores]]
+  * [[https://pt.wikipedia.org/wiki/Linguagem_de_montagem_x86|Linguagem de montagem x86]]
+  * [[https://dca.fee.unicamp.br/cursos/EA876/apostila/HTML/node107.html|Assembly do 68000]]
+Ao compreender o processo de montagem, você já deve ter percebido
+as principais vantagens em programar em C no lugar de programar
+diretamente em //Assembly//:
+  * Por ser uma linguagem de alto nível (ao menos comparado a //Assembly//), C permite maior evidenciação sobre o que o programa deve fazer, isto é, é uma linguagem mais expressiva e intuitiva;
+  * Por ser uma linguagem portável, não será necessário reescrever o programa para cada arquitetura alvo.
+Para cada arquitetura de processamento, existem diferentes montadores.
+Você pode conferir uma lista (não exaustiva) no documento a seguir:
+  * //[[https://en.wikipedia.org/wiki/List_of_assemblers|Comparison of assemblers]]// (em inglês)
 === Ligação ===
@@ Linha 698: / Linha 784: @@
 Perfiladores:
-  * [[https://sourceware.org/binutils/docs-2.42/gprof/index.html|GNU Profiler]] (''gprof'')
+  * ''gprof'' (existem diferentes implementações)
+    * [[https://www.unix.com/man-page/FreeBSD/1/gprof/|BSD]] (originário do 4.2BSD, presente em sistemas BSDs no geral)
+    * [[https://sourceware.org/binutils/docs-2.42/gprof/index.html|GNU]] (uma reimplementação no projeto [[https://www.gnu.org/software/binutils/|GNU Binutils]])
   * [[https://perf.wiki.kernel.org/index.php/Main_Page|Linux Perf]] (''perf'')
   * [[https://valgrind.org/|Valgrind]]
   * [[https://oprofile.sourceforge.io/news/|OProfile]]