MinGW installation

From CodeBlocks
Revision as of 05:18, 26 December 2015 by Headkase (Talk | contribs) (Exceptions: DW2 (Dwarf), setjmp/longjmp, SEH)

Jump to: navigation, search


A compiler suite is what Code::Blocks uses to turn the code you type into it into numbers that the computer understands. As a compiler is a very complex undertaking it is not part of Code::Blocks itself but rather is a separate project that Code::Blocks then uses. The specific compiler toolchain talked about in this page is a "MinGW" compiler. That means "Minimalist GCC for Windows." And "GCC" expands to "GNU Compiler Collection." There are many MinGW-based compiler suites, on this page we will concentrate on TDM-GCC.

GCC Compiler Toolchain Features

Various GCC compilers for Windows come with different features and which flavor of the compiler you end up choosing should reflect your specific needs.

Threads: Win32, Posix

There are two major threading models to choose from:

  • win32 threads will not give you C++11 multithreading features.
  • posix threads enable C++11 multithreading features. It will make your resulting executable depend on your compiler's libwinpthreads included Dynamic Link Library. As a result you will have to distribute that library with your executable. If you want to use standard C++11 threading then choose posix.

Using one threading model or the other is not mutually exclusive, you can directly call each others API regardless of which model your compiler uses.

Exceptions: DW2 (Dwarf), setjmp/longjmp, SEH

There are three major exception models to choose from:

  • DW2 (DWARF-2) EH, which requires the use of DWARF-2 (or DWARF-3) debugging information. DW-2 EH can cause executables to be slightly bloated because large call stack unwinding tables have to be included in the executables. The Dwarf-2 EH implementation for Windows is not designed at all to work under 64-bit Windows applications. In win32 mode, the exception unwind handler cannot propagate through non-dw2 aware code, this means that any exception going through any non-dw2 aware "foreign frames" code will fail, including Windows system DLLs and DLLs built with Visual Studio. Dwarf-2 unwinding code in gcc inspects the x86 unwinding assembly and is unable to proceed without other dwarf-2 unwind information.
  • A method based on setjmp/longjmp (SJLJ). SJLJ-based EH is much slower than DW2 EH (penalising even normal execution when no exceptions are thrown), but can work across code that has not been compiled with GCC or that does not have call-stack unwinding information.
  • SEH exceptions, unlike SJLJ, have zero overhead penalty but only available on 64-bit compilers and not 32-bit ones because of a software patent. The software patent applies specifically to 32-bit compilers, not 64-bit ones, so SEH is only available royalty-free with a 64-bit compiler. SEH exceptions are both fast and can travel through Windows APIs/code. If you are developing with a 64-bit compiler then you should use SEH.


The fastest way to set up a working compiler is to install a recent GCC release targeting the MinGW compiler system from TDM-GCC. The Code::Blocks team recommends TDM builds of MinGW.


Download the on-demand installer and run it.

Go through the installation pages, the red arrows are all the default options which we will be keeping and the last blue arrow is to indicate that you will be putting TDM-GCC into your system's PATH.

TDM Create.png TDM Arch.png

TDM Inst Dir.png TDM Inst Options.png

For most MinGW-based compiler suites, having your toolchain in your PATH is important because it means that during development the compiler libraries will be accessible by default to your programs as you develop them and also makes it easier to use utilities such as CMake as they will be able to find your compiler toolchain. When you actually distribute your programs to other computers then you will copy the needed Dynamic Link Libraries out of your toolchain folder and include them as part of your installer. On your machine they are in your PATH so you always have them, on your users computers the won't have the compiler toolchain so there you provide the .dll files with your program.

TDM-GCC does not strictly follow the preceding however, it tends to statically link the required libraries into your final executable. Which means that when you create your installer for your final program there are less files to include - they are built into your executable itself.

Once you are ready, click Install to proceed.

Code::Blocks Configuration

Go to your Compiler settings:

Compiler Settings.png

And then under the "Toolchain executables" tab (red arrow), click on the ellipsis ("...", blue arrow) and choose the root directory where you installed TDM-GCC 32-bit. Once you have that directory chosen, in the "Program Files" sub-tab (green arrow) area fill out the fields as shown. If you choose the blue arrow ellipsis first then for each ellipsis you click on under "Program Files" you will already be in your TDM-GCC bin folder where the actual programs are.

CB TDM Toolchain.png

Now, go to your Debugger settings:

Settings Debugger.png

Choose your default debugger (red arrow), and then fill in the Executable path for it as shown for TDM-GCC 32-bit (blue arrow).

Debugger Default.png


You now have a Code::Blocks environment that is configured to use TDM-GCC 32-bit properly. Using this guide as a template you can easily set up alternative compilers no matter the source - just follow the same basic procedure.

Alternative MinGW Compilers

MinGW package From Equation

MinGW-Builds ➡ In, "Toolchains targeting Win32 or Win64," ➡ "Personal Builds," ➡ "mingw-builds," ➡ Version, ➡ Threading Model, ➡ Exception Model, ➡ Revision.

Mingw-w64 - the parent project of MinGW-Builds, includes much more than is necessary - MinGW-Builds will usually suffice instead of the full works.

Development Tools

Normally you should not need many of these tools. ZIP is convenient, especially when building Code::Blocks itself, but other than that these tools only serve specialized purposes.