C Programming

Benefits and Demonstration of GCC –G Flag

The GCC is handy in compiling different source codes when coding. There are different flags that you can use when working with GCC such as the -g flag. Executing the compilation command with a given flag is ideal for specifying what output you expect from the code. This post focuses on the GCC -g flag. We will understand what the GCC -g flag is, its benefits, and the demonstration of the GCC -g flag using realistic examples. Read on!

What Is the GCC -G Flag

Code compilation also involves debugging errors that may occur within your program. You could have a case where you want to get a debugging information about your code. In that case, you must work with the GCC -g flag.

The option will help you generate additional debugging information as you compile your code, such that you will have an easier time debugging the code. As a developer, the -g flag is handy in letting you understand your code and easily debug it. It works with the following syntax:

gcc -g -o output-file input-program


The output file is the name of the compiled program, while the input program is the target code that you want to compile.

Benefits and Demonstration of the GCC -G Flag

Developers do lots of code debugging to ensure it runs as expected. Debugging is crucial in identifying and fixing issues. The GCC -g flag offers numerous benefits in allowing the developers to work smoothly with their programs.

The following are the different benefits it offers:

1. Producing Stack Trace

Stack trace refers to a report of the active stack frames that occur during the execution of a program. When your program crashes, you will get the stack traces of the different points in your program where the code breaks to identify where the error occurred and how to best fix it. The stack trace also highlights the order in which the program’s state was when the error occurred. Thus, you will easily identify the sequence of events before the error occurred and how to fix it.

2. Variable Inspection

The debugging information that comes with adding the -g flag helps inspect the values of your variables in your program at runtime. You can check what state the variables are in during runtime. Hence, you can easily understand the program’s behaviour before the error at different points.

3. Symbolic Information

When you add the -g flag, you will get the symbolic information that links the source code with the compiled binary. The symbolic information includes things like line numbers and variable names. That way, you can easily map the program’s execution with its original code which makes it easy to analyze and debug.

4. Conditional Breakpoints

Working with a debugger like GDB relies on the debugging information that you generate with the -g flag to create temporary breakpoints in your source code. These breakpoints help the developers to define the conditions or sections in the program when the program should halt. Thus, you can easily debug the code by setting the breakpoints to examine which section is causing an error in your code. Analyzing a program using its breakpoints is easier than checking the entire code.

Knowing the benefits of the GCC -g flag, it’s time to demonstrate how you can utilize it to simplify your debugging. Here, we are working with a Csource file named “linuxhint.c”.

Let’s compile it using the GCC -g flag with the following command:

gcc -g -o demo1 linuxhint.c


By adding the -g flag, you will get a binary file which contains the information and one that you can use with your debugger. We named our generated binary file as “demo1”. Let’s go ahead and give examples of using it with the GNU Debugger (GNU Debugger).

Run the debugger as illustrated in the following image:

The GNU will open and you can interact with it in debugging. For instance, in the following example, we set our breakpoint as 15. Then, we ran the program with the breakpoint and examined the various variables in the program.

Thanks to using the GCC -g flag, we can easily understand and work with the debugger if we have specific debugging information. That’s how you use the GCC -g flag.


The GCC -g flag is handy in generating the debugging information that you can use to analyze and debug your program. We explained the benefits of the GCC -g flag and provided an example to understand how to use it when compiling your program and when working with a debugger.

About the author

Denis Kariuki

Denis is a Computer Scientist with a passion for Networking and Cyber Security. I love the terminal, and using Linux is a hobby. I am passionate about sharing tips and ideas about Linux and computing.