In my last post, I reversed a string. I want to build on that to make reusable code; I want to reverse multiple strings. I do this by turning the reverse code into a function and then call it.

In my last post, I showed that I could modify a single character in a string. I want to build upon that to perform more complext string manipulations. Lets start with something simple.

When ever I write new console based code from scratch, I start with “Hello World.” Then I make one small change at a time, test it, and commit. Then I move on. While this slow process might seem tedious, it is based on years of wasting time debugging my own poorly written code in interim changes.

Once I had “Hello, World!” working in assembly, I want to make a single character change to message and see it in the console. Here’s my steps.

There are two basic ways to inspect a running program: print out a bunch of debug statements or run it through a debugger. Since I don’t yet know how to print out my own statements in ARM64 debugging (I’ll get there soon) I want to use the debugger to see my code in action.

In order for a program to run successfully, it needs two things: an entry symbol, and a return code that represents that success. The following program provides those two things.

.global _start
 
_start:     
            MOV     X0, #0
            MOV     X8, #93
            SVC     0

Compile it using the simple Makefile from the previous article.

The symbol _start is a special symbol expected by the linker. If you try to rename like this…….

.global _ADAM
 
_ADAM:     
            MOV     X0, #0
            MOV     X8, #93
            SVC     0

…you get the following error:

$ make other
as -o other.o other.s
ld -o other other.o
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400078

Which will still compile and run.

If you leave off the three assembly instructions at the end, you do not return 0 indicating the program success.

.global _start
 
_start:

That gives you this error:

To be honest, there are no instruction in the code, and I think that is a different problem. If we skip executing the function to send the return code:

.global _start
 
_start:     
            MOV     X0, #0
            MOV     X8, #93

That gives this error when run:

$ ./bad_return 
Illegal instruction (core dumped)

I want to automatically build assembly files into executable binaries. The following Makefile seems to be sufficient. I am sure I will add to it over time.

All I have to modify is the SRC_FILES line to add a new target

Note that html does not honor the tab characters.

EDIT: I swapped the SRC_ and B_ files so that the top list is the end result. This allows you to just run make and build all of your executables. It would also let you mix and match between assembly and other languages. But (most importantly) I like it better.

B_FILES=simple printer
SRC_FILES = $(B_FILES:%=%.s)
O_FILES = $(SRC_FILES:%.s=%.o)
 
all: $(B_FILES) 
 
%: %.s 
	as -o $@.o $<
	ld -o $@ $@.o
 
clean:
	rm -f $(O_FILES) $(B_FILES)