Provided by: gm2-13-m68k-linux-gnu_13.2.0-4ubuntu3cross1_amd64 bug

NAME

       gm2 - The GNU Modula-2 Compiler

SYNOPSIS

DESCRIPTION

OPTIONS

       For any given input file, the file name suffix determines what kind of compilation is
       done.  The following kinds of input file names are supported:

       file.mod
           Modula-2 implementation or program source files.  See the -fmod= option if you wish to
           compile a project which uses a different source file extension.

       file.def
           Modula-2 definition module source files.  Definition modules are not compiled
           separately, in GNU Modula-2 definition modules are parsed as required when program or
           implementation modules are compiled.  See the -fdef= option if you wish to compile a
           project which uses a different source file extension.

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

       "-g"
           create debugging information so that debuggers such as gdb can inspect and control
           executable.

       "-I"
           used to specify the search path for definition and implementation modules.  An example
           is:  "gm2 -g -c -I.:../../libs foo.mod".  If this option is not specified then the
           default path is added which consists of the current directory followed by the
           appropriate language dialect library directories.

       "-fauto-init"
           turns on auto initialization of pointers to NIL.  Whenever a block is created all
           pointers declared within this scope will have their addresses assigned to NIL.

       "-fbounds"
           turns on run time subrange, array index and indirection via "NIL" pointer checking.

       "-fcase"
           turns on compile time checking to check whether a "CASE" statement requires an "ELSE"
           clause when on was not specified.

       "-fcpp"
           preprocess the 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 prepossessed by cpp.

       "-fdebug-builtins"
           call a real function, rather than the builtin equivalent.  This can be useful for
           debugging parameter values to a builtin function as it allows users to single step
           code into a real function.

       "-fdef="
           recognize the specified suffix as a definition module filename.  The default
           implementation and module filename suffix is .def.  If this option is used GNU
           Modula-2 will still fall back to this default if a requested definition module is not
           found.

       "-fdump-system-exports"
           display all inbuilt system items.  This is an internal command line option.

       "-fexceptions"
           turn on exception handling code.  By default this option is on.  Exception handling
           can be disabled by -fno-exceptions and no references are made to the run time
           exception libraries.

       "-fextended-opaque"
           allows opaque types to be implemented as any type.  This is a GNU Modula-2 extension
           and it requires that the implementation module defining the opaque type is available
           so that it can be resolved when compiling the module which imports the opaque type.

       "-ffloatvalue"
           turns on run time checking to check whether a floating point number is about to exceed
           range.

       "-fgen-module-list=filename"
           attempt to find all modules when linking and generate a module list.  If the filename
           is - then the contents are not written and only used to force the linking of all
           module ctors.  This option cannot be used if -fuse-list= is enabled.

       "-findex"
           generate code to check whether array index values are out of bounds.  Array index
           checking can be disabled via -fno-index.

       "-fiso"
           turn on ISO standard features.  Currently this enables the ISO "SYSTEM" module and
           alters the default library search path so that the ISO libraries are searched before
           the PIM libraries.  It also effects the behavior of "DIV" and "MOD" operators.

       "-flibs="
           modifies the default library search path.  The libraries supplied are: m2pim, m2iso,
           m2min, m2log and m2cor.  These map onto the Programming in Modula-2 base libraries,
           ISO standard libraries, minimal library support, Logitech compatible library and
           Programming in Modula-2 with coroutines.  Multiple libraries can be specified and are
           comma separated with precedence going to the first in the list.  It is not necessary
           to use -flibs=m2pim or -flibs=m2iso if you also specify -fpim, -fpim2, -fpim3, -fpim4
           or -fiso.  Unless you are using -flibs=m2min you should include m2pim as the they
           provide the base modules which all other dialects utilize.  The option -fno-libs=-
           disables the gm2 driver from modifying the search and library paths.

       "-static-libgm2"
           On systems that provide the m2 runtimes as both shared and static libraries, this
           option forces the use of the static version.

       "-fm2-g"
           improve the debugging experience for new programmers at the expense of generating
           "nop" instructions if necessary to ensure single stepping precision over all code
           related keywords.  An example of this is in termination of a list of nested "IF"
           statements where multiple "END" keywords are mapped onto a sequence of "nop"
           instructions.

       "-fm2-lower-case"
           render keywords in error messages using lower case.

       "-fm2-pathname="
           specify the module mangled prefix name for all modules in the following include paths.

       "-fm2-pathnameI"
           for internal use only: used by the driver to copy the user facing -I option.

       "-fm2-plugin"
           insert plugin to identify run time errors at compile time (default on).

       "-fm2-prefix="
           specify the module mangled prefix name.  All exported symbols from a definition module
           will have the prefix name.

       "-fm2-statistics"
           generates quadruple information: number of quadruples generated, number of quadruples
           remaining after optimization and number of source lines compiled.

       "-fm2-strict-type"
           experimental flag to turn on the new strict type checker.

       "-fm2-whole-program"
           compile all implementation modules and program module at once.  Notice that you need
           to take care if you are compiling different dialect modules (particularly with the
           negative operands to modulus).  But this option, when coupled together with "-O3", can
           deliver huge performance improvements.

       "-fmod="
           recognize the specified suffix as implementation and module filenames.  The default
           implementation and module filename suffix is .mod.  If this option is used GNU
           Modula-2 will still fall back to this default if it needs to read an implementation
           module and the specified suffixed filename does not exist.

       "-fnil"
           generate code to detect accessing data through a "NIL" value pointer.  Dereferencing
           checking through a "NIL" pointer can be disabled by -fno-nil.

       "-fpim"
           turn on PIM standard features.  Currently this enables the PIM "SYSTEM" module and
           determines which identifiers are pervasive (declared in the base module).  If no other
           -fpim[234] switch is used then division and modulus operators behave as defined in
           PIM4.

       "-fpim2"
           turn on PIM-2 standard features.  Currently this removes "SIZE" from being a pervasive
           identifier (declared in the base module).  It places "SIZE" in the "SYSTEM" module.
           It also effects the behavior of "DIV" and "MOD" operators.

       "-fpim3"
           turn on PIM-3 standard features.  Currently this only effects the behavior of "DIV"
           and "MOD" operators.

       "-fpim4"
           turn on PIM-4 standard features.  Currently this only effects the behavior of "DIV"
           and "MOD" operators.

       "-fpositive-mod-floor-div"
           forces the "DIV" and "MOD" operators to behave as defined by PIM4.  All modulus
           results are positive and the results from the division are rounded to the floor.

       "-fpthread"
           link against the pthread library.  By default this option is on.  It can be disabled
           by -fno-pthread.  GNU Modula-2 uses the GCC pthread libraries to implement coroutines
           (see the SYSTEM implementation module).

       "-frange"
           generate code to check the assignment range, return value range set range and
           constructor range.  Range checking can be disabled via -fno-range.

       "-freturn"
           generate code to check that functions always exit with a "RETURN" and do not fall out
           at the end.  Return checking can be disabled via -fno-return.

       "-fruntime-modules="
           specify, using a comma separated list, the run time modules and their order.  These
           modules will initialized first before any other modules in the application dependency.
           By default the run time modules list is set to
           "m2iso:RTentity,m2iso:Storage,m2iso:SYSTEM,"
           "m2iso:M2RTS,m2iso:RTExceptions,m2iso:IOLink".  Note that these modules will only be
           linked into your executable if they are required.  Adding a long list of dependent
           modules will not effect the size of the executable it merely states the initialization
           order should they be required.

       "-fscaffold-dynamic"
           the option ensures that gm2 will generate a dynamic scaffold infrastructure when
           compiling implementation and program modules.  By default this option is on.  Use
           -fno-scaffold-dynamic to turn it off or select -fno-scaffold-static.

       "-fscaffold-c"
           generate a C source scaffold for the current module being compiled.

       "-fscaffold-c++"
           generate a C++ source scaffold for the current module being compiled.

       "-fscaffold-main"
           force the generation of the main function.  This is not necessary if the -c is
           omitted.

       "-fscaffold-static"
           the option ensures that gm2 will generate a static scaffold within the program module.
           The static scaffold consists of sequences of calls to all dependent module
           initialization and finalization procedures.  The static scaffold is useful for
           debugging and single stepping the initialization blocks of implementation modules.

       "-fshared"
           generate a shared library from the module.

       "-fsoft-check-all"
           turns on all run time checks.  This is the same as invoking GNU Modula-2 using the
           command options "-fnil" "-frange" "-findex" "-fwholevalue" "-fwholediv" "-fcase"
           "-freturn".

       "-fsources"
           displays the path to the source of each module.  This option can be used at compile
           time to check the correct definition module is being used.

       "-fswig"
           generate a swig interface file.

       "-funbounded-by-reference"
           enable optimization of unbounded parameters by attempting to pass non "VAR" unbounded
           parameters by reference.  This optimization avoids the implicit copy inside the callee
           procedure.  GNU Modula-2 will only allow unbounded parameters to be passed by
           reference if, inside the callee procedure, they are not written to, no address is
           calculated on the array and it is not passed as a "VAR" parameter.  Note that it is
           possible to write code to break this optimization, therefore this option should be
           used carefully.  For example it would be possible to take the address of an array,
           pass the address and the array to a procedure, read from the array in the procedure
           and write to the location using the address parameter.

           Due to the dangerous nature of this option it is not enabled when the -O option is
           specified.

       "-fuse-list=filename"
           if -fscaffold-static is enabled then use the file filename for the initialization
           order of modules.  Whereas if -fscaffold-dynamic is enabled then use this file to
           force linking of all module ctors.  This option cannot be used if -fgen-module-list=
           is enabled.

       "-fwholediv"
           generate code to detect whole number division by zero or modulus by zero.

       "-fwholevalue"
           generate code to detect whole number overflow and underflow.

       "-Wcase-enum"
           generate a warning if a "CASE" statement selects on an enumerated type expression and
           the statement is missing one or more "CASE" labels.  No warning is issued if the
           "CASE" statement has a default "ELSE" clause.  The option -Wall will turn on this
           flag.

       "-Wuninit-variable-checking"
           issue a warning if a variable is used before it is initialized.  The checking only
           occurs in the first basic block in each procedure.  It does not check parameters,
           array types or set types.

       "-Wuninit-variable-checking=all,known,cond"
           issue a warning if a variable is used before it is initialized.  The checking will
           only occur in the first basic block in each procedure if known is specified.  If cond
           or all is specified then checking continues into conditional branches of the flow
           graph.  All checking will stop when a procedure call is invoked or the top of a loop
           is encountered.  The option -Wall will turn on this flag with
           -Wuninit-variable-checking=known.  The -Wuninit-variable-checking=all will increase
           compile time.

SEE ALSO

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

COPYRIGHT

       Copyright (c) 1999-2023 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; with 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).