Installing SimpleASM

This will normally install all the required missing packages.

Using SASM

A bunch of files will be installed, and you won’t see the error anymore.

In SASM, go to the Settings dialog, as shown in Figure 7-1. On the Common tab, select Yes for “Show all registers in debug.”

On the Build tab, modify the settings as shown in Figure 7-2.

Be very careful here, because the settings have to be exactly as shown in the figure; one space too many, even hidden at the end of a line, and SASM will not do what you want. When you are ready, click the OK button and restart SASM.

If jump.asm does not exist, SASM will start with a new editor window; just delete the default code. If the file exists, it will open in the editor window.

Copy the code into the SASM editor window; by default SASM will use syntax highlighting. When you are finished typing, hit the green triangle icon at the top, which means “run.” If everything goes correctly, you will see your output in the Output area, as shown in Figure 7-3.

When you save a file in SASM, the source code will be saved. If you want to save the executable, you need to choose Save.exe in the File menu.

To start debugging, click in the numbered left margin to the left of the main: label. This will put a red circle between the main: label and its line number. This is a breakpoint. Then at the top click the green triangle with the bug on it. In the top menu, choose Debug and select Show Registers and Show Memory. A number of additional windows will appear on your screen: Registers, Memory, and also a GDB command-line widget.

This line can confuse other debuggers such as GDB, so make sure to remove it from the code before you run GDB separately from the CLI.

In the SASM menu Settings ➤ Common, make sure to select Yes for “Show all registers in debug.” When debugging in SASM, scroll down in the register window. At the bottom you will see 16 ymm registers, each with two values between parentheses. The first value is the corresponding xmm register. We will explain these registers in more detail when we talk about SIMD.

By the way, Figure 7-4 shows the output on the screen after building and running the program as we did before.

In the program we use a compare instruction cmp and two jump instructions, jge and jmp. The cmp instruction is what is called a conditional instruction. Here cmp compares two operands, in this case two registers. One of the two operands can also be a memory operand, and the second operand can be an immediate value. In any case, the size of the two operands must be the same (byte, word, and so on). The cmp instruction will set or clear flags in the flag register.

The flags are bits located in the rflags register that can be set to 1 or cleared to 0, depending on a number of conditions. Important in our case are the zero flag (ZF), the overflow flag (OF), and the sign flag (SF). You can use your debugger to examine these and other flags. With SASM you can easily see what is happing to all the registers, including the flag register, called eflags in SASM. Different values in the cmp operands will result in different flags being set or cleared. Experiment a little bit with the values to see what is happening with the flags.

In our program we have also an unconditional jump instruction, jmp . If the program execution hits this instruction, the program jumps to the label specified after jmp, regardless of flags or conditions.

The program adds all the numbers from 0 to the value in number. We use rbx as a counter and rax to keep track of the sum. We created a loop, which is the code between jloop: and jle jloop. In the loop, we add the value in rbx to rax, increase rbx with 1, and then compare if we have reached the end (number). If we have in rbx a value lower than or equal to number, we restart the loop; otherwise, we continue with the instruction after the loop and get ready to print the result. We used an arithmetic instruction, inc, to increase rbx. We will discuss arithmetic instructions in later chapters.

Here you see that there is a special loop instruction that uses rcx as a decreasing loop counter. With every pass through the loop, rcx is decreased automatically, and as long as rcx is not equal to 0, the loop is executed again. That’s less code to type.

Note that betterloop is slower than jumploop (see Figure 7-5)! Using the loop instruction is convenient but comes at a price in terms of execution performance. We used the Linux time instruction to measure the performance; later we will show more appropriate ways to investigate and tune program code.

You may wonder why we bothered to use DDD when there is a tool such as SASM. Well, you will see Iater that in SASM you cannot investigate the stack, but you can with DDD. We will return to DDD later.

Summary