Runtime Support for Scoping

• Goal: Understand block scopes in C
• Assembly refresher
• AT&T Instruction set syntax
• Use of the stack for local storage

Scopes in C

• Scopes can be nested

  int fun(int x, int y)
  {
     int a;
     int b;
     ...
     while (a > b)
     {
        int x;
        int a;
        ...
     }
  }

• Parameter variables are local variables in the function's outermost scope.
• Also have one global scope

  int x; // Global
  
  int main()
  {
     int x; // Local
  }

Memory Areas of a C Program

• Program instructions (“text”)
• Global variables—initialized (“data”)
• Global variables—read-only (“rodata”)
• Global variables—uninitialized (“bss”)
• Stack (local variables, return addresses)
• Heap (malloc/free, i.e. low-level new/delete)

Run-Time Stack

• Each called function has a stack frame
• Stack frame contains
  • function parameters
  • return address
  • local variables of function
• When function returns, frame is popped
• lEfficient: Local variables only require space when function is called
• Stack structure required for recursive functions

Processor Architecture

• Registers: Short-term storage in CPU
• Data moved from memory to registers
• Data processed in CPU
• Result moved back into memory

i386 32-bit Registers

AT&T Assembly Notation

• Used in Linux/Unix/Cygwin
• Slightly more consistent than Intel notation
• % means register: %eax
• $ means immediate value: movl $1, %eax
• Operand order: from/to

  movl $1, %eax ; 1 -> eax or eax = 1
  addl $1, %eax ; eax = eax + 1

• Indirect addressing: offset(base), e.g.

  movl $1, 4(%esp) ; esp[4] = 1 

Stack Allocation

• Intel stack grows downwards: After push or call, esp gets smaller
• call pushes return address, ret pops it into eip.
• Local variables are allocated below esp
• For convenience, esp is saved in ebp, and all variables are accessed through ebp

  pushl %ebp ; save old ebp
  movl %esp, %ebp
  subl $n, %esp ; skip over local variables

• Variables are accessed as -n(%ebp)

  movl $1, -16(%ebp) ; Translation of C instruction i = 1

• Nested scope: Allocated deeper on the stack
• Scope is a compile-time construct.
• At run-time, there are only memory addresses (relative to the function's stack frame)

Lab

• One of you writes the code, the other types up answers
• Switch coder/scribe roles each lab

  Submit lab work to Sakai.

Step 0. Software Installation

• If you installed Cygwin in the lab, you can skip this step.
• If you installed Cygwin on your own machine, run setup.exe again and pick gcc4-core and gdb from the package selection list, then run the installer
• If you run Linux, get GCC 4. For example, on Ubuntu Maverick, sudo apt-get install gcc-4.5-base.
• If you run Ubuntu, install Insight from here. (The automatic install didn't work for me, but I clicked on View Package Details, then the triangle next to the package, and picked the DEB for my machine.)
• Alternatively, you can build Insight from source. I had to install libx11-dev and libncurses-dev and configure as ./configure --disable-werror.

Step 1 - Reading Disassembly

• Save this C program in a file test.c

  #include <stdio.h>
  
  void fun()
  {
     int a = 1;
     int b = a + 10;
     printf("%d\n", b);
  }
  
  main() /* we don't look into main--it is special */
  {
     fun();
  }
      

• In a bash command shell, run

  gcc -S test.c

  Then look at the file test.s in a text editor

1. Where are the variables a and b allocated?
2. How do you know?
3. What are the assembly instructions for the statement int b = a + 10;

Step 2. Scopes

1. Replace the printf statement with

     while (a < b)
     {
        int a = b;
        b--;
        {
           int b = a + 1;
           printf("%d\n", b);
        }
     }

   Where are the outer and inner a and b allocated?

2. Turn the outer a into a global variable. How is a global variable accessed in assembly?

Step 3. Watching Registers and Memory

• Go back to the program of step 1. Compile it as

  gcc -o test -g test.c

• Start the debugger as

  insight test

• Set the mode from SOURCE to MIXED.
• Select View -> Registers from the menu.
• Set a breakpoint on the call to fun by clicking on the code line.
• Click on the “runner” icon.
• When the debugger stops at the call to fun, click on the first {i} (Step Asm Inst) icon.
• Repeat Step Asm Inst three times. The cursor should now be on

  movl   $0x1,-0xc(%ebp)

1. What is the contents of the ebp register?
2. Right-click on the ebp register, select Open Memory Window, then hit the up-arrow in the memory window a couple of times. What is the contents of -0xc(%ebp) before the movl instruction?
3. Step over the movl instruction. What is the contents of -0xc(%ebp) now?