COMP 2131 Cheat Sheet (DRAFT) by ununited

Software

the stuff that controls the hardware

Steps to Start a Computer System

turn on- electrical signal sent to CPU- CPU starts executing instru­ctions from a particular fixed address in the memory- instru­ctions are executed one by one- instru­ction cycle, or the fetch execution cycle repeats forever.

Signal

a transm­ission of data

Digital Waveforms

discrete waveform. Repres­ented by two possible voltages on a wire (on or off). We use binary because the technology is not advanced enough for a switch to reliably hold more than two possible states.

ASCII Code

is a set of 8 bits assigned together to. represent data. For each character, a unique byte-sized integer is assigned.

Binary File

collection of characters in only machin­e-r­eadable form. Commonly used for the computer to read and execute. Ex operating system

System Software

which is required to operate a hardware. Ex. operating system, computer languages, utility software etc...

Processes

A process is the operating systems abstract for a running program. Multiple processes can run on the system, even on a single CPU core. The instru­ctions for one process is interl­eaved with the instru­ctions for another process, using context switching.

Process vs Threads

a process is an executing instance of a program, also termed "­tas­k". Always stored in the main memory, its an active entity; all processed are closed when the computer system is restarted. One program may consist of several processed and multiple processes can be executed in parallel, whenever possible. Ex. the MS Word software running a process. Thread is a subset if a process or a light weight process. The main difference is that threads execute with the context of a process and share the same resources allotted to the process by the kernal. Multiple threads leads to true parall­elism, possible on multip­roc­essor systems. It works on the principle that all the threads running within a process share the same address space, file descri­ptors, stack, and other related attrib­utes. Ex. in Word, when we type something, it automa­tically saves. SO editing and saving are hapeing in parallel in two threads

EFLAGS

are status registers which monitor the results produced from the execution of arithmetic instru­ctions and then perform specific tasks based on the status report.

Programs and Compil­ation Systems

A high level C program is translated to a low-level machine language instru­ction, packaged into a form called an executable object program, and stored as a binary file. Object programs are also referred to as object files. A translator Ie, a Compiler or an interp­reter is used to translate high-level language program to the machine language for execution.

Prepro­cessing Phase

The prepro­cessor (cpp) modifies the original C program according to directives that begins with the # character.

Assembly Phase

The assembler translates hello.s into machine language instru­ction, packages then into a form known as a reloca­table object program and stored the result in the object file hello.o. The hello.o file is a binary file whose bytes are encoded machine language instru­ctions rather than characters

Compil­ation systems try to produce correct efficient machine codes but list the errors that it could not unders­tand.

Unders­tanding Link-time Errors

Especially in the develo­pment of a large software system

Need for Cache Memory

Since fetch time is much longer than execution time, its a good idea to solve the proces­sor­-memory gap by the introd­uction of the cache memory or the CPU memory. Cache memory is very high-speed semi conductor memory which can speed up CPU, acting as a buffer between the CPU and main memory. It can also hold those parts of DATA and PROGRAM, which are most frequently used by the CPU. Those data and programs are the first transf­erred from disk to cache memory by the OS and the CPU can access them. It is mostly integrated directly with the CPU chip or it may be placed on a separate chip and can have a separate bus interc­onnect with the CPU.

Memory Hierarchy

L0: Registers

L2:L2 cache (SRAM)

L4: Main Memory (DRAM)

L6: Remote Secondary Storage / Tertiary Storage (distr­ibuted file systems, web servers)

GPU

Graphics Processing Unit: made to enhance the creation of images for a computer display, consists of thousands of smaller, more efficient cores designed to handle multiple tasks simult­ane­ously. Main functions are texture mapping, image rotation, transl­ation, and shading.

FPGA

Field Progra­mmable Gate Array: is not a processor but is capable of creating one or multiple proces­sors. The progra­mmable hardware is completely separate from the CPU and its used for digital design and can be reconf­igured repeat­ably. Can be used to help design specia­lized circuits for a specific applic­ation and can be modified for others,

RAM

Random Access Memory: consists of two types: DRAM and SRAM

SRAM

Static Random Access Memory: (Cache): retains a value as long as power is supplied, SRAM is typically faster than DRAM. Each SRAM memory cell is comprised of 6 transi­stors; the cost per cell of SRAM is more than DRAM

Secondary Memory

Floppy, hard disks

Registers

a word sized storage device in the main memory. PC (program counter) is a special register pointing at (contains the address of) some machin­e-l­anguage instru­ction stored in main memory increased after the fetch cycle.

There are several ways memory can be organized and used for data storage:

Shared Libraries

The library files ( already written and translated programs) that are shared by multiple processes

Stack

Memory allocated for short term storage

Network

A network is a set of hardware devices that are connected together physically or logically so that they may share or exchange inform­ation. The internet is an ideal example of a global network, also called a network of networ­ks" The main advantages are; data sharing, connec­tivity, hardware and software sharing, data security and manage­ment, perfor­mance enhanc­ement.

Nodes

Nodes are the connecting hardware on the network

Elements of a C program

Applic­ation Source: applic­ation. source and header files.

Linker: Resolves external references and produces the executable module.

GNU C Compiler

GCC is GNU compiler collec­tion. It is an integrated distri­bution of compilers for several major progra­mming languages like C, C++, Java, Object­ive-C, Objective C++ etc...

Some features of GCC are:

language indepe­ndence- possib­ility of sharing code among the compilers for all supported languages.

How to compile

gcc hello.c -o hello

Do not place source code (i.e. defini­tions) in the header file with a few except­ions: inline'd code, class defini­tions and const defini­tions

stdlib.h: common utility functions: malloc, calloc etc..

Malloc

This is a function in C that reserves a specified amount of memory during runtime and returns a pointer to the beginning of the allocated block.

The prepro­cessor in C is a program that processes your code before it's compiled. It can include header files, define macros, condit­ionally compile sections of code, and handle other tasks that occur before actual code compil­ation.

Commands begin with a #. #defin­e(d­efine a macros) #inclu­de(­insert text from file).

Primitive Data Types

char, int, short, long, float, double

%o: ocatal; %x: hexa; %c: char; %s:str­ing;%%: % itself

++ --

Binary operators -- Highest

* / %

Math symbols

Symbols Presce­dence

>>=­<<=

&&

Comma operator

lowest precedence of all the operators, causes a sequence of operations "do this, then this"

Expression vs Statement

An expression in C is any valid combin­ation of operators, constants, functions and variables. A statement is a valid expression followed by a semi colon;

2D Arrays

type array_­nam­e[r­ow-­siz­e][­col­umn­-size]

String is a character array

sequence of characters in a character array that is terminated by null character '\0'

String is just a one-di­men­sional array of characters

The length of the string is the number of bytes preceding the null character. The value of a string is the sequence of the values of the contained charac­ters, in order.

Same as a method in Java

Each function logically, should perform a specific task

Call by Reference: This method passes the address of the variable to the function. Hence, any changes made to the variables in the function directly alter the original variables as they share the same memory location. Note that C doesn't directly support call by reference, but it can be simulated using pointers.

permanent so they can retain values from one function invocation to the next.

Static Variables

Static variables in C are variables that retain their values between function calls. Unlike regular local variables, which are created and destroyed every time a function is called, static variables are initia­lized only once and exist until the program ends. User how is that different than an external varaible? External variables, or global variables, are declared outside any function and can be accessed by any function throughout the program. Unlike static variables, which are only visible within their own function or file, external variables are visible to all parts of the program, making them more univer­sally accessible but also potent­ially increasing the risk of unintended modifi­cat­ions.

Scope Rules

Binary Number System

Base 2

Octal Number

Base 8

Decimal to Binary

divide the number by the base (=2). take the remainder (either 0 or 1) as a coeffi­cient. Take the quotient and repeat the division.

6/2 = 3 (quoti­ent), 0 remainder

1/2 = 0 (quoti­ent), 1 (remai­nder)

Data Repres­ent­ation in Words

A word size is the number of bits processed by the computer in one go ie. typically 32 bits or 64 bits.

Addressing and Byte Ordering

A variable X of type int (allocated 4 bytes)

This means the 4 bytes of x would be stored in memory locations 0x100, 0x101, 0x102, and 0x103.

Two conven­tions to store the values in the 4 consec­utive byte memory locations. 0x01, 0x23, 0x45, and 0x67, or 0x67, 0x45, 0x23, and 0x01, depending on the CPU archit­ecture

Big Endian

0x67, 0x45, 0x23, 0x01 Big first Refers to Refers to the byte order in which the most signif­icant byte (MSB) is stored at the lowest memory address, and the least signif­icant byte (LSB) is stored at the highest memory address.

char, unsigned char

1 byte

Int, unsigned int

4 bytes

float

4 bytes

max number able to store is bit size / 4

unsigned char

Smallest number is 0, max number is 0xff

unsigned int

32 bits, smallest number is 0. max number is 0xffffffff

unsigned long

64 bits, smallest number is 0, largest number is 0xffff­fff­fff­ffffff.

1 + 1

= 0 carry the 1

0 - 1

borrow a base when needed

Repres­ent­ation of Negative Binaries in Memory

Other 7 bits (for an int, 8 bits) is used to represent the integers

Smallest number is -128

This system allows simple binary addition to work for both positive and negative operands without needing separate subtra­ction hardware. The leftmost bit often acts as a sign bit, with 0 for non-ne­gative values and 1 for negative values.

Floating point is typically expressed in the scientific notation, with a fraction (F) and an exponent (E) of a certain radix (r), in the form of F x r ^ E

0.01

= 2^-2 = 0.25

Floats are stored in memory as follows

sign bit 's' = denoting positive or negative - 1 bit

exponent 'e' = 8 bits

Normalized values

The bit pattern of exp is neither all zeros nor all ones

The denorm­alized numbers gradually lose their precision as they get smaller because the left bits of the fraction become zeros

ASCII Character codes

Used to represent inform­ation sent as character based data

Boolean Expression

Any expression that evaluates to true or false.

Scope Rules

Outside of all functions which is called global variables

Pointers in C are like arrows that point to a location in your computer's memory where data is stored. Instead of holding a value themse­lves, they tell you where to find the value.

Pointers and arrays in C are closely related because arrays are essent­ially a block of contiguous memory locations. The name of the array is a pointer to the first element of the array. So, if you have an array like int arr[5], you can access its elements using pointers. For example, *(arr + 2) will give you the third element of the array, because the pointer arr points to the start of the array and adding 2 moves the pointer to the third element. This relation gives you another way to access and manipulate arrays, making the use of arrays more flexible in C.

Assignment to a pointer

ptr = &x; Assigns ptr to point to the address where x is stored.

*ptr is the value at the memory address given by the value of ptr

If ptr = &y then y = *ptr + 1 is the same as y = y + 1

Structures provide a way of storing many different values in variables of potent­ially different types under the same name.

Types of memory

Primary memory: most part of memory clears out everytime a computer is restarted. This is also called temporary memory or volatile memory except ROM. Ex. RAM, ROM and Cache

Dynamic Ram (DRAM)

More commonly used in memory here each cell stores a bit wit ha capacitor. One transistor is used for accessing the data. Here values must be refreshed every 10-100ms to retain. Slower and cheaper than SRAM but is used as a simple scratch area for different data manipu­lat­ions.

Enhanced DRAM

Double Data-Rate Synchr­onous DRAM (DDR SDRAM)

Double edge clocking to send two bits per cycle per pin. Different types are there that are distin­guished by size of small prefetch buffer like DDR(2 bits), DDR2(4 bits), DDR4(8 bits)

Cache Memory

There is a problem of processor - memory bottle­neck. If the processor is running at the same speed as the memory bus, both work fine, but since newer computers have high speed CPU's, the CPU will have to wait for inform­ation from the memory. Cache stores the info coming from memory and the processor can get the info from the cache must faster. Small fast storage device that acts as a staging area for a subset of the data from the larger, slower device like RAM. Can be multiple levels of cache L1, L2

Cost of cache miss

Consider: Cache hit time of 1 cycle. Miss penalty of 100 cycles.

99% hits: 1 cycle + 0.01 * 100 cycles = 2 cycles

Hit Time

Hit time is the time to deliver a line in the cache to the processor. It also includes time to determine whether the line is in the cache. Typical hit times: 1-2 clock cycles for L1

This is the non-vo­latile part of the memory used for storing data for long term storage. Ex. Floppy, hard disk, usb

A hard disk consists of platters, each with two surfaces. Each surface consists of concentric rings called tracks. Each track consists of sectors separated by gaps. A sector is the block that is addressed to store a block of inform­ation.

Counter clockwise rotation of the disk happens until it reaches the requireds ector

Calculate Disk Capacity

We may measure the disk capacity using the following technology factors:

Track Density (tacks­/in­):the number of tracks that can be squeezed into a 1 inch segment of the radius extending from the centre of the platter.

Disk Capacity Calcul­ation

Capacity = (#byte­s/s­ector) x (avg.# sector­s/t­rack) x (#trac­ks/­sur­face) x (#surf­ace­s/p­latter) x (#plat­ter­s/disk)

Average Time

Taccess = Tavg seek + Tavg rotation + Tavg transfer

Rotaional Latency (Tavg rotation)

Time wasted for first bit of target sector to pass under r/w head. Tavg rotation = 1/2 x 1/RPMs x 60sec/1min . Typical is 720RPMs

Solid State Disks (SSDs)

Device that uses integrated circuits to store data perman­ently. Since SSDs do not have mechanical compon­ents, these are typically more resistant to physical shock, run silently, have lower access time, and lower latency. More expensive

Spacial

Items near by addresses tend to be referenced close together in time

you can think of a linker as a person assembling a train set. Each car of the train is a piece of compiled code, and the linker's job is to connect these cars together in the correct order to form a complete train (the final executable program). If one car needs to connect to another in a specific way (such as a function in one piece of code calling another function in another piece), the linker ensures they're hooked together properly, so the entire train runs smoothly. The final result is a complete, operat­ional program that's ready to run on your computer. A process of collecting and combining various pieces of code and data into a single file that can be loaded into the memory and executed. Linking can be done at compile time, or run time.

Relocation A linker merges separate code and data sections in the .o files into single sections in the a.out file and relocates symbols from their relative locations in the .o files to their final absolute memory locations in the execut­able. A linker also updates all references to these symbols to reflect their new positi­ons.:

Efficiency is Implem­ented in two ways: 1. Time Efficiency - a separate compil­ation enables changes to one source file, compile, and then relink, therefore there is no need to recompile other source files again and again

think of the compiler driver as the conductor of an orchestra. The musicians in the orchestra each play their instru­ments, just as different parts of the compil­ation process (prepr­oce­ssing, compiling, assemb­ling, linking) handle specific tasks. The conductor coordi­nates all the musicians to create a harmonious piece of music, just as the compiler driver coordi­nates the various stages of the compil­ation process to produce a working execut­able. It makes sure everything happens in the right order and that all the necessary pieces come together, simpli­fying the complex process into a single, unified command. A compiler driver invokes the language pre processor, compiler, assembler, and linker as needed on behalf of the user. The name of the compiler driver on our Linux box is gcc

The steps of execution are:

1. The driver first runs the C prepro­cessor (cpp), which translates the C source file main.c into an ASCII interm­ediate file main.i

3. then the driver runs the assembler (as), which translates main.s into a reloca­table object file main.o

Primary Memory Addressing

The primary memory of the computer is used as contiguous array of physical addresses. It has two parts: 1. Low Memory Area: stores resident operating system. 2. High Memory Area: user processes

Memory Relocation Concept

memory relocation is like rearra­nging the contents of a bookshelf. If you need to make room for more books or organize them differ­ently, you might shift some of the books to different spots on the shelf. Similarly, memory relocation moves data and code to different parts of the computer's memory to make more efficient use of space or to allow programs to run correctly, even if they weren't originally designed to be placed in those exact spots in memory.

Swapping

Swapping is like moving books between a small reading table (RAM) and large booksh­elves (hard drive). If your table is full and you need a new book that's on the shelf, you'll put one book from the table back onto the shelf and take the new book you need. In a computer, when RAM is full and a new program or data needs to be loaded, the operating system puts some of the data or programs that are in RAM but not currently being used onto the hard drive, making space for the new inform­ation. This keeps the system running smoothly, even when working with more data than can fit in RAM at one time.

Static Linking

Symbol Resolu­tion: Object files define and reference symbols. The purpose of symbol resolution is to associate each symbol reference with exactly one symbol definition

Dynamic Linking

think of dynamic linking like a toy set with interc­han­geable parts. When you're playing with the toy, you might want to add special features or access­ories, like wheels or wings. Instead of storing all these parts inside the main toy (which would make it big and heavy), you keep them in a separate box and snap them on as needed. In a computer, a dynami­cally linked program works the same way. It stays small and lightw­eight because it doesn't include everything inside itself. Instead, it reaches out and grabs the extra parts (like functions or variables) from shared libraries when it needs them, keeping things more efficient and flexible.

Reloca­table Object files ( .o): Think of this as a puzzle piece that hasn't been fixed to the final picture yet. It contains compiled code, but it has references (like function calls) that aren't tied down to specific addresses. This allows the linker to move it around and fit it with other pieces when creating the final execut­able. It's a flexible, interm­ediate step in building a program.

Shared Object File (.so ): Imagine a special puzzle piece that can fit into multiple puzzles. A shared object file contains code or data that multiple programs can use simult­ane­ously. Instead of including the same code in every program (which would take up more space), the code is stored in one place, and different programs can reach into it and use what they need. It's a way to share common functions or variables between different programs, making things more efficient.

Inform­ation in Object File

Object Code: Binary instru­ctions and data generated by a compiler or assembler

Symbol­s:G­lobal symbols defined in this module, symbols to be imported from other modules or defined by the linker.

think of ELF as a standa­rdized container used for shipping various goods. Different containers might be used for different types of goods, but this particular container (ELF) is designed in such a way that it can effici­ently pack away different types of progra­mming "­goo­ds,­" like the actual programs you run (execu­tab­les), the building blocks used to create those programs (object code), or the shared pieces used by many programs (shared librar­ies). By having this standa­rdized container, the system knows exactly how to handle, load, and run these various compon­ents, regardless of what's inside. Just as shipping containers have specific ways they can be lifted, stacked, and transp­orted, ELF files have a specific structure that the operating system unders­tands, allowing it to handle them in a consistent and efficient way.

Segment Header table

For runtime execution: Page size, virtual addresses memory segments (secti­ons), segment sizes.

.rodata section: Read only data: jump tables, ...

.bss section: Uninit­ialized global variables; it has a section header but occupies no space

.rel.text section: Is the relocation info for .text section, which addresses instru­ctions that will need to be modified in the execut­able; Also instru­ctions for modifying.

.debug section: Info for symbolic debugging (gcc -g); Section header table used for linking and reloca­tion: Offsets and sizes of each section

Reloca­table: files are created by compilers and assemblers but need to be processed by the linker before running

Shared Object: are shared libraries, containing both symbol inform­ation for the linker and directly runnable code for runtime

Global symbol: defined by module m that can be referenced by other modules. For example, non-static C functions and non-static global variables. (Note that static C functions and static global variables cannot be referred from other files.)

Local symbols: Symbols defined and referenced exclus­ively by module m.

Strong: procedures and initia­lized globals

Linkers Symbol Rules

Rule 1: Multiple strong symbols are not allowed; each item can be defined only once, otherwise the result is a linker error

Rule 3: If there are multiple weak symbols, pick an arbitrary one. This can be overridden with gcc –fno-c­ommon

Relocation

Relocation consists of two steps:

Relocating symbol references within sections

Static Libraries: Concat­enate related reloca­table object files into a single file with an index (called an archive).  Enhance linker so that it tries to resolve unresolved external references by looking for the symbols in one or more archives.  If an archive member file resolves reference, link it into the execut­able.

To write an efficient code, you need to understand the basic facts: a. Constant factors o It is possible to improve the perfor­mance of the code, if it is properly written The optimi­zation can be done in various ways: Adopting an approp­riate algorithm,  Selecting proper data repres­ent­ations,  Following procedures and loops suitably and accurately

Compiler constr­uction has always been an active research topic. Compiler developers have developed very advanced and optimi­zation compilers that can automa­tically make the optimized codes by:

Nevert­heless, many places may not be optimized by compilers:  Improving asymptotic efficiency  Selecting best overall algorithm

The optimi­zation compilers have numerous constr­aints; for example, they cannot cause any change in program behaviour and cannot change the algori­thmic style of the progra­mmers

Not change behaviour that may be obvious to the programmer but can be obfuscated by languages and coding styles like data ranges may be more limited than variable types suggest

Common optimi­zat­ions:  Take the same repeated task out of the loop (Code Motion)  Replace mathem­atical operations with bitwis­e/shift operations wherever possib­le(­red­uction in strength)  Share common sub-ex­pre­ssions  Do not use functions as the loop condition checker (Optim­ization Blockers)

Replace costly operation with simpler one. Shift operations are easier as compared to multiply and divide  Use Shift operation instead of multiply or divide 16*x --> x << 4  Utility machine dependent  Depends on cost of multiply or divide instru­ction o On Intel Nehalem, integer multiply requires 3 CPU cycles  Recognize sequence of products

To calculate : p = q r + m; x = q r + n; It is always more advisable to do: s=q * r; p = s + m; x= s + n;

How this works:

Strlen is the only way to determine length of string as scans the entire length, looking for null character.  Overall perfor­mance of the program: o N calls to strlen o Require times N, N-1, N-2, …, 1 o Overall O(N2 ) perfor­mance

The optimi­zation compiler will not be able move strlen out of inner loop, as:  Procedure may have side effects  May alter global state each time called  The function may not return same value for given arguments  May depends on other parts of global state  Procedure lower could interact with strlen

Remedies for the progra­mmer:

Use of inline functions o GCC does this with –O2  Do your own code motion as discussed above

Remedy for the progra­mmer:  Get in habit of introd­ucing local variables o Accumu­lating within loops o Your way of telling compiler not to check for aliasing

Multiple data can process simult­ane­ously. To understand that, we need a general unders­tanding of modern processor design. As with multi-core systems, the CPU can execute multiple instru­ctions in parallel. In this case, perfor­mance will be limited by data depend­encies.

To see the impact of the optimi­zation, we need to have a defined metrics. The number of cycles per element (CPE), is the measure that assumes the run time, measured in clock cycles, for an array of length n is a function of the form Cn + K where Cn is the CPE.

A supers­calar processor can issue and execute multiple instru­ctions in one cycle. The instru­ctions are retrieved from a sequential instru­ction stream and are usually scheduled dynami­cally.

Another way of implem­enting optimi­zation applied to loops. This reduces the frequency of branches and loop mainte­nance instru­ctions. The number of iterations is known prior to execution of the loop. Objective is to reduce the total number of times loop runs

Phases of a Program

User programs in C (code time) [ . C file]

Assembler

The time required to execute a program depends on:

program structure (as weitten in C, for instance)

The hardware implem­ent­ation: Amount of time required to execute an instru­ction

ISA Instru­ction Set Archit­ecture

ISA is used to define: The systems state (eg. registers, memory, program counter)

The effect that each of these instru­ctions will have on the system state

The ISA describes the following

Memory model: how memory is accessed and referenced

operand registers, types, and data addressing - data storage and processing locations

Advantages include:

Machine code with a better human unders­tan­ding, ease to write and debug, the use of mnemonics for instru­ctions, and it reserves memory location for data

Need for Assembly Language

The ability to read and understand assembly code is an important skill

The programs written in high level languages usually does not run as fast as assembly language programs, so whenever execution speed is so critical, only assembly language routines can be useful.

Progra­mmers developing compilers must know assembly language

Memory: Part of primary memory, where other data and program code is stored

Registers

are small memory areas that are volatile and are used for all memory manipu­lat­ions.

Of the 8 registers, 6 are commonly used and the remaining two are rarely used.

EBX

A general purpose register, that does not have a dedicated role. It is used as a base pointer form memory access and also used to store extra pointer or calcul­ation step. Base pointer to the data section

EDX

I/O pointer. This is the data register, that holds the size of the data.

EDI

destin­ation indicator

EBP

stack frame base pointer (where the stack starts for a specific function)

EFLAGS register

a single register that may indicate different values through its different bits

Sign Flag (SF)

sets equal to the most signif­icant bit of the result

Direction Flag (DF)

determines left or right direction for moving comparing string data. When the DF value is 0, the string operation takes left-t­o-right direction

Trap Flag (TF)

allows setting the operation of the processor in single­-step mode. The DEBUG program we used sets the trap flag, so we could step through execution one instru­ction at a time.

Data Segment

repres­ented by .data section and the .bss section and is used to declare the memory region, where data elements are stored for the program.

Stack: segment contains data values passed to functions and procedures within the program. SSR (Stack segment register stores the starting address of the stack). An extra segment is used to store Extra data. It is pointed by ES (Extra segment register)

Three main catego­ries:

data transfer instru­ctions

logical and program control instru­ctions

.bss section: also declares variables

EAX

32 bit accumu­lator register

AX

16 bit accumu­lator register

PUSH

push word, double word or quad word on the stack, it automa­tically decrements the stack pointer esp, by 4

EQU

sets a variable equal to some memory

s

short (16 bit int) or single (32 bit floating point)

l

long (32 bit integer or 64 bit floating point)

t

ten bytes (80-bit floating point)

Indirect Memory Addres­sing: register contains the value

Offset Addressing (register, offset): register may calculate the memory reference for final data

%eax

refers to the value in register

9(%eax, %edx)

means use the address in %eax+%­edx*9 and use the value as addresss to refer to the data at that location

Transfer data between memory and regist­er.-­load data from memory into regist­er.-­store data into memory

MOV instru­ction

The syntax is: mov? Source, destin­ation. movb = move byte; movw = move word...

movw %bp, %sp

Regist­er-­-Re­gister, 2 bytes. :copy the 16-bit value from the base pointer register (%bp) into the stack pointer register (%sp).

Load Effective Address - leal

variant of the movl instru­ction. It has the form of an instru­ction that reads from memory to an register, but it does not reference memory at all. Its first operand appears to be a memory reference, but instead of reading from the designated location, the instru­ction copies the effective address to the destin­ation

Control

In addition to integer registers, the CPU maintains a set of single-bit condition code registers describing attributes of the most recent arithmetic or logical operation. These registers can then be tested to perform condit­ional branches

ZF

Zero Flag: The most recent operation yielded zero

OF

Overflow Flag:The most recent operation caused a two's complement overflow either negative of positive

jmp *%eax

Uses the value in register %eax as the jump target, and the instru­ction

Procedures in Assembly

A procedure call involves passing both data (in the form of procedure parameters and return values) and control from one part of a program to another.  The data passing happens using stack in the memory, that is shared by both main program and the procedure  Within the function, the need is to also allocate space for the local variables defined in the procedure on entry and deallocate them on exit.  Most machines, including IA32, provide only simple instru­ctions for transf­erring control to and from proced­ures.  The part of the program that is needed to be done many times is defined in the procedure  Each procedure is identified by a name  The procedure is defined as a label but after the execution of the procedure, the execution returns to the same place from where it has been called when ret (return) statement is executed  The procedure may flow along multiple labels as well

The stack implem­ent­ation has some special features, which are:  The stack can only hold words or double­words, not a byte.  The stack grows in the reverse direction, i.e., toward the lower memory address  The top of the stack points to the last item inserted in the stack; it points to the lower byte of the last word inserted.