1. Linux.

skills

Keyboard -> Kernel -> Windowing system -> Application program

Bartlett, Jonathan, 1977-
         Programming from the ground up / Jonathan Bartlett ; edited by Dominick
      Bruno.
           p.     cm.
        Includes index.

 incl %edi

as --gstabs maximum.s -o maximum.o

GNU gdb Red Hat Linux (5.2.1-4)
Copyright 2002 Free Software Foundation, Inc.
GDB is free software, covered by the GNU General Public
License, and you are welcome to change it and/or
distribute copies of it under certain conditions. Type
"show copying" to see the conditions.  There is
absolutely no warranty for GDB.  Type "show warranty"
for details.
This GDB was configured as "i386-redhat-linux"...
(gdb)

Starting program: /home/johnnyb/maximum

Program received signal SIGINT, Interrupt.
start_loop () at maximum.s:34
34              movl data_items(,%edi,4), %eax
Current language:  auto; currently asm
(gdb)

(gdb) stepi
35                  cmpl %ebx, %eax
(gdb) stepi
36                  jle start_loop
(gdb) stepi
32                  cmpl $0, %eax
(gdb) stepi
33                  je loop_exit
(gdb) stepi
34                  movl data_items(,%edi,4), %eax
(gdb) stepi
35                  cmpl %ebx, %eax
(gdb) stepi
36                  jle start_loop
(gdb) step
32                  cmpl $0, %eax

cmpl  $0, %eax
je    loop_exit

(gdb) print/d $eax
$1 = 3
(gdb)

 movl data_items(,%edi,4), %eax

(gdb) print/d $edi
$2 = 0
(gdb)

if (a == b)
{
/* True Branch Code Here */
}
else
{
/* False Branch Code Here */
}

/* At This Point, Reconverge */

 #Move a and b into registers for comparison
movl a, %eax
movl b, %ebx

#Compare
cmpl %eax, %ebx

#If True, go to true branch
je true_branch
false_branch:  #This label is unnecessary,
              #only here for documentation
#False Branch Code Here

#Jump to recovergence point
jmp reconverge

true_branch:
#True Branch Code Here

reconverge:
#Both branches recoverge to this point

 printf("The number is %d", 88);

 .section .data
text_string:
.ascii "The number is %d\0"
.section .text
pushl $88
pushl $text_string
call  printf
popl  %eax
popl  %eax      #%eax is just a dummy variable,
                #nothing is actually being done
                #with the value. You can also
                #directly re-adjust %esp to the
                #proper location.

int my_global_var;

int foo()
{
int my_local_var;

my_local_var = 1;
my_global_var = 2;

return 0;
}

 .section .data
.lcomm my_global_var, 4

.type foo, @function
foo:
pushl %ebp            #Save old base pointer
movl  %esp, $ebp      #make stack pointer base pointer
subl  $4, %esp        #Make room for my_local_var
.equ my_local_var, -4 #Can now use my_local_var to
                      #find the local variable

movl  $1, my_local_var(%ebp)
movl  $2, my_global_var

movl  %ebp, %esp      #Clean up function and return
popl  %ebp
ret

while(a < b)
{
/* Do stuff here */
}

/* Finished Looping */

loop_begin:
movl  a, %eax
movl  b, %ebx
cmpl  %eax, %ebx
jge   loop_end

loop_body:
#Do stuff here

jmp loop_begin

loop_end:
#Finished looping

 for(i=0; i < 100; i++)
{
 /* Do process here */
}

loop_initialize:
movl $100, %ecx
loop_begin:
#
#Do Process Here
#

#Decrement %ecx and loops if not zero
loop loop_begin

rest_of_program:
#Continues on to here

struct person {
char firstname[40];
char lastname[40];
int age;
};

 .equ PERSON_SIZE, 84
.equ PERSON_FIRSTNAME_OFFSET, 0
.equ PERSON_LASTNAME_OFFSET, 40
.equ PERSON_AGE_OFFSET, 80

void foo()
{
struct person p;

/* Do stuff here */
}

foo:
#Standard header beginning
pushl %ebp
movl %esp, %ebp

#Reserve our local variable
subl $PERSON_SIZE, %esp
#This is the variable's offset from %ebp
.equ P_VAR, 0 - PERSON_SIZE

#Do Stuff Here

#Standard function ending
movl %ebp, %esp
popl %ebp
ret

 p.age  =  30;

 movl $30, P_VAR + PERSON_AGE_OFFSET(%ebp)

int global_data = 30;

 .section .data
global_data:
.long 30

 a = &global_data;

 movl $global_data, %eax

void foo()
{
int a;
int *b;

a = 30;

b = &a;

*b = 44;
}

foo:
#Standard opening
pushl %ebp
movl  %esp, %ebp

#Reserve two words of memory
subl  $8, $esp
.equ A_VAR, -4
.equ B_VAR, -8

#a = 30
movl $30, A_VAR(%ebp)

#b = &a
movl $A_VAR, B_VAR(%ebp)
addl %ebp, B_VAR(%ebp)

#*b = 30
movl B_VAR(%ebp), %eax
movl $30, (%eax)

#Standard closing
movl %ebp, %esp
popl %ebp
ret

 #b = &a
leal A_VAR(%ebp), %eax
movl %eax, B_VAR(%ebp)

gcc -S file.c

 movl %ebp, %esp
popl %ebp

movl %eax, 8(%ebx,%edi,4)

mov  [8 + %ebx + 1 * edi], eax

gnome-example.s:

#PURPOSE:  This program is meant to be an example
#          of what GUI programs look like written
#          with the GNOME libraries
#
#INPUT:    The user can only click on the "Quit"
#          button or close the window
#
#OUTPUT:   The application will close
#
#PROCESS:  If the user clicks on the "Quit" button,
#          the program will display a dialog asking
#          if they are sure.  If they click Yes, it
#          will close the application.  Otherwise
#          it will continue running
#

.section .data

###GNOME definitions - These were found in the GNOME
#                      header files for the C language
#                      and converted into their assembly
#                     equivalents

#GNOME Button Names
GNOME_STOCK_BUTTON_YES:
.ascii "Button_Yes\0"
GNOME_STOCK_BUTTON_NO:
.ascii "Button_No\0"

#Gnome MessageBox Types
GNOME_MESSAGE_BOX_QUESTION:
.ascii "question\0"

#Standard definition of NULL
.equ NULL, 0

#GNOME signal definitions
signal_destroy:
.ascii "destroy\0"
signal_delete_event:
.ascii "delete_event\0"
signal_clicked:
.ascii "clicked\0"

###Application-specific definitions

#Application information
app_id:
.ascii "gnome-example\0"
app_version:
.ascii "1.000\0"
app_title:
.ascii "Gnome Example Program\0"

#Text for Buttons and windows
button_quit_text:
.ascii "I Want to Quit the GNOME Example Program\0"
quit_question:
.ascii "Are you sure you want to quit?\0"

.section .bss

#Variables to save the created widgets in
.equ WORD_SIZE, 4
.lcomm appPtr, WORD_SIZE
.lcomm btnQuit, WORD_SIZE

.section .text

.globl main
.type main, @function
main:
pushl %ebp
movl  %esp, %ebp

#Initialize GNOME libraries
pushl 12(%ebp)     #argv
pushl 8 (%ebp)     #argc
pushl $app_version
pushl $app_id
call  gnome_init
addl  $16, %esp    #recover the stack

#Create new application window
pushl $app_title    #Window title
pushl $app_id       #Application ID
call  gnome_app__new
addl  $8, %esp      #recover the stack
movl  %eax, appPtr  #save the window pointer
#Create new button
pushl $button_quit_text #button text
call  gtk_button_new_with_label
addl  $4, %esp          #recover the stack
movl  %eax, btnQuit     #save the button pointer

#Make the button show up inside the application window
pushl btnQuit
pushl appPtr
call  gnome_app_set_contents
addl  $8, %esp

#Makes the button show up (only after it's window
#shows up, though)
pushl btnQuit
call  gtk_widget_show
addl  $4, %esp

#Makes the application window show up
pushl appPtr
call  gtk_widget_show
addl  $4, %esp

#Have GNOME call our delete_handler function
#whenever a "delete" event occurs
pushl $NULL            #extra data to pass to our
                      #function (we don't use any)
pushl $delete_handler  #function address to call
pushl $signal_delete_event #name of the signal
pushl appPtr           #widget to listen for events on
call  gtk_signal_connect
addl  $16, %esp        #recover stack

#Have GNOME call our destroy_handler function
#whenever a "destroy" event occurs
pushl $NULL            #extra data to pass to our
                       #function (we don't use any)
pushl $destroy_handler #function address to call
pushl $signal_destroy  #name of the signal
pushl appPtr           #widget to listen for events on
call  gtk_signal_connect
addl  $16, %esp        #recover stack

#Have GNOME call our click_handler function
#whenever a "click" event occurs.  Note that
#the previous signals were listening on the
#application window, while this one is only
#listening on the button
pushl $NULL
pushl $click_handler
pushl $signal_clicked
pushl btnQuit
call  gtk_signal_connect
addl  $16, %esp

#Transfer control to GNOME.  Everything that
#happens from here out is in reaction to user
#events, which call signal handlers.  This main
#function just sets up the main window and connects
#signal handlers, and the signal handlers take
#care of the rest
call gtk_main

#After the program is finished, leave
movl  $0, %eax
leave
ret

#A "destroy" event happens when the widget is being
#removed.  In this case, when the application window
#is being removed, we simply want the event loop to
#quit
destroy_handler:
pushl %ebp
movl  %esp, %ebp

#This causes gtk to exit it's event loop
#as soon as it can.
call gtk_main_quit

movl $0, %eax
leave
ret

#A "delete" event happens when the application window
#gets clicked in the "x" that you normally use to
#close a window
delete_handler:
movl  $1, %eax
ret

#A "click" event happens when the widget gets clicked
click_handler:
pushl %ebp
movl  %esp, %ebp

#Create the "Are you sure" dialog
pushl $NULL                       #End of buttons
pushl $GNOME_STOCK_BUTTON_NO      #Button 1
pushl $GNOME_STOCK_BUTTON_YES     #Button 0
pushl $GNOME_MESSAGE_BOX_QUESTION #Dialog type
pushl $quit_question              #Dialog mesasge
call  gnome_message_box_new
addl  $16, %esp                   #recover stack
#%eax now holds the pointer to the dialog window

#Setting Modal to 1 prevents any other user
#interaction while the dialog is being shown
pushl $1
pushl %eax
call  gtk_window_set_modal
popl  %eax
addl  $4, %esp

#Now we show the dialog
pushl %eax
call  gtk_widget_show
popl  %eax

#This sets up all the necessary signal handlers
#in order to just show the dialog, close it when
#one of the buttons is clicked, and return the
#number of the button that the user clicked on.
#The button number is based on the order the buttons
#were pushed on in the gnome_message_box_new function
pushl %eax
call  gnome_dialog_run_and_close
addl  $4, %esp

#Button 0 is the Yes button.  If this is the
#button they clicked on, tell GNOME to quit
#it's event loop.  Otherwise, do nothing
cmpl  $0, %eax
jne   click_handler_end

call gtk_main_quit

click_handler_end:
leave
ret

as gnome-example.s -o gnome-example.o
gcc gnome-example.o 'gnome-config --libs gnomeui' \
   -o gnome-example

/* PURPOSE:  This program is meant to be an example
          of what GUI programs look like written
          with the GNOME libraries
*/

#include 

/* Program definitions */
#define MY_APP_TITLE "Gnome Example Program"
#define MY_APP_ID "gnome-example"
#define MY_APP_VERSION "1.000"
#define MY_BUTTON_TEXT "I Want to Quit the Example Program"
#define MY_QUIT_QUESTION "Are you sure you want to quit?"

/* Must declare functions before they are used */
int destroy_handler(gpointer window,
 GdkEventAny *e,
 gpointer data);
int delete_handler(gpointer window,
 GdkEventAny *e,
 gpointer data);
int click__handler(gpointer window,
 GdkEventAny *e,
 gpointer data);

int main(int argc, char **argv)
{
gpointer appPtr;  /* application window */
gpointer btnQuit; /* quit button */

/* Initialize GNOME libraries */
gnome_init(MY_APP_ID, MY_APP_VERSION, argc, argv);

/* Create new application window */
appPtr = gnome_app_new(MY_APP_ID, MY_APP_TITLE);

/* Create new button */
btnQuit = gtk_button_new_with_label(MY_BUTTON_TEXT);

/* Make the button show up inside the application window */
gnome_app_set_contents(appPtr, btnQuit);

/* Makes the button show up */
gtk_widget_show(btnQuit);

/* Makes the application window show up */
gtk_widget_show(appPtr);

/* Connect the signal handlers */
gtk_signal_connect(appPtr, "delete_event",
  GTK_SIGNAL_FUNC(delete_handler), NULL);
gtk_signal_connect(appPtr, "destroy",
  GTK_SIGNAL_FUNC(destroy_handler), NULL);
gtk_signal_connect(btnQuit, "clicked",
  GTK_SIGNAL_FUNC(click_handler), NULL);

/* Transfer control to GNOME */
gtk_main();

return 0;
}

/* Function to receive the "destroy" signal */
int destroy_handler(gpointer window,
 GdkEventAny *e,
 gpointer data)
{
/* Leave GNOME event loop */
gtk_main_quit();
return 0;
}

/* Function to receive the "delete_event" signal */
int delete_handler(gpointer window,
 GdkEventAny *e,
 gpointer data)
{
return 0;
}
/* Function to receive the "clicked" signal */
int click_handler(gpointer window,
 GdkEventAny *e,
 gpointer data)
{
gpointer msgbox;
int buttonClicked;

/* Create the "Are you sure" dialog */
msgbox = gnome_message_box_new(
 MY_QUIT_QUESTION,
 GNOME_MESSAGE_BOX_QUESTION,
 GNOME_STOCK_BUTTON_YES,
 GNOME_STOCK_BUTTON_NO,
 NULL);
gtk_window_set_modal(msgbox, 1);
gtk_widget_show(msgbox);

/* Run dialog box */
buttonClicked = gnome_dialog_run_and_close(msgbox);

/* Button 0 is the Yes button. If this is the
button they clicked on, tell GNOME to quit
it's event loop.  Otherwise, do nothing */
if(buttonClicked == 0)
{
 gtk_main_quit();
}

return 0;
}

gcc gnome-example-c.c 'gnome-config --cflags \
   --libs gnomeui' -o gnome-example-c

#PURPOSE:  This program is meant to be an example
#          of what GUI programs look like written
#          with the GNOME libraries
#

#lmport GNOME libraries
import gtk
import gnome.ui

####DEFINE CALLBACK FUNCTIONS FIRST####

#In Python, functions have to be defined before
#they are used, so we have to define our callback
#functions first.

def destroy_handler(event):
gtk.mainquit()
return 0

def delete_handler(window, event):
return 0

def click_handler(event):
#Create the "Are you sure" dialog
msgbox = gnome.ui.GnomeMessageBox(
 "Are you sure you want to quit?",
 gnome.ui.MESSAGE_BOX_QUESTION,
 gnome.ui.STOCK_BUTTON_YES,
 gnome.ui.STOCK_BUTTON_NO)
msgbox.set_modal(1)
msgbox.show()

result = msgbox.run_and_close()

#Button 0 is the Yes button.  If this is the
#button they clicked on, tell GNOME to quit
#it's event loop.  Otherwise, do nothing
if (result == 0):
 gtk.mainquit()

return 0

####MAIN PROGRAM####

#Create new application window
myapp = gnome.ui.GnomeApp(
"gnome-example", "Gnome Example Program")

#Create new button
mybutton = gtk.GtkButton(
"I Want to Quit the GNOME Example program")
myapp.set_contents(mybutton)

#Makes the button show up
mybutton.show()

#Makes the application window show up
myapp.show()

#Connect signal handlers
myapp.connect("delete_event", delete_handler)
myapp.connect("destroy", destroy_handler)
mybutton.connect("clicked", click_handler)
#Transfer control to GNOME
gtk.mainloop()

#include 

/* PURPOSE:  This program is mean to show a basic */
/*           C program.  All it does is print     */
/*           "Hello World!" to the screen and     */
/*           exit.                                */

/* Main Program */
int main(int argc, char **argv)
{
/* Print our string to standard output */
puts("Hello World!\n");

/* Exit with status 0 */
return 0;
}

gcc -o HelloWorld Hello-World.c

./HelloWorld

#!/usr/bin/perl

print("Hello world!\n");

perl Hello-World.pl

#!/usr/bin/python
print "Hello World"

Table of binary addition

+ |  0  |  1
--+-----+-----
0 |  0  |  0
--+-----+-----
1 |  1  | 10

Table of binary multiplication
* |  0  |  1
--+-----+-----
0 |  0  |  0
--+-----+-----
1 |  0  |  1

   10010101
+   1100101
-----------
11111010

        10010101
*   1100101
-----------
   10010101
  00000000
 10010101
00000000
00000000
10010101
10010101
---------------
11101011001001

     1    0    0    1    0    1    0    1
|    |    |    |    |    |    |    |
|    |    |    |    |    |    |    Individual units (2^0)
|    |    |    |    |    |    0 groups of 2 (2^1)
|    |    |    |    |    1 group of 4 (2^2)
|    |    |    |    0 groups of 8 (2^3)
|    |    |    1 group of 16 (2^4)
|    |    0 groups of 32 (2^5)
|    0 groups of 64 (2^6)
1 group of 128 (2^7)

1*128 + 0*64 + 0*32 + 1*16 + 0*8 + 1*4 + 0*2 + 1*1 =
128 + 16 + 4 + 1 =
149

1*64 + 1*32 + 0 * 16 + 0*8 + 1*4 + 0*2 + 1*1 =
64 + 32 + 4 + 1 =
101

1*8192 + 1*4096 + 1*2048 + 0*1024 + 1*512 + 0*256
  + 1*128 + 1*64 + 0*32 + 0*16 + 1*8 + 0*4
  + 0*2 + 1*1 =

8192 + 4096 + 2048 + 512 + 128 + 64 + 8 + 1 =

15049

15049 / 2 = 7524    Remaining 1
7524 / 2 = 3762     Remaining 0
3762 / 2 = 1881     Remaining 0
1881 / 2 = 940      Remaining 1
940 / 2 = 470       Remaining 0
470 / 2 = 235       Remaining 0
235 / 2 = 117       Remaining 1
117 / 2 = 58        Remaining 1
58 / 2 = 29         Remaining 0
29 / 2 = 14         Remaining 1
14 / 2 = 7          Remaining 0
7 / 2 = 3           Remaining 1
3 / 2 = 1           Remaining 1
1 / 2 = 0           Remaining 1

11111111  =

(1 * 2^7) + (1 * 2^6) + (1 * 2^5) + (1 * 2^4) + (1 * 2^3)
     + (1 * 2^2) + (1 * 2^1) + (1 * 2^0) =

128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 =

255

Outside   Hallway   Living Room   Bedroom
On        Off         On          On

Outside   Hallway   Living Room   Bedroom
1         0            1          1

1            0            1          1

1011

10100010101010010101101100101010 AND
10001000010101010101010101111010
--------------------------------
10000000000000010101000100101010

10100010101010010101101100101010 OR
10001000010101010101010101111010
--------------------------------
10101010111111010101111101111010

NOT 10100010101010010101101100101010
------------------------------------
01011101010101101010010011010101

10100010101010010101101100101010 XOR
10001000010101010101010101111010
--------------------------------
00101010111111000000111001010000

10100010101010010101101100101010 XOR
10100010101010010101101100101010
--------------------------------
00000000000000000000000000000000

 movl  $0, %eax

 xorl  %eax, %eax

Food: yes
Heavy Metal Music: yes
Wearing Dressy Clothes: no
Football: yes

Food: yes
Heavy Metal Music: no
Wearing Dressy Clothes: yes
Football: yes

Me
Food: 1
Heavy Metal Music: 1
Wearing Dressy Clothes: 0
Football: 1

Dad
Food: 1
Heavy Metal Music: 0
Wearing Dressy Clothes: 1
Football: 1

Me
1101

Dad
1011

1101 AND
1011
--------
1001

Things we both like
Food: yes
Heavy Metal Music: no
Wearing Dressy Clothes: no
Football: yes

1101 XOR
1011
--------
0110

Shift left  10010111 = 00101110
Rotate left 10010111 = 00101111

00000000000000000000000000001011

00000000000000000000000000000101

00000000000000000000000000000101 AND
00000000000000000000000000000001
-----------------------------------
00000000000000000000000000000001

 #NOTE - assume that the register %ebx holds
#       my Dad's preferences

movl  %ebx, %eax #This copies the information into %eax so
             #we don't lose the original data

shrl  $1, %eax   #This is the shift operator.  It stands
             #for Shift Right Long.  This first number
             #is the number of positions to shift,
             #and the second is the register to shift

#This does the masking
andl  $0b00000000000000000000000000000001, %eax

#Check to see if the result is 1 or 0
cmpl  $0b00000000000000000000000000000001, %eax

je    yes_he_likes_dressy_clothes

jmp   no_he_doesnt_like_dressy_clothes

 movl   $0xFFFFFFFF,  %eax

movl   $0b11111111111111111111111111111111,  %eax

 int   $0x80

#PURPOSE:  Convert an integer number to a decimal string
#          for display
#
#INPUT:    A buffer large enough to hold the largest
#          possible number
#          An integer to convert
#
#OUTPUT:   The buffer will be overwritten with the
#          decimal string
#
#Variables:
#
# %ecx will hold the count of characters processed
# %eax will hold the current value
# %edi will hold the base (10)
#
.equ ST_VALUE, 8
.equ ST_BUFFER, 12

.globl integer2string
.type integer2string, @function
integer2string:
#Normal function beginning
pushl %ebp
movl  %esp, %ebp
#Current character count
movl  $0, %ecx

#Move the value into position
movl  ST_VALUE(%ebp), %eax

#When we divide by 10, the 10
#must be in a register or memory location
movl  $10, %edi

conversion_loop:
#Division is actually performed on the
#combined %edx:%eax register, so first
#clear out %edx
movl  $0, %edx

#Divide %edx:%eax (which are implied) by 10.
#Store the quotient in %eax and the remainder
#in %edx (both of which are implied).
divl  %edi

#Quotient is in the right place.  %edx has
#the remainder, which now needs to be converted
#into a number.  So, %edx has a number that is
#0 through 9.  You could also interpret this as
#an index on the ASCII table starting from the
#character '0'.  The ascii code for '0' plus zero
#is still the ascii code for '0'.  The ascii code
#for '0' plus 1 is the ascii code for the
#character '1'.  Therefore, the following
#instruction will give us the character for the
#number stored in %edx
addl  $'0', %edx

#Now we will take this value and push it on the
#stack.  This way, when we are done, we can just
#pop off the characters one-by-one and they will
#be in the right order.  Note that we are pushing
#the whole register, but we only need the byte
#in %dl (the last byte of the %edx register) for
#the character.
pushl %edx

#Increment the digit count
incl  %ecx

#Check to see if %eax is zero yet, go to next
#step if so.
cmpl  $0, %eax
je    end_conversion_loop

#%eax already has its new value.

jmp conversion_loop

end_conversion_loop:
#The string is now on the stack, if we pop it
#off a character at a time we can copy it into
#the buffer and be done.

#Get the pointer to the buffer in %edx
movl ST_BUFFER(%ebp), %edx

copy_reversing_loop:
#We pushed a whole register, but we only need
#the last byte.  So we are going to pop off to
#the entire %eax register, but then only move the
#small part (%al) into the character string.
popl  %eax
movb  %al, (%edx)
#Decreasing %ecx so we know when we are finished
decl  %ecx
#Increasing %edx so that it will be pointing to
#the next byte
incl  %edx

#Check to see if we are finished
cmpl  $0, %ecx
#If so, jump to the end of the function
je    end_copy_reversing_loop
#Otherwise, repeat the loop
jmp   copy_reversing_loop

end_copy_reversing_loop:
#Done copying.  Now write a null byte and return
movb  $0, (%edx)

movl  %ebp, %esp
popl  %ebp
ret

 .include "linux.s"

.section .data

#This is where it will be stored
tmp_buffer:
.ascii "\0\0\0\0\0\0\0\0\0\0\0"
.section .text

.globl _start
_start:
movl  %esp, %ebp

#Storage for the result
pushl $tmp_buffer
#Number to convert
pushl $824
call  integer2string
addl  $8, %esp

#Get the character count for our system call
pushl $tmp_buffer
call  count_chars
addl  $4, %esp

#The count goes in %edx for SYS_WRITE
movl  %eax, %edx

#Make the system call
movl  $SYS_ WRITE, %eax
movl  $STDOUT, %ebx
movl  $tmp_buffer, %ecx

int   $LINUX_SYSCALL

#Write a carriage return
pushl $STDOUT
call  write_newline

#Exit
movl  $SYS_EXIT, %eax
movl  $0, %ebx
int   $LINUX_SYSCALL

as integer-to-string.s -o integer-to-number.o
as count-chars.s -o count-chars.o
as write-newline.s -o write-newline.o
as conversion-program.s -o conversion-program.o
ld integer-to-number.o count-chars.o write-newline.o conversion-
program.o -o conversion-program

 movl data_items(,%edi,4), %ebx

 .section .data
my_data:
.long 2, 3, 4

 pushl %eax

 movl %eax, (%esp)
subl $4, %esp

 popl %eax

 movl (%esp), %eax
addl $4, %esp

 #PURPOSE: Program to manage memory usage - allocates
#         and deallocates memory as requested
#
#NOTES:   The programs using these routines will ask
#         for a certain size of memory.  We actually
#         use more than that size, but we put it
#         at the beginning, before the pointer
#         we hand back.  We add a size field and
#         an AVAILABLE/UNAVAILABLE marker.  So, the
#         memory looks like this
#
# #########################################################
# #Available Marker#Size of memory#Actual memory locations#
# #########################################################
#                                  ^--Returned pointer
#                                     points here
#         The pointer we return only points to the actual
#         locations requested to make it easier for the
#         calling program. It also allows us to change our
#         structure without the calling program having to
#         change at all.

.section .data
#######GLOBAL VARIABLES########

#This points to the beginning of the memory we are managing
heap_begin:
.long 0

#This points to one location past the memory we are managing
current_break:
.long 0

######STRUCTURE INFORMATION####
#size of space for memory region header
.equ HEADER_SIZE, 8
#Location of the "available" flag in the header
.equ HDR_AVAIL_OFFSET, 0
#Location of the size field in the header
.equ HDR_SIZE_OFFSET, 4

###########CONSTANTS###########
.equ UNAVAILABLE, 0 #This is the number we will use to mark
                  #space that has been given out
.equ AVAILABLE, 1   #This is the number we will use to mark
                  #space that has been returned, and is
                  #available for giving
.equ SYS_BRK, 45    #system call number for the break
                  #system call

.equ LINUX_SYSCALL, 0x80 #make system calls easier to read

.section .text
##########FUNCTIONS############

##allocate_init##
#PURPOSE: call this function to initialize the
#         functions (specifically, this sets heap_begin and
#         current_break).  This has no parameters and no
#         return value.
.globl allocate_init
.type allocate_init, @function
allocate_init:
pushl %ebp                   #standard function stuff
movl  %esp, %ebp

#If the brk system call is called with 0 in %ebx, it
#returns the last valid usable address
movl  $SYS_BRK, %eax        #find out where the break is
movl  $0, %ebx
int   $LINUX_SYSCALL

incl  %eax                  #%eax now has the last valid
                         #address, and we want the
                         #memory location after that

movl  %eax, current_break   #store the current break

movl  %eax, heap_begin      #store the current break as our
                         #first address. This will cause
                         #the allocate function to get
                         #more memory from Linux the
                         #first time it is run

movl  %ebp, %esp            #exit the function
popl  %ebp
ret
#####END OF FUNCTION#######

##allocate##
#PURPOSE:    This function is used to grab a section of
#            memory. It checks to see if there are any
#            free blocks, and, if not, it asks Linux
#            for a new one.
#
#PARAMETERS: This function has one parameter - the size
#            of the memory block we want to allocate
#
#RETURN VALUE:
#            This function returns the address of the
#            allocated memory in %eax.  If there is no
#            memory available, it will return 0 in %eax
#
######PROCESSING########
#Variables used:
#
#   %ecx - hold the size of the requested memory
#          (first/only parameter)
#   %eax - current memory region being examined
#   %ebx - current break position
#   %edx - size of current memory region
#
#We scan through each memory region starting with
#heap_begin. We look at the size of each one, and if
#it has been allocated.  If it's big enough for the
#requested size, and its available, it grabs that one.
#If it does not find a region large enough, it asks
#Linux for more memory.  In that case, it moves
#current_break up
.globl allocate
.type allocate, @function
.equ ST_MEM_SIZE,  8 #stack position of the memory size
                  #to allocate
allocate:
pushl %ebp                   #standard function stuff
movl  %esp, %ebp

movl  ST_MEM_SIZE(%ebp), %ecx #%ecx will hold the size
            #we are looking for (which is the first
            #and only parameter)

movl  heap_begin, %eax      #%eax will hold the current
                         #search location

movl  current_break, %ebx   #%ebx will hold the current
                         #break

alloc_loop_begin:               #here we iterate through each
                            #memory region

cmpl  %ebx, %eax        #need more memory if these are equal
je    move_break

#grab the size of this memory
movl  HDR_SIZE_OFFSET(%eax), %edx
#If the space is unavailable, go to the
cmpl  $UNAVAILABLE, HDR_AVAIL_OFFSET(%eax)
je    next_location         #next one

cmpl  %edx, %ecx     #If the space is available, compare
jle   allocate_here  #the size to the needed size.  If its
                  #big enough, go to allocate_here
next_location:
addl  $HEADER_SIZE, %eax #The total size of the memory
addl  %edx, %eax         #region is the sum of the size
                      #requested (currently stored
                      #in %edx), plus another 8 bytes
                      #for the header (4 for the
                      #AVAILABLE/UNAVAILABLE flag,
                      #and 4 for the size of the
                      #region). So, adding %edx and $8
                      #to %eax will get the address
                      #of the next memory region

jmp   alloc_loop_begin      #go look at the next location

allocate_here:                      #if we've made it here,
                                #that means that the
                         #region header of the region
                         #to allocate is in %eax

#mark space as unavailable
movl  $UNAVAILABLE, HDR_AVAIL_OFFSET(%eax)
addl  $HEADER_SIZE, %eax    #move %eax past the header to
                         #the usable memory (since
                         #that's what we return)

movl  %ebp, %esp            #return from the function
popl  %ebp
ret

move_break:                      #if we've made it here, that
                             #means that we have exhausted
                             #all addressable memory, and
                             #we need to ask for more.
                      #%ebx holds the current
                      #endpoint of the data,
                             #and %ecx holds its size

                      #we need to increase %ebx to
                      #where we _want_ memory
                      #to end, so we
addl  $HEADER_SIZE, %ebx #add space for the headers
                      #structure
addl  %ecx, %ebx         #add space to the break for
                      #the data requested

                      #now its time to ask Linux
                      #for more memory

pushl %eax               #save needed registers
pushl %ecx
pushl %ebx

movl  $SYS_BRK, %eax     #reset the break (%ebx has
                      #the requested break point)
int   $LINUX_SYSCALL
            #under normal conditions, this should
            #return the new break in %eax, which
            #will be either 0 if it fails, or
            #it will be equal to or larger than
            #we asked for.  We don't care
            #in this program where it actually
            #sets the break, so as long as %eax
            #isn't 0, we don't care what it is

cmpl  $0, %eax           #check for error conditions
je    error

popl  %ebx               #restore saved registers
popl  %ecx
popl  %eax

#set this memory as unavailable, since we're about to
#give it away
movl  $UNAVAILABLE, HDR_AVAIL_OFFSET(%eax)
#set the size of the memory
movl  %ecx, HDR_SIZE_OFFSET(%eax)

#move %eax to the actual start of usable memory.
#%eax now holds the return value
addl  $HEADER_SIZE, %eax

movl  %ebx, current_break   #save the new break

movl  %ebp, %esp            #return the function
popl  %ebp
ret

error:
movl  $0, %eax              #on error, we return zero
movl  %ebp, %esp
popl  %ebp
ret
########END OF FUNCTION########

##deallocate##
#PURPOSE:
#    The purpose of this function is to give back
#    a region of memory to the pool after we're done
#    using it.
#
#PARAMETERS:
#    The only parameter is the address of the memory
#    we want to return to the memory pool.
#
#RETURN VALUE:
#    There is no return value
#PROCESSING:
#    If you remember, we actually hand the program the
#    start of the memory that they can use, which is
#    8 storage locations after the actual start of the
#    memory region.  All we have to do is go back
#    8 locations and mark that memory as available,
#    so that the allocate function knows it can use it.
.globl deallocate
.type deallocate, @function
#stack position of the memory region to free
.equ ST_MEMORY_SEG, 4
deallocate:
#since the function is so simple, we
#don't need any of the fancy function stuff

#get the address of the memory to free
#(normally this is 8(%ebp), but since
#we didn't push %ebp or move %esp to
#%ebp, we can just do 4(%esp)
movl  ST_MEMORY_SEG(%esp), %eax

#get the pointer to the real beginning of the memory
subl  $HEADER_SIZE, %eax

#mark it as available
movl  $AVAILABLE, HDR_AVAIL_OFFSET(%eax)

#return
ret
########END OF FUNCTION##########

as alloc.s -o alloc.o

heap_begin:
.long 0

current_break:
.long 0

 .equ HEADER_SIZE, 8
.equ HDR_AVAIL_OFFSET, 0
.equ HDR_SIZE_OFFSET, 4

 .equ UNAVAILABLE, 0
.equ AVAILABLE, 1

 .equ BRK, 45
.equ LINUX_SYSCALL, 0x80

 pushl %ebp
movl  %esp, %ebp

movl  $SYS_BRK, %eax
movl  $0, %ebx
int   $LINUX_SYSCALL

 incl  %eax
movl  %eax, current_break
movl  %eax, heap_begin
movl  %ebp, %esp
popl  %ebp
ret

 pushl %ebp
movl  %esp, %ebp
movl  ST_MEM_SIZE(%ebp), %ecx
movl  heap_begin, %eax
movl  current_break, %ebx

 cmpl %ebx, %eax
je   move_break

move_break:
addl  $HEADER_SIZE, %ebx
addl  %ecx, %ebx
pushl %eax
pushl %ecx
pushl %ebx
movl  $SYS_BRK, %eax
int   $LINUX_SYSCALL

 cmpl  $0, %eax
je    error

 popl  %ebx
popl  %ecx
popl  %eax
movl  $UNAVAILABLE, HDR_AVAIL_OFFSET(%eax)
movl  %ecx, HDR_SIZE_OFFSET(%eax)
addl  $HEADER_SIZE, %eax

 movl  %ebx, current_break
movl  %ebp, %esp
popl  %ebp
ret

 movl HDR_SIZE_OFFSET(%eax), %edx
cmpl $UNAVAILABLE, HDR_AVAIL_OFFSET(%eax)
je   next_location

 cmpl  %edx, %ecx
jle   allocate_here

 movl  $UNAVAILABLE, HDR_AVAIL_OFFSET(%eax)
addl  $HEADER_SIZE, %eax
movl  %ebp, %esp
popl  %ebp
ret

 addl  $HEADER_SIZE, %eax
addl  %edx, %eax
jmp   alloc_loop_begin

 movl  ST_MEMORY_SEG(%esp), %eax
subl  $HEADER_SIZE, %eax
movl  $AVAILABLE, HDR_AVAIL_OFFSET(%eax)
ret

 .section .bss
.lcomm, record_buffer, RECORD_SIZE

record_buffer_ptr:
.long 0

 call allocate_init

 pushl $RECORD_SIZE
call  allocate
movl  %eax, record_buffer_ptr

pushl $record_buffer

pushl record_buffer_ptr

 pushl $RECORD_FIRSTNAME + record_buffer

 movl  record_buffer_ptr, %eax
addl  $RECORD_FIRSTNAME, %eax
pushl %eax

 movl  $RECORD_FIRSTNAME + record_buffer, %ecx

 movl  record_buffer_ptr, %ecx
addl  $RECORD_FIRSTNAME, %ecx

 pushl record_buffer_ptr
call  deallocate

as read-records.s -o read-records.o
ld alloc.o read-record.o read-records.o write-newline.o count-
chars.o -o read-records

#PURPOSE:  This program writes the message "hello world" and
#          exits
#

.include "linux.s"

.section .data

helloworld:
.ascii "hello world\n"
helloworld_end:

.equ helloworld_len, helloworld_end - helloworld

.section .text
.globl _start
_start:
movl  $STDOUT, %ebx
movl  $helloworld, %ecx
movl  $helloworld_len, %edx
movl  $SYS_WRITE, %eax
int   $LINUX_SYSCALL

movl  $0, %ebx
movl  $SYS_EXIT, %eax
int   $LINUX_SYSCALL

#PURPOSE:  This program writes the message "hello world" and
#          exits
#

.section .data

helloworld:
.ascii "hello world\n\0"

.section .text
.globl _start
_start:
pushl $helloworld
call  printf

pushl $0
call  exit

as helloworld-nolib.s -o helloworld-nolib.o
ld helloworld-nolib.o -o helloworld-nolib

as helloworld-lib.s -o helloworld-lib.o
ld -dynamic-linker /lib/ld-linux.so.2 \
 -o helloworld-lib helloworld-lib.o -1c

ldd ./helloworld-nolib

ldd ./helloworld-lib

      libc.so.6 => /lib/libc.so.6 (0x4001d000)
    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x400000000)

int printf(char *string, ...);

 pushl $hello
call  printf

#PURPOSE:  This program is to demonstrate how to call printf
#

.section .data

#This string is called the format string.  It's the first
#parameter, and printf uses it to find out how many parameters
#it was given, and what kind they are.
firststring:
.ascii "Hello! %s is a %s who loves the number %d\n\0"
name:
.ascii "Jonathan\0"
personstring:
.ascii "person\0"
#This could also have been an .equ, but we decided to give it
#a real memory location just for kicks
numberloved:
.long 3

.section .text
.globl _start
_start:
#note that the parameters are passed in the
#reverse order that they are listed in the
#function's prototype.
pushl numberloved    #This is the %d
pushl $personstring  #This is the second %s
pushl $name          #This is the first %s
pushl $firststring   #This is the format string
                    #in the prototype
call printf

pushl $0
call  exit

as printf-example.s -o printf-example.o
ld printf-example.o -o printf-example -lc \
 -dynamic-linker /lib/ld-linux.so.2

Hello! Jonathan is a person who loves the number 3

struct teststruct {
int a;
char *b;
};

as write-record.s -o write-record.o
as read-record.s -o read-record.o

ld -shared write-record.o read-record.o -o librecord.so

as write-records.s -o write-records
ld -L . -dynamic-linker /lib/ld-linux.so.2 \
 -o write-records -lrecord write-records.o

./write-records: error while loading shared libraries:
librecord.so: cannot open shared object file: No such
file or directory

LD_LIBRARY_PATH=.
export LD_LIBRARY_PATH

setenv LD_LIBRARY_PATH .

 .include "linux.s"
.equ ST_ERROR_CODE, 8
.equ ST_ERROR_MSG, 12
.globl error_exit
.type error_exit, @function
error_exit:
pushl %ebp
movl  %esp, %ebp
#Write out error code
movl  ST_ERROR_CODE(%ebp), %ecx
pushl %ecx
call  count_chars
popl  %ecx
movl  %eax, %edx
movl  $STDERR, %ebx
movl  $SYS_WRITE, %eax
int   $LINUX_SYSCALL

#Write out error message
movl  ST_ERROR_MSG(%ebp), %ecx
pushl %ecx
call  count_chars
popl  %ecx
movl  %eax, %edx
movl  $STDERR, %ebx
movl  $SYS_WRITE, %eax
int   $LINUX_SYSCALL

pushl $STDERR
call  write_newline

#Exit with status 1
movl  $SYS_EXIT, %eax
movl  $1, %ebx
int   $LINUX_SYSCALL

 #Open file for reading
movl  $SYS_OPEN, %eax
movl  $input_file_name, %ebx
movl  $0, %ecx
movl  $0666, %edx
int   $LINUX_SYSCALL

movl  %eax, INPUT_DESCRIPTOR(%ebp)

#This will test and see if %eax is
#negative.  If it is not negative, it
#will jump to continue_processing.
#Otherwise it will handle the error
#condition that the negative number
#represents.
cmpl  $0, %eax
jl    continue_processing

#Send the error
.section .data
no_open_file_code:
.ascii "0001: \0"
no_open_file_msg:
.ascii "Can't Open Input File\0"

.section .text
pushl  $no_open_file_msg
pushl  $no_open_file_code
call   error_exit

continue_processing:
#Rest of program

as add-year.s -o add-year.o
as error-exit.s -o error-exit.o
ld add-year.o write-newline.o error-exit.o read-record.o write-
record.o count-chars.o -o add-year

Miscellaneous
quit	Exit GDB
help [cmd]	Print description of debugger command cmd. Without cmd, prints a list of topics.
directory [dir1] [dir2] ...	Add directories dir1, dir2, etc. to the list of directories searched for source files.

Running the Program
run [arg1] [arg2] ...	Run the program with command line arguments arg1, arg2, etc.
set args arg1 [arg2] ...	Set the program's command-line arguments to arg1, arg2, etc.
show args	Print the program's command-line arguments.

Using Breakpoints
info breakpoints	Print a list of all breakpoints and their numbers (breakpoint numbers are used for other breakpoint commands).
break linenum	Set a breakpoint at line number linenum.
break *addr	Set a breakpoint at memory address addr.
break fn	Set a breakpoint at the beginning of function fn.
condition bpnum expr	Break at breakpoint bpnum only if expression expr is non-zero.
command [bpnum] cmd1 [cmd2] ...	Execute commands cmd1, cmd2, etc. whenever breakpoint bpnum (or the current breakpoint) is hit.
Continue	Continue executing the program.
Kill	Stop executing the program.
delete [bpnum1] [bpnum2] ...	Delete breakpoints bpnuml, bpnum2, etc., or all breakpoints if none specified.
clear *addr	Clear the breakpoint at memory address addr.
clear [fn]	Clear the breakpoint at function fn, or the current breakpoint.
clear linenum	Clear the breakpoint at line number linenum.
disable [bpnum1] [bpnum2] ...	Disable breakpoints bpnum1, bpnum2, etc., or all breakpoints if none specified.
enable [bpnum1] [bpnum2] ...	Enable breakpoints bpnum1, bpnum2, etc., or all breakpoints if none specified.

Stepping through the Program
nexti	"Step over" the next instruction (doesn't follow function calls).
stepi	"Step into" the next instruction (follows function calls).
finish	"Step out" of the current function.

Examining Registers and Memory
info registers	Print the contents of all registers.
print/f $reg	Print the contents of register reg using format f. The format can be x (hexadecimal), u (unsigned decimal), o (octal), a(address), c (character), or f (floating point).
x/rsf addr	Print the contents of memory address addr using repeat count r, size s, and format f. Repeat count defaults to 1 if not specified. Size can be b (byte), h (halfword), w (word), or g (double word). Size defaults to word if not specified. Format is the same as for print, with the additions of s (string) and i (instruction).
info display	Shows a numbered list of expressions set up to display automatically at each break.
display/f $reg	At each break, print the contents of register reg using format f.
display/si addr	At each break, print the contents of memory address addr using size s (same options as for the x command).
display/ss addr	At each break, print the string of size s that begins in memory address addr.
undisplay displaynum	Remove displaynum from the display list.

Examining the Call Stack
where	Print the call stack.
backtrace	Print the call stack.
frame	Print the top of the call stack.
up	Move the context toward the bottom of the call stack.
down	Move the context toward the top of the call stack.

	+0	+1	+2	+3	+4	+5	+6	+7
0	NUL	SOH	STX	ETX	EOT	ENQ	ACK	BEL
8	BS	HT	LF	VT	FF	CR	SO	SI
16	DLE	DC1	DC2	DC3	DC4	NAK	SYN	ETB
24	CAN	EM	SUB	ESC	FS	GS	RS	US
32		!	"	#	$	%	&	'
40	(	)	*	+	,	-	.	/
48	0	1	2	3	4	5	6	7
56	8	9	:	;	<	=	>	?
64	@	A	B	C	D	E	F	G
72	H	I	J	K	L	M	N	O
80	P	Q	R	S	T	U	V	W
88	X	Y	Z	[	\	]	^	_
96	'	a	b	c	d	e	f	g
104	h	i	j	k	l	m	n	o
112	p	q	r	s	t	u	v	w
120	x	y	z	{	\|	}	~	DEL

%eax	Name	%ebx	%ecx	%edx	Notes
1	exit	return value (int)			Exits the program
3	read	file descriptor	buffer start	buffer size (int)	Reads into the given buffer
4	write	file descriptor	buffer start	buffer size (int)	Writes the buffer to the file descriptor
5	open	null-terminate file name	option list	permission mode	Opens the given file. Returns the file descriptor or an error number.
6	close	file descriptor			Closes the give file descriptor
12	chdir	null-terminated directory name			Changes the current directory of your program.
19	lseek	file descriptor	offset	mode	Repositions where you are in the given file. The mode (called the "whence") should be 0 for absolute positioning, and 1 for relative positioning.
20	getpid				Returns the process ID of the current process.
39	mkdir	null-terminated directory name	permission mode		Creates the given directory. Assumes all directories leading up to it already exist.
40	rmdir	null-terminated directory name			Removes the given directory.
41	dup	file descriptor			Returns a new file descriptor pat works just like the existing file descriptor.
42	pipe	pipe array			Creates two file descriptors, where writing on one produces data to read on the other and vice-versa. %ebx is a pointer to two words of storage to hold the file descriptors.
45	brk	new system break			Sets the system break (i.e. -the end of the data section). If the system break is 0, it simply returns the current system break.
54	ioctl	file descriptor	request	arguments	This is used to set parameters on device files. Its actual usage varies based on the type of file or device your descriptor references.

Instruction	Operands	Affected Flags
movl	I/R/M, I/R/M	O/S/Z/A/C
This copies a word of data from one location to another. movl %eax, %ebx copies the contents of %eax to %ebx
movb	I/R/M, I/R/M	O/S/Z/A/C
Same as movl, but operates on individual bytes.
leal	M, I/R/M	O/S/Z/A/C
This takes a memory location given in the standard format, and, instead of loading the contents of the memory location, loads the computed address. For example, leal 5 (%ebp, %ecx, 1), %eax loads the address computed by 5 + %ebp + 1*%ecx and stores that in %eax
popl	R/M	O/S/Z/A/C
Pops the top of the stack into the given location. This is equivalent to performing movl (%esp), R/M followed by addl $4, %esp.popfl is a variant which pops the top of the stack into the %eflags register.
pushl	I/R/M	O/S/Z/A/C
Pushes the given value onto the stack. This is the equivalent to performing subl $4, %esp followed by movl I/R/M, (%esp).pushfl is a variant which pushes the current contents of the %eflags register onto the top of the stack.
xchgl	R/M, R/M	O/S/Z/A/C
Exchange the values of the given operands.

Instruction	Operands	Affected Flags
adcl	I/R/M, R/M	O/S/Z/A/P/C
Add with carry. Adds the carry bit and the first operand to the second, and, if there is an overflow, sets overflow and carry to true. This is usually used for operations larger than a machine word. The addition on the least-significant word would take place using addl, while additions to the other words would used the adcl instruction to take the carry from the previous add into account. For the usual case, this is not used, and addl is used instead.
addl	I/R/M, R/M	O/S/Z/A/P/C
Addition. Adds the first operand to the second, storing the result in the second. If the result is larger than the destination register, the overflow and carry bits are set to true. This instruction operates on both signed and unsigned integers.
cdq		O/S/Z/A/P/C
Converts the %eax word into the double-word consisting of %edx:%eax with sign extension. The q signifies that it is a quad-word. It's actually a double-word, but it's called a quad-word because of the terminology used in the 16-bit days. This is usually used before issuing an idivl instruction.
cmpl	I/R/M, R/M	O/S/Z/A/P/C
Compares two integers. It does this by subtracting the first operand from the second. It discards the results, but sets the flags accordingly. Usually used before a conditional jump.
decl	R/M	O/S/Z/A/P
Decrements the register or memory location. Use decb to decrement a byte instead of a word.
divl	R/M	O/S/Z/A/P
Performs unsigned division. Divides the contents of the double-word contained in the combined %edx:%eax registers by the value in the register or memory location specified. The %eax register contains the resulting quotient, and the %edx register contains the resulting remainder. If the quotient is too large to fit in %eax, it triggers a type 0 interrupt.
idivl	R/M	O/S/Z/A/P
Performs signed division. Operates just like divl above.
imull	R/M/I, R	O/S/Z/A/P/C
Performs signed multiplication and stores the result in the second operand. If the second operand is left out, it is assumed to be %eax, and the full result is stored in the double-word %edx:%eax.
incl	R/M	O/S/Z/A/P
Increments the given register or memory location. Use incb to increment a byte instead of a word.
mull	R/M/I, R	O/S/Z/A/P/C
Perform unsigned multiplication. Same rules as apply to imull.
negl	R/M	O/S/Z/A/P/C
Negates (gives the two's complement inversion of) the given register or memory location.
sbbl	I/R/M, R/M	O/S/Z/A/P/C
Subtract with borrowing. This is used in the same way that adc is, except for subtraction. Normally only subl is used.
subl	I/R/M, R/M	O/S/Z/A/P/C
Subtract the two operands. This subtracts the first operand from the second, and stores the result in the second operand. This instruction can be used on both signed and unsigned numbers.

Instruction	Operands	Affected Flags
andl	I/R/M, R/M	O/S/Z/P/C
Performs a logical and of the contents of the two operands, and stores the result in the second operand. Sets the overflow and carry flags to false.
notl	R/M
Performs a logical not on each bit in the operand. Also known as a one's complement.
orl	I/R/M, R/M	O/S/Z/A/P/C
Performs a logical or between the two operands, and stores the result in the second operand. Sets the overflow and carry flags to false.
rcll	I/%c1, R/M	O/C
Rotates the given location's bits to the left the number of times in the first operand, which is either an immediate-mode value or the register %cl. The carry flag is included in the rotation, making it use 33 bits instead of 32. Also sets the overflow flag.
rcrl	I/%cl, R/M	O/C
Same as above, but rotates right.
roll	I/%cl, R/M	O/C
Rotate bits to the left. It sets the overflow and carry flags, but does not count the carry flag as part of the rotation. The number of bits to roll is either specified in immediate mode or is contained in the %cl register.
rorl	I/%cl, R/M	O/C
Same as above, but rotates right.
sall	I/%cl, R/M	C
Arithmetic shift left. The sign bit is shifted out to the carry flag, and a zero bit is placed in the least significant bit. Other bits are simply shifted to the left. This is the same as the regular shift left. The number of bits to shift is either specified in immediate mode or is contained in the %cl register.
sarl	I/%cl, R/M	C
Arithmetic shift right. The least significant bit is shifted out to the carry flag. The sign bit is shifted in, and kept as the sign bit. Other bits are simply shifted to the right. The number of bits to shift is either specified in immediate mode or is contained in the %cl register.
shll	I/%cl, R/M	C
Logical shift left. This shifts all bits to the left (sign bit is not treated specially). The leftmost bit is pushed to the carry flag. The number of bits to shift is either specified in immediate mode or is contained in the %cl register.
shrl	I/%cl, R/M	C
Logical shift right. This shifts all bits in the register to the right (sign bit is not treated specially). The rightmost bit is pushed to the carry flag. The number of bits o shift is either specified in immediate mode or is contained in the %cl register.
testl	I/R/M, R/M	O/S/Z/A/P/C
Does a logical and of both operands and discards the results, but sets the flags accordingly.
xorl	I/R/M, R/M	O/S/Z/A/P/C
Does an exclusive or on the two operands, and stores the result in the second operand. Sets the overflow and carry flags to false.

Instruction	Operands	Affected Flags
call	destination address	O/S/Z/A/C
This pushes what would be the next value for %eip onto the stack, and jumps to the destination address. Used for function calls. Alternatively, the destination address can be an asterisk followed by a register for an indirect function call. For example, call *%eax will call the function at the address in %eax.
int	I	O/S/Z/A/C
Causes an interrupt of the given number. This is usually used for system calls and other kernel interfaces.
Jcc	destination address	O/S/Z/A/C
Conditional branch. cc is the condition code. Jumps to the given address if the condition code is true (set from the previous instruction, probably a comparison). Otherwise, goes to the next instruction. The condition codes are: [n] a [e] - above (unsigned greater than). An n can be added for "not" and an e can be added for "or equal to" [n] b [e] - below (unsigned less than) [n] e - equal to [n]z - zero [n] g [e] - greater than (signed comparison) [n] l [e] - less than (signed comparison) [n] c - carry flag set [n] o - overflow flag set [p] p - parity flag set [n] s - sign flag set ecxz - %ecx is zero
jmp	destination address	O/S/Z/A/C
An unconditional jump. This simply sets %eip to the destination address. Alternatively, the destination address can be an asterisk followed by a register for an indirect jump. For example, jmp *%eax will jump to the address in %eax.
ret		O/S/Z/A/C
Pops a value off of the stack and then sets %eip to that value. Used to return from function calls.

Directive	Operands
.ascii	QUOTED STRING
Takes the given quoted string and converts it into byte data.
.byte	ALLIESVALUES
Takes a comma-separated list of values and inserts them right there in the program as data.
.endr
Ends a repeating section defined with .rept.
.equ	LABEL, VALUE
Sets the given label equivalent to the given value. The value can be a number, a character, or an constant expression that evaluates to a a number or character. prom that point on, use of the label will be substituted for the given value.
.globl	LABEL
Sets the given label as global, meaning that it can be used from separately-compiled object files.
.include	FILE
Includes the given file just as if it were typed in right there.
.lcomm	SYMBOL, SIZE
This is used in the .bss section to specify storage that should be allocated when the program is executed. Defines the symbol with the address where the storage will be located, and makes sure that it is the given number of bytes long.
.long	VALUES
Takes a sequence of numbers separated by commas, and inserts those numbers as 4-byte words right where they are in the program.
.rept	COUNT
Repeats everything between this directive and the .endr directives the number of times specified.
.section	SECTION NAME
Switches the section that is being worked on. Common sections include .text (for code), .data (for data embedded in the program itself), and .bss (for uninitialized global data).
.type	SYMBOL, @function
Tells the linker that the given symbol is a function.

	+0	+1	+2	+3	+4	+5	+6	+7
0	NUL	SOH	STX	ETX	EOT	ENQ	ACK	BEL
8	BS	HT	LF	VT	FF	CR	SO	SI
16	DLE	DC1	DC2	DC3	DC4	NAK	SYN	ETB
24	CAN	EM	SUB	ESC	FS	GS	RS	US
32		!	"	#	$	%	&	'
40	(	)	*	+	,	-	.	/
48	0	1	2	3	4	5	6	7
56	8	9	:	;	<	=	>	?
64	@	A	B	C	D	E	F	G
72	H	I	J	K	L	M	N	O
80	P	Q	R	S	T	U	V	W
88	X	Y	Z	[	\	]	^	_
96	'	a	b	c	d	e	f	g
104	h	i	j	k	l	m	n	o
112	p	q	r	s	t	u	v	w
120	x	y	z	{	\|	}	~	DEL

Programming from the Ground Up

Chapter 1: Introduction

Welcome to Programming

Your Tools

Programming from the Ground Up

Appendix I: Personal Dedication

Appendix H: GNU Free Documentation License

Appendix G: Document History

Appendix F: Using the GDB Debugger

Overview

An Example Debugging Session

Breakpoints and Other GDB Features

GDB Quick-Reference

Appendix E: C Idioms in Assembly Language

If Statement

Function Call

Variables and Assignment

Loops

Structs

Pointers

Getting GCC to Help

Appendix D: Table of ASCII Codes

Appendix C: Important System Calls

Appendix B: Common x86 Instructions

Reading the Tables

Data Transfer Instructions

Integer Instructions

Logic Instructions

Flow Control Instructions

Assembler Directives

Differences in Other Syntaxes and Terminology

Where to Go for More Information

Appendix A: GUI Programming

Introduction to GUI Programming

The GNOME Libraries

A Simple GNOME Program in Several Languages

GUI Builders

Chapter 13: Moving on From Here

Overview

From the Bottom Up

From the Top Down

From the Middle Out

Specialized Topics

Further Resources on Assembly Language

Chapter 12: Optimization

When to Optimize

Where to Optimize

Local Optimizations

Global Optimization

Review

Know the Concepts

Use the Concepts

Going Further

Chapter 11: High-Level Languages

Overview

Compiled and Interpreted Languages

Your First C Program

Perl

Python

Review

Know the Concepts

Use the Concepts

Going Further

Chapter 10: Counting like a Computer

Counting

Counting like a Human

Counting like a Computer

Conversions between Binary and Decimal

Truth, Falsehood, and Binary Numbers

The Program Status Register

Other Numbering Systems

Floating-Point Numbers

Negative Numbers

Octal and Hexadecimal Numbers

Order of Bytes in a Word

Converting Numbers for Display

Review

Know the Concepts

Use the Concepts

Going Further

	+0	+1	+2	+3	+4	+5	+6	+7
0	NUL	SOH	STX	ETX	EOT	ENQ	ACK	BEL
8	BS	HT	LF	VT	FF	CR	SO	SI
16	DLE	DC1	DC2	DC3	DC4	NAK	SYN	ETB
24	CAN	EM	SUB	ESC	FS	GS	RS	US
32		!	"	#	$	%	&	'
40	(	)	*	+	,	-	.	/
48	0	1	2	3	4	5	6	7
56	8	9	:	;	<	=	>	?
64	@	A	B	C	D	E	F	G
72	H	I	J	K	L	M	N	O
80	P	Q	R	S	T	U	V	W
88	X	Y	Z	[	\	]	^	_
96	'	a	b	c	d	e	f	g
104	h	i	j	k	l	m	n	o
112	p	q	r	s	t	u	v	w
120	x	y	z	{	\|	}	~	DEL