1. Goals for this week:

  1. Practice compiling and running C programs: gcc and using make.

  2. Practice with scanf, arrays, and the basics of memory addresses in C.

  3. Introduction to Lab 2, running the starting point code, using the CS 31 readfile library.

  4. Learn some basic gdb debugging commands. We won’t have time to learn all of gdb this week, but we’ll see some more interesting cases than just a calculator.

  cd ~/cs31/weeklylab
  mkdir week02
  cd week02
  cp ~chaganti/public/cs31/week02/* .
  ls
  arrays.c  Makefile  testprog.c  types_scanf.c

2. C compiling and running

First, let’s remind ourselves of the basics of compiling and running C programs.

Now, let’s try it out on one of the files you copied over (we will use the -g and -o outfile options to gcc):

gcc -g -o testprog testprog.c
./testprog

With the code you copied over is a Makefile. In this file are rules for compiling executables from the .c source files that are executed by typing in the make command. make is very convenient way to compile without having to type in a long gcc command every time, you just need to type make:

make         # this will compile all files as specified by the all: rule

make clean   # this removes all files generated by make (they can be rebuilt)

3. Arrays and scanf

In the code you copied over are some examples of scanf, and of arrays:

  1. We are going to start by looking at arrays.c, which contains examples of how to use (and abuse) arrays in C.

  2. Then, we are going to look at the types_scanf.c example, and try running to see what’s happening when we read user input.

  1. Note that scanf needs to know the memory location of where to put the values read in, and we use the & operator on a variable name to pass this location to scanf. For the Lab 2 assignment you will need to do something similar when you call library functions to read in values from a file. We’ll talk much more about what that ampersand means as we build up our C programming skills on future assignments.

4. GDB intro

gdb is the gnu debugger for C and C++ programs. Last week we used gdb as a calculator and converter, but it is normally used to help debug programs. Over the course of the semester will will use gdb and learn more and more features. Today, we will learn just a few basics.

To use the debugger, you usually want to compile your C program with the -g flag to add debugging information to the a.out file (this allows gdb to map machine code to C program code that the programmer understands).

$ gcc -g -o testprog testprog.c

The makefile already has this rule for us, so let’s just run make.

Next, we will run the executable file inside the gdb debugger:

$ gdb ./testprog

The first thing we get is the gdb prompt (our program has not yet started). Typically we will set a break point at main. A breakpoint tells gdb to grab control at a certain point in the execution, in this case right before the first instruction in main is executed:

(gdb) break main

Next, we will enter the run command at the gdb prompt to tell gdb to start running our program:

(gdb) run

The run command will start your program running, and gdb will only gain control again when a breakpoint is hit.

There are a few other main gdb commands we will learn today, the first is next (or just n for next), which tells gdb to execute the next instruction and then grab control again:

(gdb) next    # this will execute the instruction x = 10

The list command lists the C source code around the point where we are in the execution:

(gdb) list

list with a line number lists the source code around that line:

(gdb) list 30

cont tells gdb to let the program continue running. Since we have no more breakpoints it will run until termination.

Now lets add a breakpoint in the function mystery, and rerun the program:

(gdb) break mystery

Lets set a breakpoint at line 20, right before the call to mystery, then type cont to continue execution from breakpoint in main:

(gdb) break 20
(gdb) cont
(gdb) list

We can use the print command to print out expressions in the program, so let’s print out the values of the arguments passed to mystery, and type cont to run until the next break point is hit:

(gdb) print a    # print out the value of the variable a
(gdb) print (a - 4) # print out the value of the expression (a - 4)
(gdb) list

The where or bt command list the call stack:

(gdb) where

Lets step through some of the mystery function’s execution, and print out some of its parameters and locals.

When you’re done using gdb, type the command quit.

If you use gdb to help you debug the lab this week, you may need to know how to use it for programs that take command line arguments. For such programs, simply list the arguments after the run command:

(gdb) break main
(gdb) run 6 4 hello

We will talk more about C and gdb over the course of the semester. Professor Newhall’s "Unix and CS Info Pages and Links" page has some C programming and gdb references that will be useful this semester:

5. Lab 2 Intro

In Lab 2, you will be writing some C code to perform a sorting task.