Skip to main content

The Additon & Subtraction in Assembly

There is not much difficulty when it comes to addition and subtraction in assembly programming.

Simply, additon and substraction breaks down to the following:


    add eax, ecx                    ; eax = eax + ecx, result in eax
    add eax, DWORD [ebp-4]             ; eax = eax + localVar1, result in eax
    add DWORD [ebp-4],DWORD [ebp -4]     ; illegal, with all instruction both operands can never be memory 
    add DWORD [ebp-4], eax            ; [ebp-4] = [ebp-4] + eax

    sub eax, ecx                    ; eax = eax - ecx, result in eax
    sub eax, DWORD [ebp-4]             ; eax = eax - localVar1, result in eax
    sub DWORD [ebp-4],DWORD [ebp -4]     ; illegal, with all instruction both operands can never be memory 
    sub DWORD [ebp-4], eax            ; [ebp-4] = [ebp-4] - eax
A simple program to display the message about an arithetic operation like "Math: 8 + 4 = ?" can be achived by the following code block: 
;an equivalent program to this in assembly
SECTION .data

operChar: db '+',0
msg: db 'Math: %d %c %d = %d',10,0

SECTION .text
;allow access to printf
extern printf
;make our main available externally
global main

main:    ;int main(int numArguments, char* arg[])
     push ebp
     mov ebp , esp
    sub esp, 4    ;reserve space for a 32 bit variable[4 byes= 8*4=32]

    ;set up the register what will hold the values we want to operate on
    mov eax , 8
    mov edx , 4
    
    push eax    ;save value of eax; so msg can be displayed correctly
    add eax, edx ;translates to eax = eax + edx
    mov ecx, eax    ;mov result into ecx
    pop eax     ;restore value of eax 

    ;recall that printf tooks like
    ;printf(msg,eax,operChar,edx,result)
    push ecx    ;temporary- we will get the value using assembly, for now just bare with me
    push edx
    push DWORD [operChar]
    push eax
    push msg
    call printf
    add esp, 20     ;this cleans up the stack; we pushed 5 things unto the stack each of 4 bytes long = 5*4


     mov esp, ebp
     pop ebp
     ret
Labels:

Comments

  1. Justin T.April 16, 2013 at 11:11 AM

    Thank you for this. You've really helped me. Your videos are great.

    ReplyDelete

Post a Comment

Popular posts from this blog

Creating local variables In Assembly

Lets go over how to create local variables inside of a pure assembly source code. Much like always, you will start with a *.asm file that looks like this: source code SECTION .data SECTION .bss SECTION .text global main ;make main available to operating system(os) main: ;create the stack frame push ebp push mov ebp, esp ;destroy the stack frame mov esp, ebp pop ebp ret So, the above is the general layout of an NASM source file.  Our goal here is to create a local variable inside of the main method.  The only way to create a local variable is by using the stack.  Why?  Because we can only declare variable in storage locations and the only available storage locations are: text, bss, and data.  However, text section is only for code, so it is out of the question.  The bss and data sections are appealing, but to declare our "local" variable in these sections will defeat the purpose of these variables being local, t
2 comments
Read more

Introduction to Linux Kernel Programming

The Linux kernel is designed as a mixture of a monolithic binary image and a micro-kernel.  This combination allows for the best of both worlds.  On the monolithic side, all the code for the kernel to work with the user and hardware is already installed and ready for fast access, but the downside is that to add more functionality you need to rebuild the entire kernel.   In a different manner, a micro-kernel is composed of small pieces  of code that can be meshed today and more pieces can be added or removed as needed.  However, the downside to micro-kernel is a slower performance. Adding a module to the Kernel Linux is organized as both monolithic, one huge binary, and micro-kernel, as you can add more functionality to it.  The process of adding more functionality to the kernel can be illustrated by the crude image to the left. The process begins by using the command insmod with the name of the kernel module you want (which usually ends with extension *.ko).  From here, the mod
3 comments
Read more

NASM Programming

Many of you, if you are like me, might be interested in how assembly works.  You will be very surprised that assembly is very very easy, especially after you write a couple of simple programs.  But don't get me wrong, you will be frustrated at first, however that frustration, if you channel it right, will lead to serious life long learning and will give you a deeper appreciation of the beauty of assembly. For more tutorial on assembly and visualization of these information, visit my youtube channel . Okay so lets get started. We will be using Netwide Assembler (NASM) to write our program. The general format of NASM file is this: ;This is a comment SECTION .data ;declare variable here SECTION .bss ;declare actual, dynamic variable SECTION .text ;where your program code/assembly code lives ; Working with Data Section In your .data section, you can declare variables like this: nameOfVariable: db 32 ;this declares a variable names nameOfVariable with byte valu
Post a Comment
Read more