SPCC SOLVED PAPER DEC-2019

Q.1
1. Enlist the different types of errors that are handled by Pass I and PassII of
assembler.
Pass I:

Syntax Errors: These errors occur due to viola ons of the language syntax rules, such as missing
semicolons, incorrect token placement, etc.
Label Errors: Pass I checks for errors related to labels, such as redefined labels, invalid label names, etc.
Opcode Errors: Errors related to incorrect or invalid opcodes are checked in this phase.
Operand Errors: Pass I verifies the correctness of operands, such as invalid addressing modes,
mismatched operand types, etc.
Symbol Table Errors: Errors related to symbol table management, such as duplicate symbol defini ons,
undefined symbols, etc.
Pass II:

Addressing Errors: Pass II checks for errors related to addressing, such as invalid or out-of-range
addresses.
Expression Errors: Errors related to expressions, such as arithme c errors, undefined symbols in
expressions, etc., are handled in this phase.
Machine Code Errors: Pass II is responsible for genera ng machine code, so any errors related to
genera ng machine code or encoding instruc ons are handled here.
Reloca on Errors: Errors related to reloca on of symbols, especially in cases of relocatable code, are
checked in Pass II.
Output File Errors: Any errors related to wri ng the output file, such as disk full, permission issues,
etc., are handled in this phase.

2. Define Loader. What are different func ons of loader

A loader is a program that loads executable code from secondary storage into the computer's main
memory (RAM) and prepares it for execu on by the CPU. The loader is typically part of the opera ng
system or works closely with it. Its primary func on is to manage the process of loading executable
files into memory in a way that allows them to be executed properly.
Here are the different func ons of a loader:
Alloca on of Memory: The loader allocates memory space in the main memory to hold the executable
program and its associated data. This involves determining the star ng address in memory where the
program will be loaded and ensuring that it does not conflict with any other programs or system
components already in memory.
Loading Program into Memory: The loader reads the executable file from secondary storage (such as
a disk drive) into the allocated memory space in RAM. It ensures that the instruc ons, data, and any
other required resources are loaded correctly and in the proper order.
Address Resolu on: Many programs are wri en assuming they will be loaded at a specific memory
address. However, in a mul -programming environment, this may not be possible. The loader performs
address resolu on by adjus ng the addresses used in the program to reflect the actual loca on where
it is loaded in memory.
Reloca on: If the program contains rela ve memory addresses or references to other parts of the
program, the loader adjusts these addresses to reflect the actual memory loca ons where the program
is loaded. This process is known as reloca on and ensures that the program will execute correctly
regardless of where it is loaded in memory.
Linking: In some cases, the loader may also perform linking tasks, such as resolving references to
external libraries or modules required by the program. This may involve dynamically linking shared
libraries or resolving references to func ons defined in other parts of the program.
Ini aliza on: A er loading the program into memory, the loader may perform ini aliza on tasks, such
as se ng up data structures, ini alizing variables, or performing other setup tasks required for the
program to run correctly.
Transfer of Control: Once the program is loaded and ini alized, the loader transfers control to the
star ng point of the program, typically the main func on or entry point specified in the executable
file. From this point, the program begins execu on under the control of the CPU.

3. Compare bo om up and top down parser

4. What is the need of Intermediate code genera on? Explain any two Intermediate
code genera on forms with example
Intermediate code genera on is an essen al phase in the compila on process that transforms the
source code into an intermediate representa on before further processing. This intermediate
representa on serves as a bridge between the high-level source code and the target machine code or
assembly language. There are several reasons for the need of intermediate code genera on:
Portability: Intermediate code allows the compiler to generate target code for different pla orms
without having to perform the en re compila on process again. Once the intermediate representa on
is generated, it can be op mized and translated into target code for various pla orms.
Op miza on: Intermediate code provides a convenient stage for applying op miza on techniques.
By performing op miza ons on the intermediate representa on, the compiler can improve the
efficiency of the generated code without modifying the original source code.
Simplify Compila on: Intermediate code simplifies the compila on process by separa ng the
concerns of syntax analysis and code genera on. It allows the compiler to focus on transla ng the
high-level language constructs into a simpler, pla orm-independent representa on before genera ng
the target code.
Ease of Debugging: Intermediate code can facilitate debugging by providing a more structured and
understandable representa on of the program's behavior. Debugging tools can analyze and
manipulate the intermediate code to iden fy and fix errors more effec vely.
Three-Address Code (TAC):
t1 = a + b
t2 = c * d
e = t1 - t2
In this example, t1, t2, and e are temporary variables used to store intermediate results, while a, b, c,
and d are variables or constants from the original source code. Each instruc on represents a single
opera on, such as addi on, mul plica on, or subtrac on, with one result and two operands.
Quadruples:
1. if a < b goto L1
2. t1 = c * d
3. goto L2
4. L1:
5. t1 = e - f
6. L2:
In this example, each quadruple represents an opera on or control flow instruc on, such as
comparison, mul plica on, subtrac on, and condi onal or uncondi onal jumps. The goto statements
transfer control to the specified labels (L1 and L2), allowing the program to execute different code
paths based on the result of the comparison opera on.
Q.2
1. What is Le factoring? Find FIRST & FOLLOW for the following grammar
S->Aa
A->B D
B->b | ϵ
D->d | ϵ
Le factoring is a grammar transforma on technique used to eliminate common prefixes from the
produc ons of a grammar. This technique helps to improve the efficiency of predic ve parsing
algorithms, such as LL(1) parsing, by resolving poten al conflicts.
To le factor a grammar, you iden fy common prefixes in the produc ons of a non-terminal and create
new non-terminals to represent those prefixes. Here's the le factored version of the given grammar:

Original Grammar: Le Factored Grammar:

S -> Aa S -> Aa
A -> BD A -> B A'
B -> b | ϵ A' -> D | ϵ
D -> d | ϵ B -> b | ϵ
D -> d | ϵ
FIRST Sets:
FIRST(S) = {a}
FIRST(A) = {b, ϵ}
FIRST(A') = {d, ϵ}
FIRST(B) = {b, ϵ}
FIRST(D) = {d, ϵ}
FOLLOW Sets:
FOLLOW(S) = {$}
FOLLOW(A) = {a}
FOLLOW(A') = {a}
FOLLOW(B) = {d, ϵ}
FOLLOW(D) = {a}
2. What are the phases of compiler? Give working of each phase for the Following
statements :
int a, b, c =1 ;
a=a*b -5*3/c
The phases of a compiler can be broadly categorized into several stages. Here's an overview of the
typical phases of a compiler along with a brief explana on of each phase:
1. **Lexical Analysis (Scanner)**:
- This phase reads the source code character by character and groups them into meaningful tokens,
such as iden fiers, keywords, literals, and operators.
- For the given statements, the lexical analyzer would tokenize them into something like: `int`, `a`, `,`,
`b`, `,`, `c`, `=`, `1`, `;`, `a`, `=`, `a`, `*`, `b`, `-`, `5`, `*`, `3`, `/`, `c`, `;`.
2. **Syntax Analysis (Parser)**:
- In this phase, the tokens generated by the lexical analyzer are parsed according to the grammar
rules of the programming language to create a parse tree or syntax tree.
- For the given statements, the parser would construct a parse tree represen ng the syntax structure
of the statements. This parse tree would capture the precedence and associa vity of operators and
the structure of variable declara ons and assignments.
3. **Seman c Analysis**:
- This phase checks the seman c correctness of the source code. It ensures that the declara ons and
statements adhere to the language rules and constraints.
- Seman c analysis includes type checking, scope resolu on, and other seman c checks. It verifies
that variables are declared before use, types are compa ble in expressions, etc.
- For the given statements, seman c analysis would verify that the variables `a`, `b`, and `c` are
declared and that their types are compa ble for the arithme c opera ons.
4. **Intermediate Code Genera on**:
- In this phase, the compiler generates an intermediate representa on of the source code. This
intermediate representa on is typically closer to machine code but s ll independent of the target
architecture.
- Common intermediate representa ons include Three-Address Code (TAC), Abstract Syntax Trees
(AST), or Quadruples.
- For the given statements, the compiler would generate intermediate code represen ng the
arithme c and assignment opera ons, possibly using Three-Address Code.
5. **Op miza on**:
- The op mizer improves the intermediate code to make it more efficient. It performs various
transforma ons to reduce execu on me, memory usage, or both, while preserving the program's
behavior.
- Op miza on techniques include constant folding, common subexpression elimina on, loop
op miza on, etc.
 - For the given statements, the op mizer might iden fy opportuni es to simplify expressions or
eliminate redundant computa ons.
6. **Code Genera on**:
- Finally, the compiler translates the op mized intermediate code into the target machine code or
assembly language.
- Code genera on involves mapping the intermediate representa on to specific instruc ons
supported by the target architecture, considering factors like register alloca on, instruc on
scheduling, and memory management.
- For the given statements, the compiler would generate machine code or assembly instruc ons
corresponding to the arithme c and assignment opera ons, tailored to the target architecture.

Q.3
1. Explain YACC in detail.
Yacc (Yet Another Compiler Compiler) is a tool used in the field of compiler construc on for genera ng
parsers and lexical analyzers (scanners) based on a formal grammar specifica on. Yacc is part of the
Unix toolchain and is commonly used in conjunc on with Lex (or Flex) for complete compiler
construc on. Yacc takes a context-free grammar (CFG) as input and generates a parser in C or other
programming languages.
Working of Yacc:
Input Grammar: The user provides a context-free grammar (CFG) as input to Yacc. This grammar
describes the syntax rules of the programming language being processed.
Parser Genera on: Yacc generates a parser based on the provided grammar. The parser typically uses
LR(1) parsing technique, which is a bo om-up parsing method with one lookahead token.
Parsing Table: Yacc constructs a parsing table based on the grammar rules. This table is used by the
generated parser to parse the input and construct a parse tree or syntax tree.
Lexical Analysis: Typically, Yacc is used in combina on with Lex (or Flex), which generates the lexical
analyzer (scanner). Lex reads regular expressions and generates code that tokenizes the input based
on these expressions.
Interfacing with Lex: Yacc and Lex are o en used together in a compiler construc on project. Lex
generates tokens based on regular expressions and provides them to Yacc, which uses them in its
parsing process.
Parser Implementa on: Yacc generates parser code in C or other programming languages based on
the grammar specifica on. This code includes func ons for parsing and construc ng the parse tree
according to the grammar rules.
Seman c Ac ons: In addi on to parsing, Yacc allows the programmer to specify seman c ac ons
associated with grammar rules. These ac ons are executed when the corresponding rule is recognized
during parsing.
Error Handling: Yacc-generated parsers typically include error handling mechanisms to detect syntax
errors in the input and provide meaningful error messages to the user.
Features of Yacc:
1.Powerful Parsing: Yacc can handle complex context-free grammars and generate parsers capable of
parsing languages with intricate syntax rules.
2.Efficient Parsing: Yacc-generated parsers use efficient parsing techniques like LR(1) parsing, which
can parse input in linear me.
3.Modularity: Yacc promotes modularity by separa ng the syntax specifica on (grammar) from the
parser implementa on. This allows for easier maintenance and modifica on of the parser.
4.Error Repor ng: Yacc-generated parsers o en include robust error handling mechanisms, which
provide detailed error messages to aid in debugging.
5.Seman c Ac ons: Yacc allows programmers to specify seman c ac ons associated with grammar
rules, facilita ng the integra on of seman c analysis and code genera on phases in the compiler.

2. Explain machine independent code op miza on techniques.

Machine-independent code op miza on techniques are op miza on strategies applied during the
compila on process to improve the efficiency, performance, and quality of generated code without
relying on specific characteris cs of the target machine architecture. These op miza ons focus on
improving the code at a high-level representa on, such as intermediate code or abstract syntax trees,
before genera ng the machine code.
Here are some common machine-independent code op miza on techniques:
Constant Folding: Constant folding involves evalua ng constant expressions at compile- me instead
of run me. It replaces expressions involving only constants with their computed values.
Example: x = 2 + 3 can be op mized to x = 5.
Dead Code Elimina on: Dead code elimina on removes code that does not affect the program's
output or behavior. This includes unreachable code, code that computes values that are never used,
or redundant code.
Example: Removing assignments to variables that are never used.
Common Subexpression Elimina on: Common subexpression elimina on iden fies and eliminates
redundant computa ons by recognizing when the same subexpression is computed mul ple mes
within a program.
Example: x = a * b + c; y = a * b + d; can be op mized to compute a * b only once.
Strength Reduc on: Strength reduc on involves replacing expensive opera ons with equivalent but
less costly opera ons. For example, replacing mul plica on with addi on or using bit-shi ing instead
of mul plica on/division by powers of 2.
Example: Replacing x * 2 with x + x.
Loop Op miza on: Loop op miza on techniques aim to improve the performance of loops, which are
o en performance-cri cal sec ons of code. This includes loop unrolling, loop fusion, loop interchange,
and loop-invariant code mo on.
Example: Unrolling loops to reduce loop overhead and increase instruc on-level parallelism.
Inlining: Inlining replaces func on calls with the body of the called func on. This reduces func on call
overhead and enables other op miza ons, such as constant propaga on and dead code elimina on,
within the inlined code.
Example: Replacing a small, frequently called func on with its code at each call site.
Copy Propaga on: Copy propaga on replaces uses of a variable with its defining expression or value,
elimina ng unnecessary copies and improving register alloca on.
Example: x = y; z = x + 1; can be op mized to z = y + 1;.
Code Mo on: Code mo on moves computa ons out of loops or inner blocks to reduce redundant
computa on and improve performance.
Example: Moving loop-invariant computa ons outside the loop to execute them only once.
Data Flow Analysis: Data flow analysis techniques analyze the flow of data through a program to
iden fy opportuni es for op miza on, such as unreachable code, redundant computa ons, or
opportuni es for paralleliza on.
Example: Use of reaching defini ons analysis to determine variables whose values are defined but
never used.
Q.4
1. Compare Compiler with Interpreter.
COMPILER INTERPRETER

Processing Approach: Processing Approach:

Compila on: Compilers translate the en re Execu on on the Fly: Interpreters execute the
source code into machine code or an source code line by line or statement by
intermediate representa on (IR) in a single step statement without prior transla on to machine
before execu on. code.
Output: Output:
Executable Code: Compilers produce standalone No Standalone Output: Interpreters don't
executable files or libraries that can be run produce standalone executable files; they
independently of the compiler. directly execute the source code.
Execu on: Execu on:
Indirect: Compiled programs are executed Direct: The interpreter directly executes each
directly by the CPU without the need for the statement of the source code during run me.
compiler or any other tool during run me.
Performance: Performance:
Generally Faster: Compiled code tends to Slower: Interpreted code may execute slower
execute faster as it is already translated into than compiled code as it is translated and
machine code op mized for the target pla orm. executed simultaneously.
Portability: Portability:
Pla orm Dependent: The generated executable Pla orm Independent: Interpreters are o en
code may be pla orm-dependent, requiring pla orm-independent, as they interpret source
recompila on for different pla orms. code at run me without genera ng machine
code.
Debugging: Debugging:
Separate Step: Debugging compiled code o en Easier Debugging: Debugging interpreted code is
involves analyzing machine code or intermediate usually easier as it involves analyzing the source
representa ons, which may be less code directly, allowing for source-level
straigh orward compared to source-level debugging.
debugging.
Examples: Examples:
C, C++, Java (with JIT): Languages that are Python, JavaScript, Ruby: Languages that are
typically compiled. typically interpreted

2. Define le recursion? Eliminate le recursion from the following grammar

S -> (L) | x
L -> L,S |S
Le recursion occurs in a grammar when a non-terminal directly or indirectly produces a deriva on
where its own symbol appears as the le most symbol. Le recursion can lead to infinite recursion
during parsing, causing parsing algorithms to loop indefinitely or resul ng in stack overflow.
In the given grammar:
S -> (L) | x
L -> L,S | S
The non-terminal L is le recursive because it directly produces a deriva on with itself as the le most
symbol in the produc on rule L -> L,S.
To eliminate le recursion, we need to rewrite the produc on rules to ensure that no non-terminal
directly produces a deriva on with itself as the le most symbol.
Elimina on of Le Recursion:
We can apply the following transforma on to eliminate le recursion from the grammar:
S -> (L) | x
L -> SL'
L' -> ,SL' | ε
In this transformed grammar:
In the produc on rule for L, we replace the le recursion L -> L,S with a non-le recursive version
L -> SL'.
We introduce a new non-terminal L' to handle the recursion. The produc on rule for L' represents the
,S part of the original rule L -> L,S, and it can derive ,SL' or ε (epsilon), which represents the empty
string.

3. Explain Dynamic Linking Loader in detail.

Dynamic linking is a mechanism used in modern opera ng systems to link executable code (such as
shared libraries) with an applica on at run me rather than during the compila on phase. Dynamic
linking offers several advantages, including reduced memory footprint, improved performance, and
easier so ware maintenance and updates. A dynamic linking loader is the component responsible for
loading and linking dynamically linked libraries (DLLs or shared objects) into a running process's
memory space.
Here's an explana on of how dynamic linking and the dynamic linking loader work in detail:
### Dynamic Linking Process:
1. **Compila on**: - During the compila on phase, the source code is compiled into object files (.obj
or .o files). These object files may contain unresolved references to func ons or symbols defined in
external libraries.
2. **Linking**: - In dynamic linking, linking occurs at run me when the applica on is loaded into
memory. The executable code (main program) and the dynamically linked libraries are linked together
by the dynamic linking loader.
3. **Loading**: - When an applica on starts, the opera ng system's dynamic linker/loader locates
and loads the required shared libraries into the applica on's memory space. It loads only the por ons
of the libraries needed by the applica on, rather than loading the en re library.
4. **Symbol Resolu on**: - The dynamic linker resolves references to symbols (func ons, variables)
in the applica on and the shared libraries. It maps the symbols referenced by the applica on to their
corresponding addresses in the loaded libraries.
5. **Address Binding**: - The dynamic linker updates the address references in the applica on's code
to point to the actual memory addresses of the resolved symbols in the shared libraries. This process
is known as address binding or reloca on.
6. **Execu on**: - Once the dynamic linking process is complete, the applica on is ready for
execu on. The resolved symbols in the applica on's code now point to the appropriate func ons and
data in the shared libraries, allowing the applica on to execute correctly.
### Advantages of Dynamic Linking:
1. **Reduced Memory Usage**: - Dynamic linking allows mul ple applica ons to share a single copy
of a library in memory, reducing overall memory usage.
2. **Improved Performance**: - Dynamic linking can improve applica on startup me and reduce
memory overhead compared to sta c linking, as only the required por ons of libraries are loaded into
memory.
3. **Easier Maintenance and Updates**: - Dynamic linking allows for easier so ware maintenance
and updates, as changes to shared libraries can be made independently of the applica ons that use
them. Users can update shared libraries without recompiling or relinking the applica ons.
4. **Shared Resources**:- Dynamic linking enables the sharing of resources across mul ple
applica ons, facilita ng code reuse and modular design.
### Dynamic Linking Loader:
1. **Opera ng System Component**: - The dynamic linking loader is a component of the opera ng
system responsible for loading and linking shared libraries into a process's memory space.
2. **Dynamic Linker**: - The dynamic linker/loader is typically a part of the opera ng system's run me
environment. It performs the tasks of loca ng, loading, and linking shared libraries on behalf of the
running applica on.
3. **Run me Linking**: - The dynamic linking loader performs linking and address resolu on at
run me, enabling applica ons to access shared libraries without prior knowledge of their loca ons or
content.
4. **Pluggable Mechanism**: - The dynamic linking loader is designed to be a pluggable mechanism,
allowing different implementa ons to be used interchangeably. This flexibility enables support for
various dynamic linking formats and opera ng system environments.
5. **Error Handling**: - The dynamic linking loader includes error handling mechanisms to detect and
handle issues such as missing or incompa ble shared libraries, symbol resolu on failures, and memory
alloca on errors.
6. **Performance Considera ons**: - Dynamic linking loaders are op mized for efficiency to minimize
startup me and overhead associated with loading and linking shared libraries. Caching and lazy
loading techniques may be employed to improve performance.
Q.5
1. Explain Different assembler direc ves with example
Assembler direc ves are instruc ons or commands provided to the assembler to control the assembly
process and provide necessary informa on about the program being assembled. These direc ves are
not part of the instruc on set of the target machine and are specific to the assembler being used. Here
are some common assembler direc ves along with examples:
### 1. **ORG (Origin)**: - The ORG direc ve specifies the origin or star ng address for the program
or a par cular segment of code or data.
Example: ORG 1000
This direc ve instructs the assembler to start assembling the program at memory address 1000.
### 2. **EQU (Equa on)**:- The EQU direc ve assigns a constant value to a symbol or label.
Example: COUNT EQU 10
This direc ve assigns the value 10 to the symbol COUNT, making it equivalent to a constant.
### 3. **DB (Define Byte)**: - The DB direc ve reserves memory space and ini alizes it with one or
more byte values.
Example: DATA DB 10, 20, 30
This direc ve reserves memory space for three bytes and ini alizes them with the values 10, 20, and
30.
### 4. **DW (Define Word)**: - The DW direc ve reserves memory space and ini alizes it with one or
more word (16-bit) values.
Example: ARRAY DW 1000, 2000, 3000
This direc ve reserves memory space for three words and ini alizes them with the values 1000,
2000, and 3000.
### 5. **DS (Define Storage)**: - The DS direc ve reserves unini alized memory space for a specified
number of bytes or words.
Example: BUFFER DS 20
This direc ve reserves memory space for 20 bytes, but it does not ini alize them.
### 6. **END (End of Program)**: - The END direc ve marks the end of the program.
Example: END
This direc ve indicates to the assembler that the end of the program has been reached.
### 7. **SECTION (Sec on Defini on)**:- The SECTION direc ve defines different sec ons of the
program, such as code sec on, data sec on, etc.
Example: SECTION .data
This direc ve specifies that the following code is part of the data sec on of the program.
### 8. **INCLUDE (Include File)**:- The INCLUDE direc ve includes the contents of an external file into
the current assembly source file. Example: INCLUDE 'constants.asm'
2. Write short note on the following :
1. syntax directed transla on 2. Code genera on issues 3. Operator precendence
Parsing
1. Syntax Directed Transla on:
Syntax-directed transla on is a technique used in compiler construc on where seman c ac ons are
embedded within the produc on rules of a grammar. Each produc on rule is associated with a set of
seman c ac ons that are executed when the rule is applied during parsing. These seman c ac ons
facilitate the genera on of intermediate code or target code directly from the syntax tree or abstract
syntax tree (AST) without requiring separate passes or traversal of the tree. Syntax-directed transla on
allows for the seamless integra on of syntax analysis and seman c processing, enabling efficient code
genera on and op miza on. It simplifies the compiler design by associa ng seman c ac ons directly
with grammar rules, making the transla on process more intui ve and easier to implement.
2. Code Genera on Issues:
Code genera on is the process of transla ng intermediate code or abstract syntax trees into machine
code or assembly language instruc ons. Several key issues need to be addressed during code
genera on to produce efficient and correct executable code:
- **Target Machine Architecture**: Code genera on must consider the characteris cs and instruc on
set of the target machine architecture to generate code that is compa ble and efficient.
- **Memory Management**: Efficient memory alloca on and addressing modes are crucial for
op mizing code size and performance.
- **Instruc on Selec on**: Choosing appropriate machine instruc ons to implement high-level
language constructs while considering factors such as instruc on latency, register usage, and
addressing modes.
- **Register Alloca on**: Alloca ng registers to variables and intermediate values to minimize
memory accesses and improve performance.
- **Op miza on**: Applying op miza on techniques such as constant folding, common
subexpression elimina on, and loop op miza on to improve the efficiency and quality of generated
code.
- **Error Handling**: Detec ng and handling errors during code genera on, such as addressing mode
errors, overflow condi ons, and unsupported language features.
3. Operator Precedence Parsing:
Operator precedence parsing is a parsing technique used to parse expressions based on the
precedence of operators. It eliminates the need for explicit grammar rules for handling operator
precedence and associa vity by using a precedence table or matrix. The precedence table specifies
the rela ve precedence levels of different operators, and the parser uses this informa on to determine
the order of opera ons during parsing. Operator precedence parsing is o en implemented using a
stack-based algorithm, such as the shun ng-yard algorithm or the precedence climbing algorithm. It
efficiently handles expressions with different levels of operator precedence and associa vity, making
it suitable for parsing arithme c expressions and other languages with operator-based syntax.
However, operator precedence parsing has limita ons in handling ambiguous grammars and may
require addi onal techniques, such as disambigua on rules or explicit parentheses, to resolve
ambigui es.