Rustc-1.76.0

Introdução ao Rust

A linguagem de programação Rust foi projetada para ser uma linguagem segura, simultânea e prática.

Esse pacote é atualizado em um ciclo de lançamento de seis semanas. Por ser um pacote tão grande e lento de construir, no momento exigido somente por uns poucos pacotes neste livro, e particularmente porque as versões mais recentes tendem a quebrar pacotes Mozilla mais antigos, os(as) editores(as) do BLFS consideram que ele somente deveria ser atualizado quando isso for necessário (seja para corrigir problemas ou para permitir a construção de uma nova versão de um pacote).

Tal como acontece com muitas outras linguagens de programação, o "Rustc" (o compilador "Rust") precisa de um binário a partir do qual inicializar. Ele baixará um binário stage0 no início da construção, de forma que você não consegue compilá-lo sem uma conexão com a Internet.

[Nota]

Nota

Embora o BLFS normalmente instale em "/usr", quando você atualizar posteriormente para uma versão mais recente do "rust", as bibliotecas antigas em "/usr/lib/rustlib" permanecerão, com vários "hashes" nos nomes delas, mas não serão usáveis e desperdiçarão espaço. Os(As) editores(as) recomendam colocar os arquivos no diretório "/opt". Em particular, se você tiver motivos para reconstruir com uma configuração modificada (por exemplo, usando o "LLVM" enviado após construir com "LLVM" compartilhado, talvez para compilar caixas para arquiteturas que a construção "LLVM" do BLFS não suporta), [então] é possível que a instalação deixe um aplicativo quebrado "cargo". Em tal situação, remova a instalação existente primeiro ou use um prefixo diferente, como "/opt/rustc-1.76.0-build2".

Se preferir, você pode, certamente, mudar o prefixo para "/usr".

O atual sistema de construção rustbuild usará todos os processadores, embora não escale bem e frequentemente retorne a usar apenas um núcleo enquanto espera que uma biblioteca compile. No entanto, ele pode ser limitado, principalmente a um número especificado de processadores, por uma combinação de adicionar a chave --jobs <N> (por exemplo, '--jobs 4' para limitar a quatro processadores) em cada invocação de python3 x.py e usar uma variável de ambiente CARGO_BUILD_JOBS=<N>. No momento, isso não é eficaz quando alguns dos testes rustc são executados.

A versão atual da caixa num_cpus do Rust agora reconhece que cgroups pode ser usado para restringir quais processadores ele está autorizado a usar. Portanto, se tua máquina carecer de DRAM (normalmente, menos de 2 GB de DRAM por núcleo), isso pode ser uma alternativa para colocar as CPUs offline. Leia-se “Use o Grupo de Controle do Linux para Limitar o Uso de Recursos” para como usar um cgroup.

No momento, "Rust" não oferece nenhuma garantia de uma "ABI" estável.

[Nota]

Nota

O padrão do "Rustc" é o de construir para TODAS as arquiteturas suportadas, usando uma cópia enviada do "LLVM". No BLFS a construção é somente para a arquitetura "X86". Se você pretende desenvolver caixas "Rust", [então] essa construção possivelmente não seja boa o suficiente para os teus propósitos.

Os tempos de construção dessa versão, quando repetidos na mesma máquina, costumam ser razoavelmente consistentes, mas como acontece com todas as compilações usando "rustc", pode existir alguns valores discrepantes muito lentos.

Esse pacote é conhecido por construir e funcionar corretamente usando uma plataforma LFS 12.1.

Informação do Pacote

  • Transferência (HTTP): https://static.rust-lang.org/dist/rustc-1.76.0-src.tar.xz

  • Transferência (FTP):

  • Soma de verificação MD5 da transferência: 14a8ac688b461a3127090cad513aee05

  • Tamanho da transferência: 155 MB

  • Espaço em disco estimado exigido: 8,9 GB (298 MB instalado); adicionar 6,4 GB se executar os testes

  • Tempo de construção estimado: 6,7 UPC (incluindo o tempo de transferência; adicionar 6,2 UPC para os testes, ambos usando paralelismo=8)

Transferências Adicionais

Dependências do Rust

Exigidas

CMake-3.28.3 e cURL-8.6.0

[Nota]

Nota

Uma conexão com a Internet é necessária para construir esse pacote.

Recomendadas

[Nota]

Nota

Se uma dependência recomendada não estiver instalada, [então] uma cópia enviada no "tarball" do fonte do "Rustc" será construída e usada.

Opcionais

GDB-14.1 (usado pela suíte de teste se estiver presente), git-2.44.0 (exigido pela suíte de teste), cranelift, jemalloc, libgccjit (leia-se Explicação do Comando em GCC-13.2.0) e libgit2

Observações de Editor(a): https://wiki.linuxfromscratch.org/blfs/wiki/rust

Instalação do Rust

[Nota]

Nota

Atualmente o compilador Rust produz instruções SSE2 para x86 de 32 bits, fazendo com que o código gerado seja quebrado em sistemas de 32 bits sem um processador compatível com SSE2. Todos os modelos de processador x86 lançados após 2004 deveriam ser compatíveis com SSE2. Execute lscpu | grep sse2 como teste. Se gerar alguma coisa, tua CPU é compatível com SSE2 e está OK. Caso contrário, você pode tentar construir esse pacote em um sistema compatível com SSE2 com a seguinte correção aplicada:

sed 's@pentium4@pentiumpro@' -i \
   compiler/rustc_target/src/spec/i686_unknown_linux_gnu.rs

E copie o "/opt/rustc-1.76.0" resultante para o sistema sem capacidade "SSE2". Mas, essa mudança ainda está sob revisão do(a) desenvolvedor(a) e não foi testada pelos(as) editores(as) do BLFS.

Para instalar no diretório "/opt", remova qualquer link simbólico "/opt/rustc" existente e crie um novo diretório (ou seja, com um nome diferente se tentar uma construção modificada da mesma versão). Como o(a) usuário(a) "root":

mkdir -pv /opt/rustc-1.76.0     &&
ln -svfn rustc-1.76.0 /opt/rustc
[Nota]

Nota

Se múltiplas versões do "Rust" estiverem instaladas em "/opt", [então] a mudança para outra versão exige somente mudar o link simbólico "/opt/rustc" e então executar "ldconfig".

Se executar a suíte de teste, aplique um remendo para evitar que o sistema de construção reconstrua desnecessariamente o compilador:

patch -Np1 -i ../rustc-1.76.0-testsuite_fix-1.patch

Crie um arquivo "config.toml" adequado que configurará a construção.

cat << EOF > config.toml
# veja-se config.toml.example para mais possíveis opções
# Veja-se o livro 8.4 para um antigo exemplo usando LLVM enviada
# por exemplo, se não instalar clang ou usar uma versão anterior a 13.0

# Informe ao x.py que os editores revisaram o conteúdo deste arquivo
# e o atualizaram para acompanhar as principais mudanças do sistema de
# construção, de forma que x.py não nos avisará para fazer tal revisão.
change-id = 118703

[llvm]
# por padrão, Rust construirá para uma miríade de arquiteturas
targets = "X86"

# Ao usar o llvm do sistema, prefira bibliotecas compartilhadas
link-shared = true

[build]
# omita documentos para economizar tempo e espaço (o padrão é construí-los)
docs = false

# instalar ferramentas extendidas: cargo, clippy, etc
extended = true

# Não consulte novas versões de dependências online.
locked-deps = true

# Especifique quais ferramentas extendidas (aquelas provenientes da instalação padrão).
tools = ["cargo", "clippy", "rustdoc", "rustfmt"]

# Use o código-fonte enviado no tarball para as dependências.
# A combinação disso e da entrada "locked-deps" evita o download de muitas
# caixas a partir da Internet e torna a construção do Rustc mais estável.
vendor = true

[install]
prefix = "/opt/rustc-1.76.0"
docdir = "share/doc/rustc-1.76.0"

[rust]
channel = "stable"
description = "para BLFS 12.1"

# O BLFS costumava não instalar o executável FileCheck oriundo do llvm, então
# desabilitou os testes de codegen. Os testes de montagem dependem do FileCheck
# e não podem ser facilmente desabilitados; portanto, eles falharão de qualquer
# maneira se o FileCheck não tiver sido instalado.
#codegen-tests = false

# Habilite as mesmas otimizações da construção de fluxo de desenvolvimento oficial.
lto = "thin"
codegen-units = 1

[target.x86_64-unknown-linux-gnu]
# Observe Bem: a saída gerada de llvm-config (ou seja, opções de ajuda) pode ser
# despejada na tela quando config.toml for analisado.
llvm-config = "/usr/bin/llvm-config"

[target.i686-unknown-linux-gnu]
# Observe Bem: a saída gerada de llvm-config (ou seja, opções de ajuda) pode ser
# despejada na tela quando config.toml for analisado.
llvm-config = "/usr/bin/llvm-config"
EOF
[Nota]

Nota

Os comandos python3 x.py podem gerar uma mensagem de aviso reclamando nenhuma configuração de codegen-backends correspondeu ao caminho solicitado para construir uma estrutura de retaguarda de codegen. E a sugestão fornecida (adicionar estrutura de retaguarda a codegen-backends em config.toml) não irá silenciá-la. Esse aviso é falso e deveria ser ignorado.

Compile "Rust" executando os seguintes comandos:

{ [ ! -e /usr/include/libssh2.h ] ||
  export LIBSSH2_SYS_USE_PKG_CONFIG=1; } &&
python3 x.py build
[Nota]

Nota

A suíte de teste gerará algumas mensagens no diário do systemd para interceptações em códigos inválidos de operação e para falhas de segmentação. Por si só, isso não é motivo de preocupação, apenas uma maneira do teste ser terminado.

Para executar os testes (novamente usando todas as "CPUs" disponíveis), emita:

SSL_CERT_DIR=/etc/ssl/certs \
python3 x.py test --verbose --no-fail-fast | tee rustc-testlog

Dois testes,tests/ui/issues/issue-21763.rs e tests/debuginfo/regression-bad-location-list-67992.rs, são conhecidos por falharem.

Se o "FileCheck" originário do "LLVM" não tiver sido instalado, [então] todos os quarenta e sete (47) testes da suíte assembly falharão.

Tal como acontece com todas as grandes suítes de teste, outros testes podem falhar em algumas máquinas - se o número de falhas adicionais for baixo, verifique se existem 'failures:' no registro e revise as linhas acima, especialmente as linhas 'stderr:'. Qualquer menção ao SIGSEGV ou ao sinal onze (11) em um teste falho é motivo de preocupação.

Se você receber algum outro teste falho que informe um número de problema, então você deveria procurar por esse problema. Por exemplo, quando "Rustc" >= 1.41.1 era construído com uma versão do "LLVM" do sistema anterior à 10.0, o teste para o problema "69225" falhava https://github.com/rust-lang/rust/issues/69225 e isso deveria ser considerado como uma falha crítica (eles(as) lançaram 1.41.1 por causa disso). A maioria das outras falhas não será crítica.

Portanto, você deveria determinar o número de falhas.

O número de testes que passaram e falharam pode ser encontrado executando:

grep '^test result:' rustc-testlog |
 awk '{sum1 += $4; sum2 += $6} END { print sum1 " passed; " sum2 " failed" }'

Os outros campos disponíveis são "$8" para aqueles que foram ignorados (ou seja, pulados), "$10" para 'medido' e "$12" para 'filtrado', mas ambos os dois últimos provavelmente sejam zero.

Agora, como o(a) usuário(a) "root", instale o pacote:

[Nota]

Nota

Se sudo ou su for invocado para comutar para o(a) usuário(a) root, garanta que LIBSSH2_SYS_USE_PKG_CONFIG seja passada corretamente ou o comando seguinte possivelmente reconstrua completamente esse pacote. Para sudo, use a opção --preserve-env=LIBSSH2_SYS_USE_PKG_CONFIG. Para su, não use as opções - ou --login.

python3 x.py install

O sistema de construção tenta instalar alguns arquivos duas vezes e, durante a segunda tentativa, renomeia o antigo (instalado na primeira tentativa) com o sufixo .old. Como o(a) usuário(a) root, remova esses arquivos:

find /opt/rustc-1.76.0 -name "*.old" -delete

Ainda como o(a) usuário(a) root, crie um link simbólico de um arquivo de completação do Zsh para o local correto:

install -vdm755 /usr/share/zsh/site-functions      &&
ln -sfv /opt/rustc/share/zsh/site-functions/_cargo \
        /usr/share/zsh/site-functions

Finalmente, desconfigure a variável LIBSSH2_SYS_USE_PKG_CONFIG:

unset LIBSSH2_SYS_USE_PKG_CONFIG

Explicações do Comando

ln -svfn rustc-1.76.0 /opt/rustc: se esse não for o primeiro uso do link simbólico /opt/rustc, [então] sobrescreva-o forçando e use o sinalizador '-n' para evitar resultados confusos oriundos, por exemplo, de ls -l.

targets = "X86": isso evita construir todos os compiladores cruzados disponíveis do Linux (AArch64, MIPS, PowerPC, SystemZ, etc). Infelizmente, o Rust insiste em instalar os arquivos fonte para esses abaixo de /opt/rustc/lib/src.

extended = true: isso instala várias ferramentas (especificadas pela entrada tools) juntamente com o rustc.

tools = ["cargo", "clippy", "rustdoc", "rustfmt"]: construa somente as ferramentas a partir do perfil 'padrão' no comando binário rustup que é recomendado para a maioria dos(as) usuários(as). As outras ferramentas são improváveis que sejam úteis, a menos que se use analisadores (antigos) de código ou se edite a biblioteca padrão.

channel = "stable": isso garante que somente recursos estáveis possam ser usados. O padrão no config.toml é o de usar recursos de desenvolvimento, o que não é apropriado para uma versão lançada.

[target.x86_64-unknown-linux-gnu]: a sintaxe do config.toml exige uma entrada llvm-config para cada alvo para o qual o LLVM do sistema esteja para ser usado. Mude o alvo para [target.i686-unknown-linux-gnu] se você estiver construindo em x86 de 32 bits. Essa seção inteira pode ser omitida se você desejar construir contra o LLVM enviado ou não tiver clang, mas a construção resultante será maior e demorará mais.

export LIBSSH2_SYS_USE_PKG_CONFIG=1: Permite que o "cargo" se vincule à "libssh2" do sistema.

SSL_CERT_DIR=/etc/ssl/certs: Contorne um problema que causa falhas de teste com o esquema de armazenamento de certificados de AC usado pelo make-ca-1.13.

--verbose: essa chave às vezes pode fornecer mais informações relativas a um teste que falhe.

--no-fail-fast: essa chave garante que a suíte de teste não parará no primeiro erro.

Configurando o Rust

Informação de Configuração

Se você instalou "rustc" em "/opt", [então] você precisa atualizar os seguintes arquivos de configuração, de forma que "rustc" seja encontrado corretamente por outros pacotes e processos do sistema.

Como o(a) usuário(a) "root", crie o arquivo "/etc/profile.d/rustc.sh":

cat > /etc/profile.d/rustc.sh << "EOF"
# Inicia /etc/profile.d/rustc.sh

pathprepend /opt/rustc/bin           PATH

# Inclui "/opt/rustc/man" na variável "MANPATH" para acessar páginas de manual
pathappend  /opt/rustc/share/man     MANPATH

# Termina /etc/profile.d/rustc.sh
EOF

Imediatamente depois da instalação, atualize o "PATH" atual para o seu "shell" atual como um(a) usuário(a) normal:

source /etc/profile.d/rustc.sh

Conteúdo

Aplicativos Instalados: cargo-clippy, cargo-fmt, cargo, clippy-driver, rust-gdb, rust-gdbgui, rust-lldb, rustc, rustdoc e rustfmt
Bibliotecas Instaladas: librustc-driver-<resumo_de_16_bytes>.so, libstd-<resumo_de_16_bytes>.so e libtest-<resumo_de_16_bytes>.so
Diretórios Instalados: ~/.cargo, /opt/rustc, link simbólico para /opt/rustc-1.76.0

Descrições Curtas

cargo-clippy

fornece verificações "lint" para um pacote "cargo"

cargo-fmt

formata todos os arquivos "bin" e "lib" da caixa atual usando "Rustfmt"

cargo

é o Gerenciador de Pacote para "Rust"

clippy-driver

fornece verificações "lint" para "Rust"

rust-gdb

é um "script" envólucro para "gdb", extraindo módulos de impressão bonita do "Python" instalados em "/opt/rustc-1.76.0/lib/rustlib/etc"

rust-gdbgui

é um "script" envólucro para uma estrutura gráfica de interação direta com o(a) usuário(a) para "gdb" que executa em um navegador

rust-lldb

é um "script" envólucro para "LLDB" (o depurador "LLVM") que extrai os módulos de impressão bonita do "Python"

rustc

é o compilador "rust"

rustdoc

gera documentação a partir do código fonte "rust"

rustfmt

formata código "rust"

libstd-<resumo_de_16_bytes>.so

é a biblioteca padrão do "Rust", a fundação do logiciário portável "Rust"