GCC - Compilar, Vincular e Mais com C/C

GCC
Compile! Linque! Debug! E mais!
John Henrique Teixeira de Godoi
Mathias Felipe Lima Santos
Instituto de Ciências e Tecnologia
Universidade Federal de São Paulo
São José dos Campos – SP, Brasil
Novembro, 2011
Programa de Educa¸cão em Software Livre - PESL

Avisos!
Esse material foi elaborado para o v´ıdeo que deve ser entregue
na disciplina de multim´ıdia.
Algumas tradu¸cões podem não ser fiéis mas se adequavam
melhor ao contexto.
Além do contéudo desses slides tem a parte prática que será
exibida durante a apresenta¸cão.
Algumas bibliotecas e configura¸c˜ees podem ser necessárias
para a execu¸cão de alguns exemplos, como GNU Database
Management Library (GDBM).
A biblioteca GDBM armazena pares de
valores-chaves em um arquivo DBM, um tipo de
arquivos de dados que permite armazenar e
indexar por uma chave.

Indice
1 GCC – C/C++
GCC
Programando em C e C++

Indice
1 GCC – C/C++
GCC
2 Compilar!
Compilando um programa em C
Encontrando erros em um programa simples
Compilando a partir de v´arios arquivos

Indice
1 GCC – C/C++
GCC
2 Compilar!
3 Vincular!
Código-fontes → arquivos objetos → executáveis
Ordem para vincular os arquivos objetos
Recompilando e revinculando
Vinculando com bibliotecas externas
Ordem de vincula¸cão das bibliotecas

Indice
1 GCC – C/C++
GCC
2 Compilar!
3 Vincular!
4 E mais!
Usando bibliotecas de arquivos cabe¸calhos
Parâmetros de compila¸cão
Padrões da linguagem C
Referências

GCC – C/C++
Compilar!
Vincular!
E mais!
GCC
Uma breve história do GCC
Criador do GNU C Compiler (GCC) é Richard Stallman,que
fundou o projeto GNU, em 1984, para criar um sistema
operacional, baseado em Unix, como software livre.
Precisava de um compilador C, e devido a falta de
compiladores livres naquela época, criou-se um do zero.
1olan¸camento do GCC em 1987, sendo o primeiro compilador
otimizador ANSI C portátil lan¸cado como software livre.
1992, foi adicionado a capacidade de compilar C++
2001, adicionado melhorias na otimiza¸cão e no suporte ao
C++
Suporte para linguagens adicionais como:
Fortran, ADA, Java and Objective-C.
E a sigla GCC, agora, se refere a “GNU Compiler Collection”.
John Godoi, Mathias Santos GCC

GCC – C/C++
Compilar!
Vincular!
E mais!
GCC
Principais funcionalidades do GCC
GCC é um compilador portável que roda na maioria das
plataformas dispon´ıveis atualmente, e criar sa´ıdas para diferentes
tipos de processadores (PC, microcontrollers, DSPs e CPUs
64-bits). GCC permite compilar um programa para diferentes
plataformas, produzindo arquivos executáveis para diferentes
sistemas a partir de qualquer outro com GCC. GCC é escrito em C
com um forte foco na portabilidade, e pode se auto-compilar, para
que seja adaptado a novos sistemas facilmente.

GCC – C/C++
Compilar!
Vincular!
E mais!
GCC
Principais funcionalidades do GCC
GCC tem uma arquitetura modular, permitindo suporte para novas
linguagens e arquiteturas a serem adicionadas. Adicionando uma
nova linguagem ao GCC permite o uso dessa linguagem em
qualquer arquitetura. Finalmente, e mais importante, GCC é um
software livre, distribu´ıdo sob a GNU General Public License (GNU
GPL).
O que significa que você tem a liberdade para usá-lo, alterá-lo,
assim como outros software GNU.

GCC – C/C++
Compilar!
Vincular!
E mais!
GCC
C e C++ são linguagens que permitem acesso direto a
memória do computado.
Usadas para escrever sistemas de baixo n´ıvel, e aplica¸cões
onde alta-perfomance e controle dos recurso usados são
cr´ıticos.
Exigem um cuidado com o acesso correto memória, para
evitar corromper outras estruturas de dados.
Existem técnicas, usando GCC por exemplo, que ajudam a
detectar prováveis erros durante a compila¸cão, mas que não
eliminam o “risco ” de usar tais linguagens.

GCC – C/C++
Compilar!
Vincular!
E mais!
Podemos compilar programas a partir de um único arquivo, ou de
vários outros, e também podemos usar bibliotecas do sistema e
arquivos de cabe¸calho. Compila¸cão trata-se do processo de
converte um programa de um código fonte em texto, em uma
linguagem tal como C ou C++, em um código de máquina, uma
sequência de 1’s e 0’s usados para controla a Unidade Central de
processamento (CPU) do computador. Esse código é armazendo
em um arquivo também conhecido como arquivo executável, ou
binário.

GCC – C/C++
Compilar!
Vincular!
E mais!
Compilando um programa simples em C
Usaremos o exemplo cl´assico, Hello World, como exemplo de
programa em linguagem C.
//nome do arquivo: hello.c
# include <<stdio.h>>
int main (void)
{
printf (“Hello, world!n );
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
Compilando um programa simples em C
Para compilar ‘hello.c’: “$ gcc -Wall hello.c -o hello” O arquivo
de sa´ıda é definido usando o parâmetro ‘-o’. Se omitido, a sa´ıda é
escrita em um arquivo chamado ‘a.out’. O parâmetro ‘-Wall’ativa
os avisos para os erros mais comuns ainda na compila¸cão -
recomenda-se sempre use esse parâmetro! Para executar o
programa, digite o caminho do executável assim: “$ ./hello” O
que carregará o arquivo executável na memória e fará a CPU
executar as instru¸cões contidas nele.

GCC – C/C++
Compilar!
Vincular!
E mais!
Exemplo, ‘printf’com formato de ponto ﬂutuante, ‘%f’, usado para
imprimir um valor inteiro:
int main (void)
{
printf (“Twoplustwois%f n , 4);
return 0;
}
Um erro que pode passar despercebido primeira vista, mas
detectado se o parˆametro ‘-Wall’estiver acionado.

GCC – C/C++
Compilar!
Vincular!
E mais!
Ao compilar o código acima, o gcc lan¸ca um aviso com a seguinte
mensagem:
“$ gcc -Wall bad.c -o bad”
“bad.c: In function ‘main’:”
“bad.c:6: warning: double format, different type arg (arg2)”
O que indica o uso incorreto de formato no ‘printf’, na linha 6.
As mensagens produzidas pelo GCC sempre seguem o modelo -
arquivo:número da linha:mensagem.

GCC – C/C++
Compilar!
Vincular!
E mais!
O compilador é capaz de distinguir entre as mensagens de erro, o
que previne compilar um código com problemas, e de aviso que
indicam poss´ıveis problemas, não causariam problemas na
compila¸cão. Nesse caso, o formato correto seria ‘%d’.
Sem o parâmetro ‘-Wall’o programa aparentemente compilar
normalmente, mas produz uma sa´ıda incorreta:
“$ gcc bad.c -o bad”
“$ ./bad”
“Two plus two is 2.585495 (saida incorreta)”

GCC – C/C++
Compilar!
Vincular!
E mais!
Números inteiros e pontos flutuantes são armazenados de forma
diferentes na memória, e costumam ocupar quantidades de bytes
diferentes, causando sa´ıdas incorretas. Além de gerar sa´ıdas
incorretas, fun¸cões que não são usadas corretamente podem causar
a falha do programa, e para prevenir poss´ıveis problemas é
aconselhável verificar os avisos do compilador. Obs.: O parâmetro
‘-Wall’é capaz de identificar os erros que comumente ocorrem em
C.

GCC – C/C++
Compilar!
Vincular!
E mais!
Programa divididos em vários arquivos:
código mais fácil de editar e entender (codigosgrandes)
compilar separadamente cada arquivos
Exemplo, ‘Hello World’dividido nos arquivos ‘main.c’, ‘hello fn.c’e
o cabe¸calho ‘hello.h’.
//main.c
# include “hello.h ”
int main (void) {
hello (“world“);
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
A chamada da fun¸cão printf é feita através de uma fun¸cão externa,
hello( ), definida em ‘hello fn.c’. O programa ‘main’também inclui
o cabe¸calho ‘hello.h’que contém a declara¸cão da fun¸cão hello( ).
A declara¸cão é usada para garantir que os tipos da fun¸cão
chamada combinam com a fun¸cão definida.
Como a fun¸cão main não chama a fun¸cão ‘printf’diretamente, não
há necessidade incluir a biblioteca ‘stdio.h’no ‘main.c’.
//hello.h
void hello (const char ∗ name);

GCC – C/C++
Compilar!
Vincular!
E mais!
//hello fn.c
void hello (const char ∗ name) {
printf (“Hello, %s!n“, name);
}
Observamos que existem duas formas usar a instru¸cão # include,
no caso de # include “FILE.h ”, para indexar a biblioteca é feita
um procura pelo arquivo no diretório atual, então busca-se nos
diretórios do sistema.
E para # include <<FILE.h>>a busca pelo arquivo é feita apenas
nos diretórios do sistema.

GCC – C/C++
Compilar!
Vincular!
E mais!
Para compilar:
“$ gcc -Wall main.c hello fn.c -o newhello”
Obs.: O arquivo cabe¸calho, ‘hello.h’, não foi inclu´ıdo na lista de
arquivos. A diretiva # include “hello.h ” no código-fonte instrue o
compilador para inclu´ı-lo automaticamente aonde é necessário.
Para executar:
“$ ./newhello”
“Hello, world!”

GCC – C/C++
Compilar!
Vincular!
E mais!
Compilando os arquivos separadamente
Ao realizar uma mudan¸ca qualquer em uma fun¸cão separada: Num
único arquivo:
o programa inteiro deve ser recompilado,
pode ser um processo lento Códigos em arquivos diferentes:
somente os arquivos que possuem mudan¸cas precisam ser
recompilados. Os arquivos-fonte são compilados separadamente e
então vinculados - um processo de duas fases.

GCC – C/C++
Compilar!
Vincular!
E mais!
1 Na 1aetapa:
um arquivo é compilado sem criar um
executável.O resultado é referenciado como um
arquivo objeto que tem a extensão ‘.o’quando
usando GCC.
2 Na 2aetapa:
O Lincador combina todos os arquivos objetos
para criar um único executável.

GCC – C/C++
Compilar!
Vincular!
E mais!
Em um arquivo objeto temos o código de máquina sem referências
para endere¸cos de memória das fun¸cões (ou variaveis) em outros
arquivos, que ficam indefinidos
Isso permite que os códigos fontes sejam compilados sem uma
referência direta entre esses. O lincados preenche os endere¸cos
restantes quando produz o executável.

GCC – C/C++
Compilar!
Vincular!
E mais!
Criando arquivos objetos de código-fontes
O parâmetro ‘-c’é usado para compilar um código-fonte para um
arquivo objeto. Por exemplo, o seguinte comando irá compilar o
código-fonte ‘main.c’para um arquivo objeto:
“$ gcc -Wall -c main.c”
Isso produz um arquivo objeto ‘main.o’contém o código de
máquina para a fun¸cão main. Contém a refência para fun¸cão
externa hello, mas o endere¸co de memória é deixado indefinido no
arquivo objeto nesse estágio (queserapreenchidopelolincador).

GCC – C/C++
Compilar!
Vincular!
E mais!
Criando arquivos objetos de código-fontes
O comando que corresponde a compilar o código fonte da fun¸cão
hello em ‘hello fn.c’é:
“$ gcc -Wall -c hello fn.c”
Isso produz um arquivo objeto ‘hello fn.o’.
Perceba que não existe necessidade de usar o parâmetro ‘-o’para
especificar o nome do arquivo de sa´ıda nesse caso. Quando
compilando com ‘-c’o compilador automaticamente cria um
arquivo objeto que o nome é o mesmo do código-fonte, com
‘.o’diferente da extensão original.
Não há necessidade de inserir o arquivo cabe¸calho ‘hello.h’na linha
de comando, pois já é incluido automaticamenteo pelos comandos
# include no ‘main.c’e ‘hello fn.c’.

GCC – C/C++
Compilar!
Vincular!
E mais!
Criando executáveis a partir de arquivos objetos
O passo final em criar um arquivo executável é usar o gcc para
vincular os arquivos objetos e preencher os endere¸cos das fun¸cões
externas que faltam. Para vincular os arquivos objetos, eles são
simplesmente listados na linha de comando:
“$ gcc main.o hello fn.o -o hello”
Esse é um dos poucos casos onde não existe a necessidade do uso
do parâmetro de aviso ‘-Wall’, já que os códigos-fontes foram
separadamente compilados com sucesso para arquivos objetos.
Uma vez que os códigos fontes foram compilados, vincular é um
processo desambigo pode falhar ou não, e só falhará se existirem
referências que não poderem ser resolvidas.

GCC – C/C++
Compilar!
Vincular!
E mais!
Criando executáveis a partir de arquivos objetos
Para realizar o passo de vincula¸cão o gcc usar o vinculador ld, que
é um programa separado. Em sistemas GNU é usado o GNU ld.
Outros sistemas podem usado o GNU linker com o GCC, ou
podem usar seus próprios vinculadores.
Ao rodar o vinculador, o gcc cria um arquivo executável a partir
dos arquivos objetos.
O arquivos executável pode ser rodado por:
“$ ./hello”
“Hello, world!”
Produzindo a mesma sa´ıda da versão que utiliza um único arquivo.

GCC – C/C++
Compilar!
Vincular!
E mais!
Em sistemas derivados do Unix, o comportamento tradicional de
vinculadores e compilados é procurar por fun¸cões externas da
esquerda para a direita nos arquivos objetos especificados na linha
de comando. Isso significa que o arquivo obejto que contém a
defini¸cão de uma fun¸cão deveria aparecer depois de alguns aruivos
que chamaram aquela fun¸cão.
Nesse caso, o arquivo ‘hello fn.o’contém hello que deveria ser
especificado depois de ‘main.o’, já que main chama hello:
“$ gcc main.o hello fn.o -o hello” (ordem correta)

GCC – C/C++
Compilar!
Vincular!
E mais!
Com alguns compiladores ou vinculadores a ordem inversa
produziria um erro,
“$ cc hello fn.o main.o -o hello (ordemincorreta)”
“main.o: In function ‘main’:”
“main.o(.text + 0xf ): undefined reference to ‘hello’”
por não há nenhum arquivo obejto contendo hello depois de
‘main.o’.

GCC – C/C++
Compilar!
Vincular!
E mais!
Mas atualmente compiladores e vinculadores irão buscar em todos
arquivos objetos, mesmo fora de ordem, mas como nem todos
compildadores fazem isso é melhor seguir a ordem convencional
dos arquivos objetos da esquerda para a direita.
Assim vale a pena manter isso na mente caso você encontre
problemas imprevistos com referências indefinidas, e todos os
arquivos objetos estão presentes na linha de comando.

GCC – C/C++
Compilar!
Vincular!
E mais!
Para mostrar como os códigos-fontes podem ser compilados
independentemente nós iremos editar o programa main ‘main.c’e
modificá-lo para mostrar uma sauda¸cão para todos ao invés do
mundo:
int main (void)
{
hello (“everyone“); // mudado de “world”
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
O arquivo atualizado ‘main.c’pode agora ser recompilado com o
seguinte comando:
“$ gcc -Wall -c main.c”
Isso produzirá um novo arquivo objeto ‘main.o’. Não há
necessidade de criar um novo arquivo objeto para ‘hello fn.c’, já
que seu arquivo e dependentes, tais como arquivos cabe¸calhos, não
sofreram altera¸cões.

GCC – C/C++
Compilar!
Vincular!
E mais!
O novo arquivo objeto pode ser revinculado com a fun¸cão hello
para criar um novo executável:
“$ gcc main.o hello fn.o -o hello”
O executável resultante ‘hello’agora usa a nova fun¸cão main para
produzir a seguinte sa´ıda:
“$ ./hello”
“Hello, everyone!”
Note que somente o arquivo ‘main.c’foi recompilado e então
revinculado com os arquivos objetos existentes para a fun¸cão hello.

GCC – C/C++
Compilar!
Vincular!
E mais!
Uma biblioteca é uma cole¸cão de arquivos objetos precompilados
que podem ser vinculados em programas.
O uso mais comum de bibliotecas é para prover fun¸cões do
sistemas, tal como a fun¸cão de raiz quadrada sqrt encontrada na
na biblioteca do C “math”.
Bibliotecas são tipicamente arqmazenadas em arquivos especiais
com a extensão ‘.a’, referenciadas como bibliotecas estáticas. Elas
são criadas arquivos objetos com ferramentas separadas do gcc,
como o GNU archiver ar, e usado pelo vinculador para resolver
referências a fun¸cões no tempo de compila¸cão.

GCC – C/C++
Compilar!
Vincular!
E mais!
As bibliotecas padrões do sistema são normalmente encontradas
nos diretórios ‘/usr/lib’e ‘/lib’. Por exemplo, a biblioteca math é
normalmente armazenada no arquivo ‘/usr/lib/libm.a’em sistemas
baseados no Unix.
O protótipo das correspondentes declara¸cões para as fun¸cões nessa
biblioteca pode ser encontrado no arquivo de cabe¸calho
‘/usr/include/math.h’. A biblioteca padrão do próprio C é
arqmazenada em ‘/usr/lib/libc.a’e contém fun¸cões especificadas
no padrão ANSI/ISO C, tais como ‘printf’– essa biblioteca é
vinculada por padrão para todos os programas em C.

GCC – C/C++
Compilar!
Vincular!
E mais!
Exemplo de programa que chama uma fun¸c˜ao externa sqrt na
biblioteca math ‘libm.a’:
# include <<math.h>>
int main (void) {
double x = sqrt (2.0);
printf (“The square root of 2.0 is %f n , x);
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
Ao tentar criar um executável de código fonte sozinho o compilado
dá como sa´ıda um erro no estágio de vincula¸cão:
“$ gcc -Wall calc.c -o calc”
“/tmp/ccbR6Ojm.o: In function ‘main’:”
“/tmp/ccbR6Ojm.o(.text + 0x19): undefined reference to
‘sqrt’”

GCC – C/C++
Compilar!
Vincular!
E mais!
O problema é que a referência para a fun¸cão sqrt não pode ser
resolvida sem a biblioteca externa math ‘libm.a’. A fun¸cão sqrt
não é definida no programa ou na biblioteca padrão ‘libc.a’, e o
compilador não vincula o arquivo ‘libm.a’ao menos que seja
explicitamente selecionado. A propósito, o arquivo mencionado na
mensagem de erro ‘/tmp/ccbR60jm.o’é um arquivo objeto
temporário criado pelo compilador a partir do ‘calc.c’, a fim de
tentar realizar o processo de vincula¸cão.

GCC – C/C++
Compilar!
Vincular!
E mais!
Para habilitar o compilador vincular a fun¸cão sqrt ao programa
main em ‘calc.c’nós precisamos fornecer a biblioteca ‘libm.a’. Uma
forma óbvia de realizar isso é especificar explicitamente na linha de
comando:
“$ gcc -Wall calc.c /usr/lib/libm.a -o calc”
A biblioteca ‘libm.a’contém os arquivos objetos para todas a
fun¸cões matemáticas, tais como sin, cos, exp, log e sqrt. O
vinculador procura por esse para achar o arquivo objeto contendo a
fun¸cão sqrt.

GCC – C/C++
Compilar!
Vincular!
E mais!
Uma vez que o arquivo objeto para a fun¸cão sqrt é encontrado, o
programa main pode ser vinculado e produzir o executável
completo:
“$ ./calc”
“The square root of 2.0 is 1.414214”
O arquivo executável inclue o código de máquina para a fun¸cão
main e o código de máquina para a fun¸cão sqrt, copiado do
correspondente arquivo objeto na biblioteca ‘libm.a’.

GCC – C/C++
Compilar!
Vincular!
E mais!
Para evitar ter que especificar longos caminhos na linha de
comando, o compilador disponibilizar uma op¸cão de atalho ‘-l’para
vincular bibliotecas. Por exemplo o seguinte comando,
“$ gcc -Wall calc.c -lm -o calc”
é equivalente ao original comando anterior usando o nome
completo da biblioteca ‘/usr/lib/libm.a’.
Em geral, o parâmetro ‘-lNAME ‘anexará arquivos objetos com o
arquivo da biblioteca ‘libNAME.a’nos diretórios padr˜ees.
Adicionalmente diretórios podem ser especificados com parâmetros
na linha de comando ou variáveis de ambiente.

GCC – C/C++
Compilar!
Vincular!
E mais!
A ordem das bibliotecas na linha de comando segue a mesma
conve¸cão dos arquivos objetos: eles são buscado da esquerda para
a direita – uma biblioteca contendo a defini¸cão de uma fun¸cão
deveria aparecer depois de qualquer arquivo fonte ou arquivos
objetos que a usem. Isso inclue biblioteca especificadas com o
parâmetro de atalho‘-l’, como vemos no comando a seguir:
“$ gcc -Wall calc.c -lm -o calc (correto)”

GCC – C/C++
Compilar!
Vincular!
E mais!
Ao tentar compilar, colocando ‘-lm’antes do arquivo que a usa,
resultará no erro:
“$ cc -Wall -lm calc.c -o calc (incorreto)”
“main.o: In function ‘main’:”
“main.o(.text + 0xf ): undefined reference to ‘sqrt’because
there is no library or object file containing sqrt after ‘calc.c’.”

GCC – C/C++
Compilar!
Vincular!
E mais!
Quando diversas bibliotecas são usadas, a mesma conve¸cão deveria
ser seguida pelas próprias. Uma biblioteca que chama uma fun¸cão
externa definada em outra biblioteca apareceria antes da biblioteca
contendo a fun¸cão.
Por exemplo, um programa ‘data.c’usando a biblioteca GNU Linear
Programming ‘libglpk.a’, que por sua vez usa a biblioteca math
‘libm.a’, deveria ser compilado como,
“$ gcc -Wall data.c -lglpk -lm”
já que os arquivos objetos em ‘libglpk.a’usam fun¸c˜ees definada em
‘libm.a’.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Ao usar uma biblioteca é essencial incluir arquivo cabe¸calhos
apropriados, em ordem ao declarar os argumentos de fun¸c˜ees e os
valores de retorno com os tipos corretos. Sem declara¸c˜ees, os
argumentos de uma fun¸cão podem ser passado com tipo errado,
causando resultados adulterados.
O próximo exemplo mostrar outro programa que faz uma fun¸cão
chamar a biblioteca math do C.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Nesse caso, a fun¸cão pow é usada para calcular o cubo de 2.
int main (void) {
double x = pow (2.0, 3.0);
printf (“Twocubedis%f n , x);
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Entretanto, o programa contém um erro – o comando # include
para ‘math.h’está faltando, então o protótipo double pow
(doublex, doubley) dado não será encontrado pelo compilador.
Compilando o programa sem qualquer parâmetros para avisos
produzirá um arquivo executável que gerará resultados incorretos:
“$ gcc badpow.c -lm”
“$ ./a.out (resultado incorreto, deveria ser 8)”
“Two cubed is 2.851120”
Os resultados são adulterados porque os argumentos e o valor de
retorno da chamada pow são passados com tipos incorretos.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
O que poderia ser detectado acionando o parâmetro ‘-Wall’:
“$ gcc -Wall badpow.c -lm”
“badpow.c: In function ‘main’:”
“badpow.c:6: warning: implicit declaration of function
‘pow’(naoencontrouprototipodepow)
Prova de que o uso do parâmetro de aviso ‘-Wall’detecta diversos
problemas que poderiam ser ignorados.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Essas parâmetros controlam funcionalidades tais como busca de
caminhos usados para localiza¸cão de bibliotecas e arquivos
inclu´ıdos, o uso adicional de avisos e diagnósticos, prepocessador
de macros e dialetos do C.
Um problema comum quando compilando um programa que usa
arquivos cabe¸calhos para bibliotecas é o erro:
FILE.h : No such file or directory (arquivo nao encontrado)
Isso ocorre se um arquivo de cabe¸calho não está presente nos
diretórios de arquivos padr˜ees usados pelo gcc.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Um problema similar pode ocorre para bibliotecas:
/usr/bin/ld: cannot find library (biblioteca nao encontrada)
Isso acontece se a biblioteca usada para vincula¸cão não está
presente nos diretórios padr˜ees usados pelo gcc.
Por padrão, o gcc busca por arquivos de cabe¸calhos nos seguintes
diretórios:
/usr/local/include/
/usr/include/
e os nos seguintes diretórios para bibliotecas:
/usr/local/lib/
/usr/lib/

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
A lista de de diretórios para cabe¸calhos é frequentemente
referenciada para caminho para inclusão, e a lista de diretórios
para bibliotecas como diretório de busca ou caminho de v´ınculo.
Os diretótios nesses caminhos são buscados em ordem, do primeiro
ao último nas duas listas acima. Por exemplo, um arquivo de
cabe¸calho encontrado em ‘/usr/local/include’tem precedência em
rela¸cão ao um arquivo com mesmo nome em ‘/usr/include’.
Similarmente, uma biblioteca encontrada em ‘/usr/local/lib’ tem
precedência em rela¸cão a outra com mesmo nome em ‘/usr/lib’.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Os caminhos padr˜ees de busca podem também incluir adicionais
dependendo do sistema ou local espec´ıfico dos diretórios, e os
diretórios na instala¸cão do GCC mesmo.
Por exemplo, em plataformas 64-bit ‘lib64’diretórios adicionais
podem ser buscado por padrão.
Quando bibliotecas adicinais são instaladas em outros diretórios é
necessário extender os caminhos de busca, de forma que as
bibliotecas sejam achadas.
Os parâmetros do compilador ‘-I’e ‘-L’adicionam novos diretórios
ao in´ıcio do caminho de inclusão e busca de bibliotecas
respectivamente.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referˆencias
O programa ‘dbmain.c’, que cria um arquivo DBM contendo uma
chave ‘testkey’com o valor ‘testvalue’:
# include <<gdbm.h>>
int main (void) {
GDBM FILE dbf;
datum key = “testkey ”, 7 ; //key, length
datum value = “testvalue ”, 9 ; //value, length
printf (“Storingkey − valuepair...“);
dbf = gdbm open (“test , 0, GDBM NEWDB, 0644, 0);
gdbm store (dbf , key, value, GDBM INSERT);
gdbm close (dbf );
printf (“done.n );
return 0; }

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
O programa usa um arquivo de cabe¸calho ‘gdbm.h’e uma biblioteca
‘libgdbm.a’. Se a biblioteca foi instalada na localiza¸cão padrão de
‘/usr/local/lib’, com o arquivo cabe¸calho em ‘/usr/local/include’,
então o programa pode ser compilado com o seguinte comando:
“$ gcc -Wall dbmain.c -lgdbm”
Ambos diretórios são parte dos caminhos de v´ınculos e inclusão
padr˜ees.
Entretanto, se GDBM foi instalado em uma localiza¸cão diferente,
tentar compilar o programa irá dar o seguinte erro:
“$ gcc -Wall dbmain.c -lgdbm”
“dbmain.c:1: gdbm.h: No such file or directory”

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Por exemplo, se a versão 1.8.3 do pacote GDBM está instalado no
diretório ‘/opt/gdbm-1.8.3’a localiza¸cão do cabe¸calho poderia ser,
/opt/gdbm-1.8.3/include/gdbm.h que não é parte dos caminhos
de inclusão padr˜ees. Adicionando os diretório aproprioado ao
caminho de inclusão com o comando ‘-I’permite que o programa
seja compilado, mas não vinculado:
“$ gcc -Wall -I/opt/gdbm-1.8.3/include dbmain.c -lgdbm”
“/usr/bin/ld: cannot find -lgdbm”
“collect2: ld returned 1 exit status”
O diretório contendo a biblioteca ainda está faltando no caminho
de v´ınculo. Ele pode ser adicionado usando o seguinte parâmetros:
“-L/opt/gdbm-1.8.3/lib/”

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
A seguinte linha de comando permite que o programa seja
compilado e vinculado:
“$ gcc -Wall -I/opt/gdbm-1.8.3/include
-L/opt/gdbm-1.8.3/lib dbmain.c -lgdbm”
Isso produz o executável final vinculado a biblioteca GCBM.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Por padrão, o gcc compila programas usando o dialeto GNU da
linguagem C, referenciado como GNU C. Esse dialeto incorpora o
padrão oficial ANSI/ ISO para a linguagem C com diversas
extens˜ees utéis do GNU, tais como fun¸c˜ees aninhadas e vetores de
tamanho dinâmico. A maioria dos programas ANSI/ ISO
compilarão sob o GNU C sem problemas.
Existem diversos parâmetros que controlam o dialeto do C usado
pelo gcc.
Os mais comumente usados são ‘-ansi’e ‘-pedantic’.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
O especif´ıcio dialeto para a linguagem C para cada padrão pode
também ser selecionado com o parâmetro ‘-std’.
Ocasionalmente um programa ANSI/ ISO válido pode ser
incompat´ıvel com as extens˜ees GNU C. Para lidar com essa
situa¸cão, o parâmetros do compilador ‘-ansi’desabilita aquelas
extens˜ees GNU que tiverem conflito com o padrão ANSI/ ISO. Em
sistemas usando a biblioteca GNU C (glibc) pode-se também
desabilitar a biblioteca padrão do C. Isso permite que os programas
sejam escritos em ANSI/ ISO C sejam compilados sem efeitos
indesejáveis das extens˜ees do GNU.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referˆencias
Por exemplo, o programa ANSI/ ISO C que usa uma vari´avel
chamada asm:
int main (void) {
const char asm[]= “6502 ”;
printf (“thestringasmis‘%s n , asm);
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
A variávels asm é válida sob o padrão ANSI/ ISO, mas esse
programa não será compilado no GNU C porque asm é um palavra
chave para a extensão GNU C, o que permite usar instru¸c˜ees
assembly em fun¸c˜ees C. Consequentemente, não poderá ser usada
como nome de variável sem um erro de compila¸cão:
“$ gcc -Wall ansi.c”
“ansi.c: In function ‘main’:”
“ansi.c:6: parse error before ‘asm’”
“ansi.c:7: parse error before ‘asm’”

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Em contraste, usando o parâmetro ‘-ansi’disabilita a palavra-chave
asm, e permite que o programa acima seja compilado
corretamente:
“$ gcc -Wall -ansi ansi.c”
“$ ./a.out”
“the string asm is ‘6502’”
Outras palavras-chaves não padr˜ees e macros definidaas pelas
extens˜ees do GNU C são asm, inline, typeof, unix e vax.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
O próximo exemplo mostra o efeito do parâmetro ‘-ansi’em
sistemas usando a biblioteca GNU C, tais como sistemas
GNU/Linux. O programa abaixo imprime o valor de pi, =
3.14159..., da defini¸cão do prepocessador M PI no arquivo de
cabe¸calhos ‘math.h’:
# include <<math.h>>
int main (void) {
printf(“thevalueofpiis%f n , M PI);
return 0;
}

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
A constante M PI não é parte da biblioteca padrão ANSI/ ISO C.
Nesse caso, o programa não complicará com o parâmetro ‘-ansi’:
“$ gcc -Wall -ansi pi.c”
“pi.c: In function ‘main’:”
“pi.c:7: ‘M PI’undeclared (first use in this function)”
“pi.c:7: (Each undeclared identifier is reported only once )”
“pi.c:7: for each function it appears in.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
O programa pode ser compilado sem parâmetro ‘-ansi’. Nesse caso
ambas extens˜ees de linguagem e biblioteca são habilitadas por
padrão:
“$ gcc -Wall pi.c”
“$ ./a.out”
“the value of pi is 3.141593”
Também é poss´ıvel compilar o programa usando o ANSI/ ISO C,
habilitando somente as extens˜ees da própria biblioteca GNU C.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
Isso pode ser alcan¸cado pela especifi¸cão de macros especiais, tais
como GNU SOURCE, que habilita extens˜ees da biblioteca GNU C:
“$ gcc -Wall -ansi -D GNU SOURCE pi.c”
“$ ./a.out”
“the value of pi is 3.141593”

GCC – C/C++
Compilar!
Vincular!
E mais!
Referências
A biblioteca GNU C provê diversas dessas macros que permite
controlar o suporte para extens˜ees POSIX ( POSIX C SOURCE),
BSD ( BSD SOURCE), SVID ( SVID SOURCE), XOPEN
( XOPEN SOURCE) e GNU ( GNU SOURCE).
O parâmetro ‘-D’é usado para a defini¸cão de macros.
A macro GNU SOURCE habilita todas extens˜ees, com as
extens˜ees POSIX tendo precedência sobre as outras em casos em
que hajam conflitos.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referˆencias
Referˆencias
Traduzido e adaptado de “An Introduction to GCC: for the
GNU Compilers gcc and g++” - Brian Gough, Foreword by
Richard M. Stallman, 2004, Network Theory Limited, GNU
Free Documentation License, Version 1.2.

GCC – C/C++
Compilar!
Vincular!
E mais!
Referˆencias
2aparte
You will see in www.pinguim.pro.br

GCC - Compilar, Vincular e Mais com C/C

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (15)

Semelhante a GCC - Compilar, Vincular e Mais com C/C

Semelhante a GCC - Compilar, Vincular e Mais com C/C (20)

Mais de John Godoi

Mais de John Godoi (15)

GCC - Compilar, Vincular e Mais com C/C