Montagem x86 em um Mac
Pergunta
Alguém conhece alguma ferramenta boa (estou procurando IDEs) para escrever assembly no Mac.Xcode é um pouco complicado para mim.
Além disso, nos Macs Intel, posso usar o asm x86 genérico?Ou existe um conjunto de instruções modificado?Qualquer informação sobre pós Intel.
Também:Eu sei que no Windows, o asm pode ser executado em um ambiente emulado criado pelo sistema operacional para permitir que o código pense que está sendo executado em sua própria máquina dedicada.O OS X oferece a mesma coisa?
Solução
Depois de instalar qualquer versão do Xcode destinada a Macs baseados em Intel, você poderá escrever código assembly.Xcode é um conjunto de ferramentas, das quais apenas uma é o IDE, então você não precisa usá-lo se não quiser.(Dito isto, se houver coisas específicas que você acha desajeitadas, registre um bug em Repórter de bugs da Apple - todo bug vai para a engenharia.) Além disso, a instalação do Xcode instalará tanto o Netwide Assembler (NASM) quanto o GNU Assembler (GAS);isso permitirá que você use qualquer sintaxe de assembly com a qual você se sinta mais confortável.
Você também vai querer dar uma olhada no Guias de compilador e depuração, porque documentam as convenções de chamada usadas para as diversas arquiteturas em que o Mac OS X é executado, bem como como o formato binário e o carregador funcionam.As convenções de chamada IA-32 (x86-32) em particular podem ser um pouco diferentes daquelas com as quais você está acostumado.
Outra coisa a ter em mente é que a interface de chamada do sistema no Mac OS X é diferente daquela com a qual você está acostumado no DOS/Windows, Linux ou outros tipos de BSD.As chamadas do sistema não são consideradas uma API estável no Mac OS X;em vez disso, você sempre passa pelo libSystem.Isso garantirá que você esteja escrevendo um código portátil de uma versão do sistema operacional para a próxima.
Por fim, lembre-se de que o Mac OS X funciona em uma ampla variedade de hardware - tudo, desde o Core Single de 32 bits até o Xeon quad-core de última geração.Ao codificar em assembly você pode não estar otimizando tanto quanto pensa;o que é ideal em uma máquina pode ser pessimista em outra.A Apple mede regularmente seus compiladores e ajusta sua saída com o sinalizador de otimização "-Os" para ser decente em toda a sua linha, e há extensas bibliotecas de processamento de vetores/matrizes que você pode usar para obter alto desempenho com implementações específicas de CPU ajustadas manualmente .
Ir à assembleia para se divertir é ótimo.Ir à montagem em busca de velocidade não é para os fracos de coração hoje em dia.
Outras dicas
Como afirmado antes, não use syscall.Você pode usar chamadas de biblioteca C padrão, mas esteja ciente de que a pilha DEVE ter 16 bytes alinhadas de acordo com o padrão da Apple Chamada de função IA32 ABI.
Se você não alinhar a pilha, seu programa irá travar __dyld_misaligned_stack_error
quando você faz uma chamada para qualquer uma das bibliotecas ou estruturas.
O seguinte snippet é montado e executado em meu sistema:
; File: hello.asm
; Build: nasm -f macho hello.asm && gcc -o hello hello.o
SECTION .rodata
hello.msg db 'Hello, World!',0x0a,0x00
SECTION .text
extern _printf ; could also use _puts...
GLOBAL _main
; aligns esp to 16 bytes in preparation for calling a C library function
; arg is number of bytes to pad for function arguments, this should be a multiple of 16
; unless you are using push/pop to load args
%macro clib_prolog 1
mov ebx, esp ; remember current esp
and esp, 0xFFFFFFF0 ; align to next 16 byte boundary (could be zero offset!)
sub esp, 12 ; skip ahead 12 so we can store original esp
push ebx ; store esp (16 bytes aligned again)
sub esp, %1 ; pad for arguments (make conditional?)
%endmacro
; arg must match most recent call to clib_prolog
%macro clib_epilog 1
add esp, %1 ; remove arg padding
pop ebx ; get original esp
mov esp, ebx ; restore
%endmacro
_main:
; set up stack frame
push ebp
mov ebp, esp
push ebx
clib_prolog 16
mov dword [esp], hello.msg
call _printf
; can make more clib calls here...
clib_epilog 16
; tear down stack frame
pop ebx
mov esp, ebp
pop ebp
mov eax, 0 ; set return code
ret
Para obter uma boa introdução passo a passo específica para Mac x86, consulte http://peter.michaux.ca/articles/assembly-hello-world-for-os-x.Os outros links que experimentei apresentam algumas armadilhas que não são do Mac.
Recentemente eu queria aprender como compilar o Intel x86 no Mac OS X:
Para nasm:
-o hello.tmp - outfile
-f macho - specify format
Linux - elf or elf64
Mac OSX - macho
Para ld:
-arch i386 - specify architecture (32 bit assembly)
-macosx_version_min 10.6 (Mac OSX - complains about default specification)
-no_pie (Mac OSX - removes ld warning)
-e main - specify main symbol name (Mac OSX - default is start)
-o hello.o - outfile
Para Concha:
./hello.o - execution
Uma linha:
nasm -o hello.tmp -f macho hello.s && ld -arch i386 -macosx_version_min 10.6 -no_pie -e _main -o hello.o hello.tmp && ./hello.o
Avise-me se isso ajudar!
Escrevi como fazer isso no meu blog aqui:
http://blog.burrowsapps.com/2013/07/how-to-compile-helloworld-in-intel-x86.html
Para uma explicação mais detalhada, expliquei no meu Github aqui:
A execução do código assembly no Mac está a apenas 3 passos de você.Isso poderia ser feito usando o XCODE, mas o melhor é usar a ferramenta de linha de comando NASM.Para minha facilidade já instalei o Xcode, se você tiver o Xcode instalado está bom.
Mas você também pode fazer isso sem o XCode.
Apenas siga:
- Primeiro instale NASM usando Homebrew
brew install nasm
- converta o arquivo .asm em arquivo Obj usando este comando
nasm -f macho64 myFile.asm
- Execute o arquivo Obj para ver o OutPut usando o comando
ld -macosx_version_min 10.7.0 -lSystem -o OutPutFile myFile.o && ./64
O arquivo de texto simples denominado myFile.asm está escrito abaixo para sua conveniência.
global start
section .text
start:
mov rax, 0x2000004 ; write
mov rdi, 1 ; stdout
mov rsi, msg
mov rdx, msg.len
syscall
mov rax, 0x2000001 ; exit
mov rdi, 0
syscall
section .data
msg: db "Assalam O Alaikum Dear", 10
.len: equ $ - msg
Além disso, nos Macs Intel, posso usar o asm x86 genérico?ou existe um conjunto de instruções modificado?Qualquer informação sobre a montagem pós-Intel Mac ajuda.
É o mesmo conjunto de instruções;são os mesmos chips.
Os recursos disponíveis para uso dependem do seu processador.A Apple usa o mesmo material da Intel que todo mundo.Então, sim, x86 genérico deve servir (supondo que você não esteja em um PPC: D).
No que diz respeito às ferramentas, acho que sua melhor aposta é um bom editor de texto que “entenda” assembly.
Esqueça encontrar um IDE para escrever/executar/compilar assembler no Mac.Mas lembre-se de que mac é UNIX.Ver http://asm.sourceforge.net/articles/linasm.html.Um guia decente (embora curto) para executar assembler via GCC no Linux.Você pode imitar isso.Macs usam chips Intel, então você quer dar uma olhada na sintaxe da Intel.
Não se esqueça que, ao contrário do Windows, todos os sistemas baseados em Unix precisam ter a origem antes do destino, ao contrário do Windows
No Windows é:
mov $fonte,%destino
mas no Mac é o contrário.