Getting the values of operands for x86-64 given register and memory contents (CS:APP 3e practice problem 3.1)

Question

I need a clarification of a practice problem of Computer Systems A Programmer’s Perspective Third edition.

The problem is on page 218 of chapter 3: Practice problem 3.1:

Assume the following values are stored at the indicated memory addresses and registers:

Address     value      register     value
 0x100      0xFF       %rax         0x100
 0x104      0xAB       %rcx         0x1
 0x108      0x13       %rdx         0x3
 0x10C      0x11

Question:

Fill in the following table showing the values for the indicated operands:

Operand          Value
%rax
0x104
$0x108
(%rax)
4(%rax)
9(%rax,%rdx)
260(%rcx,%rdx)
0xFC(,%rcx,4)
(%rax,%rdx,4)

Answer is:

Operand           Value Comment
%rax              0x100  Register
0x104             0xAB   Absolute address
$0x108            0x108  Immediate
(%rax)            0xFF   Address 0x100
4(%rax)           0xAB   Address 0x104
9(%rax,%rdx)      0x11   Address 0x10C
260(%rcx,%rdx)    0x13   Address 0x108
0xFC(,%rcx,4)     0xFF   Address 0x100
(%rax,%rdx,4)     0x11   Address 0x10C

The answer is not clear to me. From where it get the values for the operands?

Any clarification would help me to understand it better.

Answer 1

The practice problem would be improved by stating complete CPU instructions up front.  The processor only runs complete instructions: it never has to run an addressing mode without the context of a complete instruction, which will include an opcode and operand specifiers.

Without the complete instruction, operand sizes are not specified (though here generally appear intended as 32 bit), and an lea opcode, where possible, instead of mov would produce vastly different results.  The processor can use addressing modes as targets as well as for sources, but targets write to memory rather than reading from memory — yet as far as we are told we don't know whether the addressing mode is for read or write.

So, there is plenty of room for improvement in the practice problem, by not abstracting a complete instruction down to one addressing mode operand (or else by making other things we will have to assume more explicit).

---

With the exception of the first (because %rax is 64 bits) imagine that each of these other addressing modes appears as if in a mov instruction as follows:

For example, given 260(%rcx,%rdx) imagine it as this: mov 260(%rcx,%rdx), %edi — and that the question is, what value appears in %edi after each such mov instruction.

The values of certain registers are given, as are the values of the certain memory locations.  So, what you need to do is be the computer running each such mov instruction, and reporting what value appears in %edi after.

So, mov 260(%rcx,%rdx), %edi says take 260₁₀ which is also 104₁₆ aka 0x104 and add that to the value held in %rcx, which is given as 1, and also to the value held in %rdx, which is given as 3, to form the effective address, here then, 0x104+1+3 = 0x108.  Now use that effective address to load a 32 bit value from that memory location, address 0x108, whose value is given as 0x13.

With a complete instruction, as I've shown, you should be able to consult an instruction set manual to see how it will execute, and derive answers given that execution and the given values in the practice problem table.