For the next couple tasks I want to do in assembly, I need to be able to inspect an array of numbers. This is useful for debugging searching and sorting algorithms. Since my last attempt to convert binary to ASCII was so ugly, I figured I would clean that up at the same time.
It turns out I can use the reverse code as well.
This is not my finest code. It is the worst case of “just make it work” I’ve produced all week.
But it runs.
What does it do? It takes the first binary number in an array, and converts it to decimal. It assumes that the number is no more than 3 digits long.
It divides that number by 100 to get the 100s digit. Then it multiples that number by 100, assuming that it has gotten truncated. It subtracts that value from the original number to chop off the 100s digit, and divides the result by 10 to get the 10s digit.
Sometime your shell scripts get out of control. Sometimes you are proud of them. Sometimes….both.
I need to be able to re-add a bunch of nodes to an OpenStack cluster on a regular basis. Yes, I could do this with Ansible, but, well, Ansible is great for doing something via SSH, and this just needs to be done here and now. So shell is fine.
This started as a one liner, and got a bit bigger.
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.
MOV X0, #0
MOV X8, #93
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…….
MOV X0, #0
MOV X8, #93
…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.
That gives you this error:
-bash: ./bad_return: cannot execute binary file: Exec format 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:
MOV X0, #0
MOV X8, #93
That gives this error when run:
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.
SRC_FILES = $(B_FILES:%=%.s)
O_FILES = $(SRC_FILES:%.s=%.o)
as -o $@.o $<
ld -o $@ $@.o
rm -f $(O_FILES) $(B_FILES)
Or, as the Peter likes to call them “Double Mambo!” but I think he got that from someone else. Triad pairs are a technique for improvising that have recently gotten a lot of attention. I had not really focused on them in the past. Here’s my notes.