Videos: Representing Procedures

These videos are about calling C functions and how those calls are implemented at the machine-code level. (We make no distinction between “procedure” and “function”.) The videos are especially about the use of the C stack for local variables and keeping track of return points.

• Procedure 1: Intro   1:40
  An introduction to function calls and the details that have to be managed at the machine level to implement functions.

• Procedure 2: C stack   5:19
  A kind of stack—specifically and colloquially known as “the C stack”—is the key implementation technique for function calls in C.

• Procedure 3: Exposing the stack in C and gdb   5:19
  Although the C standard doesn’t say anything about a stack, we can (roughly) expose its existence as reflected in local variable addresses.

• Procedure 4: Stack frames support recursion   2:19

  Why local-variable allocation is tied up with the C stack.

  The word rentrant belongs here as a more generic characterization of the kinds of functions that need stack allocation for local variables. I have simplified somewhat by just characterizing the functions as recursive.

• Procedure 5: callx and retx   5:19
  The callx and retx machine-code instructions support function calls and returns.

• Procedure 6: Arguments and result   5:28
  How a function call provides argument values to the called function, and how that function returns a result: registers and the stack.

• Procedure 7: Preserved and temporary registers   5:34

  An application binary interface (ABI) specifies how a function can use registers and correctly cooperate with other functions.

  In the video, I say “caller-saved” and “callee-saved” backwards on the “x86-64 Linux Register Usage” slide. The original slides were also backwards.

• Procedure 8: ABIs   1:42
  A little more information about what an ABI specifies.

• Procedure 9: Debugging and stack frames   5:39

  How gdb knows which functions are part of the current continuation (i.e., how to provide a backtrace)—or why it might not have that information. This exploration leads us to the notion of a frame pointer.

  I should have pointed out that compiling with -O will tend to generate code that uses a frame pointer, similar to -fno-omit-frame-pointer. However, the generated code gets generally noisier without optimization.

• Procedure 10: Using a frame pointer   4:56
  All about using %rbx as a frame pointer.

• Procedure 11: Stack layout summary   0:47
  Now that we have all the pieces, we can summarize the overall C stack layout.