CS270 x86 Assembly Blog

This is a blog dedicated to CS270 at John Carroll University. A class where we teach ourselves a new programming language. The first post is a basic "Hello World" program. The next four posts were intermediate programs. These included printing signed integers to the console, getting the modulus of two numbers, checking if a number is negative, and getting the factorial of a number. The final posts are all about programming an OS with Assembly.

[cs270assembly-blog]

OS - Entering Protected Mode

Now that we have discussed the A20 line and the Global Descriptor Table, we’re finally ready to enter protected mode. Protected mode adds a level of abstraction so that our kernel will not be able to access hardware directly. It also allows us to use up to 4GB of RAM and many other features that won’t be covered. So first, the code.

; Craig Milby ; Bootloader Stage 2 ; May 2nd, 2015 ; boot2.asm [bits 16] [org 0x500] _start: jmp _main_16 %include "A20.asm" %include "gdt.asm" %include "io_16.asm" loaded_32_msg: db "Loaded 32-Bit Protected Mode", 0 loaded_boot2_msg: db "Loaded Bootloader Stage 2", 13, 10, 0 _main_16: mov bp, 0x9000 mov sp, bp mov si, loaded_boot2_msg call _print_16 call _enable_A20_BIOS cli lgdt [_gdt_descriptor] mov eax, cr0 or eax, 1 mov cr0, eax jmp CODE_SEGMENT:_init_32 [bits 32] %include "io_32.asm" _init_32: mov ax, DATA_SEGMENT mov ds, ax mov ss, ax mov es, ax mov fs, ax mov gs, ax mov ebp, 0x90000 mov esp, ebp _main_32: call _clear_screen_32 mov ebx, loaded_32_msg call _print_32 jmp $

We are not going to be looking at the Stage 1 bootloader code because it hasn't changed. This will all be in our second stage loader. As usual, much of this code is familiar so only select parts will be discussed.

cli lgdt [_gdt_descriptor]

We know what the first instruction does, disables all interrupts. In protected mode, we cannot use BIOS interrupts because these are hardware access which we no longer have. If one is used, the OS will triple-fault and crash. The next line is how we load our Global Descriptor Table. Assembly provides a simple way of loading it with the lgdt instruction. Then we just have to specify where in memory it actually is, easy enough.

mov eax, cr0 or eax, 1 mov cr0, eax jmp CODE_SEGMENT:_init_32

Here we have new registers we haven't seen before. cr0 is a control register. We have to set its flag to the correct value to jump it into 32-bit mode like so. After that we define where our code is (remember we did this in our GDT file) and jump to it.

[bits 32] %include "io_32.asm"

Up next, we use an assembler directive to define that we are now using 32-bits. The assembly will now know to start usign 32-bit registers. After, we include another file. This is a basic input/output file for protected mode. Our 16-bit real mode printing required BIOS interrupts. This one does not. I will most likely not show this code however.

_init_32: mov ax, DATA_SEGMENT mov ds, ax mov ss, ax mov es, ax mov fs, ax mov gs, ax mov ebp, 0x90000 mov esp, ebp

This is where our 32-bit code enters. It starts by setting all the registers to the value of DATA_SEGMENT which is defined in our GDT file. We then set up our 32-bit stack. This stack is much larger due to memory limitations being expanded. ebp is the bottom of the stack and esp is the top but they both start at the same value.

_main_32: call _clear_screen_32 mov ebx, loaded_32_msg call _print_32 jmp $

This is our last bit of code. Our main protected mode code. In future version this is where the kernel would be loaded, but in our case, we are just going to pritn stuff to the screen. First we clear the screen with the clear_screen call, then we move our message to the dbx ebx register and print it. Lastly we repeatedly jump to the last line halting the CPU. Let's see what this looks like!

Wow! Colors! We can define lots of colors now that we have access to video memory when we are in protected mode. Here's more.

From here, lots of things can be done. We can load a kernel and start programming in C. This is done a lot because C is a lot easier than Asseembly. We could stay usign Assembly and go into 64-bit long mode. This will give us access to more memory and loads of other features. As for this blog, this is the end. Hope you learned something and enjoyed it.

[cs270assembly-blog]

OS - A20 Line

Back when computer were new and hardware started to become smaller, Intel decided they wanted to make their computers backwards compatible. When they made this decision, they were using 16-bit processors. Then they released 32-bit processors. Well when a 32-bit processor ran a 16-bit program, energy was wasted so they put in a gate. This can be disabled or enabled to make a processor 32 or 16 bit. I have a 64-bit processor but we’re gonna make a 32-bit OS. When our bootloader starts, the A20 line could be in either state and checking it is a lot of code so we're just gonna enable it!

There are lots of ways to do this and some work on some computers and not on others. I have found multiple that work on my computer (Intel-Based MacBook Pro, Late 2011) so we're gonna examine one way to do it.

_enable_A20_BIOS: pusha mov ax, 0x2401 int 0x15 popa ret

This is a very small amount of code so we are gonna break it down all at once. First we have the label which we know and love. Then we pusha and save the state of all our registers. Next, moving 0x2401 into ax is a special number that uses a BIOS interrupt to enable the A20 line. Then we call the inerrupt, restore the registers, and return.

We will call that before we enter protected mode. This will allow us to use a 32-bit processor. Exciting. The next post is going to be the last post. We are gonna bring it all together to enter 32-bit protected mode and print something to the screen. Except this time we will have color :-)

[cs270assembly-blog]

OS - Global Descriptor Table

Now that we have as much memory as we want to make a bootloader we can start doing more exciting things! At the moment we are in what's called 16-bit real mode. There is A LOT of theory about this and the next level but that is WAY out of the scope of this blog so just accept that the next step is to get into 32-bit real mode.

First is the Global Descriptor Table (GDT). This is required for when we he start to handle memory and the stack and other important things handed by our Kernel. This is a pretty big topic so here's code.

[bits 16] CODE_SEGMENT equ _gdt_code - _gdt_start DATA_SEGMENT equ _gdt_data - _gdt_start _gdt_start: _gdt_null: dd 0x0 dd 0x0 _gdt_code: dw 0xffff dw 0x0 db 0x0 db 10011010b db 11001111b db 0x0 _gdt_data: dw 0xffff dw 0x0 db 0x0 db 10010010b db 11001111b db 0x0 _gdt_end: _gdt_descriptor: dw _gdt_end - _gdt_start - 1 dd _gdt_start

We all know the drill. Some we know, break down the rest.

CODE_SEGMENT equ _gdt_code - _gdt_start DATA_SEGMENT equ _gdt_data - _gdt_start

These are extremely important. This is gonna keep track of where our Kernel and other code is and where the data is. If you knew assembly it would make sense why this was important but the gist is that they need to be in a different area, okay?

_gdt_null: dd 0x0 dd 0x0

This is the null descriptor. I'm not sure why it's a thing. I'm just told it is.

_gdt_code: dw 0xffff dw 0x0 db 0x0 db 10011010b db 11001111b db 0x0

This keeps track of our code. It is identical to the data descriptor. They can be different but for this small project they don't need to be.

_gdt_descriptor: dw _gdt_end - _gdt_start - 1 dd _gdt_start

This is how we will load our GDT. This defines that the GDT is 64 bits, by subtrating the start and end address and 1. Then it defines where the start is.

This is a really in-depth topic and has a lot too it but it's necessary for us to get into 32-bit protected mode. If you wan't to learn more look here. I think next time I will talk breifly about the A20 line.

[cs270assembly-blog]

OS - 2-Stage Bootloader

Now that we have a way of printing characters to the screen we can move on. Our 1-Stage bootloader is capable of doing quote a bit, however, it is not big enough to do everything. (Remember it can only be 512 bytes)

To prevent this problem, we make a 2-stage bootloader. There are many ways to do this, but since we are gonna do it the most simple way. Remeber when we talked about sectors? Well our stage 1 bootloader is loaded into the complete first sector so this means that we can load the stage-2 bootloader into the second sector and take us much space as we need. So we're gonna do this like usual, code then analysis.

; Craig Milby ; Bootloader Stage 1 ; April 28, 2015 ; Boot1.asm [bits 16] [org 0x7C00] _start: jmp _main %include "io_16.asm" boot_1_loading_msg: db "Loading Bootloader Stage 1...", 13, 10, 0 boot_1_loaded_msg: db "Loaded Bootloader Stage 1!", 13, 10, 0 _main: mov si, boot_1_loading_msg call _print_16 mov ax, cs mov ds, ax mov es, ax mov fs, ax mov gs, ax _reset: mov ax, 0 mov dl, 0 int 13h jc _reset _read: mov ax, 0 mov es, ax mov bx, 0x500 mov ah, 2 mov al, 1 mov ch, 0 mov cl, 2 mov dh, 0 mov dl, 0 int 13h jc _read mov si, boot_1_loaded_msg call _print_16 _enter_stage_2: jmp 0x500 times 510 - ($ - $$) db 0 dw 0xAA55 ; Craig Milby ; Bootloader Stage 2 ; April 28, 2015 ; Boot2.asm [bits 16] [org 0x500] _start: jmp _main %include "io_16.asm" boot_2_loaded_msg: db "Loaded Bootloader Stage 2!", 13, 10, 0 _main: mov bp, 0x9000 mov sp, bp mov si, boot_2_loaded_msg call _print_16 cli hlt

Most of this code is familiar! Let's break down what we don't know.

_reset: mov ax, 0 mov dl, 0 int 13h jc _reset

This resets our BIOS. First we set the head of the disc we are looking for then we call our BIOS interrupt and if it finds the disc, it continues.

mov ax, 0 mov es, ax mov bx, 0x500

This is setting the memory addresses. "ax" is the upper 8-bits, "es" is the lower 8, and "bx" is where in memory we should load the stage-2 bootloader.

mov ah, 2 mov al, 1 mov ch, 0 mov cl, 2 mov dh, 0 mov dl, 0 int 13h jc _read

Here we setup all the components for reading oru floppy. ah is the bios sector we are going to write too. al is how many sectors we are going to read, ch is the track, cl is which sector we are reading, dh is the head and dl is the drive. All this is necessary for a floppy and will only work for floppies. We the call our interrupt and it loads our stage two to memory. If it doesn't work it tries again.

_enter_stage_2: jmp 0x500

Here, we are going to do the actual jump to our second stage. This just jumps us to that memory address where we loaded our stage 2 bootloader.

[bits 16] [org 0x500] _start: jmp _main %include "io_16.asm"

We know most of this code. We define the second stage loader as 16 bits and set where in memory the code is at. It then jumps to our main. %include just includes an outside file. This was also seen in stage 1 and contains our print function. Nothing too crazy.

_main: mov bp, 0x9000 mov sp, bp mov si, boot_2_loaded_msg call _print_16 cli hlt

This last bit only needs a little explaining. This is where we set up the stack. Memory address 0x9000 is free all the way to 0xFFFF so we have copious room to make the stack. bp is our base pointer register and sp is our stack pointer. Both are the same because the stack is empty. Then we print our message, disabble interrupts and halt the CPU. Building this will need a little explaining though.

dd if=/dev/zero bs=1024 count=1440 > OS.dmg nasm -f bin boot1.asm -o boot1.bin nasm -f bin boot2.asm -o boot2.bin dd if=boot1.bin of=OS.dmg conv=notrunc dd if=boot2.bin of=OS.dmg obs=512 seek=1 conv=notrunc

First we use dd to create a fake floppy, we've seen this before. Then we turn our .asm files into binary files. Then we copy the binary files to the floppy. conv=notrunc keeps the file the same size. boot1.bin is added at the very beginning. boot2.bin is added with an offset of 512 bytes (The size of our bootlaoder) making it in the second sector of the floppy, just where we want it to be.

So now when we build and run it we get this.

Now we have a stage 2 bootloader which can be as big as we want. We're gonna discuss some extremely brief A20-theory (maybe) and some Global Descriptor Table theory briefly next time. Cool.

[cs270assembly-blog]

OS - Printing Characters

So now that we have an extremely basic bootloader, we can start doing stuff. One of the first things most people want to do is print characters to the screen. This is helpful when debugging, as well as useful and it can be fun!

First we need to discuss what we can and cannot do. This text WILL be white with a black background. When we enter 32-bit Protected mode, this can change, but for now, this is what we have to do. Next, we cannot type stuff on screen yet. All text on screen will be declared before runtime. So lets dive right into the code.

; Craig Milby ; 20 April, 2015 ; Print characters in 16-bit real mode ; Message in si register _print_16: pusha _print_16_loop: lodsb or al, al jz _print_16_done mov ah, 0eh int 10h jmp _print_16_loop _print_16_done: popa ret

Some of this code we've seen before, other is new. Let's break it down.

_print_16: pusha

This code adds a label for the start of the printing routine. "pusha" will then save the state of all the registers we use. At this early point in development, this isn't too important, but will be later on.

_print_16_loop: lodsb or al, al jz _print_16_done

The most confusing part of this part is the "lodsb" instruction. This loads the string from the si register into the al register. or-ing al with itself then returns how much of the string is left. If it is 0, then the whole string is printed and we can exit the function.

mov ah, 0eh int 10h jmp _print_16_loop

Next, we move 0e's hexadecimal value into our ah register, then call a BIOS invoke. The invoke 10-hexadecimal is the intrrupt for printing. This will print 1 character to the screen then the whole process is repeated for each character. Simple enough.

_print_16_done popa ret

Our final three lines first restore all registers with the popa instruction then just exit the rountine back to where it last was. Let's see this in action!

[bits 16] [org 0x7C00] _start: jmp _main _print_16: pusha _print_16_loop: lodsb or al, al jz _print_16_done mov ah, 0eh int 10h jmp _print_16_loop _print_16_done: popa ret prepare_boot1_msg: db "Loading Bootloader Stage 1...", 13, 10, 0 _main: mov si, prepare_boot1_msg call _print_16 cli hlt times 510 - ($ - $$) db 0 dw 0xAA55

We've seen most of this code before! Let's go over the new lines.

prepare_boot1_msg: db "Loading Bootloader Stage 1...", 13, 10, 0

First we declare a label so we know where in memory our message can be found. Then we declare a byte with a message. Each character of the message is stored in exactly one byte, so thats quite a few bytes (Remember, we can only use 512 bytes in this bootloader).

mov si, prepare_boot1_msg call _print_16

This is also very straightforward. The first line just moves our message into the si register. We then call our print routine and it will print it to the screen. We then clear interrupts and halt the CPU. So how does this look onscreen?

Note: I have switched from VirtualBox to bochs for various reasons. They are both emulators and will both give the same result.

Well now we have text on our screen! Time to install Google Chrome, right? Not quite! Up next we need to switch to a stage-2 bootlaoder so we can use more than 512 bytes. This will allow us to do much more.

[cs270assembly-blog]

Assembly Presentation

Here is the powerpoint from the presentation in class. The code from the presentation will be uploaded in the coming days.

[cs270assembly-blog]

OS - Extremely Basic Bootloader

Now that we know a little about bootloaders, we can implement out first one. I'm gonna show the code first then break it down line by line.

; Basic Bootloader ; ; April 14, 2015 ; Craig Miby [bits 16] [org 0x7C00] jmp _start _start: cli hlt times 510 - ($ - $$) db 0 dw 0xAA55

This is the most basic bootloader possible. So lets break it down.

[bits 16] [org 0x7C00]

The first line defines that we will be running our OS in 16 bit mode. The x86 family is backwards compatible with older systems so we add this to know what system we will be running it. It is possible to switch to 32-bit or 64-bit mode but this can be discussed later.

jmp _start start:

These two lines go together. The 'jmp' instruction jumps to the 'start' identifier which will then execute the next segments.

cli

The 'cli' instrution clears and stops all interrupts. This allows us to do the next instruction.

hlt

The 'hlt' instruction is short for halt (This is part of where the joke 'Halt and Catch Fire' comes from). This instruction stops the CPU from doing anything. This is here for our basic bootloader so we can just test our OS.

times 510 - ($ - $$) db 0

This line is ESSENTIAL. It declares an array of bytes of a variable length. The length is determined where '($ - $$)' is. This part takes the current address of the code and subtracts it from the next one, giving the total length of the code above in bytes. It is the subtracted from 510. The means that all the code in this file up to this is is equal to exactly 510 bytes.

dw 0xAA55

This needs explained. We will need to call interrupts in the next part and they need to know where to look. So we declare a variable that is two bytes in length. The first byte 0xAA and the second byte is 0x55. This allows us to load and execute our bootloader. And since this is two bytes, and our above code was 510 bytes, our entire file is 512 bytes. The exact length it needed to be.

Now that we have the code we need and we understand what it does, how do we run it. First we have to convert our file to the correct kind. My file is called 'bootloader.asm'. With NASM we run the command un Terminal/Command Prompt...

nasm -f bin bootloader.asm -o bootloader.o

This converts our Assembly file into a binary file so we can convert it to an image.

This next part varies depending on your current OS. I use Mac OSX 10.10 (Should work on all UNIX systems). So we run.

dd if=bootloader.o of=floopy.img

Now that we have our virtual floppy we can mount it to VirtualBox and run it as a new OS. It will pop up a black window and keep that open. If it does nothing, this means the CPU has ended just like we intended with the 'hlt' instruction and it works!

Now that we have the basics down, we can move on to some more advanced stuff. Next we will be outputting stuff to the screen. This is easy and will be a much shorter post.

[cs270assembly-blog]

OS Theory - Bootloaders

Operating Systems are an extremely large topic to cover, so I am going to break down some of the basics. All of the topics are very in depth so I will add links where better explanations and examples can be seen.

OS’s need to load and start somehow, and that how is called a bootloader. Bootloaders can be in many different forms like Discs, or Floppies. I will be developing it as if it was being booted of a 3 1/2″ floppy disc.

So what are some specifications of bootloaders? Well, a bootloader cannot exceed 512 bytes of memory. That is not a lot of memory, but there are ways to get around this. The reason this is the case is because on discs, there are 512 byte sectors. The bootloader must take up the entire first sector in order to work correctly. Read more about sectors here if you are interested or confused.

Now that we know what sector a bootloader is in on the floppy, where does it go in memory? The bootloader has to be loaded at memory address 0x7C00. This allows the bootloader to use interrupts.

Now that we have an extemely basic idea about what bootloaders do and a little about how they work, we can look at some code next time and we'll make the first extremely basic bootloader and run it!

[cs270assembly-blog]

CS270 Final Project Proposal

Now that I have gained a decent understanding of Assembly I decided to challenge myself. For my final project I am going to be making an extremely basic Operating System. This is one of Assembly’s main purposes and will be a great learning experience, as well as a challenging one.

Operating Systems are programmed by teams of people with years of experience so I will not be making Windows 10. Instead, I will be starting by making a basic bootloader then going on from there. (Generally, after the bootloader is written, a C compiler is added so programming in Assembly is no longer required, I will not be doing this)

Because of the nature of OS’s and how they work, it’s super easy to destroy a computers hardware if you don’t know what you’re doing. So, to be safe, I am going to only boot it on a Virtual Machine. 

As usual this will be written in x86 Assembly and compiled with NASM then run on Oracle Virtual Box. I will be posting some basics on OS’s in the coming days, as well as snippets of code and pictures. 

[cs270assembly-blog]

Programs 3 && 4

Now that the first two programs are out of the way and the next two were written in C, i re-implemented them in Assembly. The two that were implemented were checking if a number is negative, and a factorial function. First up was the negative check.

This was done by taking a number in a register in the function then comparing it to 0. If it was less than 0 it was negative, otherwise it was positive. I also implemented a check to see if it was 0 for fun even though it returns the same value as the positive check.

is_negative: ; Assume value in r15 cmp r15, 0 ; Check number compared to 0 jl is_negative_is ; If number less than, it's negative je is_negative_zero ; If zero, return 0 mov r15, 1 ; Else it's positive, return 0 ret ; Return is_negative_is: mov r15, 1 ; If negative, return 1 ret ; Return is_negative_zero: mov r15, 0 ; If 0, return 0 ret ; Return

This was pretty straight forward to implement and only required an statement to check the number against 0.

The next implementation was factorial where a positive integer is multiplied by all positive integers less than it. This required looping and multiplication but was still pretty straight forward.

factorial: ; Assume number in r15 mov r14, r15 ; Move r15 to r14 factorial_loop: dec r15 ; Subtract 1 from r15 mov rax, r15 ; Move r15 to rax mov rdx, r14 ; Move total to rdx mul rdx ; rax * rdx mov r14, rax ; Move total to r14 cmp r15, 1 ; Compare counter to 1 jne factorial_loop ; If not equal, loop mov r15, r14 ; Move value to r14 ret

Here all it took was looping while the value was greater than 1. All 4 if these function work and are complied with gcc on a mac. They should work on any intel based processor.

[cs270assembly-blog]

Programs 1 && 2

Having already implemented the first two functions in C, I used the syntax explained in the last post to implement them in Assembly. 

The first function I implemented was printing base-10 integer to the console. This proved to be a challenge because only single characters can be printed. To do this I had to first add a new line character (0x0a) onto the stack, then take in the number and determine if it was positive or negative first. If it was negative a ‘-’ character was added to the stack. After that the number was divided by 10 and the remained was added to the stack. This was done until the remainder was 0. Then, it cycled through the stack until it was empty printing the single characters to the console. The code is below.

; Craig Milby ; 03-18-2015 ; This function takes a number (positive or negative) and ; prints it to the console print_integer: ; Assume integers is in r15 push 0x0a ; Push an endline character mov r13, 0x00 ; Save empty character in case of ngative mov r14, 2 ; Setup counter push r15 ; Push number to stack to save call is_negative ; Check if number is negative cmp r15, -1 ; If 0, it's negative je print_integer_negative ; Check for negative pop r15 ; Pop new number off stack print_integer_stack_loop: mov rax, r15 ; Move r15 to rax for divison xor rdx, rdx ; Avoids error mov rcx, 10 ; Divisor because base 10 idiv rcx ; rax = rdx:rax / rcx|rdx = rdx:rax % rcx add rdx, '0' ; Convert 0-9 to ‘0’-‘9’ push rdx ; Push remainder to stack mov r15, rax ; Move quotient to r15 register inc r14 ; Counter + 1 cmp r15, 0 ; Compare quotient to 0 jne print_integer_stack_loop; If not zero, loop push r13 print_integer_print_loop: ; Characters are now on stack in reverse order mov rsi, rsp ; Put remainder in rsi mov rdx, 1 ; Print 1 char (length) mov rax, 0x2000004 ; System call write mov rdi, 1 ; Standard output, number of bytes syscall ; Invoke kernal dec r14 ; Counter - 1 pop r15 ; Remove off top of stack cmp r14, 0 ; Compare counter to 0 jne print_integer_print_loop; Loop ret ; Return print_integer_negative: ; Called when integer is negative inc r14 ; Incriment counter for negative sign pop rax ; Pop the number off the stack into rax mov rbx, -1 ; -1 in rbx to flip sign imul rbx ; Multiply so new number is positive mov r15, rax ; Move number to r15 for division mov r13, '-' ; r13 is gonna save the negative sign call print_integer_stack_loop

All the code is commented so you can follow what actually happens when it is executed. The other function that was implemented was the modulo operator. This function takes two integers in registers then gets the remainder in another register.

; Craig Milby ; 03-18-2015 ; This method takes two integers in the r15 and r14 registers, ; divides them, and returns the remained modulo: ; Assume r15 % r14 mov rax, r15 ; Move r15 to rax for division xor rdx, rdx ; Clear rdx mov rcx, r14 ; Move r14 to rcx for division idiv rcx ; Divide mov r15, rdx ; Move remaineder to r15 ret

The next two implementations will be determining if a number is negative and a factorial function. As before I implemented them in C first for ease which is as follows.

// If it's negative this method returns a // 0, if it's positive or 0, 1 is returned // (C has no boolean type) int isNegative(int num) { if (num == 0) return 1; else if (num < 0) return 0; return 1; } // Gets the factorial of integer num which is // passed in in the parameter int factorial(int num) { int factorial = 1; for (int i = 1; i <= num; i++) factorial *= i; return factorial; }

[cs270assembly-blog]

Basic Assembly Syntax

Assembly being so level means it doesn’t have the high level if’s and loops that object-oriented languages like Java has. Instead of if’s in Assembly you must first use a command called “cmp” which compares the value in a register to another value in a register or a constant.

cmp rax, 0 cmp rax, rdx

Here we compare the values in rax to 0 first then compare the values in rax to rdx.

After the values are compared, you need to use a jump command. There are many kinds of jumps for all conditions.

jg (Jump greater) jl (Jump less) je (Jump equal) jne (Jump not equal)

These are just a few of the many. So in an actual program this would be like follows.

cmp rax, 0 je _function

Here, we compare the value in rax to 0, then if it is equal to 0, the _function is executed.

Now loops. Many high level languages have for-loops, while-loop, do-while loops, or other forms of loops. Assembly has none of these. Assembly has a jump call seen above with the if as well as a "jmp" command which goes directly to the function unconditionally, and a "call" command which executed the function. These will be implemented and seen in the actual Assembly code.

Because Assembly is unlike other code, I implemented the functions in C first. The first two are as follows.

// Printing base-10 integer void print_base_10_integer(int x) { printf("%i\n", x); // Can just call print } // Modulo (Division remained) int modulo(int x, int y) { return x % y; // Can just return the remainder with operator }

In C, these were very easy to implement but will prove to be more difficult in Assembly. The actual code and an explanation will be posted in the days to come.

[cs270assembly-blog]

Intermediate Programming Project

For the next part of the assignment we have to do an intermediate project that will demonstrate some of the basic features of the language through a project. For my project I have decided to implement some basic math function. Being printing base-10 integers to the console, getting a numbers factorial, modulo, and getting the absolute value of a number. 

Assembly being so unlike anything I have done before I have decided to implement this is a higher level language first that I am more familiar with. In this case I am doing it in C. The implementations of this will be in the days to come.  

[cs270assembly-blog]

CS270 x86_64 Assembly Hello World

For my CS270 class we had to teach ourselves a programming language, I choose Assembly. I have been using my Mac to program it in. Assembly is low level and very unlike other languages. In it you have direct access to memory on the processor called registers. Here you move data in and out of those as well as on and off the stack. Below is a basic Hello World program in x86_64 Assembly.

; Craig Milby ; CS 270` section .data hello_world db “Hello World!”, 0x0a section .text global start start: mov rax, 0x2000004 mov rdi, 1 mov rsi, hello_world mov rdx, 14 syscall mov rax, 0x2000001 mov rdi, 0 syscall

In Assembly, variable decleration is done in the .data section. In this case, the string "Hello World!" and an endline character are declared.

Actual code is in the .text section. Each of the 16 registers have their own name and some have specialized purposes. The 'rax' register makes system calls. In this case its system_write. 'rdi' is set to 1 for standard output. The string is passed into 'rsi' and the length of the string is passed to 'rdx.' syscall is then made and outputs "Hello World!" The program then calls system_exit and safe exits.

This code will compile on any 64-bit Intel-based Macintosh. To compile, save the code as a text file with the extension ".s". Open Terminal, naviagate to the location of the file and convert it to an object file with "nasm -f macho64 [filename].s". Then link with "ld -o [filename].o". The program can then be run and it will print out "Hello World!"