<!--
Abstract:

CS 211
Computer Architecture
Lecture 04: Memory and Variable Size Arrays
-->

# CS 211 - Lecture 05 - Headers, Makefiles, and debugging

Bernhard Firner

2025-09-16

---

## Review!

* Dynamic memory allocation
* Heap Vs Stack memory
* Turning sieve into a library

---

## `malloc`, `calloc`, and `free`

* `Dynamically allocate` memory on the `heap`
  * This memory does *not* go out of scope
* In `stdlib.h`
  * Read the `man` pages
* Joined by `realloc` and `reallocarray`
  * Which you should avoid unless you know what you are doing

```C
void *malloc(size_t size);
void free(void *_Nullable ptr);
void *calloc(size_t nmemb, size_t size);
```

---

## `malloc`

```C
void *malloc(size_t size);
void *calloc(size_t nmemb, size_t size);
```

* `malloc` allocates `size` bytes
  * You need to do the math
  * Memory is not initialized
* `calloc` allocates `nmemb*size` bytes
  * Also sets it to 0
* Both return (void*), so you must assign the type correctly

---

## Failure

* Calloc and malloc can fail!!!!
  * Return `NULL`
  * Set `errno`

---

## `free`

```C
void free(void *_Nullable ptr);
```

* Gives the memory back
  * Basically, tells the OS that you are done with it

---

## `free` Rules

```C
void free(void *_Nullable ptr);
```

* Only call `free` on memory that you allocate
  * e.g. from `malloc` and `calloc`
* Don't call it on the same memory twice
  * Your program will crash if you are lucky
* A lot of pointer documentation mentions "undefined behavior"
  * Just means that anything could happen

---

## Stack Vs Heap Memory

* Need to set aside memory for functions, etc, free from user memory
* Solution:
  * Function memory grows on the `stack`
  * User allocated memory grows on the `heap`
* In x86 (architecture we use)
    * Stack decreases from the top
    * Heap increases from the bottom

</div>
<div>

<table>
<tr><td>Higher</td><td><b>stack</b></td></tr>
<tr><td></td><td>$\big\downarrow$</td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td></td></tr>
<tr><td></td><td>$\big\uparrow$</td></tr>
<tr><td>Lower</td><td><b>heap</b></td></tr>
</table>

</div>
</div>

---

## Example

```C
/*
 * Stack Vs Heap example
 */

#include <stdio.h>
#include <stdlib.h>

void a() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("a stack memory is %p\n", stack_memory);
    printf("a heap memory is %p\n", heap_memory);
    free(heap_memory);

return;
}

void b() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("b stack memory is %p\n", stack_memory);
    printf("b heap memory is %p\n", heap_memory);

a();

free(heap_memory);

return;
}

void c() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("c stack memory is %p\n", stack_memory);
    printf("c heap memory is %p\n", heap_memory);

b();

free(heap_memory);

return;
}

void d() {
    unsigned char stack_memory[16];
    unsigned char *heap_memory = calloc(16, sizeof(unsigned char));

printf("d stack memory is %p\n", stack_memory);
    printf("d heap memory is %p\n", heap_memory);

c();

free(heap_memory);

return;
}

int main(void) {
    d();
    return 0;
}
```

---

## Example Output

* Example values not guaranteed, direction is consistent

<pre>
$ ./a.out
d stack memory is 0x7ffc2eceb250
d heap memory is 0x55d2ddab12a0
c stack memory is 0x7ffc2eceb210
c heap memory is 0x55d2ddab16d0
b stack memory is 0x7ffc2eceb1d0
b heap memory is 0x55d2ddab16f0
a stack memory is 0x7ffc2eceb190
a heap memory is 0x55d2ddab1710
</pre>

---

## Unwinding

* When a function returns, its memory is released
  * Called unwinding because functions call functions call functions...
* Fast, efficient, and automatic
  * `Stack memory is a last in, first out stack`
  * Each function's memory is "on top of" the last one
    * We can unwind without checking anything but the current function
* In our example, `a` unwinds first, then `b`, `c`, `d`, and `main`

---

## Stack Overflows

* If you call enough functions, and they use enough memory, you can run out
* This is called a `stack overflow`
* Think of the `stack` as an array of fixed size that the compiler sets aside
  * Normally sufficient
  * Strange function calling patterns will cause problems

---

## Our sieve

```C
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

unsigned long* sieve(size_t max, size_t *size) {
    bool maybe_prime[max];
    memset(maybe_prime, true, max-3);
    maybe_prime[0] = false;
    maybe_prime[1] = false;

size[0] = 0;
    for (int i = 2; i < max; ++i) {
        // Mark multiples as not prime
        // Go through every multiple of i, starting with 2*i
        // Then 2*i+i, 3*i+i, etc
        if (maybe_prime[i]) {
            size[0] += 1;
            for (int j = 2*i; j < max; j += i) {
                maybe_prime[j] = false;
            }
        }
    }

// Allocate memory for all of the primes
    unsigned long* primes = calloc(*size, sizeof(unsigned long));
    unsigned long* cur_prime = primes;
    int index = 0;
    for (int i = 0; i < max; ++i) {
        if (maybe_prime[i]) {
            // V 1
            //primes[index] = i;
            //++index;
            // V 2
            //*(primes + index) = i;
            //++index;
            // V 3
            //*cur_prime = i;
            //++index;
            //cur_prime = primes + index;
            // V 4
            *cur_prime = i;
            ++cur_prime;
        }
    }
    return primes;
}

int main(int argc, char** argv) {
    if (argc < 2) {
        printf("Give me an argument!\n");
        return 1;
    }
    size_t max = atoi(argv[1]);
    if (max < 3) {
        printf("Give me a larger number!\n");
        return 1;
    }

size_t num_primes = 0;
    unsigned long* primes = sieve(max, &num_primes);

for (int i = 0; i < num_primes; ++i) {
        printf("%lu is prime.\n", primes[i]);
    }
    free(primes);
    return 0;
}
```

---

## Iterating vs Indexing

```C
// Allocate memory for all of the primes
unsigned long* primes = calloc(*size, sizeof(unsigned long));
unsigned long* cur_prime = primes;
int index = 0;
for (int i = 0; i < max; ++i) {
    if (maybe_prime[i]) {
        // V 1
        //primes[index] = i;
        //++index;
        // V 2
        //*(primes + index) = i;
        //++index;
        // V 3
        //*cur_prime = i;
        //++index;
        //cur_prime = primes + index;
        // V 4
        *cur_prime = i;
        ++cur_prime;
    }
}
```

---

## Modular Code

* Everyone likes `modular`, `reusable` code
  * Libraries of functions like `<stdlib.h>`
* So let's make our sieve function into a library

---

## Header files

* Notice that the file we include ends in `.h`
  * `h` stands for `header`
* Declares things variables and functions
  * [declaration syntax](https://cppreference.com/w/c/language/declarations.html)

---

## sieve header file

* Make a file named `sieve.h`

```C
/*
 * This header file declares the sieve function.
 */

unsigned long* sieve(size_t max, size_t *size);
```

---

## Header file usage

* Header files may be included in multiple other files
* C allows you to declare the same things multiple times
  * But no conflicting declarations!
  * So we will have to put values and implementations elsewhere

---

## Using sieve.h

```C
#include <stdio.h>  // For printf
#include <stddef.h> // For size_t
#include <stdlib.h> // For free

// Include sieve.h after the standard library includes
// Use quotes instead of angle brackets
#include "sieve.h"

size_t num_primes = 0;
    unsigned long* primes = sieve(max, &num_primes);

for (int i = 0; i < num_primes; ++i) {
        printf("%lu is prime.\n", primes[i]);
    }
    free(primes);
    return 0;
}
```

---

## \#include syntax

* Notice that we now use quotes instead of <>
  * #include "sieve.h"
  * #include <stdio.h>
* This changes where gcc searches for the file
  * Quotes checks the current directory
  * Angle brackets check system paths

-v-

## Search path

* If you are curious, you can get gcc to spit out its search paths with a dummy compile command

```
bfirner@ilab3:~$ gcc -xc -E -v /dev/null
Using built-in specs.
COLLECT_GCC=gcc
OFFLOAD_TARGET_NAMES=nvptx-none:amdgcn-amdhsa
OFFLOAD_TARGET_DEFAULT=1
Target: x86_64-linux-gnu
Configured with: ../src/configure -v --with-pkgversion='Ubuntu 13.3.0-6ubuntu2~24.04' --with-bugurl=file:///usr/share/doc/gcc-13/README.Bugs --enable-languages=c,ada,c++,go,d,fortran,objc,obj-c++,m2 --prefix=/usr --with-gcc-major-version-only --program-suffix=-13 --program-prefix=x86_64-linux-gnu- --enable-shared --enable-linker-build-id --libexecdir=/usr/libexec --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --enable-bootstrap --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-libstdcxx-backtrace --enable-gnu-unique-object --disable-vtable-verify --enable-plugin --enable-default-pie --with-system-zlib --enable-libphobos-checking=release --with-target-system-zlib=auto --enable-objc-gc=auto --enable-multiarch --disable-werror --enable-cet --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-offload-targets=nvptx-none=/build/gcc-13-fG75Ri/gcc-13-13.3.0/debian/tmp-nvptx/usr,amdgcn-amdhsa=/build/gcc-13-fG75Ri/gcc-13-13.3.0/debian/tmp-gcn/usr --enable-offload-defaulted --without-cuda-driver --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu --with-build-config=bootstrap-lto-lean --enable-link-serialization=2
Thread model: posix
Supported LTO compression algorithms: zlib zstd
gcc version 13.3.0 (Ubuntu 13.3.0-6ubuntu2~24.04)
COLLECT_GCC_OPTIONS='-E' '-v' '-mtune=generic' '-march=x86-64'
 /usr/libexec/gcc/x86_64-linux-gnu/13/cc1 -E -quiet -v -imultiarch x86_64-linux-gnu - -mtune=generic -march=x86-64 -fasynchronous-unwind-tables -fstack-protector-strong -Wformat -Wformat-security -fstack-clash-protection -fcf-protection -dumpbase -
ignoring nonexistent directory "/usr/local/include/x86_64-linux-gnu"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/include-fixed/x86_64-linux-gnu"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/include-fixed"
ignoring nonexistent directory "/usr/lib/gcc/x86_64-linux-gnu/13/../../../../x86_64-linux-gnu/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-linux-gnu/13/include
 /usr/local/include
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.
# 0 "<stdin>"
# 0 "<built-in>"
# 0 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 0 "<command-line>" 2
# 1 "<stdin>"
COMPILER_PATH=/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/13/:/usr/libexec/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/
LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/13/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/13/../../../:/lib/:/usr/lib/
COLLECT_GCC_OPTIONS='-E' '-v' '-mtune=generic' '-march=x86-64'
```

-v-

## Results

* Quotes only search current directory
* Angle brackets search a few directories

<pre>
#include "..." search starts here:
#include <...> search starts here:
 /usr/lib/gcc/x86_64-linux-gnu/13/include
 /usr/local/include
 /usr/include/x86_64-linux-gnu
 /usr/include
</pre>

---

## Using the sieve

* If you try to compile now, things won't quite work

<pre>
$ gcc using_sieve.c
/usr/bin/ld: /tmp/ccquSqAu.o: in function `main':
using_sieve.c:(.text+0x8e): undefined reference to `sieve'
collect2: error: ld returned 1 exit status
</pre>

* We need to compile the actual sieve code, from sieve.c

---

## sieve.c

```C
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>

unsigned long* sieve(size_t max, size_t *size) {
    bool maybe_prime[max];
    memset(maybe_prime, true, max-3);
    maybe_prime[0] = false;
    maybe_prime[1] = false;

---

## Long and short ways

* In short, `gcc using_sieve.c sieve.c -o sieve`
* But that isn't how it's usually done
  * You aren't compiling the stdlib code, for example

---

## Long way

* First, compile your code with `-c`
  * `gcc -c using_sieve.c -o using_sieve.o`
* Be careful with output filenames (-o) that you don't overwrite a code file
* The output (sieve.o) is an object file
  * It cannot run on its own because it is missing pieces
  * Need the code from `sieve.c`

---

## More object files

* Build the object file for `sieve.c`
  * `gcc -c sieve.c -o sieve.o`

---

## Linking

* Now `gcc` can link the object files
  * `gcc sieve.o using_sieve.o -o sieve_example`
* Linking combines the memory and functions of multiple pieces of code together

---

## Why?

* Some of the programs you link to are very large
* Recompiling all of them for your <100 lines of code would be a waste of time
* Doing all of this manually is a pain though, so most people use `make files`
* Rules placed into a file named `makefile`

---

## Makefile aside

* These will *simplify* your lives
* Never going to test you on the syntax, just explaining it
* Feel free to copy and paste the examples
* [makefiletutorial.com](https://makefiletutorial.com) has a fuller explanation

---

## Make example

```Makefile
# Any filename that ends in .o is made with the command gcc <filename.c> -o <filename.o>
# $@ is the list of targets (the thing before the colon)
# $^ is the list of dependencies (the things after the colon)
%.o: %.c
	gcc -c $^ -o $@

# The sieve_example program depends upon both using_sieve.o and sieve.o
# $^ expands to 'using_sieve.o sieve.o'
# $@ expands to 'sieve_example'
sieve_example: using_sieve.o sieve.o
	gcc $^ -o $@
```

---

## Building

<pre>
$ make sieve_example
gcc using_sieve.o sieve.o -o sieve_example
</pre>

* If you try to build it again without modifying any files

<pre>
$ make sieve_example
make: 'sieve_example' is up to date.
</pre>

* Make only rebuilds targets with updated dependencies
  * Helpful in giant software projects

---

## Compiler Flags

* One reason to use makefiles is to keep track of compiler flags
  * `-Wall` to turn all possible warnings
  * `-O2` to turn on optimization level 2
    * Speed optimizations that will not compromise program size
  * `-O3` to turn on optimization level 3
    * Which may compromise program size for speed
  * `-g` debug symbols

---

## Debugging

* Let's talk about debugging
* You binary executables may run into errors
  * Usually ends in program termination
* What if you want to find out what went wrong?
* The `-g` flag tells the compiler to leave information in the binary file
  * Associates compiled code to its source

---

## Current makefile

```makefile
# Compile anything with debug flags (-g)
debug_%.o: %.c
	gcc -g -c $^ -o $@

# Compile anything with debug flags
debug_%: debug_%.o
	gcc -g $^ -o $@

# Any filename that ends in .o is made with the command gcc <filename.c> -o <filename.o>
# $@ is the list of targets (the thing before the colon)
# $^ is the list of dependencies (the things after the colon)
%.o: %.c
	gcc -c $^ -o $@

# Compiles directly to a target.
%: %.c
	gcc $^ -o $@

# The sieve_example program depends upon both using_sieve.o and sieve.o
# $^ expands to 'using_sieve.o sieve.o'
# $@ expands to 'sieve_example'
sieve_example: using_sieve.o sieve.o
	gcc $^ -o $@

debug_sieve_example: debug_using_sieve.o debug_sieve.o
	gcc $^ -o $@
```

---

## gdb

* `gdb` (the gnu debugger) is a tool (like `gcc`)
* Launch a program through gdb to debug it:

<pre>
bfirner@ilab3:~/examples$ make debug_sieve_example
gcc debug_using_sieve.o debug_sieve.o -o debug_sieve_example
bfirner@ilab3:~/examples$ gdb debug_sieve_example
GNU gdb (Ubuntu 15.0.50.20240403-0ubuntu1) 15.0.50.20240403-git
Copyright (C) 2024 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later http://gnu.org/licenses/gpl.html;
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
https://www.gnu.org/software/gdb/bugs/.
Find the GDB manual and other documentation resources online at:
    http://www.gnu.org/software/gdb/documentation/.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from debug_sieve_example...
(gdb)
</pre>

---

## Now What?

* `gdb` has a `help` command
* To run you program, use `run <arguments>`

---

## Example

<pre>
(gdb) run 10
Starting program: /common/home/bfirner/examples/debug_sieve_example 10
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
2 is prime.
3 is prime.
5 is prime.
[Inferior 1 (process 3037633) exited normally]
</pre>

---

## Breakpoints

* Let's examine that iteration code

---

## sieve.c

```C[]
#include <stdbool.h>
#include <string.h>
#include <stdlib.h>

unsigned long* sieve(size_t max, size_t *size) {
    bool maybe_prime[max];
    memset(maybe_prime, true, max-3);
    maybe_prime[0] = false;
    maybe_prime[1] = false;

---

## Setting a breakpoint

<pre>
(gdb) break sieve.c:25
Breakpoint 1 at 0x555555555458: file sieve.c, line 25.
(gdb) run 10
Starting program: /common/home/bfirner/examples/debug_sieve_example 10
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".

Breakpoint 1, sieve (max=10, size=0x7fffffffe0e0) at sieve.c:25
25	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
(gdb)
</pre>

---

## Inspection

* You can now inspect values

<pre>
(gdb) print primes
$1 = (unsigned long *) 0x555555557d90
(gdb) print primes %p
No symbol "p" in current context.
(gdb) print size
$2 = (size_t *) 0x7fffffffe0e0
(gdb) print primes
$3 = (unsigned long *) 0x555555557d90
(gdb) print *primes
$4 = 93824992235968
(gdb) print primes[0]
$5 = 93824992235968
(gdb) print max
$6 = 10
(gdb) print *size
$7 = 3
</pre>

---

## Stepping

* `primes` isn't actually set yet
  * The breakpoint stop at the line of code, before it's happened
* We can advance by one line with the `step` command

---

## Stepping

<pre>
(gdb) step
__libc_calloc (n=3, elem_size=8) at ./malloc/malloc.c:3699
warning: 3699	./malloc/malloc.c: No such file or directory
(gdb) step
3709	in ./malloc/malloc.c
</pre>

* These steps are too small!
* And we don't have debugging symbols in malloc.c!
* Use `finish` to get out
* Or continue to let the program run

<pre>
(gdb) finish
Run till exit from #0  __libc_calloc (n=3, elem_size=8) at ./malloc/malloc.c:3709
0x000055555555546c in sieve (max=10, size=0x7fffffffe0e0) at sieve.c:25
25	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
Value returned is $8 = (void *) 0x5555555592a0
</pre>

---

## Examination

* You can see what functions have been called with `bt` (for backtrace)

<pre>
(gdb) bt
#0  sieve (max=10, size=0x7fffffffe0e0) at sieve.c:28
#1  0x000055555555529b in main (argc=2, argv=0x7fffffffe228) at using_sieve.c:21
</pre>

* Not very deep
* `frame` will print your current line

---

## Going up and down

* `up` and `down` go up and down the call list

Breakpoint 1, sieve (max=10, size=0x7fffffffe0e0) at sieve.c:25
25	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
(gdb) up
#1  0x000055555555529b in main (argc=2, argv=0x7fffffffe228) at using_sieve.c:21
21	    unsigned long* primes = sieve(max, &num_primes);
(gdb) up
Initial frame selected; you cannot go up.
(gdb) down
#0  sieve (max=10, size=0x7fffffffe0e0) at sieve.c:25
25	    unsigned long* primes = calloc(*size, sizeof(unsigned long));
(gdb) down
Bottom (innermost) frame selected; you cannot go down.
(gdb) up
#1  0x000055555555529b in main (argc=2, argv=0x7fffffffe228) at using_sieve.c:21
21	    unsigned long* primes = sieve(max, &num_primes);
(gdb) print max
$21 = 10
(gdb) print num_primes
$22 = 3
(gdb) print *num_primes
Cannot access memory at address 0x3
(gdb) print &num_primes
$23 = (size_t *) 0x7fffffffe0e0
</pre>

---

## Debugging

* Using gdb is far better than printing out variables and hoping to catch your error
* Using a makefile makes it simpler to set different flags
  * Also reduces the chance of a typo deleting your files

---

## Valgrind

* Another tool for error checking is `valgrind`
  * Searches for memory errors
* Not all-knowing

---

<pre>
bfirner@ilab3:~/examples$ valgrind ./debug_sieve_example 10
==3064832== Memcheck, a memory error detector
==3064832== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==3064832== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==3064832== Command: ./debug_sieve_example 10
==3064832== 
==3064832== Conditional jump or move depends on uninitialised value(s)
==3064832==    at 0x10940D: sieve (sieve.c:16)
==3064832==    by 0x10929A: main (using_sieve.c:21)
==3064832== 
==3064832== Conditional jump or move depends on uninitialised value(s)
==3064832==    at 0x109497: sieve (sieve.c:29)
==3064832==    by 0x10929A: main (using_sieve.c:21)
==3064832== 
2 is prime.
3 is prime.
5 is prime.
7 is prime.
==3064832== 
==3064832== HEAP SUMMARY:
==3064832==     in use at exit: 0 bytes in 0 blocks
==3064832==   total heap usage: 2 allocs, 2 frees, 1,056 bytes allocated
==3064832== 
==3064832== All heap blocks were freed -- no leaks are possible
==3064832== 
==3064832== Use --track-origins=yes to see where uninitialised values come from
==3064832== For lists of detected and suppressed errors, rerun with: -s
==3064832== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0)
</pre>

---

## Desired change

```C[|7]
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

unsigned long* sieve(size_t max, size_t *size) {
    bool maybe_prime[max] = {};
    memset(maybe_prime, true, max-3);
    maybe_prime[0] = false;
    maybe_prime[1] = false;

size_t num_primes = 0;
    unsigned long* primes = sieve(max, &num_primes);

for (int i = 0; i < num_primes; ++i) {
        printf("%lu is prime.\n", primes[i]);
    }
    free(primes);
    return 0;
}
```

---

## Happy valgrind

<pre>
bfirner@ilab3:~/examples$ valgrind ./debug_sieve_example 10
==3068134== Memcheck, a memory error detector
==3068134== Copyright (C) 2002-2022, and GNU GPL'd, by Julian Seward et al.
==3068134== Using Valgrind-3.22.0 and LibVEX; rerun with -h for copyright info
==3068134== Command: ./debug_sieve_example 10
==3068134== 
2 is prime.
3 is prime.
5 is prime.
==3068134== 
==3068134== HEAP SUMMARY:
==3068134==     in use at exit: 0 bytes in 0 blocks
==3068134==   total heap usage: 2 allocs, 2 frees, 1,048 bytes allocated
==3068134== 
==3068134== All heap blocks were freed -- no leaks are possible
==3068134== 
==3068134== For lists of detected and suppressed errors, rerun with: -s
==3068134== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
</pre>

---

## Next topics

* In C
  * File I/O
  * Structs