Compilador online

Compilador Assembly online

Escreva seu código em Assembly (NASM 3) abaixo e rode de graça, com entrada, num sandbox nos nossos servidores. Sem cadastro e sem anúncios.

Pela equipe do OnlineCompiler.io. Atualizado em .

Also in EnglishTambién en español

extern scanf
extern printf

section .data
formato_ler   db "%63s %d", 0
formato_ola   db "Olá, %s!", 10, 0
formato_linha db "%d ao quadrado é %d", 10, 0

section .bss
nome    resb 64
n       resd 1

section .text
global main
main:
    push rbx                    ; guarda rbx (o contador i) e alinha a pilha

    ; Lê o nome e um número da aba Entrada
    lea rdi, [rel formato_ler]
    lea rsi, [rel nome]
    lea rdx, [rel n]
    xor eax, eax
    call scanf

    lea rdi, [rel formato_ola]
    lea rsi, [rel nome]
    xor eax, eax
    call printf

    mov ebx, 1                  ; i = 1
.repete:
    cmp ebx, [rel n]
    jg .fim                     ; para quando i > n
    lea rdi, [rel formato_linha]
    mov esi, ebx                ; i
    mov edx, ebx
    imul edx, ebx               ; i * i
    xor eax, eax
    call printf
    inc ebx
    jmp .repete
.fim:
    pop rbx
    xor eax, eax
    ret
Compartilhar gera um link, sem precisar de conta. Salvar guarda o código na sua conta.

Quer conferir uma solução contra várias entradas? O compilador Assembly com casos de teste roda todas de uma vez e marca cada uma como aprovada ou reprovada.

Como dar entrada (stdin)

Antes de apertar Executar, digite na aba Entrada tudo o que o programa vai ler. Ele recebe esse texto pela entrada padrão (stdin). Em Assembly, fica assim:

lea rdi, [rel formato_ler]   ; formato_ler db "%63s %d", 0
lea rsi, [rel nome]          ; a próxima palavra, em nome resb 64
lea rdx, [rel n]             ; o próximo número, em n resd 1
xor eax, eax                 ; al = 0: nenhum argumento em ponto flutuante
call scanf                   ; com global main, o programa usa a biblioteca C

A entrada inteira é enviada quando você aperta Executar, então o programa não pode pedir mais nada enquanto roda. Coloque cada valor numa linha, ou separe por espaços, conforme o programa lê.

Versão e limites

VersãoAssembly NASM 3
Compilado comnasm -f elf64 code.asm -o code.o && ld code.o -o code.out
Executado com./code.out
Limites30 segundos, 512 MB de memória, 2 CPUs, 64 KB de saída por fluxo, sem rede
Execução típica0,68 s, e 0,84 s para a mais lenta em cada 20 (como medimos, em inglês)

Bom saber

  • Monta código x86-64 de 64 bits para Linux com o NASM 3 (nasm -f elf64).
  • Um programa com main global é ligado à biblioteca C, então pode chamar printf e scanf. Um com _start é ligado sozinho e usa chamadas de sistema.
  • Use syscall com os números de chamada de 64 bits (1 é write, 60 é exit). Chamadas int 0x80 de 32 bits derrubam o programa com o código de saída 139.

Rodar Assembly a partir do seu app

Para rodar Assembly no seu próprio app, envie o código e a entrada para o endpoint síncrono com uma chave de API, e a saída volta na resposta. É grátis até 100.000 execuções por mês. Documentação da API (em inglês).

O editor acima é um widget que você pode colocar no seu site, blog ou curso. Com o atributo data-locale="pt", os botões aparecem em português. Como incorporar o editor (em inglês).

Outras páginas

Perguntas frequentes

O compilador Assembly online é grátis?

Sim. Rodar Assembly nesta página não exige conta e não tem anúncios. Para rodar Assembly no seu próprio app ou site, a API e o widget são grátis até 100.000 execuções por mês, uso comercial incluído.

Meu programa em Assembly pode ler entrada?

Sim. Digite a entrada na aba Entrada antes de executar, e o programa a lê pela entrada padrão (stdin). A entrada inteira é enviada quando você aperta Executar, então o programa não pode pedir mais nada enquanto roda.

Posso usar bibliotecas em Assembly?

A biblioteca padrão do C, para programas que definem main. Não há outras bibliotecas nem arquivos de include, e os programas não têm acesso à rede.

Quanto tempo um programa pode rodar?

Até 30 segundos, com 512 MB de memória e 2 CPUs. Um programa que ainda estiver rodando aos 30 segundos é interrompido com o código de saída 124, e a saída acima de 64 KB por fluxo é cortada.

Onde meu código roda?

Nos nossos servidores, num sandbox gVisor novo e sem acesso à rede, que é apagado quando a execução termina. Cada execução fica guardada no histórico com a saída; a página de segurança (em inglês) explica o que é armazenado.

Existe uma API para Assembly?

Sim. Envie o código, o id do compilador nasm-3 e a entrada para https://api.onlinecompiler.io/api/run-code-sync/ com uma chave de API, e a resposta traz a saída, os erros, o código de saída, o tempo e a memória. É grátis até 100.000 execuções por mês, e a mesma chave serve para as outras 45 linguagens. A documentação está em inglês.