Setup do ambiente ARM

Antes de escrever uma única instrução ARM, vamos montar a bancada. Neste artigo você instala o JDK 25 + Maven, o toolchain ARM bare-metal (o compilador que gera binários para a arquitetura, não para o seu SO) e faz o checkout dos repositórios que vamos usar durante todo o curso: o arm-jitter (o núcleo) e o arm-box (o runner). Ao final, você será capaz de compilar um binário ARM e rodá-lo no arm-box, e terá o arm-jitter instalado localmente para brincar com a API.

O ecossistema numa foto

Tudo gira em torno de um só núcleo ARM/THUMB escrito em Java — o arm-jitter. Os outros projetos são "consumidores" desse núcleo:

arm-box — um runner de binários ARM 32-bit no estilo do qemu-arm (user-mode). É o que usamos para rodar nossos exemplos.
gbaemu / ndsemu / n3dsemu — emuladores de console que usam o arm-jitter como CPU (Game Boy Advance, Nintendo DS e 3DS). Nosso "cenário", mas o protagonista é sempre o ARM.
virtual-arm-box — system-emulation (Linux real por cima do núcleo), para quando quisermos ver um kernel bootando.

Pegue o hábito de clonar os três primeiros; os consoles entram mais tarde, quando falarmos de estudos de caso.

1. Java e Maven

O arm-jitter usa recursos recentes da JVM, então o piso é o JDK 25 (recomendo o JBR). Você também precisa do Maven para buildar tudo.

java -version
mvn -version

Se faltar algo, instale pelo seu gerenciador:

# Linux (apt + sdkman)
sudo apt install maven
sdk install java 25.0.1-jbr

# macOS (Homebrew)
brew install openjdk@25 maven

# Windows (Scoop)
scoop install openjdk25 maven

2. Toolchain ARM bare-metal

Atenção: não é o gcc do seu sistema. Precisamos do conjunto arm-none-eabi-* — ele gera código para a arquitetura ARM sem nenhuma libc do Linux. É ele que vai montar, ligar e desmontar nossos binários.

# Debian/Ubuntu
sudo apt install gcc-arm-none-eabi binutils-arm-none-eabi gdb-multiarch

# macOS (Homebrew)
brew install --cask gcc-arm-embedded

# Windows — devkitARM (mesma origem citada no hello-armbox)
pacman -S arm-none-eabi-gcc

Confira se everything está no PATH:

arm-none-eabi-gcc --version
arm-none-eabi-objdump --version

3. Clonar e buildar

O arm-jitter é o coração: fazemos o mvn install para publicá-lo no seu ~/.m2 local, de onde ele vira uma dependência utilizável nos seus próprios experimentos.

git clone https://github.com/vitorsilverio/arm-jitter
cd arm-jitter
mvn install          # publica em ~/.m2 para uso como biblioteca

Já o arm-box vira um executável. O mvn package produz o jar que usamos para rodar binários:

git clone https://github.com/vitorsilverio/armbox
cd armbox
mvn package          # gera target/armbox-1.0-SNAPSHOT.jar

(gbaemu, ndsemu, n3dsemu e virtual-arm-box buildam com o mesmo mvn package. Deixe-os de lado por ora — voltamos a eles nos estudos de caso por console.)

4. Teste de fumaça

Se a bancada estiver pronta, rode o exemplo do artigo "Criando um executável ARM e rodando no arm-box". O comando é simples:

java -jar target/armbox-1.0-SNAPSHOT.jar hello.elf

Saída esperada:

hello from a real ELF

E já aproveite para espiar o binário — o objdump é a nossa lente de aqui pra frente:

arm-none-eabi-objdump -d hello.elf | head -n 20

Próximos passos

Bancada montada. A partir daqui, todo artigo do curso traz exemplos que você consegue reproduzir. No próximo texto descemos de fato na arquitetura: o banco de registradores (R0–R15) e o CPSR com suas flags N/Z/C/V — a fundação que você precisa para ler qualquer dump. Confira a lista de artigos para acompanhar o diário do início. Até a próxima!