Montagem x86 em um Mac

Question

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?

Answer 1

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.

Answer 2

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

Answer 3

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.

Answer 4

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:

https://github.com/jaredsburrows/Assembly

Answer 5

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:

1. Primeiro instale NASM usando Homebrew brew install nasm
2. converta o arquivo .asm em arquivo Obj usando este comando nasm -f macho64 myFile.asm
3. 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

Answer 6

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.

Answer 7

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.

Answer 8

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.

Answer 9

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.