GATE IT 2008 | Question: 38

Question

Assume that EA = (X)+ is the effective address equal to the contents of location X, with X incremented by one word length after the effective address is calculated; EA = −(X) is the effective address equal to the contents of location X, with X decremented by one word length before the effective address is calculated; EA = (X)− is the effective address equal to the contents of location X, with X decremented by one word length after the effective address is calculated. The format of the instruction is (opcode, source, destination), which means (destination ← source op destination). Using X as a stack pointer, which of the following instructions can pop the top two elements from the stack, perform the addition operation and push the result back to the stack.

• A. ADD (X)−, (X)
• B. ADD (X), (X)−
• C. ADD −(X), (X)+
• D. ADD −(X), (X)

Comments

In the question, it is clearly mentioned that the order of execution is (destination ← source op destination), which means the execution proceeds left to right. If the order of execution were right to left, i.e., (destination ← destination op source), then option D would have been the correct choice.Let's see how

Let’s assume the stack initially points to address 100. First, the destination is accessed. Then, for the source operand, the address is calculated, which would be 99, as it is pre-decrement. The result would then be stored at the destination, which is address 99 itself.

Another doubt arises regarding whether the stack is growing upwards or downwards. However, if we consider the stack growing downwards, it rules out the possibility because in that case all option would be incorrect.

---

@Sachin886 I am not able to understand how "destination ← destination op source" will work. Please explain.

---

Note : This is not rule but most standard book like Carl Hamacher (refer chapter 2 & 5 of 6th edition ) , william stallings follow Left to Right operand evaluation convention in COA ...

Answer 1

1. ADD (X)−, (X):

   • This instruction decrements the stack pointer after the effective address calculation, so it pops the top two elements from the stack.

2. ADD (X), (X)−:

   • This instruction decrements the stack pointer before the effective address calculation. It pops one element from the stack, not two.

3. ADD −(X), (X)+:

   • This instruction increments the stack pointer before the effective address calculation, so it doesn't pop the top two elements from the stack.

4. ADD −(X), (X)+:

   • Similar to option 3, this instruction increments the stack pointer before the effective address calculation, so it doesn't pop the top two elements from the stack.

Therefore, the correct instruction that can pop the top two elements from the stack, perform the addition operation, and push the result back onto the stack is: ADD (X)−, (X)

Comments

This should be the best answer

Answer 2

If we assume a top down stack where top=top+1.
(100 101 102 103 104<-top)
and see option b
Add (X) ,(X)-
and look at the format= (opcode, source, destination) destination <-source + destination
103=104 + 103
Isn't this coreect

option A Add (X)-,(X)
104=103+104

So this option have not decreased our stack by 1.
but we want Pop, Pop , Push
so top should be definetly one less.

So option B.

 

Answer 3

The English of a was somewhat tricky below I have explained

Answer 4

Option A: ADD (X)−, (X)

Interpretation / order: evaluate source (X)− first, then destination (X).

1. Source (X)− (post-decrement): EA = contents at X = 1000 (this is the top element). After EA is computed the CPU does X ← X − 1 → now X = 999.

2. Destination (X) (no modifier): Now uses the current X = 999 (the former second element).

3. Compute destination ← source + destination → store sum into address 999.

Effect: we effectively read addresses 1000 and 999, decrement the pointer once (so top element removed), and store the result at 999. Net effect: top two elements were popped, their sum pushed at the new top (999). This matches exactly the required operation (pop two, add, push result). (Example in memory: 999 ← (1000) + (999)).

Option B: ADD (X), (X)−

• Source (X) reads X = 1000 (top).

• Destination (X)− is post-decrement: EA = contents at the current X (still 1000), then X decremented to 999.

• Both operands refer to same address 1000 — you add top with top, then decrement pointer once and store into address 1000 (or possibly 1000 overwritten then pointer decremented). This does not pop two distinct elements. So B fails.

Option C: ADD −(X), (X)+

• Source −(X) is pre-decrement: X becomes 999, then EA uses address 999.

• Destination (X)+ is post-increment: EA uses current X (which is 999), then increments X to 1000.

• Both operands refer to same address 999 — again not two distinct pops. So C fails.

Option D: ADD −(X), (X)

• Source −(X) pre-decrements X to 999, EA = contents at 999.

• Destination (X) then uses current X = 999 as well. Both operands refer to same address 999. So D fails.