GATE CSE · Compiler Design
Generate GATE-level questions covering activation records, stack allocation, heap allocation, parameter passing mechanisms, symbol table organization, and runtime storage management. Include conceptual and diagram-based questions.
81 questions · 0 PYQs · 20 AI practice · GATE CSE 2027
The Buddy System memory allocation scheme works as follows: Memory is always allocated in blocks of size 2^k bytes. If a block of size 2^k is split, it creates two 'buddies' of size 2^(k-1). When a buddy is freed and its partner buddy is also free, they COALESCE back into a 2^k block.
Consider a 256-byte memory using buddy system. Requests arrive in order: 30B, 40B, 50B.
After all three allocations, how many free blocks are there and what are their sizes?
Consider a tail-recursive function:
int sum(int n, int acc) {
if (n == 0) return acc;
return sum(n-1, acc+n);
}
With tail-call optimization (TCO), how does the runtime environment handle this differently from a normal recursive call?
Consider the following nested procedure declarations in a Pascal-like language:
program MAIN;
var x: integer;
procedure A;
var y: integer;
procedure B;
var z: integer;
begin { uses x and y }
end;
begin
B;
end;
begin
A;
end.
When B is executing, how many access link hops are needed to reach the activation record of MAIN to access variable x?
In a statically scoped language with nested procedures, the ACCESS LINK (static link) in an activation record is used for:
Consider the following program:
int x = 1;
void print_x() {
printf("%d\n", x);
}
void set_x(int v) {
x = v;
}
void foo() {
int x = 2;
set_x(3);
print_x();
printf("%d\n", x);
}
foo();
What is the output under STATIC scoping? (C uses static scoping)
Consider the following about memory leaks in runtime environments. A memory leak occurs when dynamically allocated memory is no longer accessible but has not been freed. Which of the following scenarios cause memory leaks? (Select all that apply)
In the context of runtime storage allocation, which of the following data items CANNOT be allocated statically (at compile time) and MUST use stack or heap allocation?
Which of the following correctly describes the typical memory layout of a running program from lower to higher addresses?
Consider the following program segment:
void f(int *p) {
int x = 10;
p = &x;
}
int main() {
int *q = NULL;
f(q);
printf("%d", *q);
}
What problem does this code exhibit at runtime?
In C, consider the following variable declarations:
(i) int a = 5; // outside all functions
(ii) static int b = 10; // outside all functions
(iii)
void f() {
static int c = 0;
}
// inside function
(iv)
void g() {
int d = 0;
}
// inside function
(v)
void h() {
int *e = malloc(4);
}
// inside function
Which variables are stored in the DATA SEGMENT (not stack, not heap)?
Consider a language where procedures can be passed as parameters (higher-order functions). A procedure P is defined at nesting level 2. It is passed as a parameter to procedure Q at nesting level 1, which calls P. In a statically scoped language, when Q calls the passed procedure P, the access link of P's new activation record should point to:
In the context of heap memory management, consider the following allocation strategies:
Which of the following statements are CORRECT? (Select all that apply)
Heap compaction is a technique used to reduce external fragmentation. Which of the following are TRUE about heap compaction? (Select all that apply)
In a runtime environment supporting exception handling (try-catch-finally), which of the following statements describe the runtime mechanism correctly? (Select all that apply)
Which of the following statements about the DISPLAY mechanism (as an alternative to access links) in runtime environments are CORRECT? (Select all that apply)
Consider the mark-and-sweep garbage collection algorithm. In the MARK phase, the collector starts from root pointers and marks all reachable objects. In the SWEEP phase, it reclaims unmarked objects.
In a heap with 10 allocated objects {O1, O2, ..., O10}, the root set points to {O1, O3}. The reference graph is:
O1 → O2, O4
O3 → O5
O4 → O6
O5 → O7
O8 → O9 (O8 is not reachable from roots)
O10 has no references
How many objects are reclaimed (collected) during the sweep phase?
Consider the program given below, in a block-structured pseudo-language with lexical scoping and nesting of procedures permitted. Program main; Var ... Procedure A1; Var ... Call A2; End A1 Procedure A2; Var ... Procedure A21; Var ... Call A1; End A21 Call A21; End A2 Call A1; End main. Consider the calling chain The correct set of activation records along with their access links is given by:
Consider the following recursive procedure:
int fact(int n) {
if (n == 0) return 1;
return n * fact(n-1);
}
How many activation records are simultaneously present on the runtime stack when fact(5) is being evaluated and has reached the base case fact(0)?
Consider the following C program:
void swap(int a, int b) {
int temp = a;
a = b;
b = temp;
}
int main() {
int x = 5, y = 10;
swap(x, y);
printf("%d %d", x, y);
}
What is the output, and under what parameter passing mechanism would x and y be swapped?
Consider the following C++ class hierarchy:
class Animal {
public:
virtual
void speak() {
printf("...");
}
void breathe() {
printf("breath");
}
};
class Dog : public Animal {
public:
void speak() override { printf("Woof"); }
};
Animal *a = new Dog();
a->speak();
a->breathe();
At runtime, which call uses vtable dispatch and which uses direct (static) dispatch?
Want unlimited AI-generated Runtime Environment questions?
Sign up free and practice with adaptive difficulty — Easy, Medium, Hard. New questions every session.
Start practising for free →