Introduction to System Software – SPCC Viva

Q1: What is system software, and what are its main goals?
A1: System software refers to a collection of programs that manage and support the
operations of a computer system. Its main goals include providing a platform for
running application software, managing hardware resources, and ensuring efficient
utilization of system resources.

Q2: Differentiate between system programs and system programming.

A2: System programs are software applications that perform specific tasks such as
managing files, controlling peripherals, and handling system resources. System
programming, on the other hand, involves the creation and development of these
system programs.

Q3: Enumerate various system programs and briefly explain their functions.
A3: Various system programs include Assembler (converts assembly language code into
machine language), Macro processor (expands macros in source code), Loader (loads
executable code into memory for execution), Linker (combines multiple object files into
a single executable program), Compiler (translates high-level programming languages
into machine code), Interpreter (executes code line by line), Device Drivers (control
hardware devices), Operating system (manages hardware and provides services to
applications), Editors (create and modify text files), Debuggers (identify and fix errors in
programs).

Q4: Describe the role of an Assembler in the context of system software.

A4: An Assembler is a system program that translates assembly language code into
machine language, which is directly executable by the computer’s hardware. It converts
mnemonic instructions and symbolic addresses into their binary equivalents.

Q5: What is the function of a Loader in system software?

A5: A Loader is responsible for loading executable code from secondary storage into the
computer’s main memory for execution. It performs address resolution and relocation,
ensuring that the program can run correctly regardless of its memory location.

Q6: Explain the role of a Linker in the software development process.

A6: A Linker combines multiple object files generated by the compiler into a single
executable program. It resolves external references, ensuring that all necessary
functions and variables are properly linked together.

Q7: How does a Compiler differ from an Interpreter?

A7: A Compiler translates the entire source code of a program into machine code
before execution, generating an executable file. In contrast, an Interpreter translates
and executes the source code line by line without generating an intermediate
executable file.
Q8: Define Device Drivers and discuss their significance in system software.
A8: Device Drivers are specialized programs that enable the operating system to
communicate with hardware devices such as printers, disk drives, and network
adapters. They facilitate the abstraction of hardware complexity and provide a
standardized interface for interacting with devices.

Q9: What are the essential functions of an Operating System (OS)?

A9: An Operating System manages hardware resources, provides a user interface,
facilitates communication between hardware and software components, implements
security measures, and supports multitasking and multi-user functionality.

Q10: Briefly explain the role of Debuggers in system software development.

A10: Debuggers are tools used by developers to identify and resolve errors (bugs) in
software code. They allow programmers to inspect the state of a program during
execution, set breakpoints, and step through code to pinpoint and fix issues.

Assemblers

Q1: What are the essential elements of Assembly Language programming?

A1: Assembly Language programming comprises mnemonic instructions, symbolic
labels, operands, and comments. Mnemonic instructions represent machine
instructions, while symbolic labels are used to denote memory addresses or variables.
Operands specify data or addresses, and comments provide human-readable
explanations within the code.

Q2: Explain the assembly scheme used in Assembly Language programming.

A2: The assembly scheme involves translating mnemonic instructions and symbolic
labels into their corresponding machine language equivalents. This translation process
typically occurs in two phases: the first pass involves scanning the source code to
generate a symbol table, while the second pass generates the actual machine code.

Q3: Describe the pass structure of an assembler.

A3: The pass structure of an assembler refers to the number of times it processes the
source code. In a single-pass assembler, the code is scanned only once, generating
machine code directly. In a two-pass assembler, the code is scanned twice: once to
generate a symbol table, and again to generate the machine code.

Q4: Discuss the design of a Two-pass Assembler for the X86 processor.
A4: A Two-pass Assembler for the X86 processor first scans the source code to build a
symbol table, mapping symbolic labels to memory addresses. During the second pass,
it generates the actual machine code, replacing symbolic labels with their
corresponding memory addresses and encoding mnemonic instructions into binary
format.
Q5: Explain the design of a Single-pass Assembler for the X86 processor.
A5: A Single-pass Assembler for the X86 processor translates source code into machine
code in a single scan. To achieve this, it uses techniques such as forward referencing
and temporary storage to handle unresolved symbols and generate machine code on
the fly.

Q6: What are the common data structures used in the design of assemblers?
A6: Common data structures used in assemblers include symbol tables, which map
symbolic labels to memory addresses; opcode tables, which define the binary encoding
for mnemonic instructions; and data structures for handling expressions and addressing
modes.

Q7: How does a Two-pass Assembler differ from a Single-pass Assembler in

terms of efficiency and complexity?
A7: A Two-pass Assembler typically offers better error detection and optimization
capabilities compared to a Single-pass Assembler. However, it requires additional
memory for storing intermediate data structures and involves two passes over the
source code, making it less efficient in terms of processing time.

Q8: Discuss the advantages and disadvantages of using a Two-pass Assembler.

A8: The advantages of a Two-pass Assembler include better error detection, support for
forward referencing, and the ability to perform optimizations. However, it requires
more memory and processing time compared to a Single-pass Assembler, making it
less suitable for resource-constrained environments.

Q9: How does the design of an assembler vary for different processor
architectures?
A9: The design of an assembler depends on the instruction set architecture (ISA) of the
target processor. Different processors may have unique instruction formats, addressing
modes, and opcode tables, requiring specific handling in the assembler design.

Q10: Explain the role of data structures in optimizing the performance of an

assembler.
A10: Data structures such as symbol tables and opcode tables are crucial for efficient
symbol resolution and code generation in an assembler. By organizing and indexing
data effectively, assemblers can quickly look up symbols and opcode encodings,
reducing the overall processing time.

Macros and Macro Processor

Q1: What is the purpose of Macros and Macro Processor in programming?

A1: Macros provide a mechanism for defining reusable code fragments, which can be
expanded inline wherever they are called. The Macro Processor is responsible for
replacing macro calls with their corresponding definitions during the preprocessing
stage of compilation, effectively automating code expansion.

Q2: Explain the concept of Macro definition and Macro call.

A2: Macro definition involves defining a named block of code using the macro keyword,
along with a unique identifier. Macro calls are instances where the macro name is used
in the code, causing the Macro Processor to replace it with the corresponding macro
definition.

Q3: What are the key features of a Macro facility?

A3: The key features include:

• Simple macros: Basic substitution of text.

• Parameterized macros: Macros that accept parameters for customization.
• Conditional macros: Macros that incorporate conditional logic.
• Nested macros: Macros that can be defined within other macros.
Q4: Discuss the design of a Two-pass Macro Processor.
A4: A Two-pass Macro Processor first scans the source code to identify macro
definitions and calls, building a table of macro definitions. During the second pass, it
replaces macro calls with their corresponding definitions, expanding nested macros as
needed.

Q5: What are the common data structures used in the design of a Macro
Processor?
A5: Common data structures include macro tables, which store macro definitions and
their parameters, as well as data structures for handling macro expansion and
argument substitution.

Q6: Explain the significance of Simple, Parameterized, Conditional, and Nested

macros in programming.
A6:

• Simple macros allow for code reuse and simplification.

• Parameterized macros enhance flexibility by accepting arguments.
• Conditional macros enable the inclusion of different code segments based on
conditions.
• Nested macros facilitate complex code generation by allowing macros to be
defined within other macros.
Q7: How does the implementation of a Macro Processor differ from that of an
Assembler?
A7: While both Assemblers and Macro Processors involve text substitution, they serve
different purposes. An Assembler translates assembly language code into machine
code, whereas a Macro Processor expands macros in source code before compilation.
Q8: Discuss the advantages of using macros in software development.
A8: The advantages of using macros include code reuse, improved readability, and the
ability to create domain-specific languages (DSLs) for expressing complex operations
concisely.

Q9: How do Parameterized macros enhance code flexibility?

A9: Parameterized macros allow developers to customize the behavior of macros by
passing arguments, enabling the creation of reusable code templates that can adapt to
different contexts.

Q10: Describe the role of Conditional macros in controlling code execution.

A10: Conditional macros incorporate logic that determines whether specific code
segments should be included or excluded based on predefined conditions, enhancing
code modularity and maintainability.

Loaders and Linkers

Q1: What are the main functions of loaders in the context of computer systems?
A1: Loaders are responsible for loading executable programs into memory for
execution. Their main functions include allocating memory space, relocating program
code and data, resolving external references, and initializing program variables.

Q2: Explain the concept of Relocation in the context of loaders and linkers.
A2: Relocation refers to the process of adjusting the memory addresses of a program’s
code and data to reflect the actual location where it will be loaded into memory. This
adjustment is necessary because the program may not always be loaded at the same
memory address.

Q3: What is Linking, and how does it relate to the concept of Relocation?
A3: Linking involves combining multiple object files and resolving external references to
create a single executable program. Relocation is a crucial step in the linking process,
as it ensures that references to external symbols are adjusted to point to the correct
memory locations.

Q4: Discuss different loading schemes used by loaders, including Relocating

Loader and Direct Linking Loader.
A4:

• Relocating Loader: A Relocating Loader loads a program into memory and

adjusts its internal references (addresses) based on the actual memory location
where it is loaded. This allows the program to execute correctly regardless of its
location in memory.
 • Direct Linking Loader: A Direct Linking Loader performs linking and loading
simultaneously, generating a fully linked executable program without the need
for intermediate object files.
Q5: What is Dynamic Linking, and how does it differ from Static Linking?
A5: Dynamic Linking involves linking libraries (such as DLLs in Windows or shared
libraries in Unix-like systems) at runtime rather than at compile time. This allows
multiple programs to share the same code in memory, reducing memory usage and
promoting code reuse. In contrast, Static Linking incorporates library code into the
executable file at compile time, resulting in larger executable sizes.

Q6: Describe the process of Dynamic Loading and its advantages.

A6: Dynamic Loading involves loading and linking portions of a program into memory
only when they are needed during execution. This allows for more efficient memory
usage, faster program startup times, and the ability to dynamically extend the
functionality of a program through plugins or modules.

Compilers: Analysis Phase

Q1: What is a compiler, and what are its main objectives?

A1: A compiler is a software tool that translates high-level programming languages
into machine code or intermediate code. Its main objectives include analyzing the
source code, generating an intermediate representation, and optimizing the code for
efficient execution.

Q2: Discuss the role of Finite State Automata (FSA) in Lexical Analysis.
A2: Finite State Automata are used in Lexical Analysis to recognize and tokenize the
input stream of characters into meaningful units, such as identifiers, keywords, and
literals. FSA provides a systematic approach for defining lexical patterns and efficiently
recognizing them during scanning.

Q3: Explain the design of a Lexical Analyzer and the data structures used.
A3: A Lexical Analyzer scans the input source code character by character, recognizing
lexemes and generating tokens. It typically uses data structures such as Finite
Automata, Regular Expressions, and Symbol Tables to perform lexical analysis
efficiently.

Q4: What is the role of Context-Free Grammar (CFG) in Syntax Analysis?

A4: Context-Free Grammar is used to formally define the syntax rules of a
programming language. It specifies the structure of valid programs in terms of
terminals (tokens) and non-terminals (syntactic constructs), facilitating syntax analysis
by parsers.
Q5: Differentiate between Top-down and Bottom-up parsers, and discuss their
types.
A5:

• Top-down parsers, such as LL(1) parsers, start parsing from the start symbol and
attempt to rewrite it to match the input string. They use a leftmost derivation to
build the parse tree.
• Bottom-up parsers, such as Shift-Reduce (SR) parsers, start parsing from the
input string and attempt to reduce it to the start symbol. They use a rightmost
derivation to build the parse tree.
• LL(1) parser: A predictive parser that reads input from left to right, constructs a
leftmost derivation, and performs one lookahead symbol to predict the next
parsing action.
• SR parser: A parser that shifts input symbols onto a stack until a reduction can
be applied, based on a set of predefined grammar rules.
• Operator precedence parser: A type of bottom-up parser that uses precedence
rules to resolve ambiguities in the grammar.
• SLR parser: A Simple LR parser that combines the efficiency of LR parsing with
the simplicity of SLR parsing.
Q6: Describe Semantic Analysis in the context of compiler phases.
A6: Semantic Analysis is the phase of the compiler that checks the meaning of the
program by examining its syntax tree or abstract syntax tree. It verifies whether the
program follows the rules of the programming language and performs type checking,
scope resolution, and other semantic validations.

Q7: Explain the concept of Syntax-Directed Definitions (SDD) in compiler

design.
A7: Syntax-Directed Definitions are rules or annotations associated with the
productions of a context-free grammar. They specify semantic actions to be performed
during parsing, such as attribute computation or code generation. SDDs facilitate the
integration of semantic analysis with syntax analysis in a compiler.

Q8: How do Lexical Analysis and Syntax Analysis differ in their approaches to
analyzing source code?
A8: Lexical Analysis focuses on recognizing and tokenizing individual lexemes based on
patterns defined by regular expressions or finite automata. Syntax Analysis, on the
other hand, focuses on analyzing the structure of the program and verifying its
syntactic correctness according to the rules defined by the grammar.

Q9: Discuss the importance of efficient data structures in the design of Lexical
Analyzers.
A9: Efficient data structures, such as Finite Automata and Symbol Tables, are crucial for
optimizing the performance of Lexical Analyzers. They allow for fast recognition and
storage of lexemes, reducing the time complexity of the lexical analysis phase.
Q10: How do Syntax Analyzers handle ambiguity in the grammar of a
programming language?
A10: Syntax Analyzers use techniques such as lookahead symbols, operator precedence
rules, and parsing algorithms (e.g., LL(1) and LR) to resolve ambiguity in the grammar
of a programming language. Ambiguities may arise from ambiguous productions or
conflicting parsing decisions, which need to be resolved to construct a valid parse tree.

Compilers: Synthesis Phase

Q1: What is the role of the Synthesis phase in the compiler process?
A1: The Synthesis phase, also known as the Code Generation phase, is responsible for
generating efficient machine code or intermediate code from the high-level
representation of the source program. It translates the optimized intermediate
representation into executable instructions.

Q2: Describe the different types of Intermediate Codes used in compiler design.
A2:

• Syntax tree: A hierarchical representation of the syntactic structure of the source

program, usually generated during syntax analysis.
• Postfix notation: Also known as Reverse Polish Notation (RPN), it represents
expressions using postfix notation, which is easier to translate into machine
code.
• Three-address codes: Intermediate code representations that use instructions
with at most three operands, such as assignment statements.
• Quadruples: Intermediate code representation that uses four fields to represent
operations, operands, and results.
• Indirect triples: Similar to triples, but the addresses of operands and results are
stored indirectly.
Q3: Discuss the need for Code Optimization in the compiler process.
A3: Code Optimization aims to improve the performance, size, and efficiency of the
generated code. It reduces execution time, memory usage, and power consumption,
making the program run faster and consume fewer resources.

Q4: What are the sources of optimization in code generation?

A4: The sources of optimization include the algorithmic efficiency of the source
program, the structure of intermediate representations, and the efficiency of the code
generation algorithm. Additionally, compiler optimizations can be applied at various
levels, including the instruction level, loop level, and global program level.

Q5: Describe the distinction between Machine-Dependent and Machine-

Independent Code Optimization techniques.
A5:
 • Machine-Dependent Optimization techniques are tailored to the characteristics
of a specific target machine architecture. They exploit features such as
instruction set architecture, memory hierarchy, and pipeline structure to
optimize code.
• Machine-Independent Optimization techniques focus on improving program
performance without relying on specific machine details. They include
optimizations such as constant folding, common subexpression elimination, and
loop optimization.
Q6: What are the primary issues in the design of a code generator?
A6: The primary issues in the design of a code generator include selecting appropriate
instructions for the target machine, managing register allocation and memory usage,
handling control flow structures, and ensuring correctness and efficiency in the
generated code.

Q7: Explain the algorithm used in code generation during the Synthesis phase.
A7: The code generation algorithm translates the intermediate representation (such as
syntax trees or three-address code) into machine code. It typically traverses the
intermediate representation and emits corresponding machine instructions or assembly
code, while also performing optimizations to improve code quality.

Q8: Define Basic Blocks and Flow Graphs in the context of code generation.
A8:

• Basic Blocks are sequences of consecutive instructions with a single entry point
and a single exit point. They represent straight-line code segments without any
branching.
• Flow Graphs represent the control flow structure of a program, with nodes
representing basic blocks and edges representing control flow between them.
They provide a graphical representation of the program’s execution paths.