How to compile arm assembly on an m1 macbook

Question

I am completely new to assembly and would like to learn arm assembly (simply because I own an m1 mac). I can't really find many ressources online, that's why I'm here. My code is as follows (file is called first.asm):

global _main
section .text

_main: 
    mov r7, 0x4
    mov r0, 1
    ldr r1, message
    mov r2, 13
    swi 0

.section .data
    message: .ascii "Hello, World\n"

When I use

as first.asm -o hello.o 

I get the following errors:

first.asm:2:1: error: invalid instruction mnemonic 'global'
global _main
^~~~~~
first.asm:3:1: error: invalid instruction mnemonic 'section'
section .text
^~~~~~~
first.asm:6:2: error: unknown use of instruction mnemonic without a size suffix
        mov r7, 0x4
        ^
first.asm:7:2: error: unknown use of instruction mnemonic without a size suffix
        mov r0, 1
        ^
first.asm:8:2: error: invalid instruction mnemonic 'ldr'
        ldr r1, message
        ^~~
first.asm:9:2: error: unknown use of instruction mnemonic without a size suffix
        mov r2, 13
        ^
first.asm:10:2: error: invalid instruction mnemonic 'swi'
        swi 0
        ^~~
first.asm:12:15: error: unexpected token in '.section' directive
.section .data

I have a couple of questions:

1. Is "as" a built-in mac compiler for assembly code?
2. Do I need a different compiler?
3. Does it make sense for me to learn arm assembly since I'm on an m1 mac or could I write x86 assembly without issues?

Answer 1

The following tutorial from Stephen Smith details some of the differences between Linux ARM64 assembly language and MacOS ARM64 assembly language: https://smist08.wordpress.com/2021/01/08/apple-m1-assembly-language-hello-world/

Here is a sample HelloWorld.s source assembler program for MacOS ARM64:

// Assembler program to print "Hello World!"
// to stdout.
//
// X0-X2 - parameters to linux function services
// X16 - linux function number
//
.global _start             // Provide program starting address to linker
.p2align 3 // Feedback from Peter

// Setup the parameters to print hello world
// and then call Linux to do it.

_start: mov X0, #1     // 1 = StdOut
        adr X1, helloworld // string to print
        mov X2, #13     // length of our string
        mov X16, #4     // MacOS write system call
        svc 0     // Call linux to output the string

// Setup the parameters to exit the program
// and then call Linux to do it.

        mov     X0, #0      // Use 0 return code
        mov     X16, #1     // Service command code 1 terminates this program
        svc     0           // Call MacOS to terminate the program

helloworld:      .ascii  "Hello World!\n"

The commands to assemble and link it are the following:

as -o HelloWorld.o HelloWorld.s
ld -macosx_version_min 13.0.0 -o HelloWorld HelloWorld.o -lSystem -syslibroot `xcrun -sdk macosx --show-sdk-path` -e _start -arch arm64

IMO, the ideal way to approach the challenge of learning ARM64 assembler on MacOS ARM64 is to use Xcode with its built in source code management and debugger.

The Stephen Smith book and his source code examples is for Linux ARM64 and I believe iOS ARM64. The HelloSilicon GIT repository referenced by Albert is Stephen's source code updated to support native macOS ARM64. Stephen's Chapter 3 source code includes a Xcode.project to run ARM64 on an iOS device with all the view controller junk. The HelloSilicon Chapter 03 includes a much simpler Xcode project for native macOS - Invaluable to you (and me) since you will also develop skills around source code management in Xcode together with using in the Xcode debugger.

Assembler languages are very different between CPU architectures. Whatever one you decide to learn, stick with it.

Answer 2

You are very naive with regards to assemblers. If you have a standard ISO c program chances are that it will run as is on different systems. Adding more of a utility to a program you will discover that you need a standard library that will e.g. read files that are vastly different from MS-Windows to Linux. Even so, if you are presented with a standard program that runs on Linux, you will be at a loss using it on MS-Windows. You will have to learn how to use a compiler on MS-Windows. This could take up one hour, for very experienced people, to one week, or even a year.

The situation with assemblers is worse. Suppose you have understood the machine instructions well enough to craft a program. You will encounter the problem that although Intel has specified the instructions, few assemblers or only the Intel supplied assembler can handle your source. In fact every single assembler program creates its own dialect for Intel instructions (and there is a separate universe for ARM instructions.)

Notorious is that GNU insisted on calling the AX register %ax. Then there is are the assembler directives. You pointed out "global" and "section". They are invented from whole cloth by the inventor of the assembler. As luck may have it there are certain convertions, but they are not much use to you, being inexperienced. In my experience you can port a program in assembler and find 6000 errors in 13000 lines. This can be caused e.g. by different comment conventions, renaming registers, insisting that instruction are lower case, or the order of operands. So you are surprised by finding that "global" is not understood? The first thing to get a manual for that as you are using and discover that "global" is not in there.

That is on top of the problem to run the assembler and use it to make a program, probably a separate link step. That is the difficulty that was familiar with running the c-compiler with a standard library, but on steroids.

If you plan to go on with learning assembly in this way you are advised to goto https://github.com/below/HelloSilicon where there is a whole course, specifically targeting the Apple M1. I cannot stress this enough, assembly language is specific, general advise doesn't cut it. Buy the $50 book, study it, and go step by step.

An alternative is to use an embedded assembler. The idea is that you code a small snippet of code in an interpreter with a high level language. You still have to be aware of register usage within that high level language. This is done in C but the simplest is Forth.

I have written a dialect of Forth. https://github.com/albertvanderhorst/ciforth Within the AMD_64 release you can find the source code of an assembler in the library and an example how to use that to add e.g. floating point instructions to the high level interpreter.

CODE F+ FADDP, ST1|     NEXT, END-CODE

You see here that the single, high-level instruction, F+ is defined, the code to add two floating pointer numbers. CODE is invoking the assembler and END-CODE end this. You are talking to the interpreter of the high level language before and afterwards. The assembler itself understands F+ FADDP, ST1| . NEXT, is a shorthand for instructions that are always the same and instructs the interpreter to go on with the next instruction. That only illustrates the simplest possible use of assembly language for AMD_86 Unfortunately the example is not available for the ARM language, although ciforth has a 64 bits ARM compiler for Linux.