Este é o compilador cruzado RISC-V C e C ++. Ele suporta dois modos de construção: uma cadeia de ferramentas ELF/newlib genérico e uma cadeia de ferramentas Linux-Helf-ELF/GLIBC mais sofisticada.
Esse repositório usa submódulos, mas os submódulos buscarão automaticamente a demanda, então -Atualização --recursive ou git submodule update --init --recursive não é necessária.
$ git clone https://github.com/riscv/riscv-gnu-toolchain
Aviso: o clone Git leva cerca de 6,65 GB de disco e tamanho de download
Vários pacotes padrão são necessários para construir a cadeia de ferramentas.
No Ubuntu, executar o seguinte comando deve ser suficiente:
$ sudo apt-get install autoconf automake autotools-dev curl python3 python3-pip libmpc-dev libmpfr-dev libgmp-dev gawk build-essential bison flex texinfo gperf libtool patchutils bc zlib1g-dev libexpat-dev ninja-build git cmake libglib2.0-dev libslirp-dev
No Fedora/CentOS/RHEL OS, a execução do comando a seguir deve ser suficiente:
$ sudo yum install autoconf automake python3 libmpc-devel mpfr-devel gmp-devel gawk bison flex texinfo patchutils gcc gcc-c++ zlib-devel expat-devel libslirp-devel
No Arch Linux, a execução do comando a seguir deve ser suficiente:
$ sudo pacman -Syyu autoconf automake curl python3 libmpc mpfr gmp gawk base-devel bison flex texinfo gperf libtool patchutils bc zlib expat libslirp
Também disponível para usuários de arco na AUR: https://aur.archlinex.org/packages/riscv-gnu-toolchain-bin
No MacOS, você pode usar o Homebrew para instalar as dependências:
$ brew install python3 gawk gnu-sed make gmp mpfr libmpc isl zlib expat texinfo flock libslirp
Ao executar as instruções neste ReadMe, use gmake em vez de make para usar a versão recém -instalada do Make. Para construir o GLIBC (Linux) no macOS, você precisará construir dentro de um sistema de arquivos sensível ao caso. A abordagem mais simples é criar e montar uma nova imagem de disco com um formato sensível ao caso. Certifique -se de que o ponto de montagem não contenha espaços. Isso não é necessário para construir o Newlib ou o GCC no MacOS.
Esse processo começará baixando cerca de 200 MIB de fontes upstream e, em seguida, corrigirá, criará e instalará a cadeia de ferramentas. Se existir um cache local das fontes a montante em $ (distdir), ele será usado; O local padrão é/var/cache/distfiles. Seu computador precisará de cerca de 8 GIB de espaço em disco para concluir o processo.
Para construir o compilador cruzado Newlib, escolha um caminho de instalação (que é escritor). Se você escolher, digamos, /opt/riscv , adicione /opt/riscv/bin ao seu PATH . Em seguida, basta executar o seguinte comando:
./configure --prefix=/opt/riscv
make
Agora você deve poder usar o RISCV64-UNKNOWN-HELS-GCC e seus primos.
Nota: Se você planeja usar uma biblioteca externa que substitua parte do newlib (por exemplo, libgloss-htif ), leia as perguntas frequentes.
Para construir o compilador cruzado do Linux, escolha um caminho de instalação (que é escrito). Se você escolher, digamos, /opt/riscv , adicione /opt/riscv/bin ao seu PATH . Em seguida, basta executar o seguinte comando:
./configure --prefix=/opt/riscv
make linux
A construção padrão é direcionada a RV64GC (64 bits) com o GLIBC, mesmo em um ambiente de construção de 32 bits. Para construir a cadeia de ferramentas RV32GC de 32 bits, use:
./configure --prefix=/opt/riscv --with-arch=rv32gc --with-abi=ilp32d
make linux
Caso você prefira Musl Libc a Glibc, configure como acima e opte por make musl em vez de make linux .
As arquiteturas suportadas são extensões padrão RV32I ou RV64I PLUS (a) Tomics, (M) Ultiplicação e Divisão, (f) Loat, (d) OBLE ou (G) Eneral para MAFD.
Os ABIS suportados são ILP32 (flutuação suave de 32 bits), Ilp32d (hard-float de 32 bits), Ilp32f (32 bits com precisão única em registros e duplo na memória, apenas uso de nicho), LP64 LP64F LP64D (mesmo com 64 bits de comprimento e ponteiros).
Para construir o compilador cruzado com suporte para 32 e 64 bits, execute o seguinte comando:
./configure --prefix=/opt/riscv --enable-multilib
E então make , make linux ou make musl para o Newlib, Linux Glibc ou Linux Musl Libc Compiler, respectivamente.
O compilador Multilib terá o prefixo riscv64-uknown-elim e riscv64-abnown-linux-gnu-, mas poderá atingir sistemas de 32 e 64 bits. Ele suportará as opções mais comuns -march / -mabi , que podem ser vistas usando o sinalizador --print-multi-lib em qualquer um dos compiladores cruzados.
O Linux Toolchain possui uma opção adicional --enable-default-pie para controlar a ativação da torta padrão do GCC, que é desativada por padrão.
Para personalizar os idiomas habilitados, use a opção --with-languages= . Por exemplo, se você deseja ativar c,c++,fortran , use ./configure --with-languages=c,c++,fortran . Esta opção entra em vigor apenas para a cadeia de ferramentas GNU.
Construções funcionam melhor se instalar em um diretório vazio. Se você construir uma cadeia de ferramentas de tolo rígido e tentar construir uma cadeia de ferramentas de tiro macio com o mesmo diretório de prefixo, os scripts de construção poderão ficar confusos e sair com um erro de vinculador reclamando que o código de flutuação duro não pode ser vinculado a Código de flutuação suave. A remoção da cadeia de ferramentas existente primeiro ou usando um prefixo diferente para a segunda compilação evita o problema. Não há problema em criar um newlib e uma cadeia de ferramentas Linux com o mesmo prefixo. Mas você deve evitar a criação de dois newlib ou duas cadeias de ferramentas do Linux com o mesmo prefixo.
Se a criação de uma cadeia de ferramentas Linux em um sistema MacOS ou em um sistema Windows usando o subsistema Linux ou Cygwin, você deve garantir que o sistema de arquivos seja sensível ao maiúsculas de minúsculas. Uma criação de um sistema de arquivos insensível ao caso falhará ao criar o GLIBC porque os arquivos *.OS e *.OS se agarram durante a compilação, resultando em erros de link confusos.
O CentOS (e o RHEL) fornecem versões antigas do GNU Tools que podem ser antigas demais para criar uma cadeia de ferramentas RISC-V. Há um conjunto de ferramentas alternativo fornecido que inclui versões atuais das ferramentas GNU. Este é o DevToolset fornecido como parte do serviço de coleta de software. Para mais informações, consulte o URL DevToolset-7. Existem várias versões do DevToolset que estão disponíveis; portanto, você também pode tentar outras versões, mas temos pelo menos um relatório que o DevToolset-7 funciona.
Existem várias opções adicionais que podem ser passadas para configurar. Veja './configure - -help' para obter mais detalhes.
Além disso, você pode definir sinalizadores extras para passar para projetos específicos: BINUTILS_NATIVE_FLAGS_EXTRA, BINUTILS_TARGET_FLAGS_EXTRA, GCC_EXTRA_CONFIGURE_FLAGS, GDB_NATIVE_FLAGS_EXTRA, GDB_TARGET_FLAGS_EXTRA, GLIBC_TARGET_FLAGS_EXTRA, NEWLIB_TARGET_FLAGS_EXTRA . Exemplo: GCC_EXTRA_CONFIGURE_FLAGS=--with-gmp=/opt/gmp make linux
--with-isa-spec= pode especificar a versão padrão da especificação ISA não privilegiada RISC-V (anteriormente no nível do usuário).
As opções possíveis são: 2.2 , 20190608 e 20191213 .
A versão padrão é 20191213 .
Mais detalhes sobre esta opção, você pode consultar este post risc-v gnu ferramentas batendo a especificação ISA padrão para 20191213.
--with-multilib-generator= pode especificar quais multilibs construir. O argumento é uma lista de valores separada por Semicolon, possivelmente consistindo em um único valor. Atualmente suportado apenas para RISCV* - -Elf . Os valores e significados aceitos são fornecidos abaixo.
Cada configuração é construída com quatro componentes: string de arquitetura, ABI, regra de reutilização com string de arquitetura e regra de reutilização com sub-extensão.
Reutilize o operador de expansão de suporte à peça (*) para simplificar a combinação de diferentes sub-extensões, o Exemplo 4 demonstrar como ele usa e funciona.
Exemplo 1: Adicione suporte multi-libra para Rv32i com ILP32.
./configure --with-multilib-generator="rv32i-ilp32--"
Exemplo 2: Adicione suporte multi-libra para Rv32i com ILP32 e Rv32ImAfd com Ilp32.
./configure --with-multilib-generator="rv32i-ilp32--;rv32imafd-ilp32--"
Exemplo 3: Adicione suporte multi-libra para Rv32i com ILP32; Rv32Im com ILP32 e Rv32ic com ILP32 reutilizará esse conjunto multi-libera.
./configure --with-multilib-generator="rv32i-ilp32-rv32im-c"
Exemplo 4: Adicione suporte multi-libra para Rv64IMA com LP64; Rv64IMAF com LP64, Rv64Imac com LP64 e Rv64ImAfc com LP64 reutilizará esse conjunto de vários liberes.
./configure --with-multilib-generator="rv64ima-lp64--f*c"
A suíte de teste DEJAGNU foi portada para o RISC-V. Isso pode ser executado com um simulador para as cadeias de ferramentas ELF e Linux. O simulador pode ser selecionado pela variável SIM no makefile, por exemplo, sim = qemu, sim = gdb ou sim = spike (experimental). Adição, o simulador também pode ser selecionado com a opção de tempo de configuração --with-sim= . No entanto, a lista de permissões do TestSuite é apenas cunhada para Qemu. Outros simuladores podem obter falhas extras.
Um script auxiliar para configurar o ambiente de teste requer pyelftools.
Em versões mais recentes do Ubuntu, a execução do comando a seguir deve ser suficiente:
$ sudo apt-get install python3-pyelftools
Em versões mais recentes do Fedora e CentOS/Rhel OS (9 ou mais posterior), a execução do comando a seguir deve ser suficiente:
$ sudo yum install python3-pyelftools
No Arch Linux, a execução do comando a seguir deve ser suficiente:
$ sudo pacman -Syyu python-pyelftools
Se a sua distribuição/OS não tiver pacote PyelfTools, você poderá instalá -lo usando o PIP.
# Assuming that PIP is installed
$ pip3 install --user pyelftools
Para testar o GCC, execute os seguintes comandos:
./configure --prefix=$RISCV --disable-linux --with-arch=rv64ima # or --with-arch=rv32ima
make newlib
make report-newlib SIM=gdb # Run with gdb simulator
./configure --prefix=$RISCV
make linux
make report-linux SIM=qemu # Run with qemu
./configure --prefix=$RISCV --with-sim=spike
make linux
make report # Run with spike
Observação:
Por padrão, o GCC executará todos os testes de seu conjunto de testes de regressão. Enquanto executá -los em paralelo (por exemplo, make -j$(nproc) report ) será significativo para acelerar o tempo de execução nos sistemas multiprocessadores, o tempo necessário para executar todos os testes geralmente é muito alto para os ciclos de desenvolvimento típicos. Portanto, o GCC permite selecionar os testes que estão sendo executados usando a variável de ambiente RUNTESTFLAGS .
Para restringir uma execução de teste a apenas testes específicos do RISC-V, o comando a seguir pode ser usado:
RunTestflags = "riscv.exp" faça relatório
Para restringir uma execução de teste a apenas testes específicos do RISC-V com o padrão "zb*.c" e "sm*.c", o seguinte comando pode ser usado:
RunTestflags = "riscv.exp = zb*.c sm*.c" faça relatório
O alvo makefile padrão para executar testes da cadeia de ferramentas é report . Isso executará todos os testes do conjunto de testes de regressão do GCC. Como alternativa, o comando a seguir pode ser usado para fazer o mesmo:
make check-gcc
O comando a seguir pode ser usado para executar os testes de Binutils:
make check-binutils
O comando abaixo pode ser usado para executar os testes do GLIBC:
make check-glibc-linux
--with-extra-multilib-test pode ser usado quando você deseja testar mais combinação de arco/abi, por exemplo: construir uma cadeia de ferramentas Linux com multilib com rv64gc/lp64d e rv64imac/lp64 , mas você deseja testar mais configuração como rv64gcv/lp64d ou rv64gcv_zba/lp64d , então você pode usar--ex-ex- --with-extra-multilib-test="rv64gcv-lp64d;rv64gcv_zba-lp64d" Para rv64gc/lp64d , rv64imac/lp64 , rv64gcv/lp64d e rv64gcv_zba/lp64d .
--with-extra-multilib-test suporta-metal e suporte de ferramentas de metal e linux e suporte até o Multilib é desativado, mas o usuário deve garantir uma configuração extra de teste multilibe Se o Multilib não tivesse nenhum RV32 Multilib.
--with-extra-multilib-test também suporta formato mais complicado para atender aos requisitos dos usuários finais. Primeiro de tudo, o argumento é uma lista de configurações de teste. Cada configuração de teste é separada por ; . Por exemplo:
rv64gcv-lp64d;rv64_zvl256b_zvfh-lp64d
Para cada configuração de teste, possui duas partes, também conhecidas como parte do arqui-abi e sinalizadores de construção opcionais. Aproveitamos : para separá -los com algumas restrições.
: para separá-las. Por exemplo: rv64gcv-lp64d:--param=riscv-autovec-lmul=dynamic:--param=riscv-autovec-preference=fixed-vlmax
será considerado como uma placa -alvo da mesma forma que abaixo:
riscv-sim/-march=rv64gcv/-mabi=lp64d/-mcmodel=medlow/--param=riscv-autovec-lmul=dynamic/--param=riscv-autovec-preference=fixed-vlmax
rv64gcv-lp64d:--param=riscv-autovec-lmul=dynamic,--param=riscv-autovec-preference=fixed-vlmax
será considerado como duas placas -alvo iguais a abaixo:
riscv-sim/-march=rv64gcv/-mabi=lp64d/-mcmodel=medlow/--param=riscv-autovec-preference=fixed-vlmax
riscv-sim/-march=rv64gcv/-mabi=lp64d/-mcmodel=medlow/--param=riscv-autovec-lmul=dynamic
: :), ou ( , ) operador juntos, mas o ( , ) sempre terá a prioridade mais alta. Por exemplo: rv64gcv-lp64d:--param=riscv-autovec-lmul=dynamic:--param=riscv-autovec-preference=fixed-vlmax,--param=riscv-autovec-lmul=m2
será considerado como javalis de alvo de reboque igual a abaixo:
riscv-sim/-march=rv64gcv/-mabi=lp64d/-mcmodel=medlow/--param=riscv-autovec-lmul=dynamic/--param=riscv-autovec-preference=fixed-vlmax
riscv-sim/-march=rv64gcv/-mabi=lp64d/-mcmodel=medlow/--param=riscv-autovec-lmul=m2
O LLVM pode ser usado em combinação com o RISC-V GNU Compiler Toolchain para criar aplicativos RISC-V. Para construir LLVM com suporte C e C ++, o sinalizador de configuração --enable-llvm pode ser usado.
Por exemplo, para construir LLVM no topo de uma cadeia de ferramentas Rv64 Linux, os seguintes comandos podem ser usados:
./configure --prefix = $ riscv --enable-llvm --enable-linux
Observe que uma combinação de sinalizadores de configuração --enable-llvm e multilib não é suportada.
Abaixo estão exemplos de como criar uma cadeia de ferramentas RV64GC Linux/Newlib com suporte a LLVM, como usá -lo para criar um aplicativo C e C ++ usando CLANG e como executar os binários gerados usando o QEMU.
Crie a Chapé de Ferramentas do Linux e execute exemplos:
# Build rv64gc toolchain with LLVM
./configure --prefix=$RISCV --enable-llvm --enable-linux --with-arch=rv64gc --with-abi=lp64d
make -j$(nproc) all build-sim SIM=qemu
# Build C application with clang
$RISCV/bin/clang -march=rv64imafdc -o hello_world hello_world.c
$RISCV/bin/qemu-riscv64 -L $RISCV/sysroot ./hello_world
# Build C++ application with clang
$RISCV/bin/clang++ -march=rv64imafdc -stdlib=libc++ -o hello_world_cpp hello_world_cpp.cxx
$RISCV/bin/qemu-riscv64 -L $RISCV/sysroot ./hello_world_cpp
Construa a NEWLIB Toolchain e execute exemplos (não trabalhe com --with-multilib-generator= ):
# Build rv64gc bare-metal toolchain with LLVM
./configure --prefix=$RISCV --enable-llvm --disable-linux --with-arch=rv64gc --with-abi=lp64d
make -j$(nproc) all build-sim SIM=qemu
# Build C application with clang
$RISCV/bin/clang -march=rv64imafdc -o hello_world hello_world.c
$RISCV/bin/qemu-riscv64 -L $RISCV/sysroot ./hello_world
# Build C++ application with clang using static link
$RISCV/bin/clang++ -march=rv64imafdc -static -o hello_world_cpp hello_world_cpp.cxx
$RISCV/bin/qemu-riscv64 -L $RISCV/sysroot ./hello_world_cpp
Esta seção é apenas para desenvolvedor ou usuário avançado, ou você deseja criar uma cadeia de ferramentas com sua própria árvore de origem.
riscv-gnu-toolchain contém uma fonte estável, mas não mais recente para cada submódulo, caso você queira usar a árvore desenvolvida mais recente, você pode usar o seguinte comando para atualizar todo o submodule.
git submodule update --remote
Ou você pode atualizar apenas o submódulo específico.
git submodule update --remote <component>
Por exemplo, atualize apenas o GCC, você pode usar o seguinte comando:
git submodule update --remote gcc
As informações da filial gravaram no arquivo .gitmodules , que pode definir ou atualizar via git submodule add -b ou git submodule set-branch .
No entanto, a única maneira de verificar qual ramificação está usando é verificar o arquivo .gitmodules , aqui está o exemplo do gcc , ele está usando o ramo de lançamentos/GCC-12, para que ele tenha uma seção chamada gcc e possui uma branch de campo é releases/gcc-12 .
[submodule "gcc"]
path = gcc
url = ../gcc.git
branch = releases/gcc-12
riscv-gnu-toolchain riscv-gnu-toolchain também suporta o uso da fonte fora da árvore para construir a cadeia de ferramentas. Existem várias opções de configuração para especificar a árvore de origem de cada submódulo/componente.
Por exemplo, se você possui fontes do GCC em $HOME/gcc , use --with-gcc-src para construir a cadeia de ferramentas usando essas fontes:
./configure ... --with-gcc-src=$HOME/gcc
Aqui está a lista de opções de configuração para especificar fontes alternativas para os vários submódulos/componentes:
--with-binutils-src
--with-dejagnu-src
--with-gcc-src
--with-gdb-src
--with-glibc-src
--with-linux-headers-src
--with-llvm-src
--with-musl-src
--with-newlib-src
--with-pk-src
--with-qemu-src
--with-spike-src
--with-uclibc-src
As contribuições do GCC precisam atender a vários requisitos para se qualificar para a inclusão a montante. Aviso A compilação gratuita com um compilador construído das mesmas fontes está entre elas. A bandeira --enable-host-gcc exaclty exaclty:
-Werror para identificar problemas de códigoSe partes do newlib forem substituídas por uma biblioteca externa (como a interface LibGloss-htif para Berkeley Host-Target), você deve ter cuidado para garantir que o Newlib e a biblioteca externa sejam construídos usando o mesmo modelo de código. Para obter mais informações sobre os modelos de código RISC-V, leia este artigo do Blog Sifive.
Os erros que indicam uma incompatibilidade de modelo de código incluem erros "Relocation Overling" ou "Relocation truncados" do vinculador que não conseguem realocar com sucesso os símbolos no executável.
Por padrão, riscv-gnu-toolchain constrói newlib com -mcmodel=medlow . Você pode usar o modelo alternativo de código medany (conforme usado no libgloss-htif), passando --with-cmodel=medany no script de configuração.
