1. What is Assembly Language?
Introduction to the GNU/Linux assembler and linker
for Intel Pentium processors

2. High-Level Language
Most programming nowdays is done using so-called “high-level” languages (such as
FORTRAN, BASIC, COBOL, PASCAL, C, C++, JAVA, SCHEME, Lisp, ADA, etc.)
These languages deliberately “hide” from a programmer many details concerning HOW his problem actually will be solved by the underlying computing machinery

3. The BASIC language
Some languages allow programmers to forget about the computer completely!
The language can express a computing problem with a few words of English, plus formulas familiar from high-school algebra
EXAMPLE PROBLEM: Compute 4 plus 5

4. The example in BASIC LET X = 4 LET Y = 5 LET Z = X + Y
PRINT X, “+”, Y, “=“, Z
END
Output: = 9

5. The Python language
It shares some of the best features of the earlier BASIC language – but improves it by incorporating more modern capabilities
The Python Language Reference manual is handily accessible online:
<
Lots of tutorials and program examples can be quickly discovered using ‘google’

6. Example in Python
If you type these Python statements into a textfile named ‘example’, you can execute them in a Windows or Linux environment:
e.g., $ python example
x = 4
y = 5
z = x + y
print x, ‘+’, y, ‘=‘, z

7. The C language
Other high-level languages do require a small amount of awareness by the program-author of how a computation is going to be processed
For example, that:
- the main program will get “linked” with a “library” of other special-purpose subroutines
- instructions and data will get placed into separate sections of the machine’s memory
- variables and constants get treated differently
- data items have specific space requirements

8. Same example: rewritten in C
#include <stdio.h> // needed for printf()
int x = 4, y = 5; // initialized variables
int z; // unitialized variable
int main() {
z = x + y;
printf( “%d + %d = %d \n”, x, y, z ); }

9. “ends” versus “means”
Key point: high-level languages let programmers focus attention on the problem to be solved, and not exspend effort thinking about details of “how” a particular piece of electrical machiney is going to carry out the pieces of a desired computation
Key benefit: their problem gets solved sooner (because their program can be written faster)
Programmers don’t have to know very much about how a digital computer actually works

10. computer scientist vs. programmer
But computer scientists DO want to know how computers actually work:
-- so we can diagnose computer errors
-- so we can employ optimum algorithms
-- so we can predict computer behavior
-- so we can devise faster computers
-- so we can build cheaper computers
-- so we can pick one suited to a problem

11. A machine’s own language
For understanding how computers work, we need familiarity with the computer’s own language (called “machine language”)
It’s LOW-LEVEL language (very detailed)
It is specific to a machine’s “architecture”
It is a language “spoken” using voltages
Humans represent it with zeros and ones

12. Example of machine-language
Here’s what a program-fragment looks like:
It means: z = x + y;

13. Incomprehensible?
Though possible, it is extremely difficult, tedious (and error-prone) for humans to read and write “raw” machine-language
When unavoidable, a special notation can help (called hexadecimal representation):
A1 BC
03 05 C
A3 C
But still this looks rather meaningless!

14. Hence assembly language
There are two key ideas:
-- mnemonic opcodes: we use abbreviations of English language words to denote operations
-- symbolic addresses: we invent “meaningful” names for memory storage locations we need
These make machine-language understandable to humans – if they know their machine’s design
Let’s see our example-program, rewritten using actual “assembly language” for Intel’s Pentium

15. Simplified Block Diagram
Central
Processing
Unit
Main
Memory
system bus
I/O
device
I/O
device
I/O
device
I/O
device

16. The visible x86 registers
RAX
RSP R8
R12
RBX
RBP R9
R13
RCX
RSI
R10
R14
RDX
RDI
R11
R15 CS DS ES FS GS SS
RIP
RFLAGS
Intel Core-2 Quad processor

17. The “Fetch-Execute” Cycle
main memory
central processor
Temporary
Storage
(STACK)
RSP
Program
Variables
(DATA)
EAX
EAX
EAX
RAX
Program
Instructions
(TEXT)
RIP
the system bus

18. Define symbolic constants
.equ device_id, 1
.equ sys_write, 1
.equ sys_exit, 60

19. our program’s ‘data’ section
.section .data
x: .quad 4
y: .quad 5
fmt: .asciz “%d + %d = %d \n”

20. Our program’s ‘bss’ section
.section .bss
z: .quad 0
n: .quad 0
buf: .space 80

21. our program’s ‘text’ section
.section .text
_start:
# comment: assign z = x + y
movl x, %rax
addl y, %rax
movl %rax, z

22. ‘text’ section (continued)
# comment: prepare program’s output
push z # arg 5
push y # arg 4
push x # arg 3
push $fmt # arg 2
push $buf # arg 1
call sprintf # function-call
addl $40, %rsp # discard the args
movl %rax, n # save return-value

23. ‘text’ section (continued)
# comment: request kernel assistance
movl $sys_write, %rax
movl $device_id, %rdi
movl $buf, %rsi
movl n, %rdx
syscall

24. ‘text’ section (concluded)
# comment: request kernel assistance
movl $sys_exit, %rax
movl $0, %rdi
syscall
# comment: make label visible to linker
.global _start
.end

25. program translation steps
demo.s
demo.o
program
source
module
demo
program
object
module
assembly
linking
the
executable
program
object module library
object module library
other object modules

26. The GNU Assembler and Linker
With Linux you get free software tools for compiling your own computer programs
An assembler (named ‘as’): it translates
assembly language (called the ‘source code’) into machine language (called the ‘object code’)
$ as demo.s -o demo.o
A linker (named ‘ld’): it combines ‘object’ files with function libraries (if you know which ones)

27. How a program is loaded 0xFFFFFFFFFFFFFFFF Kernel’s code and data
stack
runtime libraries
.bss
uninitialized variables
.data
initialized variables
.text
program instructions 0x
Main memory

28. What must programmer know?
Needs to use CPU register-names (rax)
Needs to know space requirements (quad)
Needs to know how stack works (push)
Needs to make symbol ‘global’ (for linker)
Needs to understand how to quit (exit)
And of course how to use system tools:
(e.g., text-editor, assembler, and linker)

29. Summary
High-level programming (offers easy and speedy real-world problem-solving)
Low-level programming (offers knowledge and power in utilizing machine capabilities)
High-level language hides lots of details
Low-level language reveals the workings
High-level programs: are readily ‘portable’
Low-level programs: tied to specific CPU

30. In-class exercise #1
Download the source-file for ‘demo1’, and compile it using the GNU C compiler ‘gcc’:
$ gcc demo1.c -o demo1
Website:
Execute this compiled application using:
$ ./demo1

31. In-class exercise #2
Download the two source-files needed for our ‘demo2’ application (i.e., ‘demo2.s’ and ‘sprintf.s’), and assemble them using:
$ as demo2.s -o demo2.o
$ as sprintf.s -o sprintf.o
Link them using:
$ ld demo2.o sprintf.o -o demo2
And execute this application using: $ ./demo2

32. In-class exercise #3
Use your favorite text-editor (e.g., ‘vi’) to modify the ‘demo2.s’ source-file, by using different initialization-values for x and y
Reassemble your modified ‘demo2.s’ file, and re-link it with the ‘sprintf.o’ object-file
Run the modified ‘demo2’ application, and see if it prints out a result that is correct

33. In-class exercise #4
Download the ‘ljpages.cpp’ system-utility from our class website and compile it:
$ g++ ljpages.cpp –o ljpages
Execute this utility-program to print your modified assembly language source-file:
$ ./ljpages demo2.s
Write your name on the printed hardcopy and turn it in to your course instructor

34. Summary of the exercises
Download and Compile a high-level program
Assemble and Link a low-level program
Edit and recompile an assembly program
Print out and turn in your hardcopy