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

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.

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

Table of Contents

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.

	+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

	+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