x86-64 Assembly on an M-series Mac

2026-06-02T00:00:00+00:00

If you're looking for a way to code and execute x86-64 programs on arm64 macs, this is a tutorial for you. Through Rosetta 2</a> it is possible to compile x86-64 programs, whether written in C or assembly, into x86-64 binary and be able to run it as if was an arm64 binary. Here, I will specifically demonstrate how one can write assembly code and call them in a C code.</p>

It is really simple. Write your assembly code in a .s</code> file. Within it expose a symbol that you later on want to call in a C file.</p>

  .text
  .global _my_func
_my_func:
   ...
</code></pre>
In this particular example, we made the _my_func symbol visible to the linker.</p>
Then in a C file, to be able to compile the code, before even linking it against the assembly code, declare the function that corresponds to the exposed symbol in the assembly file.</p>
// ~~~

extern <return_type> my_func(<params>...);

// ~~~

int main(void)
{...}
</code></pre>

You don't have to specify the extern</code> keyword before the function prototype since functions in C are by default external.
However, for readability sake, I like to keep the extern</code> keyword to
indicate the function is defined in an assembly file.</p>
</blockquote>
Finally, we compile the whole thing by passing both, C and assembly, files to the compiler as well as the -target x86_64-apple-macos</code> flag.</p>

C Compilers are able to do cross-compilation and produce binaries that target a specific architecture and ABI.
In this case, by passing this flat, we essentially tell it to</p>

assemble into x86-64 instructions</li>
an in doing so use Mac's x86-64 ABI and Mach-o binary file format.</li>
</ul>
It results in generation of an executable that runs on Intel x86_64 binary.
But, again, because of rossetta2, ARM64 Macs are able to translate those instructions into ARM64 instruction on the fly.</p>
</blockquote>
Example: Adding Integer Arrays with SIMD Operations</h2>
Finally, I'm gonna leave you with a simple example.
Let's use SSE instructions</a> to add two arrays of integers.</p>
Let's go through the steps I mentioned above.
Here's the assembly code.</p>
# file: add_simd.s

.text
.globl _add_arrays

# void add_arrays(
#     const int *a,   rdi
#     const int *b,   rsi
#     int *out,       rdx
#     int n           rcx
# )

_add_arrays:
    xorq %r8, %r8

.loop:
    cmpq %rcx, %r8
    jge .done

    # Load four integers from `a` (%rdi)
    movdqu (%rdi,%r8,4), %xmm0

    # Load four integers from `b` (%rdi)
    movdqu (%rsi,%r8,4), %xmm1

    # Add four integers in parallel
    paddd %xmm1, %xmm0

    # Store the result
    movdqu %xmm0, (%rdx,%r8,4)

    addq $4, %r8
    jmp .loop

.done:
    ret
</code></pre>

Note the exposed symbol _add_arrays</code>, which matches a C function with name add_arrays</code>.
This convention is part of MacOS's x86-64 ABI.</p>
</blockquote>
In the C code, we declare the add_arrays</code> function at the top the file.</p>
// file: main.c

extern void
add_arrays(const int *a,
           const int *b,
           int *out,
           int n);
</code></pre>
Testing the code:</p>
// file: main.c

#include <stdio.h>
#include <stdint.h>

extern void add_arrays(const int *a, const int *b, int *out, int n);

int main(void)
{
    int a[] = {1, 2, 3, 4, 5, 6, 7, 8};
    int b[] = {10, 20, 30, 40, 50, 60, 70, 80};
    int out[8];

    add_arrays(a, b, out, 8);

    for (int i = 0; i < 8; i++) {
        printf("%d ", out[i]);
    }

    printf("\n");
}
</code></pre>

Each XMM register above is 128 bits wide, which means it can hold, 4 (32-bit) integers, so every loop iteration performs something like the following</p>
out[i + 0] = a[i + 0] + b[i + 0]
out[i + 1] = a[i + 1] + b[i + 1]
out[i + 2] = a[i + 2] + b[i + 2]
out[i + 3] = a[i + 3] + b[i + 3]
</code></pre>
with a single SIMD addition instruction.</p>
</blockquote>
Now, to compile</p>
$ clang -target x86_64-apple-macos main.c add_simd.s
</code></pre>
We can inspect to see what kind of file it's generated</p>
$ file a.out
a.out: Mach-O 64-bit executable x86_64
</code></pre>
Running it,</p>
$ ./a.out
11 22 33 44 55 66 77 88
</code></pre>

First Post

2026-06-01T00:00:00+00:00

The first principle is that you must not fool yourself — and you are the easiest person to fool.</p>

Richard Feynman </footer> </blockquote> </div>

It is a capital mistake to theorize before one has data.</p> </blockquote> </div>

I have made this longer than usual because I have not had time to make it shorter.</p>

Blaise Pascal , Lettres Provinciales </footer> </blockquote> </div>

Quotes</h2>

Graphical excellence is the well-designed presentation of interesting data.</p>

Edward Tufte , The Visual Display of Quantitative Information </footer> </blockquote>

This is exactly what Orwell had in mind when he wrote:</p>

Never use a long word where a short one will do.</p>

George Orwell , Politics and the English Language </footer> </blockquote>

And that principle applies equally to code.</p>

Side notes and margin notes</h2>
This is the `simd</code> first post.</label> You can use all your shortcodes here too.</span> </p>`

Full-width stuff</h2>
int main(void)
{
  std::cout << "Hello, World\n";
}
</code></pre>

# a wide block that needs more horizontal space
result = some_very_long_function_name(argument_one, argument_two, argument_three) 
</code></pre>
</div>
Alert environments</h2>

Beware of double pointers!</p>
hello world is</p>
int main(void) { ... }
</code></pre>
and then later it is note as ...</p>
</blockquote>

A helpful tip for the reader.</p>
</blockquote>

Something the reader really should not miss.
This is the simd</code> first post.</label>

You can use all your shortcodes here too.</span>
</p>
</blockquote>

A warning about potential pitfalls.</p>
</blockquote>

A strong caution about destructive or irreversible actions.</p>
</blockquote>
To use Tufte CSS, copy tufte.css and the et-book directory of font files to your project directory, then add the following to your HTML document’s head block:</p>
<link rel="stylesheet" href="tufte.css"/>
</code></pre>
Math support</h2>
$$
x^2
\frac{1}{x}
12\,\rm{m}^2
$$</p>
Inline math: 

\(\frac{1}{2}\)</span>
</p>
Display math:


 $\[\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2} 12\,\rm{m}^2\]</div> </p> ...</p> \[x^2 \frac{1}{x} 12\,\rm{m}^2\]</div> ...</p> \[\int_0^\infty...\]</div>$

Ali's Blog

x86-64 Assembly on an M-series Mac

First Post

Math support</h2> $$ x^2 \frac{1}{x} 12\,\rm{m}^2 $$</p> Inline math: \(\frac{1}{2}\)</span> </p> Display math: \[\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2} 12\,\rm{m}^2\]</div> </p> ...</p> \[x^2 \frac{1}{x} 12\,\rm{m}^2\]</div> ...</p> \[\int_0^\infty...\]</div>

Math support</h2>
$$ x^2 \frac{1}{x} 12\,\rm{m}^2 $$</p>
Inline math: \(\frac{1}{2}\)</span> </p>
Display math:
$\[\int_0^\infty e^{-x^2} dx = \frac{\sqrt{\pi}}{2} 12\,\rm{m}^2\]</div> </p> ...</p> \[x^2 \frac{1}{x} 12\,\rm{m}^2\]</div> ...</p> \[\int_0^\infty...\]</div>$