📄 non-bugs.html
字号:
<html lang="en">
<head>
<title>Using the GNU Compiler Collection (GCC)</title>
<meta http-equiv="Content-Type" content="text/html">
<meta name="description" content="Using the GNU Compiler Collection (GCC)">
<meta name="generator" content="makeinfo 4.3">
<link href="http://www.gnu.org/software/texinfo/" rel="generator-home">
<!--
Copyright © 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
<p>Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "GNU General Public License" and "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".
<p>(a) The FSF's Front-Cover Text is:
<p>A GNU Manual
<p>(b) The FSF's Back-Cover Text is:
<p>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.-->
</head>
<body>
<div class="node">
<p>
Node:<a name="Non-bugs">Non-bugs</a>,
Next:<a rel="next" accesskey="n" href="Warnings-and-Errors.html#Warnings%20and%20Errors">Warnings and Errors</a>,
Previous:<a rel="previous" accesskey="p" href="Protoize-Caveats.html#Protoize%20Caveats">Protoize Caveats</a>,
Up:<a rel="up" accesskey="u" href="Trouble.html#Trouble">Trouble</a>
<hr><br>
</div>
<h3 class="section">Certain Changes We Don't Want to Make</h3>
<p>This section lists changes that people frequently request, but which
we do not make because we think GCC is better without them.
<ul>
<li>Checking the number and type of arguments to a function which has an
old-fashioned definition and no prototype.
<p>Such a feature would work only occasionally--only for calls that appear
in the same file as the called function, following the definition. The
only way to check all calls reliably is to add a prototype for the
function. But adding a prototype eliminates the motivation for this
feature. So the feature is not worthwhile.
</p><li>Warning about using an expression whose type is signed as a shift count.
<p>Shift count operands are probably signed more often than unsigned.
Warning about this would cause far more annoyance than good.
</p><li>Warning about assigning a signed value to an unsigned variable.
<p>Such assignments must be very common; warning about them would cause
more annoyance than good.
</p><li>Warning when a non-void function value is ignored.
<p>Coming as I do from a Lisp background, I balk at the idea that there is
something dangerous about discarding a value. There are functions that
return values which some callers may find useful; it makes no sense to
clutter the program with a cast to <code>void</code> whenever the value isn't
useful.
</p><li>Making <code>-fshort-enums</code> the default.
<p>This would cause storage layout to be incompatible with most other C
compilers. And it doesn't seem very important, given that you can get
the same result in other ways. The case where it matters most is when
the enumeration-valued object is inside a structure, and in that case
you can specify a field width explicitly.
</p><li>Making bit-fields unsigned by default on particular machines where "the
ABI standard" says to do so.
<p>The ISO C standard leaves it up to the implementation whether a bit-field
declared plain <code>int</code> is signed or not. This in effect creates two
alternative dialects of C.
<p>The GNU C compiler supports both dialects; you can specify the signed
dialect with <code>-fsigned-bitfields</code> and the unsigned dialect with
<code>-funsigned-bitfields</code>. However, this leaves open the question of
which dialect to use by default.
<p>Currently, the preferred dialect makes plain bit-fields signed, because
this is simplest. Since <code>int</code> is the same as <code>signed int</code> in
every other context, it is cleanest for them to be the same in bit-fields
as well.
<p>Some computer manufacturers have published Application Binary Interface
standards which specify that plain bit-fields should be unsigned. It is
a mistake, however, to say anything about this issue in an ABI. This is
because the handling of plain bit-fields distinguishes two dialects of C.
Both dialects are meaningful on every type of machine. Whether a
particular object file was compiled using signed bit-fields or unsigned
is of no concern to other object files, even if they access the same
bit-fields in the same data structures.
<p>A given program is written in one or the other of these two dialects.
The program stands a chance to work on most any machine if it is
compiled with the proper dialect. It is unlikely to work at all if
compiled with the wrong dialect.
<p>Many users appreciate the GNU C compiler because it provides an
environment that is uniform across machines. These users would be
inconvenienced if the compiler treated plain bit-fields differently on
certain machines.
<p>Occasionally users write programs intended only for a particular machine
type. On these occasions, the users would benefit if the GNU C compiler
were to support by default the same dialect as the other compilers on
that machine. But such applications are rare. And users writing a
program to run on more than one type of machine cannot possibly benefit
from this kind of compatibility.
<p>This is why GCC does and will treat plain bit-fields in the same
fashion on all types of machines (by default).
<p>There are some arguments for making bit-fields unsigned by default on all
machines. If, for example, this becomes a universal de facto standard,
it would make sense for GCC to go along with it. This is something
to be considered in the future.
<p>(Of course, users strongly concerned about portability should indicate
explicitly in each bit-field whether it is signed or not. In this way,
they write programs which have the same meaning in both C dialects.)
</p><li>Undefining <code>__STDC__</code> when <code>-ansi</code> is not used.
<p>Currently, GCC defines <code>__STDC__</code> unconditionally. This provides
good results in practice.
<p>Programmers normally use conditionals on <code>__STDC__</code> to ask whether
it is safe to use certain features of ISO C, such as function
prototypes or ISO token concatenation. Since plain <code>gcc</code> supports
all the features of ISO C, the correct answer to these questions is
"yes".
<p>Some users try to use <code>__STDC__</code> to check for the availability of
certain library facilities. This is actually incorrect usage in an ISO
C program, because the ISO C standard says that a conforming
freestanding implementation should define <code>__STDC__</code> even though it
does not have the library facilities. <code>gcc -ansi -pedantic</code> is a
conforming freestanding implementation, and it is therefore required to
define <code>__STDC__</code>, even though it does not come with an ISO C
library.
<p>Sometimes people say that defining <code>__STDC__</code> in a compiler that
does not completely conform to the ISO C standard somehow violates the
standard. This is illogical. The standard is a standard for compilers
that claim to support ISO C, such as <code>gcc -ansi</code>--not for other
compilers such as plain <code>gcc</code>. Whatever the ISO C standard says
is relevant to the design of plain <code>gcc</code> without <code>-ansi</code> only
for pragmatic reasons, not as a requirement.
<p>GCC normally defines <code>__STDC__</code> to be 1, and in addition
defines <code>__STRICT_ANSI__</code> if you specify the <code>-ansi</code> option,
or a <code>-std</code> option for strict conformance to some version of ISO C.
On some hosts, system include files use a different convention, where
<code>__STDC__</code> is normally 0, but is 1 if the user specifies strict
conformance to the C Standard. GCC follows the host convention when
processing system include files, but when processing user files it follows
the usual GNU C convention.
</p><li>Undefining <code>__STDC__</code> in C++.
<p>Programs written to compile with C++-to-C translators get the
value of <code>__STDC__</code> that goes with the C compiler that is
subsequently used. These programs must test <code>__STDC__</code>
to determine what kind of C preprocessor that compiler uses:
whether they should concatenate tokens in the ISO C fashion
or in the traditional fashion.
<p>These programs work properly with GNU C++ if <code>__STDC__</code> is defined.
They would not work otherwise.
<p>In addition, many header files are written to provide prototypes in ISO
C but not in traditional C. Many of these header files can work without
change in C++ provided <code>__STDC__</code> is defined. If <code>__STDC__</code>
is not defined, they will all fail, and will all need to be changed to
test explicitly for C++ as well.
</p><li>Deleting "empty" loops.
<p>Historically, GCC has not deleted "empty" loops under the
assumption that the most likely reason you would put one in a program is
to have a delay, so deleting them will not make real programs run any
faster.
<p>However, the rationale here is that optimization of a nonempty loop
cannot produce an empty one, which holds for C but is not always the
case for C++.
<p>Moreover, with <code>-funroll-loops</code> small "empty" loops are already
removed, so the current behavior is both sub-optimal and inconsistent
and will change in the future.
</p><li>Making side effects happen in the same order as in some other compiler.
<p>It is never safe to depend on the order of evaluation of side effects.
For example, a function call like this may very well behave differently
from one compiler to another:
<pre class="example"> void func (int, int);
int i = 2;
func (i++, i++);
</pre>
<p>There is no guarantee (in either the C or the C++ standard language
definitions) that the increments will be evaluated in any particular
order. Either increment might happen first. <code>func</code> might get the
arguments <code>2, 3</code>, or it might get <code>3, 2</code>, or even <code>2, 2</code>.
</p><li>Not allowing structures with volatile fields in registers.
<p>Strictly speaking, there is no prohibition in the ISO C standard
against allowing structures with volatile fields in registers, but
it does not seem to make any sense and is probably not what you wanted
to do. So the compiler will give an error message in this case.
</p><li>Making certain warnings into errors by default.
<p>Some ISO C testsuites report failure when the compiler does not produce
an error message for a certain program.
<p>ISO C requires a "diagnostic" message for certain kinds of invalid
programs, but a warning is defined by GCC to count as a diagnostic. If
GCC produces a warning but not an error, that is correct ISO C support.
If test suites call this "failure", they should be run with the GCC
option <code>-pedantic-errors</code>, which will turn these warnings into
errors.
</ul>
</body></html>
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -