DDD basics

• For debugging, you should use -g option when you are compiling the source code. The compiler will include extra information in the object code.

      gcc -g uniqRand.c
  

• Start the debugger with the name of the program (in our case a.out) as it's argument.

      ddd a.out &
  

  You'll notice that the window is separated intro 3 sections.
  

• Breakpoints
  Inside of the section where source code is displayed, click the white space left of the statement max = MAX; with right mouse button, and select ``Set Breakpoint''.

  Alteratively, left click the place where you want to set the break point, and push the ``Break'' button of the bar below menu bar.
  

• run
  • Push ``Run'' button of ``Command Tool'', or type run in the ``Debugger Console''.

  • You notice that the program start to run and stop at the breakpoint. The green arrow moves to the break point, showing our current line (the statement about to be executed).

  • If your program needs command line arguments and options, choose ``Program->Run'' from the menu and type in the arguments in the window. For example if you usually run the program with ./a.out -c conf.txt infile > out, type -c conf.txt infile > out in the window (i.e., don't type in the name of the program).
• Stepping through the process:
  1. push ``Next'' button of ``Command Tool'' or type next in the ``Debugger Console''.

     The green arrow moves to the next line, indicating that the statement max = MAX; was executed.

  2. To check if the assignment is successful, you can see the value of max in one of the following ways.
     • Move the mouse cursor to any place where max appears in the ``Source Code'' window. Leave the cursor there for a second. You'll get yellow pop-up box containing the current value of max. Also notice ``Status Line'' shows the same information.
     • Select (highlight) ANY max by left-click or left-click-and-drag. Then right click on the highlighted variable.
       
       If you choose ``Print max'' (the 1st item in the drop down item), the value of max will be printed in the ``Debugger Console''.
     • If you select ``Display max'' (the 2nd item), the value gets displayed in the top, ``Data'' window. This is convenient when you are tracking how the values of variables are changing: the values get updated after executing each statement.
     • To get rid of the displayed value, right-click the box in the ``Data'' window, and select ``Undisplay'' (the last item). Or after highlighting it, press ``Undisp'' button in the bar below menu bar.
     • Instead of right-clicking, you can press the button ``Print'' or ``Display'' in the bar below the menu bar after highlighting a variable
     • Note that you can display or print de-referenced values of a pointer by ``Print *'' and ``Display *''. If you are pushing the button instead of right-click, you have to push and hold down the button for a second or so to get these options.
     • You can print and display the values of arrays. If you want to see all elements of an array, highlight the name of the array (i.e., without [ ] part).
  3. Press ``Next'' a couple times, and you will notice that the green arrow freezes at the line of function call UniqRandInt(). Hmmmm, maybe there is an infinite loop inside of this function.
  4. To get out from the infinite loop (interrupt the process), press the ``Interrupt'' button.
  5. Move the red ``Stop'' sign by clicking and dragging with left-mouse button. It should be next to UniqRandInt().
  6. Press ``Run'' button, again. This will restart the program.
  7. To move into a function, press ``Step''. But before doing it, check what values are getting passed to the function.
  8. Let's ``display'' values of cntr and r. And check if everything is working as intended. Did you find a bug?
  9. It is drwaing a random number, check if the random number is already in the array pointed by resultPtr. If the integer is not already in the array, the value get added.

     Hah, it never goes inside of the if statement. The first random number should be always new, so it should be added.

     We forgot ``!'' in front of MemberQ(): we want to add the value r if r is NOT already a member.

  10. We need to edit the source code. You can select ``Source->Edit Source...'' from the menu, and emacs should open. Add ``!'', save, and quit emacs. Note that the source code in ddd is updated. The correct source should look like:

         if (! MemberQ(resultPtr, cntr, r)) {
      

      Then go to the terminal and recompile.

      Alternatively, you can just open the source code with emacs from the terminal, and rund the ddd and emacs in parallel. In this case, you can select ``Source -> Reload Source''. Or if you recompile and ``run'' again, it will automatically load the edited source.

  11. Displaying contiguous memory pointed by a pointer
      
      • After the correction, run the program and step into UniqRandInt().
      • Highlight resultPtr by left-clicking.
      • Select ``Data -> Memory'' from the menu.
        
        The size of resultPtr is 3, but let's display 4 elements. Type ``4'' in the box after ``Examine''. Select ``decimal'' from the next box, and select ``words(4)'' from the next box. Then push ``Display''.

        You'll notice a new box in ``Display'' window. The first number starting with ``0x'' is value of the pointer (address in hexadecimal number), then you get the contents of the array elements.

        The first selectable box indicate what kind of data (decimal for integer, unsigned for unsigned integer and float for floating points).

        The 2nd box indicate the size of each element. If you look at the table which lists the range of variables, the column ``bytes required'' contains the value required for each type of variable. Integer variable uses 4 bytes in x86/linux, so we are selection ``words(4)''.

  12. Now keep stepping, and make sure the function is working as intended. After you are satisfied, you can go back to main() by pressing ``Next'' repeatedly or press ``Finish'', which will finish the function and the process goes back to the place where the function was called from.
  13. There is another bug, so find it.
• Additional Features:
  • Continue
    ``Cont'' button will resume the process (instead of moving step by step), and the program will run until it hits the next breakpoint (or until the program ends).
  • If you want to execute the program until a certain statement (without setting a breakpoint), you can right click the left end of a line (similar to setting the breakpoint), and select ``Continue until here''.

    Alternatively, after left-clicking the location, press and hold down ``Break'' button in the bar below menu bar. You can see this option.

  • conditional breakpoint: Useful when you want to run the program until certain conditions are met.

    Right click the red ``Stop'' sign, and select ``Properties''. Or double click the ``Stop'' sign. Then put a C logical expression in the ``Condition'' box.

    For the stop sign left of UniqRandInt(), you can put i > 2. When you run the program, the stop sign will be ignored until i become greater than 2.

  • Setting values of variables

    You can select a variable (or an array elements) by left-click, and push the button ``Set'': located at the right end of the bar below menu bar. In the pop up window, you can type in the value.

    Or use the ``Debugger Console'' and type in a set command
        set variable arr[i] = 4
    In this example, the current value of i will be used.