System Programming Assignment 1

8/2/2019 System Programming Assignment 1......

1/24

Department of Computer Science and Information Technology

SYSTEM PROGRAMMING ASSIGNMENT - 1Submission Date: 2nd April, 2012

1. What is language processor? Explain with figure.

Ans: Language processors are language translation software like

assembler, interpreter and compiler. Allows the development of

applications in the language most appropriate to the task, removing the need for

developing at the machine level. Programmers can ignore the machine-dependentdetails of programming. Receives a textual representation of an algorithm in a

source language, and produces as output a representation of the same algorithm in

the objectortarget language.

Source languageObject or o object of targetlanguage

Fig. Language processor

Language processor represented by T-Diagram:-

The language processor itself is written in what is`s1called the

implementation language. These relations are often represented in T-diagrams.

LPs nameSource language Target language

ImplementationLanguage

T-Diagram Example:-

LAKSHMI NARAIN COLLEGE OF TECHNOLOGY

Sanwer Road, INDORE

Language processor
http://www.lnctindore.com/(S(qslapvyrmtczcnjj3xf4zya5))/index.aspx


2/24

Delphi

Pascal Machine code

C++

This diagram represents a language processor which translates Pascal to machine

code; the processor is called Delphi, and is written in C++.

Conceptual structure:

Source Executable codetext

Front-end Back-end

Front-end: the part of the language processor that performs the analysis of thesource language

Back-end: the part of the language processor that does the target languagesynthesis.

In a fully-modular design the front-end is totally unaware of the back-end inpractice, this is inefficient, and even the best-structured compilers compromise.

Types of language processing:-

Analysis Semanti

cSynthes

is


3/24

Assemblers:Language processors that map low-level language instructions intomachine code, e.g. the ARM assembler>

Compilers:Language processors that map high-level language instructions intomachine code, e.g. Delphi, GCC, Visual C++ etc.Pre-processors: Language processors that map a superset of a high-levellanguage into the original high-level language, or perform simple text substitutions

before translation takes place.

Interpreters:Language processors that include an execution component, i.e. theyperform the operations specified in the source text, rather than re-expressing them

in another language; e.g. Mat lab.

Dissemblers:language processors that attempt to take object code at a low leveland regenerate source code at a higher level.

Language Processor Examples:

GCC, Delphi, Visual StudioTeX/LaTeX

Postscript

HTML & Web browsers

XML

2. What is assembly language programming?

Explain with example.


4/24

Assembly language is the most basic programming language available for any

processor. With assembly language, a programmer works only with operations

implemented directly on the physical CPU. Assembly language lacks high-level

conveniences such as variables and functions, and it is not portable between

various families of processors. Nevertheless, assembly language is the mostpowerful computer programming language available, and it gives programmers the

insight required to write effective code in high-level languages. Learning assembly

language is well worth the time and effort of every serious programmer.

The Basics:

Before we can explore the process of writing computer programs, we have to go

back to the basics and learn exactly what a computer is and how it works. Every

computer, no matter how simple or complex has at its heart exactly two things: aCPU and some memory. Together, these two things are what make it possible for

your computer to run programs.

On the most basic level, a computer program is nothing more than a collection of

numbers stored in memory. Different numbers tell the CPU to do different things.

The CPU reads the numbers one at a time, decodes them, and does what the

numbers say. For example, if the CPU reads the number 64 as part of a program, it

will add 1 to the number stored in a special location called AX. If the CPU reads

the number 146, it will swap the number stored in AX with the number stored in

another location called BX. By combining many simple operations such these into

a program, a programmer can make the computer perform many incredible things.

As an example, here are the numbers of a simple computer program: 184, 0, 184,

142, 216, 198, 6, 158, 15, 36, 205, and 32. If you were to enter these numbers into

your computer's memory and run them under MS-DOS, you would see a dollar

sign placed in the lower right hand corner of your screen, since that is what these

numbers tell the computer to do.

Assembly Language:


5/24

Although the numbers of the above program make perfect sense to a computer,

they are about as clear as mud to a human. Who would have guessed that they put

a dollar sign on the screen? Clearly, entering numbers by hand is a lousy way to

write a program.

It doesn't have to be this way, though. Along time ago, someone came up with the

idea that computer programs could be written using words instead of numbers.

program called an assembler would then take the programmer's words and convert

them to numbers that the computer could understand. This new method, called

writing a program in assembly language, saved programmers thousands of hours,

since they no longer had to look up hard-to-remember numbers in the backs of

programming books, but could use simple words instead.

The program above, written in assembly language, looks like this:

MOV AX, 47104

MOV DS, AX

MOV [3998], 36

INT 32

When an assembler reads this sample program, it converts each line of code in

toone CPU-level instruction. This program uses two types of instructions, MOVand INT. On Intel processors, the MOV instruction moves data around, while the

INT instruction transfers processor control to the device drivers or operating

system.

The program still isn't quite clear, but it is much easier to understand than it was

before. The first instruction, MOV AX, 47104, tells the computer to copy the

number 47104 into the location AX. The next instruction, MOV DS, AX, tells the

computer to copy the number in AX into the location DS. The next instruction,

MOV [3998], 36 tells the computer to put the number 36 into memory location3998. Finally, INT 32 exits the program by returning to the operating system.

Before we go on, I would like to explain just how this program works. Inside the

CPU are a number of locations, called registers, which can store a number. Some

registers, such as AX, are general purpose, and don't do anything special. Other

registers, such as DS, control the way the CPU works. DS just happens to be a


6/24

segment register, and is used to pick which area of memory the CPU can write to.

In our program, we put the number 47104 into DS, which tells the CPU to access

the memory on the video card. The next thing our program does is to put the

number 36 into location 3998 of the video card's memory. Since 36 is the code for

the dollar sign, and 3998 is the memory location of the bottom right hand corner ofthe screen, a dollar sign shows up on the screen a few microseconds later. Finally,

our program tells the CPU to perform what is called an interrupt. An interrupt is

used to stop one program and execute another in its place. In our case, we want

interrupt 32, which ends our program and goes back to MS-DOS, or whatever

other program was used to start our program.

3. What is Macro? Define stepwise.

A macro instruction (abbreviated to macro) is simply a notational convenience for

the programmer. A macro represents a commonly used group of statements in the

source programming language.

Replace each macro instruction with the corresponding group of

source language statements.A macro processor is not directly related to thearchitecture of the computer on which it is to run Macro processors can also be

used with high-level programming languages, OS command languages, etc.He

twill ingredients of macro processing are the s: rmbol table aril the input text. Thisprocessor has a very small initial Sybil table (mostly consisting of processor option

swig etches) so the input text contains the information to build the Sybil table. The

facilities are of four skirls:

(1) Substitution of text,

(2) Manipulation of the Sybil table.

(3) control of the substitution,

(4) Others (e.g. comments, .processor options).

Basic Macro Processor Functions:

Expanded program


7/24

One-Pass Macro Processor:

Prerequisite:

Every macro must be defined before it is called.

Sub-procedures:

Macro definition: DEFINE.

Macro invocation: EXPAND

MACRO NAMTAB

DEFTAB

A program with Macro

definitions and Macro

invocations. Macro

Processor

A program without

Macro definitions

Assembler

Object

program

PROCESSLINE

DEFINE

EXPAND


8/24

CALLARGTAB

Keyword Macro Parameters:

Positional parameters

Parameters and arguments were associated with each other according

to their positions in the macro prototype and the macro invocation

statement

Consecutive commas is necessary for a null argument

GENER, DIRECT,,,,,,3

4. What is Macro concept? Give example.

Macro processors have been developed for some high-level programminglanguages. These special-purpose macro processors are similar in general function

and approach; however, the details differ from language to language.

Macros automate application tasks. For example, Corel WordPerfect macros

automate tasks such as setting margins, selecting a font, or creating a merge file.

Macros tasks consist of instructions calledstatements. There are several kinds of

statements: assignments, conditions, loops, comments, and commands. For

example,

Margin Left (1.0")

Margin Right (1.0")

Are Corel WordPerfect commands that set one inch left and right margins (the

task). Each command represents one instruction or statement. The simplest macro

consists of only one statement. Complex macros have hundreds of statements. The

sequence of statements determines how a macro performs its tasks.


9/24

Syntax:

Syntax refers to rules that govern the form of macro statements and expressions.

For example, the following statement types John Doe:

Type (Text: "John Doe")

The next example lacks a closing parenthesis.

Type (Text: "John Doe"

The syntax is incorrect and produces an error message.

Expressions:

Expressions represent values. They are used in several statements (assignments,conditions, loops, and commands) to form a statement that the computer can

understand. To create expressions, you use variables and constants. Variables

represent data that can change while a macro is playing (for example, vCount), and

constants represent data items that cannot change during macro play. You combine

variables and constants with operators (+, -, *, %, etc.) to create an expression. For

example, a valid expression would be count .

Assignment Statements:

Assignment statements assign the value of an expression to a variable. For

example,

x := "John Doe"

Result: x equals John Doe

y := 5

Result: y equals 5

z := 3 + 4

Result: z equals the result of 3 + 4

The assignment operator (:= or =) assigns the value of a right operand expression

to a left operand variable.


10/24

Conditional Statements:

Conditional statements play a statement or group of statements (statement block)

when a specified condition is met. Conditional statements are useful for displaying

a list of options. A statement block is played depending on which option the user

chooses. Conditional statements include Case, If, and Switch.

Loop Statements:

An expression is true or while an expression is true. The macro then exits the loop

and continues to the next statement. Loop statements play a statement or statement

block a specified number of times until statements include For, For Next, For

Each, Repeat, and While.

Comment Statements:

Comment statements contain notes and other information that do not affect macro

play. Use comment statements to explain the purpose of your macro, describe its

components, or to prevent a statement from playing. Comment statements help if

you have to modify a macro months after it is written or if someone else has to

understand your macro. A comment either begins with // and ends with a hardreturn [HRt], or it begins with /* and ends with */. See Perfect Script // and /* */

commands.

Command Statements:

Command statements consist of a name and can include one or more parameters.

Commands represent instructions to the parent application. There are three types of

macro commands: product commands, OLE Object commands, and programming

commands. Product commands are specific to a product; for example, Corel

WordPerfect or Corel Quattro Pro. OLE object commands perform tasks on an

OLE object. Programming commands work across applications; they are Perfect

Script commands. Command names often describe an action, such as Font, Margin

Left, Advance, and Foot note Options in Corel WordPerfect; or Align Objects Left,

Bitmap Blur, Select All Objects, and Tool bar Copy in Corel Presentations; or

Range in Microsoft Excel. Command names are not case sensitive and usually do
http://jdan.com/perfectscript/macros/ch11_aa.htm#_VPID_11_78http://jdan.com/perfectscript/macros/ch11_aa.htm#_VPID_11_79http://jdan.com/perfectscript/macros/ch11_aa.htm#_VPID_11_79http://jdan.com/perfectscript/macros/ch11_aa.htm#_VPID_11_78


11/24

not contain spaces. Exceptions include programming commands that call a

subroutine, such as Case Call or On Cancel Call. A macro can use more than one

application product and OLE object. Commands to the non-default application or

OLE Object require a prefix, which is specified in an Application or Object

statement. In this example,

A1.AboutDlg ()

A1 (followed by a period) is the prefix. It tells the compiler to use the application orObject assigned A1 in a Perfect Script Application or Object statement.

Subroutines:

Subroutines consist of a statement or group of statements (statement block) that are

played when the macro calls a subroutine. For example,

Call (Sub Example)

...(other statements)...

Label (Sub Example)

...statement block...

Return

The calling statement Call (Sub Example) calls (directs macro play to) the

subroutine Label (Sub Example). Return directs macro play to the statement that

follows Call (Sub Example).

Subroutines include functions, procedures, and labels. Subroutines are useful

because the statements in a subroutine are accessible to any part of a macro, and

can be called any number of times during play.

Compilers:

A macro compiler is used to compile or "translate" macros so that Corel

WordPerfect Suite applications can play them. Macros in Corel WordPerfect are

compiled when you record, play, or save them, or when you click Save & Compileor Options Close Macro on the Macro Edit feature bar.

5. What is relocated concept?


12/24

Relocation is an important concept. To understand this concept we shall begin

with linear map (one-dimensional view) of main memory. If we know an address

we can fetch its contents. So, a process residing in the main memory, we set the

program counter to an absolute address of its first instruction and can initiate its

run. Also, if we know the locations of data then we can fetch those too. All of this

stipulates that we know the

Figure : The relocation concept

absolute addresses for a program, its data and process context etc. This means that

we can load a process with only absolute addresses for instructions and data, only

when those specific addresses are free in main memory. This would mean we lose

flexibility with regard to loading a process. For instance, we cannot load a process,if some other process is currently occupying that area which is needed by this

process. This may happen even though we may have enough space in the memory.

To avoid such a catastrophe, processes are generated to be reloadable. In Figure

4.1 we see a process resident in main memory. Initially, all the addresses in the

process are relative to the start address. With this flexibility we can allocate any

area in the memory to load this process. Its instruction, data process context

(process control block) and any other data structure required by the process can be

accessed easily if the addresses are relative. This is most helpful when processes

move in and out of main memory. Suppose a process created a hole on moving

out. In case we use non-relocatable addresses, we have the following very severe

problem. When the process moves back in, that particular hole (or area) may not be

available any longer. In case we can relocate, moving a process back in creates no

problem. This is so because the process can be relocated in some other free area.

We shall next examine the linking and loading of programs to understand the

process of relocation better.


13/24

EXAMPLE:

There are 5 relocation table entries. The relocation table contains the offsets 0001,

0007,0000F, 001F, 0023.There is one external-table entry. It contains the name-

offset pair {submit, 0000}.

There are no import-table entries.

Name Meaning

length 003316

rlength 5

rtable

0001

0007

000F

001F

0023

xlength 1

xtable summit 0000

ilength 0

itable

code 51 bytes of code

If the code is loaded into memory at location 100016, the operand references forcount, loop, done, array, and sum will still point to locations near zero. Consider

the case of count, which has been relocated to 102816 and so the reference at

location 000116, now at location 100116, should be relocated to contain the value

102816 instead of 002816.

The following algorithm can be applied:

// base = relocation target

for (int i = 0; i < r length; i++) {

word = mem.get(r table[i]+base);


14/24

word += base;

mem.put(r table[i]+base, word);

}

6. What is linking concept? Explain with example.

The Linking System links separately compiled or assembled subprograms into a

whole program before loading, at loading, or during execution. It can tailor a

program for a specific application. It is for use with Universal Compiling System

(UCS) compilers. It executes on OS 2200 systems.

Purpose:

The Linking System Programming Reference Manual introduces the Linking

System for users unfamiliar with the Linking System and gives basic static and

dynamic linking run streams. This reference manual supplies information on more

advanced topics and assumes you are familiar with that guide. For example, it

discusses individual static linking commands. It is written in a reference format to

facilitate location of information.

Scope:

This reference manual covers the following major topics:

Banking in extended mode

Resolving references, including how files are searched for definitions

Cross-referencing object modules

Static linking

Using fixed-gate shared subsystems

Creating a process from a program written in a high-level language like C++ is

done in several stages, and numerous actors are involved in this creation. Consider

a program P that is written in C++ in several modules M1, Mn (several *.cpp files),and that uses some "build-in" library functions for I/O, string manipulation, etc.

1. Compiler- Separately compiles each one of the program's modules. Denote

the object module resulting in compiling M1 by O1.

2. Linker- Combines several object modules into one, coherent module. Thismodule may be eitherexecutable object, orlibrary of functions (see below).


15/24

3. Loader - Brings an executable object into the memory and relocates it.

Relocation is an object modification so that it can be loaded at addressdifferent than 0.

Here we describe several linking and loading paradigms, and discuss advantages

and disadvantages of each one of them. This classification will provide us an

ability to analyse our applications and to choose the appropriate linking/loading

strategies for them.

Why Linking Is Needed:

Linking is the process of converting a program from the form produced by a

compiler or assembler into a form that the computer hardware can execute. The

two biggest tasks of linking are to Replace symbolic external references (calls) with the entry point addresses

(Definitions) those references represent. This usually involves combining two or

More separately compiled or assembled object modules (routines) into a new

object

Module or into a whole executing program.

Adjust addresses affected by address relocation.

Linking Functions:

First, let understand what linking means and why it is necessary. Software is madeup of instructions grouped in logical sections called subroutines or functions. Most

functions perform a specific task based on a set of input and output variables.

These individual functions are able to use or call each other using a process called

linking. Calling one function from another function is based on knowing the

address or location of each function. Once this address is known, the calling

function executes or passes control to the called function. When the called function

completes, control is returned to the calling function. Linking is simply the process

of placing the address of a called function into the calling function's code. This is a

fundamental software concept. Now consider a functionFcontains a call to afunctionH, and suppose that these two functions were defined in the same module

(informally, the same *.cpp file). In this case, the linking between the call toHin

F, and the address ofHcan be done by compiler, since both functions are given toit at the same compilation session. Well, this is nice and simple, but it is not always

the case when the modularity is a part of our programming life. Suppose that the

functionsFandHare defined in two different modulesM(F) andM(H). In this


16/24

case, the compiler can not resolve the problem of linking between the call toHin

F, and the address ofH. Note that the this situation is always the case if thefunctionHwas not written by us, but, for example, is a part of a library of

functions that was created for general use. For example, in our C code, we are

using the function socket (...) which is definitely was not written by us.

In this case, some linking should be done afterthe separate compiling of the

modules by a linker. In general, there are three types of linkers:

Static Linker(orlinkage editor) - linking prior to load time.

Implicit Dynamic Linker(orlinking loader) - linking at load time.

Explicit Dynamic Linker- linking is performed at execution time.

Static Linking:

The simplest form of linking is called static linking. Static linking is used tocombine multiple functions into a single object module. These functions may be a

part of your compiled program modules, and/or a part of various archive libraries

that it uses. The result of static linking may be either an executable object, or anarchive library. The notion of executable object is pretty intuitive -- an executable

object contains specification of a process (or, informally, you can "run" it). The

notion of archive library is novel and well-known for you at the same time -- until

now, you never created one, but you used them many times. For example, if you

are giving -socket as a parameter to your linking command (see your Make file forthe Connector component in the third assignment), then you explicitly specify to

your linking to look for the unresolved references in the lib socket.a archive

library.

As we said, the linker is given your compiled code, containing many unresolved

references to library routines. It also gets archive libraries (for example

/usr/lib/limbs) containing each library routine as a separate module. The linker

keeps working until there are no more unresolved references and writes out a

single file that combines your code and a jumbled mixture of modules containing

parts of several libraries. The library routines make system calls directly, so a

statically linked application is built to work with the kernel's system call interface.

This static linking process takes place once - when the executable module is

created. All internal references to functions within a module are resolved at this

time. In some cases, an entire application is built out of a single statically linked

executable module. In this case, the resulting module is an autonomous unit that


17/24

can execute without referencing any other modules.

Now, let present the advantages and disadvantages of the static linking:

Advantages

o One linking for many executions.

o Calls into the library routines have a little less overhead since they are

linked together directly.

o Start-up time at program loading is reduced as there is no need to

locate and load the dynamic libraries.

o Possibility to create archive libraries is unique for static linking.

Disadvantages

o Physical memory wasted by duplicating the same library code in

every static linked process can be significant. For example, if all the

window system tools were statically linked, several tens of megabytes

of physical memory would be wasted for a typical user, and the userwould be slowed down by a lot of paging.

o Subsequent versions of the operating system contain better-tuned and

debugged library routines, or routines that enable new functionality.

Static linking locks in the old slow or buggy routines and prevents

access to the new functionality.

o A static-linked program contains a subset of the jumbled library

routines. The library cannot be tuned as a whole to put routines that

call each other onto the same memory page. The whole application

could be tuned this way, but very few developers take the trouble.

o During program development, recompiling for nearly every execution.

As far as we are talking about developing an assignment for our

course, this may be not so important parameter. However, if

compiling of a product that has been developed is taking the whole

night, then it the picture is completely different.

o Since the size of the executable object may be relatively large, the

storage waste is significant, especially in case of infrequently used

program.

Dynamic Linking:


18/24

A second way to link functions together is through a process called dynamic

linking. With dynamic linking, executable modules created by static linking cancontain references to functions in other modules. All modules that reference each

other must be linked together dynamically when they are executed. Thus the term

dynamic linking.

The central property of the dynamic linking is that even if many processes are using

a particular, dynamically linked function, only a SINGLE copy of this function

appears in the memory, and it is shared by all these processes.

The dynamic linking process consists of two steps. First, the module that contains

the external function must be located. Second, the address of the function within

this module must be found. Once this address is found, the calling module can use

this external function just as if it was linked statically.

Dynamically imported functions are functions that are called from within onemodule but actually reside in another module. In order to import a function, the

developer must provide the name of the module and the function name. These two

items should uniquely identify the imported function.

Dynamic linking occurs when this information is used to find the imported

function's address. If the specified module is found, its headers are examined for

the desired function name. If the specified function is also found, its address is

dynamically placed in the calling module's code

There are two dynamic linking methods:

Implicit Dynamic Linking

Explicit Dynamic Linking

Implicit Dynamic Linking:

With implicit dynamic linking, the process of identifying imported functions is

handled automatically by operating system at runtime. When using implicit

dynamic linking, the importing module contains header fields for each implicitly

imported function. These header fields are generated by a static linker, and eachone of them contain the exporting module and imported function name. The static

linker also adds to the executable object a start-up code to load the required

libraries to the memory at runtime (if they are still not there!), and each library call

goes through a jump table. The first time a routine is actually called, the jump table

is patched to point at the library routine. For subsequent calls, the only overhead is

the indirect reference.


19/24

Note that the operating system must terminate an application that references an

implicitly linked module or function that can not be found.

The central property of the implicit dynamic linking is that ALL the functions

imported by a process should be loaded into memory before the beginning of its

execution.

Under UNIX or LINUX, use ldd to generate a list ofshared libraries an executableobject depends on. Likewise, under UNIX or LINUX, shared object libraries have

a .so suffix and a version number (*.DLL files in Windows). For example, consider

the UNIX standard program grep:

% ldd /bin/grep

libintl.so.1 => /usr/lib/libintl.so.1

libc.so.1 => /usr/lib/libc.so.1libw.so.1 => /usr/lib/libw.so.1

libdl.so.1 => /usr/lib/libdl.so.1

These libraries include the main system interface library libc.so, the dynamic

linking library libdl.so, wide character support (libw.so), and internationalization

support (libintl.so). Note that on your version of OS the result of ldd /bin/grep may

be different.

Actually, this raises another good reason to use dynamic linking. Statically linked

programs may not be able to take advantage of some internationalization,

networking, and other features that may vary across configurations and

environments.

Explicit Dynamic Linking:

With explicit dynamic linking, the process of linking to imported functions is

handled by the application, not by the operating system. The operating system

provides services that an application can use to explicitly load a module into

memory. Once loaded, another service of the operating system can be used to

extract an imported function's address using its name. If both of these stages are

successful, the application can call the imported function.

The explicit dynamic linking functions return an error if either an exporting

module or an imported function is not found. Thus the application can handle

either of these conditions without terminating. Most large-scale applications

employ both implicit and explicit dynamic linking. The choice of technique

depends on the developer's requirements. From the application user's perspective,

once modules are properly dynamically linked, there is no difference in the two


20/24

techniques.

While explicit dynamic linking is more complicated to implement from the

developer's perspective, it does offer several advantages over implicit dynamic

linking (see below).

Example of Dynamic Linking:

Linking loader v.s. linkage editor:


21/24

Linking loader:

Linkage editor:


22/24

Difference between a linkage editor and loader:


23/24

Linking loader

Performs all linkingand relocation operations, including automatic

library search, and loads the linked program into memory for execution.

Linkage editor

Produces a linked version of the program, which is normally written to afile or library for later execution. A simple relocating loader(one pass) can be used

to Load the program into memory for execution. The linkage editor performs

relocation of all control sections relative to the start of the linked program. The

only object code modification necessary is the addition of an actual load address to

relative values within the program.

Dr. B.S.Patel (H.O.D) Dr. D. Mitra

(Principal)


24/24

NOTE:

Submission can be hand written or soft copy.

Do mention the references.

Documents

System Programming Assignment 1