How to Build Both Release and Debug Versions of a C Application Using Makefile

Описание: Learn how to modify your C Makefile to produce both `release` and `debug` builds of your application and resolve common issues encountered.
---
This video is based on the question https://stackoverflow.com/q/63127485/ asked by the user 'batuman' ( https://stackoverflow.com/u/2467772/ ) and on the answer https://stackoverflow.com/a/63128075/ provided by the user 'the busybee' ( https://stackoverflow.com/u/11294831/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Build c program for release and build

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
A Guide to Building Both Release and Debug Versions of a C Program

When developing C applications, it's common to require both Release and Debug builds for various reasons, such as optimizing performance for production or debugging issues during development. If you're facing challenges in configuring your Makefile to achieve this goal, you're in the right place! In this post, we'll walk you through the process of effectively building both versions of a C application using a Makefile.

Understanding the Problem

You may have an original Makefile that builds a release version of your application, but you want to extend this to support a debug version as well. The initial configuration only helps you compile the application as deepstream-app, while we also want to create a second binary, deepstream-app-debug, for debugging purposes without altering the existing build process significantly.

Solution Overview

The solution to this challenge involves a few simple modifications to your Makefile. Here’s a breakdown of how to adapt your existing setup to build both release and debug versions.

Step 1: Add a Debug Target

To ensure your Makefile builds both applications, you need to include an entry for DEBUGAPP in your all target. This tells the build system to consider both applications when the make command is initially run. Here’s how you can modify your all target:

[[See Video to Reveal this Text or Code Snippet]]

Step 2: Define Compilation for Debug Version

You will also need to specify how the debug version will be compiled. This typically involves using the -g flag with the compiler, which includes debugging information in the binary. Here’s how to separate the compilation rules for both applications:

[[See Video to Reveal this Text or Code Snippet]]

Step 3: Compile Object Files Differently

In some cases, you might also want the object files to be created differently depending on whether you are building for release or debug. This is achieved by introducing appropriate flags in your %.o rule. You can keep the existing build command while adding a debug one as follows:

[[See Video to Reveal this Text or Code Snippet]]

However, in the updated version, just the debug one will be invoked whenever you run the build for the debug target.

Step 4: Clean Up Build Artifacts

Don't forget to update your clean target to remove the debug application when cleaning up build artifacts:

[[See Video to Reveal this Text or Code Snippet]]

Final Touches: Building Your Applications

After you’ve made these modifications, you can now build both versions of your application simply by running:

[[See Video to Reveal this Text or Code Snippet]]

This command will compile both deepstream-app and deepstream-app-debug accordingly. If you only want to build the debug version, you can use:

[[See Video to Reveal this Text or Code Snippet]]

Conclusion

By following the above steps, you'll transform your Makefile into a capable build system for both release and debug versions of your C application. This flexibility is crucial in software development, allowing for better debugging and performance during various phases of the project lifecycle. With these tools at your disposal, you can optimize your coding workflow and improve debugging efficiency.

Feel free to leave your thoughts or any questions below! Happy coding!