Linkers Loaders Compilers Assemblers

What is Linkers and Loaders? Explain static and dynamic scope for linking. Also differentiate
between compiler and assembler. [Marks: 16]

Linkers and Loaders

Linkers:

Definition: A linker is a program that combines one or more object files generated by a compiler
into a single executable file.
Functions:
Resolves external symbols (functions or variables used in one file but defined in another).
Combines code and data segments of different modules.
Assigns addresses to various modules to prepare an executable.

Loaders:

Definition: A loader is a system program responsible for loading an executable file into memory
and preparing it for execution.
Functions:
Allocates memory space.
Maps executable code to physical memory.
Adjusts addresses and links dynamically during program loading (relocation).

Static and Dynamic Linking

Static Linking:

Definition: Links libraries and object files during compilation time.

Features:
All required code is combined into a single executable file.
No dependency on external files during execution.
Larger executable size due to inclusion of all library functions.
Faster execution since linking is done beforehand.

Dynamic Linking:

Definition: Links libraries during program execution or runtime.

Features:
Only references to shared libraries are included in the executable.
Libraries are loaded into memory only when needed.
Smaller executable size.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 1/17
 Offers flexibility and easier updates to libraries without recompiling programs.

Difference Between Compiler and Assembler

Aspect Compiler Assembler

Converts high-level language (HLL) into machine Converts assembly language into machine
Definition
code. code.

Source code in a high-level programming

Input Source code in assembly language.
language.
Produces intermediate object files or executable
Output Produces machine code directly.
code.
Languages Works with languages like C, C++, Java, etc. Works with low-level assembly language.

Complexity Handles complex syntax and semantic analysis. Handles simpler, lower-level code.

For software development using high-level For system-level programming and

Use
languages. optimization.

Conclusion: Linkers and loaders play critical roles in making a program executable, while understanding
static and dynamic linking provides insight into memory management. Differentiating between
compilers and assemblers highlights the workflow of transforming code from high-level to machine-
level.

What do you mean by System Software Tools? Explain the variety of software tools in detail. [Marks:
16]

System Software Tools

Definition:
System software tools are specialized programs that assist in managing, monitoring, and controlling
computer hardware and software. These tools provide essential services and functionalities to ensure
efficient system performance, security, and usability.

Types of System Software Tools

1. Operating Systems (OS):

Manages hardware resources and provides services for application software.
Examples: Windows, Linux, macOS.
Functions:
Process management
Memory management
File system handling
Device management
User interface (CLI/GUI).
2. Utility Software:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 2/17
 Provides maintenance and optimization services for system performance.
Examples: Disk cleanup tools, antivirus programs, backup software.
Categories:
File Management Tools: File compression (WinRAR), file recovery (Recuva).
Disk Management Tools: Disk defragmentation, disk partitioning.
Security Tools: Firewalls, anti-malware programs.
3. Language Translators:
Converts code written in high-level or assembly language to machine code.
Types:
Compiler: Converts HLL to machine code (C Compiler).
Interpreter: Executes HLL line-by-line (Python Interpreter).
Assembler: Converts assembly code to machine code.
4. Linkers and Loaders:
Linkers: Combines object files into an executable file by resolving external references.
Loaders: Loads executable files into memory for execution.
Importance: Supports modular programming and efficient memory utilization.
5. Device Drivers:
Software that allows the OS to communicate with hardware devices.
Examples: Printer drivers, graphics card drivers.
Functions:
Acts as a bridge between the OS and hardware.
Ensures compatibility between hardware and software.
6. Performance Monitoring Tools:
Monitors system resource usage, performance, and health.
Examples: Task Manager (Windows), Activity Monitor (macOS).
Functions:
Tracks CPU, memory, and disk usage.
Identifies resource-intensive processes.
7. Backup and Recovery Tools:
Protect data by creating backups and providing recovery options.
Examples: Acronis True Image, Windows Backup.
Functions:
Ensures data safety.
Restores data in case of accidental deletion or system failure.
8. Network Management Tools:
Manage and monitor network performance and connectivity.
Examples: Wireshark, NetStat.
Functions:
Analyzes network traffic.
Troubleshoots network issues.
9. Virtualization Tools:
Allows multiple OSs to run on the same hardware through virtualization.
Examples: VMware, VirtualBox.
Functions:
Creates virtual environments.
Supports resource allocation and isolation.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 3/17
Conclusion

System software tools are essential for maintaining the efficiency, reliability, and security of computer
systems. Their diverse functionalities cater to hardware-software communication, system optimization,
and resource management, ensuring smooth operations across various computing environments.

(a) Absolute loader and general loader schemes.

(b) Direct linkage loader and subroutine linkage.

(a) Absolute Loader and General Loader Schemes

Absolute Loader:

Definition: A simple type of loader that directly places object code into specific memory locations
as defined in the program.
Features:
Requires the programmer to specify absolute memory addresses.
No program relocation or address modification is done.
Advantages:
Simple and fast because no address adjustments are required.
Disadvantages:
Programs cannot be moved to different memory locations.
Inflexible for dynamic environments.
Example: Early systems with fixed memory locations.

General Loader Schemes:

Definition: Advanced loaders that perform relocation, linking, and loading tasks to provide
flexibility and modularity.
Types:
1. Relocating Loader: Modifies addresses in the object code to adjust for memory location
changes.
2. Direct Linkage Loader: Links multiple program modules during loading by resolving external
references.
3. Dynamic Linking Loader: Links libraries or modules during execution rather than at load
time.
Advantages:
Supports relocation and modular programming.
Enables dynamic memory allocation and sharing of libraries.

(b) Direct Linkage Loader and Subroutine Linkage

Direct Linkage Loader:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 4/17
 Definition: A loader that resolves external references by linking subprograms or libraries directly
during loading.
Features:
Combines multiple modules into a single executable by resolving symbolic references to
addresses.
Suitable for modular programming.
Advantages:
Efficient for large systems with multiple modules.
Reduces redundancy by reusing external libraries.
Disadvantages:
Increased complexity due to dependency resolution.

Subroutine Linkage:

Definition: A mechanism for linking subroutines (small code blocks) dynamically during program
execution.
Features:
Allows modular code execution, where subroutines are loaded and linked as needed.
Involves saving and restoring the execution context (registers, program counter).
Advantages:
Improves memory efficiency by loading subroutines only when required.
Supports code reuse and better maintainability.
Disadvantages:
Adds overhead due to runtime context switching and linking.

Comparison

Aspect Direct Linkage Loader Subroutine Linkage

Purpose Resolves external references during loading. Links subprograms during execution.
Execution Time Performed before execution starts. Happens dynamically during runtime.
Memory Usage Entire program is loaded at once. Subroutines are loaded as needed.
Efficiency Faster execution as linking is pre-done. Memory-efficient but incurs runtime cost.

Conclusion

Both loaders and linkage mechanisms provide flexibility in handling code modularity, memory
management, and execution efficiency. Absolute loaders offer simplicity but lack flexibility, while general
loaders and subroutine linkage enable efficient program execution in modern systems.

What are the problems faced by a one-pass assembler? Draw and explain the detailed flowchart for
pass-2 of a two-pass assembler.

Problems Faced by a One-Pass Assembler

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 5/17
A one-pass assembler processes the source code in a single pass, which can lead to the following
problems:

1. Forward References:
Symbols (e.g., labels or variables) are often used before they are defined.
The assembler cannot resolve such references in one pass.
2. Lack of Modular Code:
Does not allow reusability of independent code modules.
All code must be in a specific order.
3. Inefficient Memory Utilization:
Relocation and address resolution are harder to manage, leading to inefficient memory
allocation.
4. No Optimizations:
Cannot optimize or rearrange code for better memory or performance management.
5. Error Detection:
Limited error reporting due to the inability to analyze the entire source code in advance.

Pass-2 of a Two-Pass Assembler

Purpose:

The second pass resolves forward references and generates the final machine code using
information gathered in the first pass (symbol table, opcode table, and intermediate code).

Flowchart for Pass-2 of a Two-Pass Assembler

Steps in Pass-2:

1. Start Pass-2:
Initialize data structures and load tables (symbol table, opcode table).
2. Read Intermediate Code:
Read the intermediate code generated in Pass-1 line by line.
3. Translate Instructions:
Identify instruction type (e.g., mnemonic, directive).
Replace symbolic operands with actual memory addresses using the symbol table.
4. Generate Object Code:
Convert instructions into machine code or object code using the opcode table.
5. Handle Literals:
Replace literals with actual memory addresses (from the literal table).
6. Error Checking:
Check for undefined symbols or invalid instructions.
Report errors with appropriate messages.
7. Write Object Code:
Write the final object code to the output file.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 6/17
 8. End of Pass-2:
Ensure all references are resolved and finalize the output.

Flowchart Diagram:

plaintext

+--------------------+
| Start Pass-2 |
+--------------------+
|
v
+--------------------+
| Load Symbol Table |
| and Opcode Table |
+--------------------+
|
v
+--------------------+
| Read Intermediate |
| Code Line by Line |
+--------------------+
|
v
+-----------------------------+
| Is it a Mnemonic/Directive?|
+-----------------------------+
| |
v v
+----------------+ +----------------+
| Translate and | | Replace Symbols|
| Generate Code | | Using Symbol |
+----------------+ | Table/Literal |
| +----------------+
v |
+--------------------+ v
| Write to Object | <------+
| Code File |
+--------------------+
|
v
+--------------------+
| Check for Errors |
+--------------------+
|
v
+--------------------+
| End of Pass-2 |
+--------------------+

Explanation of Flowchart:

1. Input Loading:
Loads all necessary data structures from Pass-1.
Prepares the assembler to process the intermediate code.
2. Instruction Translation:
Each instruction in the intermediate code is translated into machine code.
Forward references are resolved using the symbol table.
3. Error Handling:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 7/17
 Detects and reports errors such as missing labels or invalid opcodes.
4. Output Generation:
Writes the object code to an output file.
5. Finalization:
Ends Pass-2 after processing all lines of the intermediate code.

Conclusion

A one-pass assembler faces challenges in handling forward references and complex code, while a two-
pass assembler overcomes these by separating symbol resolution (Pass-1) and code generation (Pass-2).
The flowchart of Pass-2 illustrates how it resolves symbols, translates instructions, and generates
machine code efficiently.

What is loader? Discuss different loading schemes. Explain reallocating loader scheme with its
advantages and disadvantages.

Loader

Definition:

A loader is a system software component responsible for loading executable files into main memory and
preparing them for execution. It allocates memory, resolves addresses, and initiates the execution of the
program.

Different Loading Schemes

1. Absolute Loading:
The object code is loaded at specific memory addresses as specified in the source code.
Features:
Simple and fast.
No address relocation is performed.
Limitations:
Fixed memory location; no flexibility for relocation.
2. Relocatable Loading:
The program is loaded at a memory location determined at runtime, with addresses modified
accordingly.
Features:
Supports program relocation.
More flexible compared to absolute loading.
3. Dynamic Loading:
Parts of the program are loaded into memory only when they are required during execution.
Features:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 8/17
 Saves memory by loading only the required portions.
Commonly used in operating systems for efficient memory usage.
4. Dynamic Linking:
External modules or libraries are linked at runtime instead of load time.
Features:
Reduces executable size by linking shared libraries dynamically.
Enables easy updates to libraries without recompiling the program.

Relocating Loader Scheme

Definition:

A relocating loader modifies the addresses in a program's object code to suit the memory area where
the program will be loaded. This allows the program to be loaded at any memory location, avoiding the
need for absolute memory addresses.

Working:

1. Input: The loader takes the object program and a relocation table (containing address adjustment
information).
2. Address Modification:
Adds a relocation factor to the relative addresses in the program.
Adjusts all memory references in instructions accordingly.
3. Loading: Places the relocated object code into the assigned memory locations.
4. Execution: Transfers control to the program’s starting address after successful relocation.

Advantages of Relocating Loader:

1. Flexibility:
Programs can be loaded at any available memory location.
2. Efficient Memory Usage:
Utilizes memory better by avoiding fixed memory allocation.
3. Supports Multiprogramming:
Enables multiple programs to coexist in memory, reducing memory wastage.
4. Dynamic Relocation:
Allows programs to run without recompilation, even if loaded at different addresses.

Disadvantages of Relocating Loader:

1. Complexity:
Requires a relocation table and additional computations, increasing loader complexity.
2. Execution Time Overhead:
Address modification during loading adds overhead.
3. Dependency:
Relies on the relocation information provided by the assembler.

Conclusion
Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 9/17
Loaders are essential components for preparing programs for execution. Different loading schemes
cater to specific needs, such as absolute simplicity, relocatable flexibility, or dynamic memory
optimization. Among these, the relocating loader stands out due to its flexibility and efficient memory
usage, making it suitable for modern, multiprogramming environments. However, its complexity and
runtime overhead are trade-offs that must be considered.

What are the basic fuctions of loaders? Differentiate absolute, relative and linking loader.

Basic Functions of Loaders

1. Loading:
Transfers the executable program into the main memory for execution.
2. Relocation:
Adjusts memory addresses in the object code to match the program's allocated memory
location.
3. Linking:
Resolves external references (symbols or addresses) between different program modules.
4. Allocation:
Allocates required memory space for the program and its data structures.
5. Error Handling:
Detects and reports errors such as unresolved symbols or invalid memory locations.

Comparison of Absolute, Relative, and Linking Loaders

Aspect Absolute Loader Relative Loader Linking Loader

Loads programs with

Loads programs with relative Links external references
absolute memory
Definition addresses and relocates them and resolves symbols
addresses specified in the
based on allocated memory. during loading.
object code.

Performs relocation by adding Performs relocation and

Relocation No relocation is performed. a relocation factor to relative linking for inter-module
addresses. dependencies.

Supports modular
Fixed memory location; no Allows loading at different
Flexibility programming with
relocation possible. memory locations.
interdependent modules.
Moderate complexity due to Complex due to linking and
Complexity Simple to implement.
address adjustments. symbol resolution.
Requires symbol and
Requires absolute memory Requires a relocation table in
Dependencies relocation tables for
locations at compile-time. the object code.
linking.

Higher overhead for

Execution Minimal overhead for
No execution overhead. resolving symbols and
Overhead relocation during loading.
addresses.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 10/17
 Aspect Absolute Loader Relative Loader Linking Loader

Large, modular programs

Examples Early computer systems. Modern relocatable programs.
using shared libraries.

Conclusion

Loaders are essential for preparing programs for execution by performing tasks like loading, relocation,
and linking. Absolute loaders are simple but inflexible, relative loaders add flexibility with relocation,
and linking loaders provide comprehensive linking and relocation for modular and dynamic programs.

Discuss the basic tasks a macro instrution processor performs. Explain how the nested macro calls
are executed with example.

Tasks Performed by a Macro Instruction Processor

A macro instruction processor is responsible for expanding macros during the assembly process. The
basic tasks include:

1. Macro Definition Handling:

Recognizes and stores macro definitions from the source code.
Adds the macro name, parameters, and body to the macro definition table (MDT) and
macro name table (MNT).
2. Macro Invocation/Expansion:
Identifies macro calls in the source code and expands them into their corresponding
instructions.
Replaces formal parameters with actual arguments provided in the macro call.
3. Parameter Substitution:
Substitutes formal parameters in the macro definition with the actual parameters during
macro expansion.
4. Nested Macro Support:
Handles macros within other macros (nested calls), ensuring correct substitution and
expansion.
5. Error Detection:
Detects errors like undefined macros, incorrect parameter counts, or invalid syntax in macro
calls.
6. Code Assembly:
Produces the final expanded source code, which can be passed to the assembler for further
processing.

Nested Macro Calls

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 11/17
Nested macros occur when one macro invokes another macro. The macro processor must handle such
scenarios by managing expansions in a last-in-first-out (LIFO) manner using a macro expansion stack
(MES).

Steps for Execution:

1. Macro Invocation:
When a macro call is encountered, its parameters and body are substituted and expanded.
2. Nested Call Detection:
If the macro body contains a call to another macro, the processor pauses the current macro
expansion and processes the nested call.
3. Stack Management:
The macro processor uses a stack to keep track of active macro expansions.
The nested macro is expanded first, and control returns to the outer macro once the nested
macro is completely processed.
4. Final Expansion:
After all nested calls are resolved, the outer macro expansion completes.

Example: Nested Macro Calls

Macro Definitions:

assembly

MACRO MACRO1 &ARG1, &ARG2

LOAD &ARG1
MACRO2 &ARG2
STORE &ARG1
MEND

MACRO MACRO2 &ARG3

ADD &ARG3
MEND

Source Code:

assembly

START
MACRO1 A, B
END

Execution Process:

1. Outer Macro Call (`MACRO1`):

The processor encounters `MACRO1 A, B` and begins expansion:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 12/17
 assembly

LOAD A
MACRO2 B
STORE A

2. Nested Macro Call (`MACRO2`):

While expanding `MACRO1`, the nested call `MACRO2 B` is detected.
The processor pauses the expansion of `MACRO1` and expands `MACRO2`:

assembly

ADD B

3. Final Expansion:
After expanding `MACRO2`, control returns to `MACRO1` to complete its expansion:

assembly

LOAD A
ADD B
STORE A

Final Output:

assembly

START
LOAD A
ADD B
STORE A
END

Key Points in Handling Nested Macros

Stack Usage: Tracks the nested calls for proper sequencing.

Parameter Substitution: Ensures correct replacement of parameters for each macro.
Error Handling: Detects recursion loops or undefined nested macros.

Conclusion

A macro instruction processor efficiently handles macro definition, invocation, parameter substitution,
and nested calls. By managing expansions in a structured manner, it simplifies the code-writing process
and reduces repetition while ensuring the correct execution of nested macros.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 13/17
 What are the basic functions of loaders? Differentiate absolute, relative and linking loader.

Basic Functions of Loaders

1. Loading:
Transfers the program's object code into main memory for execution.
2. Relocation:
Adjusts the addresses in the object code to match the actual memory location assigned to the
program.
3. Linking:
Resolves references between different program modules or external symbols.
4. Allocation:
Allocates memory space for the program and its data.
5. Error Handling:
Detects and reports issues like undefined symbols or invalid addresses.

Comparison: Absolute Loader, Relative Loader, and Linking Loader

Aspect Absolute Loader Relative Loader Linking Loader

Loads programs at any

Loads programs at fixed, Links and resolves external
Definition memory location, adjusting
predefined addresses. references during loading.
addresses.
No relocation is Relocation is done using Performs relocation and
Relocation
performed. relocation information. linking simultaneously.
Inflexible; requires fixed Flexible; supports relocation to Highly flexible; supports
Flexibility
memory locations. different memory areas. modular programming.
Requires relocation
Requires predefined Requires symbol and
Dependency information (e.g., relocation
memory addresses. relocation tables for linking.
table).
Moderately complex due to Complex due to linking and
Complexity Simple to implement.
relocation handling. symbol resolution.

Execution No overhead during Minimal overhead during Higher overhead due to

Overhead execution. loading. linking at load time.
Early systems with fixed Modern systems requiring Large, modular programs
Usage
memory assignments. relocatable programs. with shared libraries.

Early mainframes and Operating systems using

Examples General-purpose programs.
embedded systems. dynamic/shared libraries.

Conclusion

The absolute loader is simple but inflexible, suitable for fixed memory assignments. The relative
loader adds flexibility by enabling relocation, making it suitable for dynamic memory environments. The

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 14/17
linking loader is the most versatile, supporting modular programming and shared libraries, but it
comes with higher complexity and runtime overhead.

Discuss the basic task a macro instruction processor performs. Explain how the nested macro calls
are executed with example.

Basic Tasks Performed by a Macro Instruction Processor

A macro instruction processor automates the process of expanding macros during assembly. It
performs the following tasks:

1. Macro Definition Handling:

Recognizes and stores macro definitions in tables like the Macro Name Table (MNT) and
Macro Definition Table (MDT) for later use.
2. Macro Invocation and Expansion:
Identifies macro calls in the source code and replaces them with corresponding macro body
instructions.
3. Parameter Substitution:
Substitutes formal parameters in the macro body with actual arguments provided in the
macro call.
4. Nested Macro Handling:
Supports macros invoking other macros, resolving them in a last-in-first-out (LIFO) manner
using a stack.
5. Error Detection:
Checks for errors like undefined macros, incorrect parameter counts, or improper syntax.
6. Final Code Generation:
Produces fully expanded source code that is free from macros, ready for assembly.

Execution of Nested Macro Calls

Definition:

Nested macro calls occur when a macro invokes another macro during its expansion. The macro
processor must correctly handle these calls to ensure accurate parameter substitution and expansion.

Steps to Handle Nested Macros:

1. Macro Invocation:
The macro processor starts expanding the outer macro when a macro call is encountered.
2. Detection of Nested Call:

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 15/17
 If the body of the current macro contains another macro call, the processor pauses the
current expansion.
3. Stack Usage:
Uses a macro expansion stack (MES) to save the state of the current macro expansion and
processes the nested macro first.
4. Expansion of Nested Macro:
The nested macro is expanded, substituting its parameters with the actual arguments.
5. Return to Outer Macro:
After the nested macro is expanded, the processor resumes the expansion of the outer
macro.
6. Final Code Generation:
Produces fully expanded source code.

Example: Nested Macro Calls

Macro Definitions:

assembly

MACRO MACRO1 &ARG1, &ARG2

LOAD &ARG1
MACRO2 &ARG2
STORE &ARG1
MEND

MACRO MACRO2 &ARG3

ADD &ARG3
MEND

Source Code:

assembly

START
MACRO1 A, B
END

Execution Process:

1. Expand `MACRO1 A, B`:

Substitute `&ARG1 = A` and `&ARG2 = B`:

assembly

LOAD A
MACRO2 B
STORE A

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 16/17
 2. Detect Nested Macro (`MACRO2 B`):
Pause expansion of `MACRO1` and process `MACRO2`:

assembly

ADD B

3. Combine Results:
Replace `MACRO2 B` with its expansion and complete `MACRO1`:

assembly

LOAD A
ADD B
STORE A

Final Expanded Code:

assembly

START
LOAD A
ADD B
STORE A
END

Key Considerations:

1. Parameter Substitution:
Ensure the correct replacement of parameters for each macro.
2. Stack Management:
Handle multiple nested levels using a stack for proper sequencing.
3. Error Handling:
Detect and report recursion or undefined macros.

Conclusion

The macro instruction processor automates repetitive code expansion tasks and efficiently handles
nested macro calls using structured stack-based expansion. This ensures accurate and seamless
substitution, enhancing code readability and modularity.

Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 17/17