I don't have specific sources that state what 'f' and 'm' mean, but we can infer based on usage patterns found in documentation.

'f' stands for 'flag'.

Flags are on if specified via '-fFLAG' and off via '-fno-FLAG'

ex:

  -fpic         # flag to set position independent code 
  -fno-builtin  # don't recognize build in functions ... 

The technical definition is that 'f' defines "Control the interface conventions used in code generation".

Src: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html (e.g -fpci, when this flag is set)

 -mabi=name   #abi mode = name
 -mcpu=cpu

Src: https://gcc.gnu.org/onlinedocs/gccint/Standard-Names.html (e.g ... when this mode...)

Summary

• This option was introduced on compilers much earlier than GCC, and GCC used the same naming for compatibility.

• My best guess from the historical evidence is that -E stands for "expand macros".

• The authors of those earlier compilers couldn't call it -P because there was already a -P option, which also ran only the preprocessor, but wrote the output to .i files instead of to standard output. -p was also taken.

• Over time, -E became preferred to -P, and when GCC was written, it supported only -E and not -P.

Despite being supposedly off topic for Stack Overflow, I think a bit of history will help explain how this option got its name.

gcc(1) inherited its basic command line options from much earlier Unix C compilers. Many versions can be found in the Unix Tree archive.

It looks like the first version that supported -E was Research Unix V7, circa 1979: cc(1) source, man page source. There was also a -P option that also just ran the preprocessor, but sent the result to a file foo.i instead of to standard output. V6 had already supported -P but not -E: cc(1) source, man page source.

This at least answers why -E wasn't named -P instead: because -P was already in use. (And -p was also taken, it was used to request profiling.) The only hint I found as to why -E was chosen is that the corresponding flag variable in the source code is named exflag. I would hazard a guess that this stands for "expand", as what -E does is basically to expand macros.

It appears that -P was eventually deprecated in favor of -E. V8 still supported it, but omitted it from the man page. V10 (circa 1989) included two versions of the compiler, cc which compiled traditional C, and lcc for ANSI C. The man page says that cc supports -P with the preprocessor behavior, but for lcc, -P did something else ("write declarations for all defined globals on standard error"). They both supported -E. On other fronts, 32V and BSD, at least initially, supported both, but -P would emit a warning that it was obsolete and -E should be used instead.

It looks like gcc, from its earliest version, only supported -E and not -P. Since then, a -P option has been introduced, but it does something else ("inhibit generation of linemarkers").

Here are mine:

• -Wextra and -Wall: essential.
• -Wfloat-equal: useful because usually testing floating-point numbers for equality is bad.
• -Wundef: warn if an uninitialized identifier is evaluated in an #if directive.
• -Wshadow: warn whenever a local variable shadows another local variable, parameter or global variable or whenever a built-in function is shadowed.
• -Wpointer-arith: warn if anything depends upon the size of a function or of void.
• -Wcast-align: warn whenever a pointer is cast such that the required alignment of the target is increased. For example, warn if a char * is cast to an int * on machines where integers can only be accessed at two- or four-byte boundaries.
• -Wstrict-prototypes: warn if a function is declared or defined without specifying the argument types.
• -Wstrict-overflow=5: warns about cases where the compiler optimizes based on the assumption that signed overflow does not occur. (The value 5 may be too strict, see the manual page.)
• -Wwrite-strings: give string constants the type const char[length] so that copying the address of one into a non-const char * pointer will get a warning.
• -Waggregate-return: warn if any functions that return structures or unions are defined or called.
• -Wcast-qual: warn whenever a pointer is cast to remove a type qualifier from the target type^*.
• -Wswitch-default: warn whenever a switch statement does not have a default case^*.
• -Wswitch-enum: warn whenever a switch statement has an index of enumerated type and lacks a case for one or more of the named codes of that enumeration^*.
• -Wconversion: warn for implicit conversions that may alter a value^*.
• -Wunreachable-code: warn if the compiler detects that code will never be executed^*.

Those marked ^* sometimes give too many spurious warnings, so I use them on as-needed basis.