GATE CSE 1999 | Question: 2.23

Question

A certain processor supports only the immediate and the direct addressing modes. Which of the following programming language features cannot be implemented on this processor?

• A. Pointers
• B. Arrays
• C. Records
• D. Recursive procedures with local variable

Comments

i have a doubt how indirect modes are used to implement the array and records ,as indirect mode stores the pointer to the actual address of the operand and everytime the program is loaded in the main memory operand location changes ,it is not possible if we hard code the address of the pointer in the instruction i think?

---

Records = Structures

Refer: CO & Architecture: GATE CSE 2017 Set 1 | Question: 11

---

pointer cot't access by direct or immidiate addressing mode and it requried indexed addressing or register indirect addressing. Also an array and record need to a pointer access then  option A, B, C is con't implemented using pointer.

option D is

To handle recursive procedures we need to use stack which is an pointer

So none of the option is implemented using direct and immididate addressing

---

==> Indirect addressing provides pointer flexibility, whereas Indexed addressing provides array capability.  a[i] and *(a+i)  compile down to equivalent assembly sequences using either mode.

==> Pointers require dynamic runtime resolution.Direct addressing cannot simulate dynamic pointers because instruction registers cannot change their immediate address fields dynamically

Answer 1

Pointer access requires indirect addressing which can be simulated with indexed addressing or register indirect addressing but not with direct and immediate addressing. An array and record access needs a pointer access. So, options (A), (B) and (C) cannot be implemented on such a processor.

Now, to handle recursive procedures we need to use stack. A local variable inside the stack will be accessed as *$(SP+\text{offset})$ which is nothing but a pointer access and requires indirect addressing. Usually this is done by moving the SP value to Base register and then using Base Relative addressing to avoid unnecessary memory accesses for indirect addressing- but not possible with just direct and immediate addressing.

So, options (A), (B), (C) and (D) are correct.

Comments

@Tmajestical If this could be done, there would be no use of other AMs like : Indirect, Based AM, etc. :)

In order to have random access to array we need to have Indexed AM, for which Index Register + Base register (or base address) is reqd. Nothing is mentioned about these registers are provided or not. Hence, we can’t do it as you mentioned.

---

here Option : C is records which means structures then structures can be implemented by using arrays.

so option C is false.

---

@surya_siddina 

A record is a collection of fields (of possibly different types) grouped together.

Accessing specific fields in a structure often requires knowing the base address of the structure and then accessing the individual fields via fixed offsets. Since direct addressing can be used to access fields by their fixed offsets, structures can also be implemented on this processor.

How C is wrong? Please correct.

Answer 2

A.Pointers can be implemented only with the use of the indexed addressing mode or indirect addressing mode
B.Same for arrays as option A.
C.Records and arrays are typically types of structure so we will need atleast of the two addressing modes mentioned in option 1.
D.Recursion cant be implemented without stack as we cannot use any register to hold function calls as the no of the function calls would be limited by the number of registers available and we generally do independent compilation.So to use stack and access the data variables we need to use *(SP+offset) which is again a pointer application.

All four options are correct

Comments

Could you please tell, How indexed addressing mode can be used for pointers?

---

Last paragraph from page 157

Indexed addressing mode is alone capable of handling indirect addressing and absolute addressing.

Indexed addressing mode contains *(Index Reguster+offset)

If we consider the content of index register to be zero it will become *(0+offset)=*(offset),which is direct addressing mode

Indirect addressing mode can be developed by placing the offset value as 0.(Registe indirect addressing mode)

 

---

Thanks @Psy Duck

Answer 3

pointer require indirect addressing mode.Array and record need index addressing modes.

int foo(int a) {

  int b = 1 + a;

  int c = bar(b);

  return c;

}

int bar(int x) {

//do something

}

When bar  is done executing, it stores its return value in a register which  foo knows to check for the return value. So register addressing mode is required.

Hence the answer is A,B,C,D

Answer 4

Pointer is a variable who holds address of different memory cell ,can change their values and much more.

int x = 10;
int y = 20;
int *p;

p = &x; // Now p holds the address of x
p = &y; // Now p holds the address of y

understand direct memory address now
    the memory address of the data is part of the instruction.
   Instruction: LOAD R1, 0x1000
   Meaning: "Load the value from the fixed address 0x1000 into register R1.
now lets say 
 we initialize int *p=0x1000
but we have fixed address we cant change it 

for indirect addressing mode

In indirect addressing mode, the instruction contains the location of the address, not the address of the final data. This creates the level of indirection that pointers require

Instruction: LOAD R1, [R2]  //Look at the address stored inside register R2. Go to that address and load the value you find there into register R1.

now this is what we needed here R2 can be pointer which holds address itself and data
now u can perform all operation of pointer here

now array need pointer,record also need pointer
and pointer can be implement by indirect addressing mode
since index addressing mode can able to perform indirec addressing mode

henc all needed indirect addressing mode or indexed can be used

Comments

How indexed addressing mode can simulate or perform like indirect addressing mode?

---

in indexed addressing mode we have
opcode + index register+address part
now effective address=Mem[Content of index register +address part]
NOW MAKE ADDRESS PART =0
effective address is Mem[Index register]
which behaves like an indirect register

Answer 5

Question :- Processor with only Immediate and Direct Addressing Modes

1. Limitation:

• Immediate mode only handles fixed constants.
• Direct mode only handles fixed, static memory addresses known at compile time.

1. Why Recursive procedures with local variables CANNOT be implemented:

• Recursion requires a runtime Stack to store distinct sets of local variables for each function call (Activation Records).
• Accessing dynamic stack variables fundamentally requires Register-Indirect, Indexed, or Base-Register addressing modes (Effective Address = Stack Pointer + Offset).
• Without a relative or indirect addressing mode, the processor cannot reference a dynamically changing stack frame location.

1. Why Pointers, Arrays, and Records CAN be implemented:

• Records: Field offsets are constant and pre-calculated at compile time, matching Direct mode.
• Pointers & Arrays: While inefficient, they can be implemented using "Self-Modifying Code," where a program manually updates the target memory address embedded inside a Direct Addressing instruction before running it.