CS32, Fall 2017

Lab07:
Inspecting object/load modules

Goals for this lab

By the time you have completed this lab you should be able to

Identify and interpret file types with the file command.
Inspect object and load module contents and structure with command line tools, strings, nm, objdump and readelf
Explain key memory concepts for C and C++ programs

Step by Step Instructions

Step 1: Choose roles, log in, and get a file

Partner up (and remember to switch roles after a while). If your regular partner is more than 5 minutes late, ask the TA to pair you with someone else for this week.
Download lab07.cpp and save it into ~/cs32/lab07

Step 2: Compile, link separately, and begin exploring the binaries

First compile with both -g and -c flags to provide debugging information and write the object module, lab07.o to disk:
```
g++ -g -c lab07.cpp
```
Now create the executable file from this object file:
```
g++ -o lab07 lab07.o
```
Next, read and interpret the output of the file command for the three files:
```
-bash-4.3$ file lab07*
lab07:     ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically
linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.6.32,
BuildID[sha1]=bc979079d929c86213775cf197744af9d597b51f, not stripped
lab07.cpp: C source, ASCII text
lab07.o:   ELF 64-bit LSB relocatable, x86-64, version 1 (SYSV), not stripped
```
ELF stands for "Executable and Linking Format" as you learned from the Reader and lecture, LSB means "Linux Standard Base" (a collection of APIs meant to be supported by all Linux systems), and SYSV abbreviates "UNIX System V." What else can you learn from these results? And what do you suppose "not stripped" means?
The strings command can be used to list the printable strings in a binary file. For example, the relocatable object file (lab07.o) has the two strings created in the source code ("element " and " is "), plus lots of other printable strings added in the compile step. The '-d' option means "Only print strings from initialized, loaded data sections in the file." Try it:
```
-bash-4.3$ strings -d lab07.o
element 
 is 
```
Depending on how the strings program is configured, the '-d' behavior might be the default. If you want to see all printable strings in a binary file, use '-a' to override the default. Meanwhile, the executable file contains even more strings. Try `strings lab07` to see them if you are curious.

Step 3: Inspect object module names/sections with `nm` and `objdump`

The command nm lists the "names" (symbols) in an object or load module, and objdump displays various information about such files. Both commands have useful options that are worth learning.

Show the names in lab07.o:

-bash-4.3$ nm lab07.o
0000000000000000 D a
0000000000000000 B b
                 U __cxa_atexit
                 U __dso_handle
00000000000000e5 t _GLOBAL__sub_I_a
0000000000000000 T main
00000000000000a7 t _Z41__static_initialization_and_destruction_0ii
0000000000000000 r _ZL1M
                 U _ZNSolsEi
                 U _ZNSolsEPFRSoS_E
                 U _ZNSt8ios_base4InitC1Ev
                 U _ZNSt8ios_base4InitD1Ev
                 U _ZSt4cout
                 U _ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_
0000000000000028 b _ZStL8__ioinit
                 U _ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc
0000000000000028 d _ZZ4mainE1k

The values on the left side are addresses in hexadecimal, and you can show these values in decimal with the "-td" option. The next column shows the class of each symbol, where T and t are functions, D and d are data (global variables), r is read-only data, B and b are uninitialized data, and U is undefined.

Notice the names are shown in their "mangled" form by default. For example, "_ZL1M" is really just the global constant M, "_ZNSolsEi" is "std::ostream::operator<<(int)" in more familiar notation. The "-C' option will decode (demangle) such symbols for you. Try it now.
By the way, the default format for nm, "BSD format" is more difficult to read than "System V format" which can be achieved with the "-f sysv" option. Try that now too (and you probably want to widen your terminal window to fit the format).

Using objdump can reveal more details about object files. At least one option must be specified.

Try it first with the "-S" option - and always pipe the results through more to view one screenful at a time:
```
objdump -S lab07.o | more
```
Try it now. According to man, the "-S" option will "display source code intermixed with disassembly, if possible. Implies -d" where "-d" means disassemble the code.
Use man objdump or read the man page at http://sourceware.org/binutils/docs/binutils/objdump.html#objdump to learn about more options. You might like the "-l" (ELL) option in particular - use it along with the "-d" option as follows:
```
objdump -d -l lab07.o | more
```
Try some other option switches. Notice for example that "-C" serves the same purpose it did for the nm command. Do you remember that purpose? The -j option lets you specify "just" particular sections. Interesting sections include .text, .data, .rodata, and .ctors, among others.

Step 4: Inspect executable module with `readelf`

Although you could use objdump to inspect this load module, the readelf tool gives more information about load modules (so called because they are ready to be loaded into memory for execution). As with objdump, at least one option must be specified.

First learn about readelf from its man page (at the console or here: http://sourceware.org/binutils/docs/binutils/readelf.html#readelf).
Did you notice that the "-S" option has a different meaning for readelf than it does for objdump? It means "Display the sections' header" for readelf. Use it now to find out the names of the sections in lab07:
```
readelf -S lab07
```
Also notice that readelf can be used to further inspect the object module (lab07.o) too.
Finally, find answers to the following questions in case the TA asks you about them:
1. What is the name of the section with the program's instructions?
2. In what section is the array named a stored?
3. In what section is the constant M stored?
4. In what section is the static variable k stored?
5. How is the array b handled differently than other variables?
6. The variable i is handled differently too. How?
  (Hint: remember what you know about "automatic" data storage.)

By the way, don't just search the object and load modules for answers to these questions. Instead recall what you learned from the reading. Ask if you get stuck.

Step 5: Show off your work and get credit for the in-lab requirements

First be sure you know the answers to all of questions a through f listed at the end of Step 4. Then ...

Get your TA's attention to inspect your work, and to record completion of your in-lab work.

Now look around the lab to find out if there are other students who might need your help. If yes, first ask them if they would like you to help, and if they say "Yes" then do help guide them through their remaining lab steps - without just giving them the exact solution. When all students are either successful or are being helped by someone else, then you may leave early! But make sure that you were checked off first.

Step 5a. ONLY IF YOU RAN OUT OF TIME TO HAVE THE TA INSPECT YOUR WORK

If you must complete this assignment at CSIL, then submit it with the turnin program - but do NOT turn it in if the TA already checked you off.

First create a text file named lab07.txt, and type answers to each of the six questions at the end of Step 4 above. You MUST have both your name and your partner's name in lab07.txt in order to receive credit.

Bring up a terminal window on CSIL, and cd into the original pilot's ~/cs32/lab07 directory. Then type the following to turn in your text file:
turnin lab07@cs32 lab07.txt

Evaluation and Grading

Each pair of students must accomplish the following to earn full credit for this lab:

[50 points] You can tell the TA the answers to each of the six questions listed in Step 4.

ONLY IF STEP 5a IS NECESSARY - lab07.txt has been turned in.
Deadline for after-lab submission: tonight at 11:59pm.

[-0 to -50 points, at the TA's discretion] The student arrived on time to their lab session, and worked diligently on CS32-related material until dismissed.

No after-lab work this week

Prepared by Michael Costanzo.