Lines Matching full:them
65 compilers, including how to port them to new targets and some
166 you want them to be errors rather than warnings). *Note Options
239 environment, you will need to find them elsewhere (for example, in the
265 specify `-pedantic' (or `-pedantic-errors' if you want them to be
279 `-pedantic-errors' if you want them to be errors rather than warnings).
329 documented here, since you rarely need to use any of them.
1364 have no documentation associated with them will also be displayed.
1527 these names and compiles them as C++ programs even if you call the
1573 want to use them in an ISO C program, of course, but it is useful
1574 to put them in header files that might be included in compilations
1901 has been added for putting variables into BSS without making them
2547 them.
2598 the remaining front ends would be able to digest them correctly.
2710 these escape routes; application programs should avoid them.
2779 them warn about constructions that users generally do not consider
2783 to suppress the warning. Some of them are enabled by `-Wextra' but
2784 many of them must be enabled individually.
3043 with no sequence point between them, the order in which the
3392 traditional C by indenting them. Some traditional
3576 to them. Warnings about conversions between signed and unsigned
4154 `-femit-struct-debug-detailed' does not yet implement them.
4188 information describing them as in `NEW' instead.
4597 passes generate them. The default with no option is to sum
4805 that produce them. You can use the `-frandom-seed' option to
4829 them in the current directory and name them based on the source
4878 switches that enable them. The directory name is separated from
4902 components where `gcc' expects to find them, or you can set the
4904 installed them. Don't forget the trailing `/'. *Note Environment
4964 when compiling each of them.
5086 the stack for several function calls and pops them all at once.
5312 them independently. This normally generates better code for those
6041 sections and linker must place them in a reasonable way.
6201 statements. Output them in the same order that they appear in the
6334 modifying them to store all pertinent intermediate computations
6546 actually performs the optimizations based on them. Currently the
6723 on them. This value is ignored in the case where all
6736 compilation process, and unfactors them as late as possible.
7357 performed on them. The default value of the parameter is
7490 by default and have no options to control them.
7561 them.
7569 Some of them are left out by default, since they trigger
7624 and adds them to the dependency list without raising an error.
7650 specify. If you want multiple targets, you can specify them as a
8035 trigraphs, but in standard-conforming modes it converts them. See
8295 supply the correct flags may lead to subtle defects. Supplying them in
8429 3.15 Specifying subprocesses and the switches to pass to them
8556 expanding these sequences. Therefore you can concatenate them together
8557 or combine them with constant text in a single argument.
8636 automatically placed around them. You should write spaces around
8956 them if you can just run that directly.
9913 man page describes them in detail.
9933 built so as not to call them.
10508 floats on 4 byte boundaries. `-malign-300' causes them to be
11651 generate special code to reference them.
11655 generate special instructions to reference them.
12395 supports them.
12588 support them and `-mdivide-breaks' to force the use of breaks.
12628 assembler files (with a `.s' suffix) when assembling them.
13204 disable them individually if you're sure it'll work in your
13336 64-bit `long' type, and the infrastructure needed to support them.
14483 its branch. There is little reason to disable them, except for
14822 them as close as possible to their references. This may be
14872 Most of them have both positive and negative forms; the negative form
15007 section of the object file, rather than generating them as common
15010 multiple-definition error when you link them. In this case, you
15374 An overview of these techniques, their benefits and how to use them
15385 operates. Some of them work by specifying directories or prefixes to
15475 for special linker files, if it can't find them using
15594 a project, include them from another header file, precompile that header
15714 of the source file, to make them available for any calls that precede
15754 compilation options to make them a single word in the shell.
16448 These extensions are available in C and Objective-C. Most of them are
16496 (With them you can define ``built-in'' functions.)
16654 contains nested loops, a `goto' can be useful for breaking out of them.
16757 them being always the same, `__attribute__((__noinline__))' should be
16831 technique called "trampolines". A paper describing them is available as
16898 therefore, not recommended to use them outside very simple functions
17117 and as an extension GCC supports them in C89 mode and in C++. Simply
17147 supports them in C89 mode and in C++, and supports complex integer data
17416 elements in array" is given, and the excess elements (all of them, in
17476 extension GCC accepts them in C89 mode and in C++. (However, GCC's
17568 GNU CPP has two further variadic macro extensions, and permits them to
17622 them. As an extension, GCC allows such arrays to be subscripted in C89
17831 Currently, GCC will discard them and issue a warning.
17940 keyword. This allows you to use them in header files without being
18666 their own functions that never return. You can declare them
19248 translation units and performing a reloadable link on them.
19254 You can specify multiple attributes in a declaration by separating them
19556 machines, typically because the target assembler does not allow them.
19615 keyword. This allows you to use them in header files without being
19949 may be that the Microsoft ABI packs them differently than GCC
19950 would normally pack them. Particularly when moving packed data
20417 may be that the Microsoft ABI packs them differently than GCC
20418 would normally pack them. Particularly when moving packed data
20426 To specify multiple attributes, separate them by commas within the
20643 The connection between them is expressed by constraints which say they
20805 they cannot take account of them when deciding how to optimize.
20808 encapsulate them in macros that look like functions. For example,
20830 used, but you must be careful, because the compiler may eliminate them
20831 if the output operands aren't used, or move them out of loops, or
20984 and replaces them with one output. The user must code the `st(1)'
21143 them an input-output operand:
22890 (unless you recompile them specially for the task at hand).
22921 variables, and to restore them in a `longjmp'. This way, the same
23015 as macros to replace them with the customary keywords. It looks like
23112 3.4 and later treat them as variables, like `__func__'. In C++,
23234 You can declare variables and use them in function calls and returns,
23408 them, it returns `(size_t) -1' for TYPE 0 or 1 and `(size_t) 0'
23410 and all of them are known at compile time, the returned number is
23501 the compiler is able to optimize them to `fputc' etc. functions, it
23580 purpose to which ISO C99 puts them. All these functions have
23795 supports them, data prefetch instructions will be generated. If
30329 mode. All of them implement the function that is part of the name.
30341 of them generate the machine instruction that is part of the name.
30398 of them generate the machine instruction that is part of the name.
30416 All of them generate the machine instruction that is part of the name.
30520 All of them generate the machine instruction that is part of the name.
30678 All of them generate the machine instruction that is part of the name.
30699 All of them generate the machine instruction that is part of the name
30720 All of them generate the machine instruction that is part of the name
30741 used. All of them generate the machine instruction that is part of the
30818 used. All of them generate the machine instruction that is part of the
30864 All of them generate the machine instruction that is part of the name.
30996 All of them generate the machine instruction that is part of the name.
31011 All of them generate the machine instruction that is part of the name.
31021 All of them generate the machine instruction that is part of the name
31234 All of them generate the machine instruction that is part of the name.
31258 `-march=athlon' are used. All of them generate the machine instruction
32059 `pixel' and `bool' is disabled. To use them, you must include
34065 may make them incompatible. This pragma is useful when a
34158 platforms whose system headers need them. To get this effect on all
34274 them as errors depending on which preprocessor macros are defined.
34279 controlled by `-W...') can be controlled, and not all of them.
34281 controllable and which option controls them.
34294 your sources, the only supported location for them is before any
34902 will use them. This way one copy will override all the others, but the
34926 mentioned in *Note Vague Linkage::. Using them can actually cause your
35019 emits template instances in each translation unit that uses them,
35020 and the linker collapses them together. The advantage of this
35095 perhaps putting them in the translation units where the instances
35117 other files) without having to specify them as well.
35381 writing C++ code that uses Java exceptions, and handle them
35401 destructors when exceptions are thrown through them.
35778 the allocated objects, yet allow them to be collected. This kind of
35841 class. To be able to support them, the GNU Objective-C compiler
35871 will find them at runtime).
36114 your complex macros behave like functions, you can replace them with
36244 `gcov' development progresses -- do not rely on them remaining
36446 combining them with other lines. For example, code like this:
36554 use them for profile directed optimizations (`--use-profile'), or to
36564 of these are not GCC bugs per se--if they were, we would fix them. But
36702 may even be impossible to generate them.
37034 way around them.
37086 look for them. The scripts adapt to various systems by searching
37102 them into memory truncates them.
37115 destructor are unused and removing them before the scanning can
37206 declarations for them after declaring the template, but before
37422 without them.
37433 macro calls, you can easily convert them manually.
37439 instances and warn about them.
37444 There is no automatic way to verify that you have got them all,
37478 do not make because we think GCC is better without them.
37497 Such assignments must be very common; warning about them would
37535 in every other context, it is cleanest for them to be the same in
37637 program is to have a delay, so deleting them will not make real
37646 taken to execute them, of course). In case the loop can be proved
37711 but include the text `warning:' to distinguish them from error
37717 warnings are issued only if you ask for them, with one of the `-W'
37726 `-pedantic-errors' says to make them errors instead. This does not
37870 it from them. So when you compare distributors, judge them partly by
37892 contribute little, since someone else would surely do them; difficult
37952 them if you wish), that you receive source code or can get it if you
37964 or can get the source code. And you must show them these terms so they
37978 modified versions of the software inside them, although the
38104 sole purpose of having them make modifications exclusively for
38110 terms that prohibit them from making any copies of your
38173 Notices, your work need not make them do so.
38472 receiving the covered work authorizing them to use, propagate,
38596 to attach them to the start of each source file to most effectively
38707 regarding them.
38824 copies, to give them a chance to provide you with an updated
38942 unmodified, and list them all as Invariant Sections of your
39083 them the project would not have been nearly as successful as it has
