Computer Assembly/Architecture.

Question

Computer Assembly/Architecture. Explain which two programs work with prime numbers and which two programs work with square numbers looking at the program assembly code below and explaining why.

There are two programs that work with prime numbers, and two programs that work with square numbers. For each number sequence, one of the programs will fill in an array of 100 quadword integers with the first 100 numbers in the sequence; the other program will fill in an array of 100 bytes with booleans indicating which of the numbers up to 100 is a member of the sequence. For example, the first-100-primes program will fill in an array of quadwords with 2, 3, 5, 7, …, while the primes-up-to-100 program will fill in an array of bytes with 0, 0, 1, 1, 0, 1, 0, 1, … (notice that the 1s are at indices 2, 3, 5, 7, …).

The task is to figure out which program is which, using the debugger. Don’t care a lot that you tell me which is which correctly; what is important is that you show the steps you went through in the debugger and your reasoning about which is which. These programs were compiled from C programs; I have taken care that the names of the files and the names of symbols won’t be a giveaway, but I have neither stripped the symbol tables (which would make it harder) nor added debugging symbols (which would make it easier).

Use the script program to record your debugging sessions. First, within the Environment, run script. It will say something like “Script started, file is typescript”. Proceed to run gdb and explore one of the programs. When you are done and have exited gdb, also exit the shell with exit or by pressing control-d. You should see “Script done, file is typescript”. There should now be a file named typescript that has a complete log of your debugging session.

Put together a document that explains your belief about which program is which, and why, with supporting evidence from typescripts recorded from debugging. You will not get credit for an answer that says which programs are which correctly but does not include evidence from the debugger. You can use the disas command (e.g. disas main) in the debugger to see the machine code as assembly code, as well as the other debugging techniques we discussed for previous assignments.

If in the disassembly you encounter instructions you are not familiar with, stop and look them up and figure out what the code is doing. You could probably figure out which program is which just by looking at how each one fills in its array, but it’s worth even more credit if you can reverse engineer how the programs are doing their work and sketch the algorithms in your document.

ProgA:

Dump of assembler code for function main:

  0x00000000000005fa <+0>: push %rbp

  0x00000000000005fb <+1>: mov %rsp,%rbp

  0x00000000000005fe <+4>: movq $0x2,0x200a37(%rip) # 0x201040

  0x0000000000000609 <+15>: movq $0x1,-0x20(%rbp)

  0x0000000000000611 <+23>: movq $0x3,-0x28(%rbp)

  0x0000000000000619 <+31>: movq $0x1,-0x18(%rbp)

  0x0000000000000621 <+39>: jmpq 0x6ac

  0x0000000000000626 <+44>: mov -0x18(%rbp),%rax

  0x000000000000062a <+48>: lea 0x0(,%rax,8),%rdx

  0x0000000000000632 <+56>: lea 0x200a07(%rip),%rax # 0x201040

  0x0000000000000639 <+63>: mov (%rdx,%rax,1),%rsi

  0x000000000000063d <+67>: mov -0x28(%rbp),%rax

  0x0000000000000641 <+71>: mov $0x0,%edx

  0x0000000000000646 <+76>: div %rsi

  0x0000000000000649 <+79>: mov %rax,-0x10(%rbp)

  0x000000000000064d <+83>: mov -0x18(%rbp),%rax

  0x0000000000000651 <+87>: lea 0x0(,%rax,8),%rdx

  0x0000000000000659 <+95>: lea 0x2009e0(%rip),%rax # 0x201040

  0x0000000000000660 <+102>: mov (%rdx,%rax,1),%rcx

ProgB:

Dump of assembler code for function main:

  0x00000000000005fa <+0>: push %rbp

  0x00000000000005fb <+1>: mov %rsp,%rbp

  0x00000000000005fe <+4>: movq $0x0,-0x10(%rbp)

  0x0000000000000606 <+12>: jmp 0x61e

  0x0000000000000608 <+14>: lea 0x200a31(%rip),%rdx # 0x201040

  0x000000000000060f <+21>: mov -0x10(%rbp),%rax

  0x0000000000000613 <+25>: add %rdx,%rax

  0x0000000000000616 <+28>: movb $0x0,(%rax)

  0x0000000000000619 <+31>: addq $0x1,-0x10(%rbp)

  0x000000000000061e <+36>: cmpq $0x63,-0x10(%rbp)

  0x0000000000000623 <+41>: jbe 0x608

  0x0000000000000625 <+43>: movq $0x1,-0x8(%rbp)

  0x000000000000062d <+51>: jmp 0x675

  0x000000000000062f <+53>: movq $0x0,-0x10(%rbp)

  0x0000000000000637 <+61>: jmp 0x669

  0x0000000000000639 <+63>: lea 0x200a00(%rip),%rdx # 0x201040

  0x0000000000000640 <+70>: mov -0x10(%rbp),%rax

  0x0000000000000644 <+74>: add %rdx,%rax

  0x0000000000000647 <+77>: movzbl (%rax),%eax

  0x000000000000064a <+80>: test %al,%al

Answer 1

Answer:

Let's break down the functionality step by step:

1. The assembly code begins by pushing the value of the %rbp register onto the stack. This is a common practice at the beginning of function calls to create a stack frame.
2. The value of the %rsp (stack pointer) register is moved into the %rbp (base pointer) register. This establishes a new stack frame for the function.
3. The instruction movq $0x2,0x200a37(%rip) sets the value 0x2 into the memory location at address 0x201040. The use of (%rip) indicates a relative addressing mode, meaning the actual address is calculated based on the current instruction pointer.
4. Values are being stored in memory and registers using the instructions movq $0x1,-0x20(%rbp), movq $0x3,-0x28(%rbp), and movq $0x1,-0x18(%rbp). These instructions are storing the values 0x1, 0x3, and 0x1 in memory locations relative to the base pointer (%rbp).
5. The instruction jmpq 0x6ac performs an unconditional jump to the address 0x6ac. This seems to be a jump to a different part of the code, possibly a loop or another section of the program.
6. From 0x6ac, the code returns to this point and continues execution.
7. Several instructions involve mathematical operations:
8. Loading a value from memory into the %rax register using mov -0x18(%rbp),%rax.
9. Using the loaded value to calculate an address offset and storing the result in the %rdx register using lea 0x0(,%rax,8),%rdx. This operation effectively multiplies the value in %rax by 8.
10. Loading a value from a memory location calculated based on %rdx and %rax into the %rsi register using mov (%rdx,%rax,1),%rsi.
11. Division operation:
12. The value in %rsi is being divided by the value in %rax using the div instruction.
13. The quotient of the division is stored in the %rax register using mov %rax,-0x10(%rbp).
14. Similar operations involving multiplication and loading values from memory occur using %rax, %rdx, and %rcx.

Without the complete context and additional instructions, it's challenging to provide a definitive understanding of the overall purpose of the program. However, the assembly code seems to involve memory operations, arithmetic calculations, and possibly branching or looping constructs. If you can provide more details or context about the program's objective, I could offer a more accurate interpretation of its functionality.