M2(1)

🎀 M2(1) — the GNU manual 🎀

✨ NAME ✨

okay bestie, gm2 is just the GNU Modula-2 Compiler 💅 the whole name, no notes 👑

✨ SYNOPSIS ✨

✨ DESCRIPTION ✨

✨ OPTIONS ✨

okay so first things first 💖 for every input file, the file name suffix decides what kind of compilation happens. these are the kinds gm2 knows about:

• file.mod — Modula-2 implementation or program source files 🦋 if your project uses a different source extension, check out -fmod=
• file.def — Modula-2 definition module source files 🙈 these don't get compiled on their own. in GNU Modula-2 they get parsed as needed when program or implementation modules are compiled. if your project uses another extension, look at -fdef= 🌸

You can specify more than one input file on the gm2 command line,

• -g — make debugging info so debuggers like gdb can inspect and control the executable 🔥
• -I — the search path for definition and implementation modules 🧚 for example: gm2 -g -c -I.:../../libs foo.mod. if you don't specify this, the default path is the current directory followed by the right language dialect library directories ✨
• -fauto-init — turns on auto initialization of pointers to NIL 🫶 whenever a block is created, every pointer declared in that scope gets its address assigned to NIL
• -fbounds — turns on run time checking for subrange, array index and indirection via NIL pointers 💅
• -fcase — compile time checking to see whether a CASE statement needs an ELSE clause when you didn't specify one 🍓
• -fcpp — okay this one preprocesses your source with cpp -lang-asm -traditional-cpp. For further details about these options If -fcpp is supplied then all definition modules and implementation modules which are parsed will be preprocessed by cpp 🌈
• -fdebug-builtins — calls a real function instead of the builtin equivalent 🎀 super useful for checking the parameter values going into a builtin, since you can single step right into an intrinsic function 🦋
• -fdef= — recognize the specified suffix as a definition module filename ✨ the default implementation and module filename suffix is .def. If you use this option, GNU Modula-2 will still fall back to that default if a requested definition module isn't found 💖
• -fdump-system-exports — displays all inbuilt system items 🙈 this is an internal command line option, so it's more of a behind-the-scenes thing
• -fexceptions — turns on exception handling code 👑 this one is on by default. You can disable it with -fno-exceptions, and then no references get made to the run time exception libraries
• -fextended-opaque — lets opaque types be implemented as any type 🔥 this is a GNU Modula-2 extension, and it needs the implementation module that defines the opaque type to be available so it can be resolved when compiling the module that imports it
• -ffloatvalue — turns on run time checking to see whether a floating point number is about to exceed its range 🌸
• -fgen-module-list=filename — tries to find all modules when linking and generates a module list 🧚 if the filename is -, then the contents aren't written and it's only used to force the linking of all module ctors. This option can't be used if -fuse-list= is enabled 🙅‍♀️
• -findex — generates code to check whether array index values are out of bounds 💅 you can turn array index checking off with -fno-index
• -fiso — turns on ISO standard features 🦋 right now this enables the ISO SYSTEM module and changes the default library search path so the ISO libraries get searched before the PIM libraries. It also affects how the DIV and MOD operators behave
• -flibs= — modifies the default library search path 📚 the libraries you can supply are m2pim, m2iso, m2min, m2log and m2cor. These map onto the Programming in Modula-2 base libraries, ISO standard libraries, minimal library support, the Logitech compatible library, and Programming in Modula-2 with coroutines. You can specify multiple libraries, comma separated, and precedence goes to the first one in the list. You don't need -flibs=m2pim or -flibs=m2iso if you also specify -fpim, -fpim2, -fpim3, -fpim4 or -fiso. Unless you're using -flibs=m2min, you should include m2pim, since it provides the base modules all the other dialects use 🫶 and -fno-libs=- stops the gm2 driver from touching the search and library paths
• -static-libgm2 — on systems that ship the m2 runtimes as both shared and static libraries, this forces the static version 🔥
• -fm2-debug-trace= — turns on trace debugging with a comma separated list: line,token,quad,all 🙈 this is an internal command line option
• -fm2-dump= — enables dumping of the modula-2 internal representation of data structures using a comma separated list 💖 the list can contain quad,gimple,decl,all
• -fm2-dump-decl=filestem — dumps the modula-2 representation of a symbol to the filestem you specify 🌈 this only takes effect if -fm2-dump-filter is specified
• -fm2-dump-gimple=filestem — dumps the modula-2 gimple representation to the filestem you specify 🧚
• -fm2-dump-quad=filestem — dumps the quadruple representation to the filestem you specify 🦋
• -fm2-dump-filter=rules — filters the language dumps -fdump-lang-decl, -fdump-lang-gimple and-fdump-lang-quad on rules 🎀 rules has to be a comma separated list, and it can take three forms: the full decl textual name of a procedure, [libname.]module.ident, or [filename:]module.ident. This is an internal command line option. Right now it only filters on procedure names, and regexp matching isn't implemented 😭 three examples following the forms above: -fm2-dump-filter=_M2_hello_init, -fm2-dump-filter=m2pim.StrIO.WriteString and -fm2-dump-filter=StrLib.mod:StrIO.WriteString
• -fm2-file-offset-bits= — forces the type SYSTEM.COFF_T to be built with the number of bits you specify ✨ if you don't use this option, the default is CSSIZE_T bits
• -fm2-g — makes the debugging experience better for new programmers 💅 the tradeoff is that nop instructions may be generated when needed, so single stepping is precise over all code related keywords. For example, when a list of nested IF statements ends with several END keywords, those get mapped onto a sequence of nop instructions 🙈
• -fm2-lower-case — renders keywords in error messages in lower case 🌸
• -fm2-pathname= — specifies the module mangled prefix name for all modules in the include paths that follow 🧚
• -fm2-pathnameI — for internal use only 🙈 the driver uses it to copy the user facing -I option
• -fm2-pathname-root=pathroot — adds search paths derived from the specified pathroot 🫶
• -fm2-pathname-rootI — for internal use only 🙈 the driver uses it to copy every user -fm2-pathname-root= facing option, in order, along with all the other -I options 💖

okay that's the first half of the options, bestie 🦋

• -fruntime-modules= — ✨ Give this a comma-separated list and you decide which run time modules come first and in what order. They get initialized before any other modules in the application dependency. By default the list is "m2iso:RTentity,m2iso:Storage,m2iso:SYSTEM," "m2iso:M2RTS,m2iso:RTExceptions,m2iso:IOLink". These modules only get linked into your executable if they're actually required, so a long list won't make your executable bigger. It only sets the initialization order for when they're needed 🧚
• -fscaffold-dynamic — 💜 This makes gm2 generate a dynamic scaffold when it compiles implementation and program modules. It's on by default. Use -fno-scaffold-dynamic to turn it off, or pick -fno-scaffold-static instead.
• -fscaffold-c — 🌸 Generates a C source scaffold for the module you're currently compiling.
• -fscaffold-c++ — 🦋 Generates a C++ source scaffold for the module you're currently compiling.
• -fscaffold-main — 👑 Forces the main function to be generated. You don't need this if -c is left out.
• -fscaffold-static — 🍓 Makes gm2 generate a static scaffold inside the program module. That scaffold is a sequence of calls to every dependent module's initialization and finalization procedures. It's super useful for debugging and single stepping through the initialization blocks of implementation modules 🔥
• -fshared — 🌈 Generates a shared library from the module.
• -fsoft-check-all — 💅 Turns on every run time check. It's the same as invoking GNU Modula-2 with -fnil -frange -findex -fwholevalue -fwholediv -fcase -freturn.
• -fsources — 🔍 Shows the path to the source of each module. You can use this at compile time to double-check you're using the right definition module 🫶
• -fswig — 🧚 Generates a swig interface file.
• -funbounded-by-reference — 🔥 This turns on an optimization for unbounded parameters. It tries to pass non VAR unbounded parameters by reference, which skips the implicit copy inside the callee procedure. GNU Modula-2 only lets unbounded parameters go by reference if, inside the callee, they aren't written to, no address is calculated on the array, and they aren't passed as a VAR parameter. You can still write code that breaks this optimization, so use it carefully. For example, you could take the address of an array, pass both the address and the array to a procedure, read from the array inside that procedure, and write to the location through the address parameter.

⚠️ Bestie, this one is dangerous! Because of that, it is not enabled when the -O option is specified.

• -fuse-list=filename — 📜 If -fscaffold-static is enabled, this uses the file filename for the initialization order of modules. If -fscaffold-dynamic is enabled instead, the file is used to force linking of all module ctors. You can't use this option if -fgen-module-list= is enabled 🙈
• -fwholediv — ➗ Generates code that detects whole number division by zero and modulus by zero.
• -fwholevalue — 🔢 Generates code that detects whole number overflow and underflow.
• -Wcase-enum — ⚠️ Gives you a warning if a CASE statement selects on an enumerated type expression and is missing one or more CASE labels. If the CASE statement has a default ELSE clause, no warning is issued. The -Wall option turns this flag on too 💖
• -Wuninit-variable-checking — 👀 Gives you a warning if a variable gets used before it's initialized. The checking only happens in the first basic block in each procedure. It doesn't check parameters, array types, or set types.
• -Wuninit-variable-checking=all,known,cond — 🔎 Gives you a warning if a variable gets used before it's initialized. Checking only happens in the first basic block in each procedure if known is specified. If cond or all is specified, checking keeps going into conditional branches of the flow graph. All checking stops when a procedure call is invoked or the top of a loop is encountered. The -Wall option turns this on with -Wuninit-variable-checking=known. Using -Wuninit-variable-checking=all will increase compile time 🐢
• -fwideset — 🎀 Turns on access to the run time support library module M2WIDESET. It's on by default. You can disable wideset support with -fno-wideset, and then there will be no reference to the run time M2WIDESET library.

✨ SEE ALSO ✨

gpl(7), gfdl(7), fsf-funding(7), gcc(1) and the Info entries for gm2 and gcc 📚

🎀 COPYRIGHT 🎀

Copyright (c) 1999-2026 Free Software Foundation, Inc.

Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free Documentation License, Version 1.3 or any later version published by the Free Software Foundation. There are no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the man page gfdl(7) 💜

---

That's the whole page, bestie! 🦋 Source: gcc-16, dated 2026-03-22, M2(1) 🌈 Stay iconic! 💅✨