| <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"> |
| <html> |
| <!-- Copyright (C) 1988-2015 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 the |
| Invariant Sections being "Funding Free Software", the Front-Cover |
| Texts being (a) (see below), and with the Back-Cover Texts being (b) |
| (see below). A copy of the license is included in the section entitled |
| "GNU Free Documentation License". |
| |
| (a) The FSF's Front-Cover Text is: |
| |
| A GNU Manual |
| |
| (b) The FSF's Back-Cover Text is: |
| |
| You have freedom to copy and modify this GNU Manual, like GNU |
| software. Copies published by the Free Software Foundation raise |
| funds for GNU development. --> |
| <!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ --> |
| <head> |
| <title>Using the GNU Compiler Collection (GCC): C++ Dialect Options</title> |
| |
| <meta name="description" content="Using the GNU Compiler Collection (GCC): C++ Dialect Options"> |
| <meta name="keywords" content="Using the GNU Compiler Collection (GCC): C++ Dialect Options"> |
| <meta name="resource-type" content="document"> |
| <meta name="distribution" content="global"> |
| <meta name="Generator" content="makeinfo"> |
| <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> |
| <link href="index.html#Top" rel="start" title="Top"> |
| <link href="Option-Index.html#Option-Index" rel="index" title="Option Index"> |
| <link href="index.html#SEC_Contents" rel="contents" title="Table of Contents"> |
| <link href="Invoking-GCC.html#Invoking-GCC" rel="up" title="Invoking GCC"> |
| <link href="Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options.html#Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options" rel="next" title="Objective-C and Objective-C++ Dialect Options"> |
| <link href="C-Dialect-Options.html#C-Dialect-Options" rel="prev" title="C Dialect Options"> |
| <style type="text/css"> |
| <!-- |
| a.summary-letter {text-decoration: none} |
| blockquote.smallquotation {font-size: smaller} |
| div.display {margin-left: 3.2em} |
| div.example {margin-left: 3.2em} |
| div.indentedblock {margin-left: 3.2em} |
| div.lisp {margin-left: 3.2em} |
| div.smalldisplay {margin-left: 3.2em} |
| div.smallexample {margin-left: 3.2em} |
| div.smallindentedblock {margin-left: 3.2em; font-size: smaller} |
| div.smalllisp {margin-left: 3.2em} |
| kbd {font-style:oblique} |
| pre.display {font-family: inherit} |
| pre.format {font-family: inherit} |
| pre.menu-comment {font-family: serif} |
| pre.menu-preformatted {font-family: serif} |
| pre.smalldisplay {font-family: inherit; font-size: smaller} |
| pre.smallexample {font-size: smaller} |
| pre.smallformat {font-family: inherit; font-size: smaller} |
| pre.smalllisp {font-size: smaller} |
| span.nocodebreak {white-space:nowrap} |
| span.nolinebreak {white-space:nowrap} |
| span.roman {font-family:serif; font-weight:normal} |
| span.sansserif {font-family:sans-serif; font-weight:normal} |
| ul.no-bullet {list-style: none} |
| --> |
| </style> |
| |
| |
| </head> |
| |
| <body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000"> |
| <a name="C_002b_002b-Dialect-Options"></a> |
| <div class="header"> |
| <p> |
| Next: <a href="Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options.html#Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options" accesskey="n" rel="next">Objective-C and Objective-C++ Dialect Options</a>, Previous: <a href="C-Dialect-Options.html#C-Dialect-Options" accesskey="p" rel="prev">C Dialect Options</a>, Up: <a href="Invoking-GCC.html#Invoking-GCC" accesskey="u" rel="up">Invoking GCC</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p> |
| </div> |
| <hr> |
| <a name="Options-Controlling-C_002b_002b-Dialect"></a> |
| <h3 class="section">3.5 Options Controlling C++ Dialect</h3> |
| |
| <a name="index-compiler-options_002c-C_002b_002b"></a> |
| <a name="index-C_002b_002b-options_002c-command_002dline"></a> |
| <a name="index-options_002c-C_002b_002b"></a> |
| <p>This section describes the command-line options that are only meaningful |
| for C++ programs. You can also use most of the GNU compiler options |
| regardless of what language your program is in. For example, you |
| might compile a file <code>firstClass.C</code> like this: |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">g++ -g -frepo -O -c firstClass.C |
| </pre></div> |
| |
| <p>In this example, only <samp>-frepo</samp> is an option meant |
| only for C++ programs; you can use the other options with any |
| language supported by GCC. |
| </p> |
| <p>Here is a list of options that are <em>only</em> for compiling C++ programs: |
| </p> |
| <dl compact="compact"> |
| <dt><code>-fabi-version=<var>n</var></code></dt> |
| <dd><a name="index-fabi_002dversion"></a> |
| <p>Use version <var>n</var> of the C++ ABI. The default is version 2. |
| </p> |
| <p>Version 0 refers to the version conforming most closely to |
| the C++ ABI specification. Therefore, the ABI obtained using version 0 |
| will change in different versions of G++ as ABI bugs are fixed. |
| </p> |
| <p>Version 1 is the version of the C++ ABI that first appeared in G++ 3.2. |
| </p> |
| <p>Version 2 is the version of the C++ ABI that first appeared in G++ 3.4. |
| </p> |
| <p>Version 3 corrects an error in mangling a constant address as a |
| template argument. |
| </p> |
| <p>Version 4, which first appeared in G++ 4.5, implements a standard |
| mangling for vector types. |
| </p> |
| <p>Version 5, which first appeared in G++ 4.6, corrects the mangling of |
| attribute const/volatile on function pointer types, decltype of a |
| plain decl, and use of a function parameter in the declaration of |
| another parameter. |
| </p> |
| <p>Version 6, which first appeared in G++ 4.7, corrects the promotion |
| behavior of C++11 scoped enums and the mangling of template argument |
| packs, const/static_cast, prefix ++ and –, and a class scope function |
| used as a template argument. |
| </p> |
| <p>See also <samp>-Wabi</samp>. |
| </p> |
| </dd> |
| <dt><code>-fno-access-control</code></dt> |
| <dd><a name="index-fno_002daccess_002dcontrol"></a> |
| <p>Turn off all access checking. This switch is mainly useful for working |
| around bugs in the access control code. |
| </p> |
| </dd> |
| <dt><code>-fcheck-new</code></dt> |
| <dd><a name="index-fcheck_002dnew"></a> |
| <p>Check that the pointer returned by <code>operator new</code> is non-null |
| before attempting to modify the storage allocated. This check is |
| normally unnecessary because the C++ standard specifies that |
| <code>operator new</code> only returns <code>0</code> if it is declared |
| ‘<samp>throw()</samp>’, in which case the compiler always checks the |
| return value even without this option. In all other cases, when |
| <code>operator new</code> has a non-empty exception specification, memory |
| exhaustion is signalled by throwing <code>std::bad_alloc</code>. See also |
| ‘<samp>new (nothrow)</samp>’. |
| </p> |
| </dd> |
| <dt><code>-fconstexpr-depth=<var>n</var></code></dt> |
| <dd><a name="index-fconstexpr_002ddepth"></a> |
| <p>Set the maximum nested evaluation depth for C++11 constexpr functions |
| to <var>n</var>. A limit is needed to detect endless recursion during |
| constant expression evaluation. The minimum specified by the standard |
| is 512. |
| </p> |
| </dd> |
| <dt><code>-fdeduce-init-list</code></dt> |
| <dd><a name="index-fdeduce_002dinit_002dlist"></a> |
| <p>Enable deduction of a template type parameter as |
| <code>std::initializer_list</code> from a brace-enclosed initializer list, i.e. |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">template <class T> auto forward(T t) -> decltype (realfn (t)) |
| { |
| return realfn (t); |
| } |
| |
| void f() |
| { |
| forward({1,2}); // call forward<std::initializer_list<int>> |
| } |
| </pre></div> |
| |
| <p>This deduction was implemented as a possible extension to the |
| originally proposed semantics for the C++11 standard, but was not part |
| of the final standard, so it is disabled by default. This option is |
| deprecated, and may be removed in a future version of G++. |
| </p> |
| </dd> |
| <dt><code>-ffriend-injection</code></dt> |
| <dd><a name="index-ffriend_002dinjection"></a> |
| <p>Inject friend functions into the enclosing namespace, so that they are |
| visible outside the scope of the class in which they are declared. |
| Friend functions were documented to work this way in the old Annotated |
| C++ Reference Manual, and versions of G++ before 4.1 always worked |
| that way. However, in ISO C++ a friend function that is not declared |
| in an enclosing scope can only be found using argument dependent |
| lookup. This option causes friends to be injected as they were in |
| earlier releases. |
| </p> |
| <p>This option is for compatibility, and may be removed in a future |
| release of G++. |
| </p> |
| </dd> |
| <dt><code>-fno-elide-constructors</code></dt> |
| <dd><a name="index-fno_002delide_002dconstructors"></a> |
| <p>The C++ standard allows an implementation to omit creating a temporary |
| that is only used to initialize another object of the same type. |
| Specifying this option disables that optimization, and forces G++ to |
| call the copy constructor in all cases. |
| </p> |
| </dd> |
| <dt><code>-fno-enforce-eh-specs</code></dt> |
| <dd><a name="index-fno_002denforce_002deh_002dspecs"></a> |
| <p>Don’t generate code to check for violation of exception specifications |
| at run time. This option violates the C++ standard, but may be useful |
| for reducing code size in production builds, much like defining |
| ‘<samp>NDEBUG</samp>’. This does not give user code permission to throw |
| exceptions in violation of the exception specifications; the compiler |
| still optimizes based on the specifications, so throwing an |
| unexpected exception results in undefined behavior at run time. |
| </p> |
| </dd> |
| <dt><code>-fextern-tls-init</code></dt> |
| <dt><code>-fno-extern-tls-init</code></dt> |
| <dd><a name="index-fextern_002dtls_002dinit"></a> |
| <a name="index-fno_002dextern_002dtls_002dinit"></a> |
| <p>The C++11 and OpenMP standards allow ‘<samp>thread_local</samp>’ and |
| ‘<samp>threadprivate</samp>’ variables to have dynamic (runtime) |
| initialization. To support this, any use of such a variable goes |
| through a wrapper function that performs any necessary initialization. |
| When the use and definition of the variable are in the same |
| translation unit, this overhead can be optimized away, but when the |
| use is in a different translation unit there is significant overhead |
| even if the variable doesn’t actually need dynamic initialization. If |
| the programmer can be sure that no use of the variable in a |
| non-defining TU needs to trigger dynamic initialization (either |
| because the variable is statically initialized, or a use of the |
| variable in the defining TU will be executed before any uses in |
| another TU), they can avoid this overhead with the |
| <samp>-fno-extern-tls-init</samp> option. |
| </p> |
| <p>On targets that support symbol aliases, the default is |
| <samp>-fextern-tls-init</samp>. On targets that do not support symbol |
| aliases, the default is <samp>-fno-extern-tls-init</samp>. |
| </p> |
| </dd> |
| <dt><code>-ffor-scope</code></dt> |
| <dt><code>-fno-for-scope</code></dt> |
| <dd><a name="index-ffor_002dscope"></a> |
| <a name="index-fno_002dfor_002dscope"></a> |
| <p>If <samp>-ffor-scope</samp> is specified, the scope of variables declared in |
| a <i>for-init-statement</i> is limited to the ‘<samp>for</samp>’ loop itself, |
| as specified by the C++ standard. |
| If <samp>-fno-for-scope</samp> is specified, the scope of variables declared in |
| a <i>for-init-statement</i> extends to the end of the enclosing scope, |
| as was the case in old versions of G++, and other (traditional) |
| implementations of C++. |
| </p> |
| <p>If neither flag is given, the default is to follow the standard, |
| but to allow and give a warning for old-style code that would |
| otherwise be invalid, or have different behavior. |
| </p> |
| </dd> |
| <dt><code>-fno-gnu-keywords</code></dt> |
| <dd><a name="index-fno_002dgnu_002dkeywords"></a> |
| <p>Do not recognize <code>typeof</code> as a keyword, so that code can use this |
| word as an identifier. You can use the keyword <code>__typeof__</code> instead. |
| <samp>-ansi</samp> implies <samp>-fno-gnu-keywords</samp>. |
| </p> |
| </dd> |
| <dt><code>-fno-implicit-templates</code></dt> |
| <dd><a name="index-fno_002dimplicit_002dtemplates"></a> |
| <p>Never emit code for non-inline templates that are instantiated |
| implicitly (i.e. by use); only emit code for explicit instantiations. |
| See <a href="Template-Instantiation.html#Template-Instantiation">Template Instantiation</a>, for more information. |
| </p> |
| </dd> |
| <dt><code>-fno-implicit-inline-templates</code></dt> |
| <dd><a name="index-fno_002dimplicit_002dinline_002dtemplates"></a> |
| <p>Don’t emit code for implicit instantiations of inline templates, either. |
| The default is to handle inlines differently so that compiles with and |
| without optimization need the same set of explicit instantiations. |
| </p> |
| </dd> |
| <dt><code>-fno-implement-inlines</code></dt> |
| <dd><a name="index-fno_002dimplement_002dinlines"></a> |
| <p>To save space, do not emit out-of-line copies of inline functions |
| controlled by ‘<samp>#pragma implementation</samp>’. This causes linker |
| errors if these functions are not inlined everywhere they are called. |
| </p> |
| </dd> |
| <dt><code>-fms-extensions</code></dt> |
| <dd><a name="index-fms_002dextensions-1"></a> |
| <p>Disable Wpedantic warnings about constructs used in MFC, such as implicit |
| int and getting a pointer to member function via non-standard syntax. |
| </p> |
| </dd> |
| <dt><code>-fno-nonansi-builtins</code></dt> |
| <dd><a name="index-fno_002dnonansi_002dbuiltins"></a> |
| <p>Disable built-in declarations of functions that are not mandated by |
| ANSI/ISO C. These include <code>ffs</code>, <code>alloca</code>, <code>_exit</code>, |
| <code>index</code>, <code>bzero</code>, <code>conjf</code>, and other related functions. |
| </p> |
| </dd> |
| <dt><code>-fnothrow-opt</code></dt> |
| <dd><a name="index-fnothrow_002dopt"></a> |
| <p>Treat a <code>throw()</code> exception specification as if it were a |
| <code>noexcept</code> specification to reduce or eliminate the text size |
| overhead relative to a function with no exception specification. If |
| the function has local variables of types with non-trivial |
| destructors, the exception specification actually makes the |
| function smaller because the EH cleanups for those variables can be |
| optimized away. The semantic effect is that an exception thrown out of |
| a function with such an exception specification results in a call |
| to <code>terminate</code> rather than <code>unexpected</code>. |
| </p> |
| </dd> |
| <dt><code>-fno-operator-names</code></dt> |
| <dd><a name="index-fno_002doperator_002dnames"></a> |
| <p>Do not treat the operator name keywords <code>and</code>, <code>bitand</code>, |
| <code>bitor</code>, <code>compl</code>, <code>not</code>, <code>or</code> and <code>xor</code> as |
| synonyms as keywords. |
| </p> |
| </dd> |
| <dt><code>-fno-optional-diags</code></dt> |
| <dd><a name="index-fno_002doptional_002ddiags"></a> |
| <p>Disable diagnostics that the standard says a compiler does not need to |
| issue. Currently, the only such diagnostic issued by G++ is the one for |
| a name having multiple meanings within a class. |
| </p> |
| </dd> |
| <dt><code>-fpermissive</code></dt> |
| <dd><a name="index-fpermissive"></a> |
| <p>Downgrade some diagnostics about nonconformant code from errors to |
| warnings. Thus, using <samp>-fpermissive</samp> allows some |
| nonconforming code to compile. |
| </p> |
| </dd> |
| <dt><code>-fno-pretty-templates</code></dt> |
| <dd><a name="index-fno_002dpretty_002dtemplates"></a> |
| <p>When an error message refers to a specialization of a function |
| template, the compiler normally prints the signature of the |
| template followed by the template arguments and any typedefs or |
| typenames in the signature (e.g. <code>void f(T) [with T = int]</code> |
| rather than <code>void f(int)</code>) so that it’s clear which template is |
| involved. When an error message refers to a specialization of a class |
| template, the compiler omits any template arguments that match |
| the default template arguments for that template. If either of these |
| behaviors make it harder to understand the error message rather than |
| easier, you can use <samp>-fno-pretty-templates</samp> to disable them. |
| </p> |
| </dd> |
| <dt><code>-frepo</code></dt> |
| <dd><a name="index-frepo"></a> |
| <p>Enable automatic template instantiation at link time. This option also |
| implies <samp>-fno-implicit-templates</samp>. See <a href="Template-Instantiation.html#Template-Instantiation">Template Instantiation</a>, for more information. |
| </p> |
| </dd> |
| <dt><code>-fno-rtti</code></dt> |
| <dd><a name="index-fno_002drtti"></a> |
| <p>Disable generation of information about every class with virtual |
| functions for use by the C++ run-time type identification features |
| (‘<samp>dynamic_cast</samp>’ and ‘<samp>typeid</samp>’). If you don’t use those parts |
| of the language, you can save some space by using this flag. Note that |
| exception handling uses the same information, but G++ generates it as |
| needed. The ‘<samp>dynamic_cast</samp>’ operator can still be used for casts that |
| do not require run-time type information, i.e. casts to <code>void *</code> or to |
| unambiguous base classes. |
| </p> |
| </dd> |
| <dt><code>-fstats</code></dt> |
| <dd><a name="index-fstats"></a> |
| <p>Emit statistics about front-end processing at the end of the compilation. |
| This information is generally only useful to the G++ development team. |
| </p> |
| </dd> |
| <dt><code>-fstrict-enums</code></dt> |
| <dd><a name="index-fstrict_002denums"></a> |
| <p>Allow the compiler to optimize using the assumption that a value of |
| enumerated type can only be one of the values of the enumeration (as |
| defined in the C++ standard; basically, a value that can be |
| represented in the minimum number of bits needed to represent all the |
| enumerators). This assumption may not be valid if the program uses a |
| cast to convert an arbitrary integer value to the enumerated type. |
| </p> |
| </dd> |
| <dt><code>-ftemplate-backtrace-limit=<var>n</var></code></dt> |
| <dd><a name="index-ftemplate_002dbacktrace_002dlimit"></a> |
| <p>Set the maximum number of template instantiation notes for a single |
| warning or error to <var>n</var>. The default value is 10. |
| </p> |
| </dd> |
| <dt><code>-ftemplate-depth=<var>n</var></code></dt> |
| <dd><a name="index-ftemplate_002ddepth"></a> |
| <p>Set the maximum instantiation depth for template classes to <var>n</var>. |
| A limit on the template instantiation depth is needed to detect |
| endless recursions during template class instantiation. ANSI/ISO C++ |
| conforming programs must not rely on a maximum depth greater than 17 |
| (changed to 1024 in C++11). The default value is 900, as the compiler |
| can run out of stack space before hitting 1024 in some situations. |
| </p> |
| </dd> |
| <dt><code>-fno-threadsafe-statics</code></dt> |
| <dd><a name="index-fno_002dthreadsafe_002dstatics"></a> |
| <p>Do not emit the extra code to use the routines specified in the C++ |
| ABI for thread-safe initialization of local statics. You can use this |
| option to reduce code size slightly in code that doesn’t need to be |
| thread-safe. |
| </p> |
| </dd> |
| <dt><code>-fuse-cxa-atexit</code></dt> |
| <dd><a name="index-fuse_002dcxa_002datexit"></a> |
| <p>Register destructors for objects with static storage duration with the |
| <code>__cxa_atexit</code> function rather than the <code>atexit</code> function. |
| This option is required for fully standards-compliant handling of static |
| destructors, but only works if your C library supports |
| <code>__cxa_atexit</code>. |
| </p> |
| </dd> |
| <dt><code>-fno-use-cxa-get-exception-ptr</code></dt> |
| <dd><a name="index-fno_002duse_002dcxa_002dget_002dexception_002dptr"></a> |
| <p>Don’t use the <code>__cxa_get_exception_ptr</code> runtime routine. This |
| causes <code>std::uncaught_exception</code> to be incorrect, but is necessary |
| if the runtime routine is not available. |
| </p> |
| </dd> |
| <dt><code>-fvisibility-inlines-hidden</code></dt> |
| <dd><a name="index-fvisibility_002dinlines_002dhidden"></a> |
| <p>This switch declares that the user does not attempt to compare |
| pointers to inline functions or methods where the addresses of the two functions |
| are taken in different shared objects. |
| </p> |
| <p>The effect of this is that GCC may, effectively, mark inline methods with |
| <code>__attribute__ ((visibility ("hidden")))</code> so that they do not |
| appear in the export table of a DSO and do not require a PLT indirection |
| when used within the DSO. Enabling this option can have a dramatic effect |
| on load and link times of a DSO as it massively reduces the size of the |
| dynamic export table when the library makes heavy use of templates. |
| </p> |
| <p>The behavior of this switch is not quite the same as marking the |
| methods as hidden directly, because it does not affect static variables |
| local to the function or cause the compiler to deduce that |
| the function is defined in only one shared object. |
| </p> |
| <p>You may mark a method as having a visibility explicitly to negate the |
| effect of the switch for that method. For example, if you do want to |
| compare pointers to a particular inline method, you might mark it as |
| having default visibility. Marking the enclosing class with explicit |
| visibility has no effect. |
| </p> |
| <p>Explicitly instantiated inline methods are unaffected by this option |
| as their linkage might otherwise cross a shared library boundary. |
| See <a href="Template-Instantiation.html#Template-Instantiation">Template Instantiation</a>. |
| </p> |
| </dd> |
| <dt><code>-fvisibility-ms-compat</code></dt> |
| <dd><a name="index-fvisibility_002dms_002dcompat"></a> |
| <p>This flag attempts to use visibility settings to make GCC’s C++ |
| linkage model compatible with that of Microsoft Visual Studio. |
| </p> |
| <p>The flag makes these changes to GCC’s linkage model: |
| </p> |
| <ol> |
| <li> It sets the default visibility to <code>hidden</code>, like |
| <samp>-fvisibility=hidden</samp>. |
| |
| </li><li> Types, but not their members, are not hidden by default. |
| |
| </li><li> The One Definition Rule is relaxed for types without explicit |
| visibility specifications that are defined in more than one |
| shared object: those declarations are permitted if they are |
| permitted when this option is not used. |
| </li></ol> |
| |
| <p>In new code it is better to use <samp>-fvisibility=hidden</samp> and |
| export those classes that are intended to be externally visible. |
| Unfortunately it is possible for code to rely, perhaps accidentally, |
| on the Visual Studio behavior. |
| </p> |
| <p>Among the consequences of these changes are that static data members |
| of the same type with the same name but defined in different shared |
| objects are different, so changing one does not change the other; |
| and that pointers to function members defined in different shared |
| objects may not compare equal. When this flag is given, it is a |
| violation of the ODR to define types with the same name differently. |
| </p> |
| </dd> |
| <dt><code>-fvtable-verify=<var>std|preinit|none</var></code></dt> |
| <dd><a name="index-fvtable_002dverify"></a> |
| <p>Turn on (or off, if using <samp>-fvtable-verify=none</samp>) the security |
| feature that verifies at runtime, for every virtual call that is made, that |
| the vtable pointer through which the call is made is valid for the type of |
| the object, and has not been corrupted or overwritten. If an invalid vtable |
| pointer is detected (at runtime), an error is reported and execution of the |
| program is immediately halted. |
| </p> |
| <p>This option causes runtime data structures to be built, at program start up, |
| for verifying the vtable pointers. The options <code>std</code> and <code>preinit</code> |
| control the timing of when these data structures are built. In both cases the |
| data structures are built before execution reaches ’main’. The |
| <samp>-fvtable-verify=std</samp> causes these data structure to be built after the |
| shared libraries have been loaded and initialized. |
| <samp>-fvtable-verify=preinit</samp> causes them to be built before the shared |
| libraries have been loaded and initialized. |
| </p> |
| <p>If this option appears multiple times in the compiler line, with different |
| values specified, ’none’ will take highest priority over both ’std’ and |
| ’preinit’; ’preinit’ will take priority over ’std’. |
| </p> |
| </dd> |
| <dt><code>-fvtv-debug</code></dt> |
| <dd><a name="index-_0028fvtv_002ddebug_0029"></a> |
| <p>Causes debug versions of the runtime functions for the vtable verification |
| feature to be called. This assumes the <samp>-fvtable-verify=std</samp> or |
| <samp>-fvtable-verify=preinit</samp> has been used. This flag will also cause the |
| compiler to keep track of which vtable pointers it found for each class, and |
| record that information in the file “vtv_set_ptr_data.log”, in the dump |
| file directory on the user’s machine. |
| </p> |
| <p>Note: This feature APPENDS data to the log file. If you want a fresh log |
| file, be sure to delete any existing one. |
| </p> |
| </dd> |
| <dt><code>-fvtv-counts</code></dt> |
| <dd><a name="index-fvtv_002dcounts"></a> |
| <p>This is a debugging flag. When used in conjunction with |
| <samp>-fvtable-verify=std</samp> or <samp>-fvtable-verify=preinit</samp>, this |
| causes the compiler to keep track of the total number of virtual calls |
| it encountered and the number of verifications it inserted. It also |
| counts the number of calls to certain runtime library functions |
| that it inserts. This information, for each compilation unit, is written |
| to a file named “vtv_count_data.log”, in the dump_file directory on |
| the user’s machine. It also counts the size of the vtable pointer sets |
| for each class, and writes this information to “vtv_class_set_sizes.log” |
| in the same directory. |
| </p> |
| <p>Note: This feature APPENDS data to the log files. To get a fresh log |
| files, be sure to delete any existing ones. |
| </p> |
| </dd> |
| <dt><code>-fno-weak</code></dt> |
| <dd><a name="index-fno_002dweak"></a> |
| <p>Do not use weak symbol support, even if it is provided by the linker. |
| By default, G++ uses weak symbols if they are available. This |
| option exists only for testing, and should not be used by end-users; |
| it results in inferior code and has no benefits. This option may |
| be removed in a future release of G++. |
| </p> |
| </dd> |
| <dt><code>-nostdinc++</code></dt> |
| <dd><a name="index-nostdinc_002b_002b"></a> |
| <p>Do not search for header files in the standard directories specific to |
| C++, but do still search the other standard directories. (This option |
| is used when building the C++ library.) |
| </p></dd> |
| </dl> |
| |
| <p>In addition, these optimization, warning, and code generation options |
| have meanings only for C++ programs: |
| </p> |
| <dl compact="compact"> |
| <dt><code>-Wabi <span class="roman">(C, Objective-C, C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wabi"></a> |
| <a name="index-Wno_002dabi"></a> |
| <p>Warn when G++ generates code that is probably not compatible with the |
| vendor-neutral C++ ABI. Although an effort has been made to warn about |
| all such cases, there are probably some cases that are not warned about, |
| even though G++ is generating incompatible code. There may also be |
| cases where warnings are emitted even though the code that is generated |
| is compatible. |
| </p> |
| <p>You should rewrite your code to avoid these warnings if you are |
| concerned about the fact that code generated by G++ may not be binary |
| compatible with code generated by other compilers. |
| </p> |
| <p>The known incompatibilities in <samp>-fabi-version=2</samp> (the default) include: |
| </p> |
| <ul> |
| <li> A template with a non-type template parameter of reference type is |
| mangled incorrectly: |
| <div class="smallexample"> |
| <pre class="smallexample">extern int N; |
| template <int &> struct S {}; |
| void n (S<N>) {2} |
| </pre></div> |
| |
| <p>This is fixed in <samp>-fabi-version=3</samp>. |
| </p> |
| </li><li> SIMD vector types declared using <code>__attribute ((vector_size))</code> are |
| mangled in a non-standard way that does not allow for overloading of |
| functions taking vectors of different sizes. |
| |
| <p>The mangling is changed in <samp>-fabi-version=4</samp>. |
| </p></li></ul> |
| |
| <p>The known incompatibilities in <samp>-fabi-version=1</samp> include: |
| </p> |
| <ul> |
| <li> Incorrect handling of tail-padding for bit-fields. G++ may attempt to |
| pack data into the same byte as a base class. For example: |
| |
| <div class="smallexample"> |
| <pre class="smallexample">struct A { virtual void f(); int f1 : 1; }; |
| struct B : public A { int f2 : 1; }; |
| </pre></div> |
| |
| <p>In this case, G++ places <code>B::f2</code> into the same byte |
| as <code>A::f1</code>; other compilers do not. You can avoid this problem |
| by explicitly padding <code>A</code> so that its size is a multiple of the |
| byte size on your platform; that causes G++ and other compilers to |
| lay out <code>B</code> identically. |
| </p> |
| </li><li> Incorrect handling of tail-padding for virtual bases. G++ does not use |
| tail padding when laying out virtual bases. For example: |
| |
| <div class="smallexample"> |
| <pre class="smallexample">struct A { virtual void f(); char c1; }; |
| struct B { B(); char c2; }; |
| struct C : public A, public virtual B {}; |
| </pre></div> |
| |
| <p>In this case, G++ does not place <code>B</code> into the tail-padding for |
| <code>A</code>; other compilers do. You can avoid this problem by |
| explicitly padding <code>A</code> so that its size is a multiple of its |
| alignment (ignoring virtual base classes); that causes G++ and other |
| compilers to lay out <code>C</code> identically. |
| </p> |
| </li><li> Incorrect handling of bit-fields with declared widths greater than that |
| of their underlying types, when the bit-fields appear in a union. For |
| example: |
| |
| <div class="smallexample"> |
| <pre class="smallexample">union U { int i : 4096; }; |
| </pre></div> |
| |
| <p>Assuming that an <code>int</code> does not have 4096 bits, G++ makes the |
| union too small by the number of bits in an <code>int</code>. |
| </p> |
| </li><li> Empty classes can be placed at incorrect offsets. For example: |
| |
| <div class="smallexample"> |
| <pre class="smallexample">struct A {}; |
| |
| struct B { |
| A a; |
| virtual void f (); |
| }; |
| |
| struct C : public B, public A {}; |
| </pre></div> |
| |
| <p>G++ places the <code>A</code> base class of <code>C</code> at a nonzero offset; |
| it should be placed at offset zero. G++ mistakenly believes that the |
| <code>A</code> data member of <code>B</code> is already at offset zero. |
| </p> |
| </li><li> Names of template functions whose types involve <code>typename</code> or |
| template template parameters can be mangled incorrectly. |
| |
| <div class="smallexample"> |
| <pre class="smallexample">template <typename Q> |
| void f(typename Q::X) {} |
| |
| template <template <typename> class Q> |
| void f(typename Q<int>::X) {} |
| </pre></div> |
| |
| <p>Instantiations of these templates may be mangled incorrectly. |
| </p> |
| </li></ul> |
| |
| <p>It also warns about psABI-related changes. The known psABI changes at this |
| point include: |
| </p> |
| <ul> |
| <li> For SysV/x86-64, unions with <code>long double</code> members are |
| passed in memory as specified in psABI. For example: |
| |
| <div class="smallexample"> |
| <pre class="smallexample">union U { |
| long double ld; |
| int i; |
| }; |
| </pre></div> |
| |
| <p><code>union U</code> is always passed in memory. |
| </p> |
| </li></ul> |
| |
| </dd> |
| <dt><code>-Wctor-dtor-privacy <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wctor_002ddtor_002dprivacy"></a> |
| <a name="index-Wno_002dctor_002ddtor_002dprivacy"></a> |
| <p>Warn when a class seems unusable because all the constructors or |
| destructors in that class are private, and it has neither friends nor |
| public static member functions. Also warn if there are no non-private |
| methods, and there’s at least one private member function that isn’t |
| a constructor or destructor. |
| </p> |
| </dd> |
| <dt><code>-Wdelete-non-virtual-dtor <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wdelete_002dnon_002dvirtual_002ddtor"></a> |
| <a name="index-Wno_002ddelete_002dnon_002dvirtual_002ddtor"></a> |
| <p>Warn when ‘<samp>delete</samp>’ is used to destroy an instance of a class that |
| has virtual functions and non-virtual destructor. It is unsafe to delete |
| an instance of a derived class through a pointer to a base class if the |
| base class does not have a virtual destructor. This warning is enabled |
| by <samp>-Wall</samp>. |
| </p> |
| </dd> |
| <dt><code>-Wliteral-suffix <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wliteral_002dsuffix"></a> |
| <a name="index-Wno_002dliteral_002dsuffix"></a> |
| <p>Warn when a string or character literal is followed by a ud-suffix which does |
| not begin with an underscore. As a conforming extension, GCC treats such |
| suffixes as separate preprocessing tokens in order to maintain backwards |
| compatibility with code that uses formatting macros from <code><inttypes.h></code>. |
| For example: |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">#define __STDC_FORMAT_MACROS |
| #include <inttypes.h> |
| #include <stdio.h> |
| |
| int main() { |
| int64_t i64 = 123; |
| printf("My int64: %"PRId64"\n", i64); |
| } |
| </pre></div> |
| |
| <p>In this case, <code>PRId64</code> is treated as a separate preprocessing token. |
| </p> |
| <p>This warning is enabled by default. |
| </p> |
| </dd> |
| <dt><code>-Wnarrowing <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wnarrowing"></a> |
| <a name="index-Wno_002dnarrowing"></a> |
| <p>Warn when a narrowing conversion prohibited by C++11 occurs within |
| ‘<samp>{ }</samp>’, e.g. |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">int i = { 2.2 }; // error: narrowing from double to int |
| </pre></div> |
| |
| <p>This flag is included in <samp>-Wall</samp> and <samp>-Wc++11-compat</samp>. |
| </p> |
| <p>With <samp>-std=c++11</samp>, <samp>-Wno-narrowing</samp> suppresses the diagnostic |
| required by the standard. Note that this does not affect the meaning |
| of well-formed code; narrowing conversions are still considered |
| ill-formed in SFINAE context. |
| </p> |
| </dd> |
| <dt><code>-Wnoexcept <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wnoexcept"></a> |
| <a name="index-Wno_002dnoexcept"></a> |
| <p>Warn when a noexcept-expression evaluates to false because of a call |
| to a function that does not have a non-throwing exception |
| specification (i.e. ‘<samp>throw()</samp>’ or ‘<samp>noexcept</samp>’) but is known by |
| the compiler to never throw an exception. |
| </p> |
| </dd> |
| <dt><code>-Wnon-virtual-dtor <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wnon_002dvirtual_002ddtor"></a> |
| <a name="index-Wno_002dnon_002dvirtual_002ddtor"></a> |
| <p>Warn when a class has virtual functions and an accessible non-virtual |
| destructor itself or in an accessible polymorphic base class, in which |
| case it is possible but unsafe to delete an instance of a derived |
| class through a pointer to the class itself or base class. This |
| warning is automatically enabled if <samp>-Weffc++</samp> is specified. |
| </p> |
| </dd> |
| <dt><code>-Wreorder <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wreorder"></a> |
| <a name="index-Wno_002dreorder"></a> |
| <a name="index-reordering_002c-warning"></a> |
| <a name="index-warning-for-reordering-of-member-initializers"></a> |
| <p>Warn when the order of member initializers given in the code does not |
| match the order in which they must be executed. For instance: |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">struct A { |
| int i; |
| int j; |
| A(): j (0), i (1) { } |
| }; |
| </pre></div> |
| |
| <p>The compiler rearranges the member initializers for ‘<samp>i</samp>’ |
| and ‘<samp>j</samp>’ to match the declaration order of the members, emitting |
| a warning to that effect. This warning is enabled by <samp>-Wall</samp>. |
| </p> |
| </dd> |
| <dt><code>-fext-numeric-literals <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-fext_002dnumeric_002dliterals"></a> |
| <a name="index-fno_002dext_002dnumeric_002dliterals"></a> |
| <p>Accept imaginary, fixed-point, or machine-defined |
| literal number suffixes as GNU extensions. |
| When this option is turned off these suffixes are treated |
| as C++11 user-defined literal numeric suffixes. |
| This is on by default for all pre-C++11 dialects and all GNU dialects: |
| <samp>-std=c++98</samp>, <samp>-std=gnu++98</samp>, <samp>-std=gnu++11</samp>, |
| <samp>-std=gnu++1y</samp>. |
| This option is off by default |
| for ISO C++11 onwards (<samp>-std=c++11</samp>, ...). |
| </p></dd> |
| </dl> |
| |
| <p>The following <samp>-W…</samp> options are not affected by <samp>-Wall</samp>. |
| </p> |
| <dl compact="compact"> |
| <dt><code>-Weffc++ <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Weffc_002b_002b"></a> |
| <a name="index-Wno_002deffc_002b_002b"></a> |
| <p>Warn about violations of the following style guidelines from Scott Meyers’ |
| <cite>Effective C++</cite> series of books: |
| </p> |
| <ul> |
| <li> Define a copy constructor and an assignment operator for classes |
| with dynamically-allocated memory. |
| |
| </li><li> Prefer initialization to assignment in constructors. |
| |
| </li><li> Have <code>operator=</code> return a reference to <code>*this</code>. |
| |
| </li><li> Don’t try to return a reference when you must return an object. |
| |
| </li><li> Distinguish between prefix and postfix forms of increment and |
| decrement operators. |
| |
| </li><li> Never overload <code>&&</code>, <code>||</code>, or <code>,</code>. |
| |
| </li></ul> |
| |
| <p>This option also enables <samp>-Wnon-virtual-dtor</samp>, which is also |
| one of the effective C++ recommendations. However, the check is |
| extended to warn about the lack of virtual destructor in accessible |
| non-polymorphic bases classes too. |
| </p> |
| <p>When selecting this option, be aware that the standard library |
| headers do not obey all of these guidelines; use ‘<samp>grep -v</samp>’ |
| to filter out those warnings. |
| </p> |
| </dd> |
| <dt><code>-Wstrict-null-sentinel <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wstrict_002dnull_002dsentinel"></a> |
| <a name="index-Wno_002dstrict_002dnull_002dsentinel"></a> |
| <p>Warn about the use of an uncasted <code>NULL</code> as sentinel. When |
| compiling only with GCC this is a valid sentinel, as <code>NULL</code> is defined |
| to <code>__null</code>. Although it is a null pointer constant rather than a |
| null pointer, it is guaranteed to be of the same size as a pointer. |
| But this use is not portable across different compilers. |
| </p> |
| </dd> |
| <dt><code>-Wno-non-template-friend <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wno_002dnon_002dtemplate_002dfriend"></a> |
| <a name="index-Wnon_002dtemplate_002dfriend"></a> |
| <p>Disable warnings when non-templatized friend functions are declared |
| within a template. Since the advent of explicit template specification |
| support in G++, if the name of the friend is an unqualified-id (i.e., |
| ‘<samp>friend foo(int)</samp>’), the C++ language specification demands that the |
| friend declare or define an ordinary, nontemplate function. (Section |
| 14.5.3). Before G++ implemented explicit specification, unqualified-ids |
| could be interpreted as a particular specialization of a templatized |
| function. Because this non-conforming behavior is no longer the default |
| behavior for G++, <samp>-Wnon-template-friend</samp> allows the compiler to |
| check existing code for potential trouble spots and is on by default. |
| This new compiler behavior can be turned off with |
| <samp>-Wno-non-template-friend</samp>, which keeps the conformant compiler code |
| but disables the helpful warning. |
| </p> |
| </dd> |
| <dt><code>-Wold-style-cast <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wold_002dstyle_002dcast"></a> |
| <a name="index-Wno_002dold_002dstyle_002dcast"></a> |
| <p>Warn if an old-style (C-style) cast to a non-void type is used within |
| a C++ program. The new-style casts (‘<samp>dynamic_cast</samp>’, |
| ‘<samp>static_cast</samp>’, ‘<samp>reinterpret_cast</samp>’, and ‘<samp>const_cast</samp>’) are |
| less vulnerable to unintended effects and much easier to search for. |
| </p> |
| </dd> |
| <dt><code>-Woverloaded-virtual <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Woverloaded_002dvirtual"></a> |
| <a name="index-Wno_002doverloaded_002dvirtual"></a> |
| <a name="index-overloaded-virtual-function_002c-warning"></a> |
| <a name="index-warning-for-overloaded-virtual-function"></a> |
| <p>Warn when a function declaration hides virtual functions from a |
| base class. For example, in: |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">struct A { |
| virtual void f(); |
| }; |
| |
| struct B: public A { |
| void f(int); |
| }; |
| </pre></div> |
| |
| <p>the <code>A</code> class version of <code>f</code> is hidden in <code>B</code>, and code |
| like: |
| </p> |
| <div class="smallexample"> |
| <pre class="smallexample">B* b; |
| b->f(); |
| </pre></div> |
| |
| <p>fails to compile. |
| </p> |
| </dd> |
| <dt><code>-Wno-pmf-conversions <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wno_002dpmf_002dconversions"></a> |
| <a name="index-Wpmf_002dconversions"></a> |
| <p>Disable the diagnostic for converting a bound pointer to member function |
| to a plain pointer. |
| </p> |
| </dd> |
| <dt><code>-Wsign-promo <span class="roman">(C++ and Objective-C++ only)</span></code></dt> |
| <dd><a name="index-Wsign_002dpromo"></a> |
| <a name="index-Wno_002dsign_002dpromo"></a> |
| <p>Warn when overload resolution chooses a promotion from unsigned or |
| enumerated type to a signed type, over a conversion to an unsigned type of |
| the same size. Previous versions of G++ tried to preserve |
| unsignedness, but the standard mandates the current behavior. |
| </p></dd> |
| </dl> |
| |
| <hr> |
| <div class="header"> |
| <p> |
| Next: <a href="Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options.html#Objective_002dC-and-Objective_002dC_002b_002b-Dialect-Options" accesskey="n" rel="next">Objective-C and Objective-C++ Dialect Options</a>, Previous: <a href="C-Dialect-Options.html#C-Dialect-Options" accesskey="p" rel="prev">C Dialect Options</a>, Up: <a href="Invoking-GCC.html#Invoking-GCC" accesskey="u" rel="up">Invoking GCC</a> [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p> |
| </div> |
| |
| |
| |
| </body> |
| </html> |