xcode - sierra - Asamblea x86 en una Mac

xcode 10 night mode

Question

¿Alguien sabe de alguna buena herramienta (estoy buscando IDE) para escribir el ensamblaje en la Mac? Xcode es un poco engorroso para mí.

Además, en los Intel Macs, ¿puedo usar el asm genérico x86? ¿O hay un conjunto de instrucciones modificado? Cualquier información sobre la publicación de Intel.

Además, sé que en Windows, asm puede ejecutarse en un entorno emulado creado por el sistema operativo para permitir que el código crea que se ejecuta en su propia máquina dedicada. ¿OS X proporciona lo mismo?

Answer 1

Además, en los Intel Macs, ¿puedo usar el asm genérico x86? o hay un conjunto de instrucciones modificado? Cualquier información sobre el montaje de la publicación Intel Mac ayuda.

Es el mismo conjunto de instrucciones; son las mismas fichas.

Answer 2

Como se dijo anteriormente, no use syscall. Sin embargo, puede usar las llamadas estándar de la biblioteca C, pero tenga en cuenta que la pila DEBE estar alineada con 16 bytes según la llamada de función IA32 de Apple ABI .

Si no alinea la pila, su programa se bloqueará en __dyld_misaligned_stack_error cuando haga una llamada a cualquiera de las bibliotecas o marcos.

El siguiente fragmento se ensambla y se ejecuta en mi 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

Ejecutar Assembly Code en Mac está a solo 3 pasos de ti. Se podría hacer usando XCODE, pero es mejor usar NASM Command Line Tool. Para Mi Facilidad ya he instalado Xcode, si tienes Xcode instalado es bueno.

Pero también puedes hacerlo sin XCode.

Solo sigue:

1. Primero instale NASM usando Homebrew brew install nasm
2. convierte el archivo .asm en Obj File usando este comando nasm -f macho64 myFile.asm
3. Ejecute Obj File para ver OutPut usando el comando ld -macosx_version_min 10.7.0 -lSystem -o OutPutFile myFile.o && ./64

El archivo de texto simple llamado myFile.asm se escribe a continuación para su conveniencia.

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 4

Las funciones disponibles para usar dependen de su procesador. Apple usa las mismas cosas de Intel que todos los demás. Así que sí, genérico x86 debería estar bien (suponiendo que no está en un PPC: D).

En cuanto a las herramientas, creo que su mejor opción es un buen editor de texto que ''entienda'' el ensamblaje.

Answer 5

No olvide que, a diferencia de Windows, todo sistema basado en Unix necesita tener el origen antes de su destino a diferencia de Windows

En Windows es:

mov $ fuente,% destino

pero en la Mac es al revés.

Answer 6

Olvídese de encontrar un ensamblador IDE para escribir / ejecutar / compilar en Mac. Pero recuerda que mac es UNIX. Ver http://asm.sourceforge.net/articles/linasm.html . Una guía decente (aunque breve) para ejecutar ensamblador a través de GCC en Linux. Puedes imitar esto. Los Mac usan chips Intel, por lo que se debe tener en cuenta la sintaxis de Intel.

Answer 7

Para obtener una introducción paso a paso específica de Mac x86, consulte http://peter.michaux.ca/articles/assembly-hello-world-for-os-x . Los otros enlaces que he probado tienen algunos inconvenientes que no son de Mac.

Answer 8

Recientemente, quería aprender a compilar Intel x86 en 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 Shell:

./hello.o - execution

Un trazador de líneas:

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

¡Déjeme saber si esto ayuda!

Escribí cómo hacerlo en mi blog aquí:

http://blog.burrowsapps.com/2013/07/how-to-compile-helloworld-in-intel-x86.html

Para una explicación más detallada, expliqué en mi Github aquí:

https://github.com/jaredsburrows/Assembly

Answer 9

Después de instalar cualquier versión de Xcode dirigida a Mac basadas en Intel, debería poder escribir el código de ensamblado. Xcode es un conjunto de herramientas, de las cuales solo una es IDE, por lo que no tiene que usarla si no desea. (Dicho esto, si hay cosas específicas que te parecen torpes, por favor presenta un error en el reportero de errores de Apple ; cada error va a la ingeniería). Además, la instalación de Xcode instalará tanto el ensamblador de Netwide (NASM) como el ensamblador de GNU (GAS); que le permitirá usar la sintaxis de ensamblaje con la que se sienta más cómodo.

También querrá echar un vistazo a las Guías de compilación y depuración , ya que documentan las convenciones de llamada utilizadas para las diversas arquitecturas en las que se ejecuta Mac OS X, así como el funcionamiento del formato binario y el cargador. Las convenciones de llamadas IA-32 (x86-32) en particular pueden ser ligeramente diferentes de las que está acostumbrado.

Otra cosa a tener en cuenta es que la interfaz de llamada del sistema en Mac OS X es diferente de lo que podría estar acostumbrado en DOS / Windows, Linux u otros sabores de BSD. Las llamadas al sistema no se consideran una API estable en Mac OS X; en su lugar, siempre pasas por libSystem. Eso asegurará que esté escribiendo código que sea portátil desde una versión del sistema operativo al siguiente.

Finalmente, tenga en cuenta que Mac OS X se ejecuta en una amplia gama de hardware, desde el Core Single de 32 bits hasta el Xeon de cuatro núcleos de alta gama. Al codificar en ensamblaje, es posible que no esté optimizando tanto como cree; lo que es óptimo en una máquina puede ser pésimo en otra. Apple mide regularmente sus compiladores y ajusta su salida con la bandera de optimización "-Os" para ser aceptable en toda su línea, y hay extensas bibliotecas de procesamiento vectorial / matriz que puede usar para obtener un alto rendimiento con implementaciones específicas de CPU ajustadas a mano .

Ir a montar por diversión es genial. Ir a la reunión para la velocidad no es para los débiles de corazón en estos días.