Chapter 4

Software
 Chapter Outline
• Assembler, compiler, and linker are tools
for generating object programs
• Loader transfers programs into memory and
handles execution initiation/termination
• Debugger identifies programming errors
• I/O and other tasks can be programmed
in multiple languages
• Operating system manages everything
 The Assembly Process
• Source program created using text editor
• Written to file on disk for later processing
• Assembler translates source file to object
code
• Recognizes mnemonics for OP codes
• Interprets addressing modes for operands
• Recognizes directives that define constants
and allocate space in memory for data
• Labels and names placed in symbol table
 Two-Pass Assembler
• Consider forward branch to label in program
• Offset cannot be found without target address
• Let assembler make two passes over program
• 1st pass: generate all machine instructions,
and enter labels/addresses into symbol table
• Some instructions incomplete but sizes known
• 2nd pass: calculate unknown branch offsets
using address information in symbol table
 Loading/Executing Object Programs
• Loader invoked when user types command
or clicks on icon in graphical user interface
• User input identifies object file on disk
• Object file has information on starting location
in memory and length of program
• Loader transfers object program from disk to
memory and branches to starting address
• At program termination, loader recovers
space in memory and awaits next command
Separate Processing of Object Files
• Can partition one program into multiple files
• Can also use subroutines defined by others
• Let assembler process each file separately,
making list of unknown external names
• Object file augmented with list of names and
list of instructions with external references
• Programmer must also export names from an
object file that could be used with other files
 The Linker
• Combines object files into object program
• Constructs map of full program in memory
using length information in each object file
• Map determines addresses of all names
• External names matched with exported names
• Instructions referring to external names are
finalized with addresses determined by map
• Unmatched names are reported as errors
 Libraries
• Subroutines that are useful in one program
are often useful in other programs
• Separate file assembly and linking enables
reuse of source files with these subroutines
• Alternatively, generate object files once and
use archiver to collect them into a library file
• Library includes name information to aid in
resolving references from calling program
 The Compiler
• Assembly-language programming requires
knowledge of machine-specific details
• Programming in a high-level language (like C)
reduces need for machine-specific knowledge
• Program in high-level language must be
translated into assembly language for machine
• The compiler performs this translation
• The assembler processes compiler output file
 The Compiler
• Just as in assembly language, use multiple files
to partition a program in high-level language
• Must declare external subroutines & variables
• Enables checking of data types across all files
• Assembler invoked for each output file, then
linker combines object files (with any libraries)
• Compiler automates various tedious tasks,
such as managing stack frames for subroutines
 Compiler Optimizations
• Assembly-language program from compiler
may not be efficient in size or execution time
• An optimizing compiler applies techniques to
enhance performance or reduce code size
• Much execution time is spent in loops
• Optimize performance by using registers to
hold value of loop index and other variables
• Use Load/Store instructions before/after loop
 Programs Using Multiple Languages
• Once assembler generates an object file,
original source language is less relevant
• Linker combines object files & library routines
for source programs written in any language
• Machine-specific calling conventions define
register usage and stack frames
• Routines written in assembly language can call
high-level language routines, and vice-versa
 The Debugger
• Programming errors, or bugs, can cause an
object program to produce incorrect results
• The debugger enables the programmer to
identify such errors at execution time
• Execution can be stopped at points of interest
• At such points, debugger accepts commands
to display contents of registers or memory
• Execution resumed until next point of interest
 Trace Mode and Breakpoints
• The debugger can use trace mode interrupts
• Service routine invoked after each instruction
to enable user to inspect registers/memory
• Trace mode disabled within debugger, then
re-enabled upon return from interrupt
• Breakpoints involve placing software-interrupt
instruction in program to enter debugger
• Old instruction restored to resume execution
 Using a High-Level Language for I/O
• Use of high-level language preferred due to
ease of program development & maintenance
• Consider example in assembly-language and C
for I/O task to show use of high-level language
• Polling of keyboard, sending chars to display
• Assembly-language reads/writes I/O registers
and uses polling loop to check device status
• C program must perform same operations
 Using a High-Level Language for I/O
• #define statements in C are similar to EQU for
associating a symbolic name with an address
• They also define pointer type for C code
• Use of volatile qualifier is important for I/O
• Prevents unwanted compiler optimizations
that might use register instead of I/O location
• Also necessary in presence of cache memory;
ensures cache is bypassed when accessing I/O
Interaction: C  Assembly Language
• Program may need access to control registers
• Example: enabling processor interrupts
• Assembly-language instructions used for this,
but no equivalent in high-level language like C
• Compilers therefore permit inclusion of such
instructions within high-level source program
• Use similar keyboard/display example, but
now with interrupts from keyboard interface
Interaction: C  Assembly Language
• Main routine peforms necessary initialization
• Accesses keyboard I/O control register to
enable interface to assert interrupt request
• Writes service routine address to location in
memory that holds interrupt vector
• Accesses processor control register using
special instruction to enable interrupts
• Service routine sends each char. to display
Interaction: C  Assembly Language
• Processor control register has no address, so
#define technique cannot be used as before
• Must use special instruction that compiler
does not emit in output assembly language
• Use special asm() directive to insert desired
assembly-language instructions where needed
• Service routine must end with proper return
instruction; use special interrupt directive
 The Operating System
• Coordinates all activities in a computer system
• Comprises essential memory-resident routines
and utility programs stored on magnetic disk
• Manages processing, memory, I/O resources
• Interprets user commands, allocates storage,
transfers information, handles I/O operations
• Loader discussed previously is part of OS
• Used by OS to execute application programs
 The Boot-strapping Process
• OS for general-purpose computer is large
• All parts, including memory-resident, on disk
• Boot-strapping loads memory-resident part,
enabling OS to assume control over resources
• At power-up, processor fetches instructions
initially from permanent memory to read disk
• Progressively larger programs transfer OS into
memory in preparation for user commands
 Managing Execution of Programs
• Discuss OS operation with example computer
having keyboard, display, disk, and printer
• User enters command, loader transfers code
and data in object file to memory to execute
• To read data file on disk, request made to OS
• OS and I/O activity occur while program waits
• Program waits again after sending to printer
• Timeline diagram illustrates this behavior
 Managing Execution of Programs
• Computer resources not being used efficiently
when I/O devices and processor are idle
• Start execution of other application programs
before initial program terminates
• Concurrent processing for computation and
I/O requests can result whenever possible
• OS manages activity for efficient utilization
• Called multiprogramming or multitasking
Use of Interrupts in Operating Systems
• Interrupts used extensively for I/O operations
• Also enable OS to assign execution priorities,
switch between programs, coordinate I/O, etc.
• Service routines for I/O devices are part of OS
• I/O requests made through library routines
that raise software interrupt to enter OS
• OS initiates I/O activity while program waits
• Hardware interrupts signal completion to OS
 Example of Multitasking
• Multitasking requires various OS capabilities
• OS uses hardware timer for time slicing when
managing execution of multiple programs
• Enables fair allocation of processor usage
• OS must also support I/O requests to enable
concurrent computation and I/O activity
• Consider organization of OS software with
initialization, scheduler, I/O routines, drivers
 Example of Multitasking
• A process is a program with its execution state
• Can be Running, Runnable, or Blocked for I/O
• Assume application programs A and B initiated
• If A is executing when time slice expires,
SCHEDULER is entered and registers are saved
• OS then selects B, restores its register values,
then uses return-from-interrupt to resume B
• This event sequence is called a context switch
 Example of Multitasking
• Now A calls I/O routine for software interrupt
• OS calls IOINIT, then KBDINIT in device driver
• Device interrupts are enabled for transfer
• SCHEDULER routine in OS then selects B
• Keyboard interrupt invokes IODATA routine
which polls devices to find interrupt source
• A made Runnable, OS lets B resume execution
• After later context switch, A executes again
 Concluding Remarks
• Software makes computers useful & versatile
• Utility programs enable creation, execution,
and debugging of application software
• High-level language and assembly language
can be used for the same program
• Where necessary, assembly language can be
included within high-level source program
• OS and multitasking provide more versatility