C Memory Management and Valgrind

C Tool Chain & Announcements

• Student Accessibility Services needs volunteer notetakers for class notes.
• Being a volunteer contributes to academic success for fellow students.
• The volunteer notetaking position requires a one-semester commitment.
• As a volunteer, notes are shared with students approved for notetaking services due to documented disabilities.
• More details can be found at uoguel.ph/notetaker

What is a "Tool Chain"?

• Software project development is inherently tied to the tools used, including languages, libraries, and additional software.
• A "tool chain" is the sequence of software tools converting source code into binary code
• The tool chain involves a sequence of tools, making it more complex than just a compiler

Lecture Overview

• C will be used for the "native" portion (A1-A2) of the course.
• Python/SQL will be used for the UI/database portion (A3).
• The first half of the course focuses on the Big Picture of tools used by C programmers, especially on *nix systems.
• Key aspects of the lecture:
  • Exposing all tools to view.
  • Revealing tools "hiding" inside others.
  • Understanding how they "chain" together.
  • Learning how to control them.
• A goal is to elevate understanding beyond ritualized mumbo-jumbo.

The Usual Suspects

• The "five amigos" in the C toolchain are: C Preprocessor, C Compiler, Linker, Loader, and Make.

IDE (Interactive Development Environment)

• IDEs manage tools "under the hood".
• IDEs abstract the complexities of the toolchain.
• Examples:
  • Windows: Visual Studio
  • macOS: Xcode
  • Multi-platform: Eclipse, IntelliJ, Codelite, CodeBlocks
• Different languages use different tool chains, although one IDE often supports multiple.

A Word on Compilers

• Multiple C compilers are available.
• Popular FOSS (free, open-source) compilers:
  • GNU Compiler Collection (GCC): widespread, available on many platforms, often pre-installed on Linux.
  • Clang: newer, an alternative to GCC, available on many platforms, installed on macOS with Xcode.
• GCC and Clang both implement C standards and offer custom extensions.
• The C compiler from GCC will primarily be used

The Big Picture: C Toolchain Components

• .c and .h files feed into the preprocessor (cpp*).
• cpp* outputs a .i file, which becomes the input for the C compiler (gcc*).
• gcc* generates an assembly file (.s), which the assembler (gas) turns into an object file (.o/.obj).
• The linker (ld*) combines object files with system libraries (.a/.lib) to produce an executable (prog.exe, a.out).
• The loader (ld.so) loads the executable into process memory at runtime for execution.
• Make automates this build-time data flow.

Creating Intermediate Files

• Intermediate files (.i, .s, .o) are not always generated by default.
• Creating .o files is sometimes required.
• Compile code with the -save-temps flag to see intermediate files.
• The .i and .s files are almost never needed.

C Preprocessor

• Primary function: interprets # directives in .h and .c files before compilation, producing an intermediate .i file.
• Common directives:
  • #include: merges header files.
  • #define: creates macros (with or without arguments), expanded through find-and-replace.
  • #ifdef, #if, #else, #endif: enables conditional compilation.
• Exception: #pragma directives are passed to the compiler and ignored if unrecognized.
• Note: Often abbreviated as "cpp", which can be confusing as "cpp" is also a file extension for C++ source files
• Note: "cpp" refers to a C preprocessor, not C++.

Prevent Multiple/Circular Includes

• Use the ".h pattern" to prevent issues.
• Inside the header file (headername.h):

#ifndef HEADERNAME_H
#define HEADERNAME_H
// body of .h file...
#endif

• This pattern defines HEADERNAME_H when the header is first included.
• If the header is included again, the file's contents are skipped.

Headers and Paths

• The #include directive has different syntax variants for different headers.
• #include <file>: for system header files.
  • Searches a standard list of system directories.
• #include "file": for header files of your own program.
  • Searches for file following these priorities:
    • The directory containing the current file.
    • "Quote" directories.
    • Standard directories (same as <file>).

Header and Path "Must Not's"

• Avoid including paths in the #include statement (e.g. #include "../includeDir/Parser.h") because code will no longer compile if and/or the header file moves to a different location.
• Instead, include only the file name (e.g. #include "Parser.h"), and allow the compiler toolchain to handle the paths.

Headers and Paths: -I Option

• Header file directories can be passed to the compiler using the -I option.
• Example: gcc -I../includeDir myFile.c.
• Paths specified with -I can be relative or absolute.
• You can pass multiple include directories:
• Example: gcc -I../includeDir -I/home/username/stuff/otherIncludeDir myFile.c

C Compiler

• Purpose: compiles C language source code (.i file) into assembly language (.s).
• Diagnoses language abuses, issues warnings and errors.
• Intermediate .i and .s files are normally deleted after assembly, unless the -save-temps option is used.
• The sample.c,.i,.s files are found in the GCC_intermediate_files.zip example posted on the course website (Week 1).
• Compile with gcc -save-temps test.c.

Assembler = [G]AS

• Function: converts assembly code (.s) from the compiler into object code (.o).
• This step is normally transparent.
• There are options for controlling it, but rare to use them.
• Assembly statements can be inserted into C programs for CPU vector instruction use.

Linker (Link Editor) = ld

• Function: stitches object files (.o) into a single binary program file i.e. executable or library.
• Includes .o files of the user program and references to system libraries.
• Linkers create static and dynamic libraries.
  • Static libraries (.a/.lib): inserted into the executable file.
  • Dynamic libraries (.so/.dll): linked at runtime.

What is the Linker Doing?

• Object files has tables with external references e.g. calls to "printf".
• Libraries are read to define external definitions.

Libraries - Static and Dynamic

• Static and dynamic libraries are two types of libraries.
• Difference in how definitions are linked: differently with code from "printf() function • Static linking: Definitions (function code + global variables) are pulled into the program file and fixes all refs to locations. • Dynamic linking: "Makes a note" of what the library file to pull code from at runtime.

Linking and Paths - Linking Libraries

• Linker automatically links standard "C" libraries(not "C" Math libraries)
• Libraries explicitly passed with the -l option.
  • Where 'm' standard math library for linker.

Paths - Giving Linker Library Path

The linker has to know where disk location "Binaries" are

• Default: Only looks in number directory (e.g. /usr/lib OR /usr/local/lib
• Important: It does NOT look in current director
• Solution: use -L flags

*I, -L And -1

• -I used for preprocessor to find headers
• -L tell linker where to find files
• -1 option links the library to look for a library

GCC Involvement

• GCC is a front end for {cpp, gcc, ld}.
• GCC calls those tools for you!
• GCC knows standard libraries
• Reason: makes *FLAGS portable

Loader Id.so

• Concern with create binary file from library
• "Command Shell" tells OS to execute program file
• OS opens fresh process > loads to "fill up" -> transfers in to regions into memory for process • Program instructions ("text" segment) • OS creates a new stack and an empty heap, then transfers control to first instruction of program

Loader = dlopen

• Using dynamic link library: ld.so will load program starts - but references/functions are fixed on demand
• Some use dlopen to load shared object

Loaders Note

• On Linux: check shared object use ldd
• Loader must know where shared libraries are run time
• Look for files in

Path for Loader

By default current directory is *not *included > shared libraries

Fix: Environment Variable "LD_LIBRARY_PATH."

• Export the lib: export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:. in .bashrc file
• Test with ls -a

Compiling List Library

• Assignment: Simple list library and Sample code

3 files:

• LinkedListAPI.c implement library LinkedListAPI.h - Header library

StructListDemo.c - demo executable with a list

Need:

• To run Example: Must Compile Library (further lecture) Can compile Demo
• The location of Library Headers + Binary File.

Compiling Pt 2

Makefile given

• NOTE: When creating link: Linker only know which library m and "SomeLibrary"

Fix Library Errors

If it can't compile - linker. Check for library to link it

Execute list demo

• Use the loader to look into current directory
• Check for the path Then "Programs execute correctly."

Makefiles Overview

• The make utility executes a sequence of commands from a description file.
• Typically used to create executables, but can also: remove files, report project status, package files, install files, and build libraries.
• ant in Java + Cmake but make is common

Makefiles: Relation to Compiler Toolchain

• make and Compiler Tollchain are separate entities.
• However: make is typically used automate code building + pass flags (compilations/library names etc) flags
• Understanding compiler: essential to use makefiles.

Make - The Vanilla Approach

• Multiple ways achieve same thing
• Programmers develop styles. Expose to others.
• Learn features never seen.
• Avoid "Magical Incantation" just to use it.
• Simple convention for readability
• Never use understand what you do. Bad Idea

Makefiles - Process Overview

• Examines Dependencies between files and date.
  • Attempts build if doesnt Exist.

Makefile entries

• Made Three things:
• Target, Prerequisites , Command line

Makefile Structure: Tab Notes

Command lines MUST Prefaced w/ Tabs.

• Pain if forgotten

Makefile "part1/2/3"

• Part1: Target -> what Makefile aims build
• Part2: Prerequisites : files must exit
• Part3: Command Like: Unix Command needed (with arguments.)

Invoking Make

• Type make at command

• Type make <target>

Common Targets

• Targets dont need to Files. Can be clean
  • "All Targets," and temporary files .o

Checking Commands

• Check with -n flags

Command Lines pt 2

• Use ; for multiple command line

Makefile Macros

Macros - AVOID typing long text. (paths,flags etc.)

• Defined with "="
• Reference using `$(LIBS), ${LIBS}

Sample Makefile pt.1 (1/3rd example with upper case)

Macro Naming Standard: Upper Case

CC = clang LIB = -Im /usr/local/lib -L. Ilmylib

prog: prog.c

This example can:

• Easily specify different compiler (instead of CLang)
• m or myLib. Include this
• Additonal library added: //user/local/lib"

Macros and More

Macros - String substitutions exist Macro CC - predefined as "Command CC" (Link to Unix "CC")

Macro LD - predefined as "Command ld"

• Can user without defined: replace with something

Macro Substituation

• Will change to O
• Reduce coding

Suffix Rules

• C file will use predefined macro command convert to Executable

Makefile Comments

• Begin with # and continue

Compiler Options + Flags

• Multiplatform Use make (cmmake)

Preprocessor Flags

• Preprocessor: CPPFLAGS =

• I include file_dir

This to avoid hardcoding relative or absolute paths into #include statements E.g. -I~/myproj/include Will add "~/myproj/include" to the include path, so all files in that directory can be included with a simple #include "filename.h" directive Other flags useful

• Dsymbol value Equivalent to #define symbol value

• DNDEBUG disable assertions

Compiler

Flags Compiler: CFLAGS = Save symbols for debugger Optimization level: 0,1,2,3

• Wall -std=c11

Linker Flags

Link Flag:

• Can use calltest examples

Create an output file with a specific name can be set

Code ORganziation for Library

Large c libraries often broken into libraries Headers into "include directory"

Public head -> in include, "other headers into "other directories" The source codes into src "directory." Binary files in more directories like \Bin, \libs or \externs.

Notes on Code conventions

Standard for Course:

• Code in \src
• Header Files in Include

Structure of Link API

• Macro shine.
• Use macro to define location Use these macros

List API

• Abstraction to store any data/type
• "Nodes links/pointers on Data" - links others nodes + pointers
• Structure contains "Function pointers."

Common List operation

• create a list insert a node at front/back remove a node from front/back

• retrieve an arbitrary node iterate through a list clear/delete list create a "humanly" redable

Iterating list

 - Step every data

For linked collections - use an iterator Create iterate -> traverse data collection

iterator

• Java example: iterate the elements
• c example: //Create an operator List iterate ltr =createiterate (let) Traverse list examine
• See structListDemo.cto

Libraries

• Use to develope many times! Reusable pre-compiled functions and ancillary data types
  • Example: "application programming interface." - interface user.
  • Made from all public componets of your library (functions,constants, data types).
  • "List API described is used libraary "StrutClustDemo.c

Public Design

• Deciding what makes up is like deciding on "public functions Class/Interface/Data struct"
• What does user want?

Private Design

• It IMPORTANT what is private That is what dont want "other programmers to see used". Hiding info - so user doesn mess stuff.

Libraries Practice

• Normally stored /ib + user.lib
• header.h contains contant One u would used Math.lib :

Static vs Dynamic

1/2 Libraries of two types static libraries are "compiles, code will copies + stores" that code in. Can compile dynamic libraries are " link together for to function. • Also known as shared libraries in the Unix/Linux world, dynamically linked libraries (DLLs) in

Static or dynamic

Dynamic library = "Flexible, non bloated" However, a lot more experience

Naming

• Libraries begin with lib File name libsample.so

Library Symbol

• Links used - Used multiple names to link
• Example: libabc3.8 or 3.8

dynamic library cont.

• Note: need creation of position independence
• Step create (PIC) - so it work where you want
• So it varies at run time

Done in 2 steps: "GCC + C/FP." See

Shared Library Cont.

• Need include headers w/ library Must include -1 (with -1)

using A library

The compile "step converted into object file" with compiler code The Link "step" links those Library Code

• Use /lxyz

Memory and Valgrind refresher

to modify a thing in a function, we must pass its address i.e. to pointer otherwise. we modified a copy Want change value "referere"

"What Modified in function is a copy of variable"

Modifying a function

Pass it to address Value of the pointer can modify a function/address Address of the pointer is double - you access "address on address"

• We call FUNCTION. Can say "allocate + pass ADD array"
• Note in Allocate; "p" point and set address

malloc

• Allocates bits and bytes of that memory "address start block" for the system to then return that value
• This assigns "p's value to the location on thing function
• Other function, now can call that address, or can call something
• Need extra memory location
• ALL function is there"

"to modify a thing in a function, we must pass its address otherwise we're modifying a copy"

ValGrind Note

Create -> and "recommend" : Card* tmp = malloc End - you can modify thng obj "Address is there!"

Valgrind

• Tool check for memory leaks"
• It needs/only run on "Unix/Linux on Ubuntu shell. Or Mac's < then OS"
• Use "-n" flag to what execute and look with HEAP SUMMARY .ERROR

Tool Check Pt 2

• Also check + make "code compile and run!" - but "slow"
• Note from "Valgrind"
• "Fix + check" You are going to fix that issues
• Otherwise, never see this at all

Look into this at https://valghrind/org

ValOutput pt 2

Shows value before calling free So...

• We NEED allocate double points - not pointers for it to operate right!"

Valgrind output memory error

• Valrgind with "Memory error + Mallac" Error shows + says, "Your malloc call did NOT allocate enough memory"
• Error: the malloc is " too small + can't store it right"

Reminders

Function will use and "ONLY FREE IT," after "you finish sing it"

Scoping

• Variables + how control

• Note 4 types.

• Program -> visible. • E.g. Variables declared within a method are only visible within that method (local scope)

• Class will determine " Alive.""

• *Access * -> who has access visible

Access

• Most are access functions/ Methods Java 4 types: public private protected.
• Class var = class scope. Visibly data struct in code Make code inaccessible."
• Example: "private"
• C has NOT ACCESS

types scope

There are 4 types of scope: • "Program" scope • "Function" scope • "File" scope • "Block" scope

Scope Cont.

1. You narrowest
2. Rereading

Quiz on C memory management, pointers, and Valgrind. Covers double pointers, memory allocation, using -g flag with Valgrind, and interpreting Valgrind's "still reachable" reports. Explores memory debugging and custom memory allocators.