![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-20 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to gcc.info-20 CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: This is Info file gcc.info, produced by Makeinfo-1.54 from the input
2: file gcc.texi.
3:
4: This file documents the use and the internals of the GNU compiler.
5:
6: Published by the Free Software Foundation 675 Massachusetts Avenue
7: Cambridge, MA 02139 USA
8:
9: Copyright (C) 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
10:
11: Permission is granted to make and distribute verbatim copies of this
12: manual provided the copyright notice and this permission notice are
13: preserved on all copies.
14:
15: Permission is granted to copy and distribute modified versions of
16: this manual under the conditions for verbatim copying, provided also
17: that the sections entitled "GNU General Public License" and "Protect
18: Your Freedom--Fight `Look And Feel'" are included exactly as in the
19: original, and provided that the entire resulting derived work is
20: distributed under the terms of a permission notice identical to this
21: one.
22:
23: Permission is granted to copy and distribute translations of this
24: manual into another language, under the above conditions for modified
25: versions, except that the sections entitled "GNU General Public
26: License" and "Protect Your Freedom--Fight `Look And Feel'", and this
27: permission notice, may be included in translations approved by the Free
28: Software Foundation instead of in the original English.
29:
30:
31: File: gcc.info, Node: Instruction Output, Next: Dispatch Tables, Prev: Macros for Initialization, Up: Assembler Format
32:
33: Output of Assembler Instructions
34: --------------------------------
35:
36: `REGISTER_NAMES'
37: A C initializer containing the assembler's names for the machine
38: registers, each one as a C string constant. This is what
39: translates register numbers in the compiler into assembler
40: language.
41:
42: `ADDITIONAL_REGISTER_NAMES'
43: If defined, a C initializer for an array of structures containing
44: a name and a register number. This macro defines additional names
45: for hard registers, thus allowing the `asm' option in declarations
46: to refer to registers using alternate names.
47:
48: `ASM_OUTPUT_OPCODE (STREAM, PTR)'
49: Define this macro if you are using an unusual assembler that
50: requires different names for the machine instructions.
51:
52: The definition is a C statement or statements which output an
53: assembler instruction opcode to the stdio stream STREAM. The
54: macro-operand PTR is a variable of type `char *' which points to
55: the opcode name in its "internal" form--the form that is written
56: in the machine description. The definition should output the
57: opcode name to STREAM, performing any translation you desire, and
58: increment the variable PTR to point at the end of the opcode so
59: that it will not be output twice.
60:
61: In fact, your macro definition may process less than the entire
62: opcode name, or more than the opcode name; but if you want to
63: process text that includes `%'-sequences to substitute operands,
64: you must take care of the substitution yourself. Just be sure to
65: increment PTR over whatever text should not be output normally.
66:
67: If you need to look at the operand values, they can be found as the
68: elements of `recog_operand'.
69:
70: If the macro definition does nothing, the instruction is output in
71: the usual way.
72:
73: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
74: If defined, a C statement to be executed just prior to the output
75: of assembler code for INSN, to modify the extracted operands so
76: they will be output differently.
77:
78: Here the argument OPVEC is the vector containing the operands
79: extracted from INSN, and NOPERANDS is the number of elements of
80: the vector which contain meaningful data for this insn. The
81: contents of this vector are what will be used to convert the insn
82: template into assembler code, so you can change the assembler
83: output by changing the contents of the vector.
84:
85: This macro is useful when various assembler syntaxes share a single
86: file of instruction patterns; by defining this macro differently,
87: you can cause a large class of instructions to be output
88: differently (such as with rearranged operands). Naturally,
89: variations in assembler syntax affecting individual insn patterns
90: ought to be handled by writing conditional output routines in
91: those patterns.
92:
93: If this macro is not defined, it is equivalent to a null statement.
94:
95: `PRINT_OPERAND (STREAM, X, CODE)'
96: A C compound statement to output to stdio stream STREAM the
97: assembler syntax for an instruction operand X. X is an RTL
98: expression.
99:
100: CODE is a value that can be used to specify one of several ways of
101: printing the operand. It is used when identical operands must be
102: printed differently depending on the context. CODE comes from the
103: `%' specification that was used to request printing of the
104: operand. If the specification was just `%DIGIT' then CODE is 0;
105: if the specification was `%LTR DIGIT' then CODE is the ASCII code
106: for LTR.
107:
108: If X is a register, this macro should print the register's name.
109: The names can be found in an array `reg_names' whose type is `char
110: *[]'. `reg_names' is initialized from `REGISTER_NAMES'.
111:
112: When the machine description has a specification `%PUNCT' (a `%'
113: followed by a punctuation character), this macro is called with a
114: null pointer for X and the punctuation character for CODE.
115:
116: `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
117: A C expression which evaluates to true if CODE is a valid
118: punctuation character for use in the `PRINT_OPERAND' macro. If
119: `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
120: punctuation characters (except for the standard one, `%') are used
121: in this way.
122:
123: `PRINT_OPERAND_ADDRESS (STREAM, X)'
124: A C compound statement to output to stdio stream STREAM the
125: assembler syntax for an instruction operand that is a memory
126: reference whose address is X. X is an RTL expression.
127:
128: On some machines, the syntax for a symbolic address depends on the
129: section that the address refers to. On these machines, define the
130: macro `ENCODE_SECTION_INFO' to store the information into the
131: `symbol_ref', and then check for it here. *Note Assembler
132: Format::.
133:
134: `DBR_OUTPUT_SEQEND(FILE)'
135: A C statement, to be executed after all slot-filler instructions
136: have been output. If necessary, call `dbr_sequence_length' to
137: determine the number of slots filled in a sequence (zero if not
138: currently outputting a sequence), to decide how many no-ops to
139: output, or whatever.
140:
141: Don't define this macro if it has nothing to do, but it is helpful
142: in reading assembly output if the extent of the delay sequence is
143: made explicit (e.g. with white space).
144:
145: Note that output routines for instructions with delay slots must be
146: prepared to deal with not being output as part of a sequence (i.e.
147: when the scheduling pass is not run, or when no slot fillers could
148: be found.) The variable `final_sequence' is null when not
149: processing a sequence, otherwise it contains the `sequence' rtx
150: being output.
151:
152: `REGISTER_PREFIX'
153: `LOCAL_LABEL_PREFIX'
154: `USER_LABEL_PREFIX'
155: `IMMEDIATE_PREFIX'
156: If defined, C string expressions to be used for the `%R', `%L',
157: `%U', and `%I' options of `asm_fprintf' (see `final.c'). These
158: are useful when a single `md' file must support multiple assembler
159: formats. In that case, the various `tm.h' files can define these
160: macros differently.
161:
162: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
163: A C expression to output to STREAM some assembler code which will
164: push hard register number REGNO onto the stack. The code need not
165: be optimal, since this macro is used only when profiling.
166:
167: `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
168: A C expression to output to STREAM some assembler code which will
169: pop hard register number REGNO off of the stack. The code need
170: not be optimal, since this macro is used only when profiling.
171:
172:
173: File: gcc.info, Node: Dispatch Tables, Next: Alignment Output, Prev: Instruction Output, Up: Assembler Format
174:
175: Output of Dispatch Tables
176: -------------------------
177:
178: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
179: This macro should be provided on machines where the addresses in a
180: dispatch table are relative to the table's own address.
181:
182: The definition should be a C statement to output to the stdio
183: stream STREAM an assembler pseudo-instruction to generate a
184: difference between two labels. VALUE and REL are the numbers of
185: two internal labels. The definitions of these labels are output
186: using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the
187: same way here. For example,
188:
189: fprintf (STREAM, "\t.word L%d-L%d\n",
190: VALUE, REL)
191:
192: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
193: This macro should be provided on machines where the addresses in a
194: dispatch table are absolute.
195:
196: The definition should be a C statement to output to the stdio
197: stream STREAM an assembler pseudo-instruction to generate a
198: reference to a label. VALUE is the number of an internal label
199: whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For
200: example,
201:
202: fprintf (STREAM, "\t.word L%d\n", VALUE)
203:
204: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
205: Define this if the label before a jump-table needs to be output
206: specially. The first three arguments are the same as for
207: `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
208: which follows (a `jump_insn' containing an `addr_vec' or
209: `addr_diff_vec').
210:
211: This feature is used on system V to output a `swbeg' statement for
212: the table.
213:
214: If this macro is not defined, these labels are output with
215: `ASM_OUTPUT_INTERNAL_LABEL'.
216:
217: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
218: Define this if something special must be output at the end of a
219: jump-table. The definition should be a C statement to be executed
220: after the assembler code for the table is written. It should write
221: the appropriate code to stdio stream STREAM. The argument TABLE
222: is the jump-table insn, and NUM is the label-number of the
223: preceding label.
224:
225: If this macro is not defined, nothing special is output at the end
226: of the jump-table.
227:
228:
229: File: gcc.info, Node: Alignment Output, Prev: Dispatch Tables, Up: Assembler Format
230:
231: Assembler Commands for Alignment
232: --------------------------------
233:
234: `ASM_OUTPUT_ALIGN_CODE (FILE)'
235: A C expression to output text to align the location counter in the
236: way that is desirable at a point in the code that is reached only
237: by jumping.
238:
239: This macro need not be defined if you don't want any special
240: alignment to be done at such a time. Most machine descriptions do
241: not currently define the macro.
242:
243: `ASM_OUTPUT_LOOP_ALIGN (FILE)'
244: A C expression to output text to align the location counter in the
245: way that is desirable at the beginning of a loop.
246:
247: This macro need not be defined if you don't want any special
248: alignment to be done at such a time. Most machine descriptions do
249: not currently define the macro.
250:
251: `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
252: A C statement to output to the stdio stream STREAM an assembler
253: instruction to advance the location counter by NBYTES bytes.
254: Those bytes should be zero when loaded. NBYTES will be a C
255: expression of type `int'.
256:
257: `ASM_NO_SKIP_IN_TEXT'
258: Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
259: text section because it fails put zeros in the bytes that are
260: skipped. This is true on many Unix systems, where the pseudo-op
261: to skip bytes produces no-op instructions rather than zeros when
262: used in the text section.
263:
264: `ASM_OUTPUT_ALIGN (STREAM, POWER)'
265: A C statement to output to the stdio stream STREAM an assembler
266: command to advance the location counter to a multiple of 2 to the
267: POWER bytes. POWER will be a C expression of type `int'.
268:
269:
270: File: gcc.info, Node: Debugging Info, Next: Cross-compilation, Prev: Assembler Format, Up: Target Macros
271:
272: Controlling Debugging Information Format
273: ========================================
274:
275: * Menu:
276:
277: * All Debuggers:: Macros that affect all debugging formats uniformly.
278: * DBX Options:: Macros enabling specific options in DBX format.
279: * DBX Hooks:: Hook macros for varying DBX format.
280: * File Names and DBX:: Macros controlling output of file names in DBX format.
281: * SDB and DWARF:: Macros for SDB (COFF) and DWARF formats.
282:
283:
284: File: gcc.info, Node: All Debuggers, Next: DBX Options, Up: Debugging Info
285:
286: Macros Affecting All Debugging Formats
287: --------------------------------------
288:
289: `DBX_REGISTER_NUMBER (REGNO)'
290: A C expression that returns the DBX register number for the
291: compiler register number REGNO. In simple cases, the value of this
292: expression may be REGNO itself. But sometimes there are some
293: registers that the compiler knows about and DBX does not, or vice
294: versa. In such cases, some register may need to have one number in
295: the compiler and another for DBX.
296:
297: If two registers have consecutive numbers inside GNU CC, and they
298: can be used as a pair to hold a multiword value, then they *must*
299: have consecutive numbers after renumbering with
300: `DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to
301: access such a pair, because they expect register pairs to be
302: consecutive in their own numbering scheme.
303:
304: If you find yourself defining `DBX_REGISTER_NUMBER' in way that
305: does not preserve register pairs, then what you must do instead is
306: redefine the actual register numbering scheme.
307:
308: `DEBUGGER_AUTO_OFFSET (X)'
309: A C expression that returns the integer offset value for an
310: automatic variable having address X (an RTL expression). The
311: default computation assumes that X is based on the frame-pointer
312: and gives the offset from the frame-pointer. This is required for
313: targets that produce debugging output for DBX or COFF-style
314: debugging output for SDB and allow the frame-pointer to be
315: eliminated when the `-g' options is used.
316:
317: `DEBUGGER_ARG_OFFSET (OFFSET, X)'
318: A C expression that returns the integer offset value for an
319: argument having address X (an RTL expression). The nominal offset
320: is OFFSET.
321:
322:
323: File: gcc.info, Node: DBX Options, Next: DBX Hooks, Prev: All Debuggers, Up: Debugging Info
324:
325: Specific Options for DBX Output
326: -------------------------------
327:
328: `DBX_DEBUGGING_INFO'
329: Define this macro if GNU CC should produce debugging output for DBX
330: in response to the `-g' option.
331:
332: `XCOFF_DEBUGGING_INFO'
333: Define this macro if GNU CC should produce XCOFF format debugging
334: output in response to the `-g' option. This is a variant of DBX
335: format.
336:
337: `DEFAULT_GDB_EXTENSIONS'
338: Define this macro to control whether GNU CC should by default
339: generate GDB's extended version of DBX debugging information
340: (assuming DBX-format debugging information is enabled at all). If
341: you don't define the macro, the default is 1: always generate the
342: extended information if there is any occasion to.
343:
344: `DEBUG_SYMS_TEXT'
345: Define this macro if all `.stabs' commands should be output while
346: in the text section.
347:
348: `ASM_STABS_OP'
349: A C string constant naming the assembler pseudo op to use instead
350: of `.stabs' to define an ordinary debugging symbol. If you don't
351: define this macro, `.stabs' is used. This macro applies only to
352: DBX debugging information format.
353:
354: `ASM_STABD_OP'
355: A C string constant naming the assembler pseudo op to use instead
356: of `.stabd' to define a debugging symbol whose value is the current
357: location. If you don't define this macro, `.stabd' is used. This
358: macro applies only to DBX debugging information format.
359:
360: `ASM_STABN_OP'
361: A C string constant naming the assembler pseudo op to use instead
362: of `.stabn' to define a debugging symbol with no name. If you
363: don't define this macro, `.stabn' is used. This macro applies
364: only to DBX debugging information format.
365:
366: `DBX_NO_XREFS'
367: Define this macro if DBX on your system does not support the
368: construct `xsTAGNAME'. On some systems, this construct is used to
369: describe a forward reference to a structure named TAGNAME. On
370: other systems, this construct is not supported at all.
371:
372: `DBX_CONTIN_LENGTH'
373: A symbol name in DBX-format debugging information is normally
374: continued (split into two separate `.stabs' directives) when it
375: exceeds a certain length (by default, 80 characters). On some
376: operating systems, DBX requires this splitting; on others,
377: splitting must not be done. You can inhibit splitting by defining
378: this macro with the value zero. You can override the default
379: splitting-length by defining this macro as an expression for the
380: length you desire.
381:
382: `DBX_CONTIN_CHAR'
383: Normally continuation is indicated by adding a `\' character to
384: the end of a `.stabs' string when a continuation follows. To use
385: a different character instead, define this macro as a character
386: constant for the character you want to use. Do not define this
387: macro if backslash is correct for your system.
388:
389: `DBX_STATIC_STAB_DATA_SECTION'
390: Define this macro if it is necessary to go to the data section
391: before outputting the `.stabs' pseudo-op for a non-global static
392: variable.
393:
394: `DBX_TYPE_DECL_STABS_CODE'
395: The value to use in the "code" field of the `.stabs' directive for
396: a typedef. The default is `N_LSYM'.
397:
398: `DBX_STATIC_CONST_VAR_CODE'
399: The value to use in the "code" field of the `.stabs' directive for
400: a static variable located in the text section. DBX format does not
401: provide any "right" way to do this. The default is `N_FUN'.
402:
403: `DBX_REGPARM_STABS_CODE'
404: The value to use in the "code" field of the `.stabs' directive for
405: a parameter passed in registers. DBX format does not provide any
406: "right" way to do this. The default is `N_RSYM'.
407:
408: `DBX_REGPARM_STABS_LETTER'
409: The letter to use in DBX symbol data to identify a symbol as a
410: parameter passed in registers. DBX format does not customarily
411: provide any way to do this. The default is `'P''.
412:
413: `DBX_MEMPARM_STABS_LETTER'
414: The letter to use in DBX symbol data to identify a symbol as a
415: stack parameter. The default is `'p''.
416:
417: `DBX_FUNCTION_FIRST'
418: Define this macro if the DBX information for a function and its
419: arguments should precede the assembler code for the function.
420: Normally, in DBX format, the debugging information entirely
421: follows the assembler code.
422:
423: `DBX_LBRAC_FIRST'
424: Define this macro if the `N_LBRAC' symbol for a block should
425: precede the debugging information for variables and functions
426: defined in that block. Normally, in DBX format, the `N_LBRAC'
427: symbol comes first.
428:
429:
430: File: gcc.info, Node: DBX Hooks, Next: File Names and DBX, Prev: DBX Options, Up: Debugging Info
431:
432: Open-Ended Hooks for DBX Format
433: -------------------------------
434:
435: `DBX_OUTPUT_LBRAC (STREAM, NAME)'
436: Define this macro to say how to output to STREAM the debugging
437: information for the start of a scope level for variable names. The
438: argument NAME is the name of an assembler symbol (for use with
439: `assemble_name') whose value is the address where the scope begins.
440:
441: `DBX_OUTPUT_RBRAC (STREAM, NAME)'
442: Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
443:
444: `DBX_OUTPUT_ENUM (STREAM, TYPE)'
445: Define this macro if the target machine requires special handling
446: to output an enumeration type. The definition should be a C
447: statement (sans semicolon) to output the appropriate information
448: to STREAM for the type TYPE.
449:
450: `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
451: Define this macro if the target machine requires special output at
452: the end of the debugging information for a function. The
453: definition should be a C statement (sans semicolon) to output the
454: appropriate information to STREAM. FUNCTION is the
455: `FUNCTION_DECL' node for the function.
456:
457: `DBX_OUTPUT_STANDARD_TYPES (SYMS)'
458: Define this macro if you need to control the order of output of the
459: standard data types at the beginning of compilation. The argument
460: SYMS is a `tree' which is a chain of all the predefined global
461: symbols, including names of data types.
462:
463: Normally, DBX output starts with definitions of the types for
464: integers and characters, followed by all the other predefined
465: types of the particular language in no particular order.
466:
467: On some machines, it is necessary to output different particular
468: types first. To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
469: output those symbols in the necessary order. Any predefined types
470: that you don't explicitly output will be output afterward in no
471: particular order.
472:
473: Be careful not to define this macro so that it works only for C.
474: There are no global variables to access most of the built-in
475: types, because another language may have another set of types.
476: The way to output a particular type is to look through SYMS to see
477: if you can find it. Here is an example:
478:
479: {
480: tree decl;
481: for (decl = syms; decl; decl = TREE_CHAIN (decl))
482: if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
483: "long int"))
484: dbxout_symbol (decl);
485: ...
486: }
487:
488: This does nothing if the expected type does not exist.
489:
490: See the function `init_decl_processing' in `c-decl.c' to find the
491: names to use for all the built-in C types.
492:
493: Here is another way of finding a particular type:
494:
495: {
496: tree decl;
497: for (decl = syms; decl; decl = TREE_CHAIN (decl))
498: if (TREE_CODE (decl) == TYPE_DECL
499: && (TREE_CODE (TREE_TYPE (decl))
500: == INTEGER_CST)
501: && TYPE_PRECISION (TREE_TYPE (decl)) == 16
502: && TYPE_UNSIGNED (TREE_TYPE (decl)))
503: /* This must be `unsigned short'. */
504: dbxout_symbol (decl);
505: ...
506: }
507:
508:
509: File: gcc.info, Node: File Names and DBX, Next: SDB and DWARF, Prev: DBX Hooks, Up: Debugging Info
510:
511: File Names in DBX Format
512: ------------------------
513:
514: `DBX_WORKING_DIRECTORY'
515: Define this if DBX wants to have the current directory recorded in
516: each object file.
517:
518: Note that the working directory is always recorded if GDB
519: extensions are enabled.
520:
521: `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
522: A C statement to output DBX debugging information to the stdio
523: stream STREAM which indicates that file NAME is the main source
524: file--the file specified as the input file for compilation. This
525: macro is called only once, at the beginning of compilation.
526:
527: This macro need not be defined if the standard form of output for
528: DBX debugging information is appropriate.
529:
530: `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
531: A C statement to output DBX debugging information to the stdio
532: stream STREAM which indicates that the current directory during
533: compilation is named NAME.
534:
535: This macro need not be defined if the standard form of output for
536: DBX debugging information is appropriate.
537:
538: `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
539: A C statement to output DBX debugging information at the end of
540: compilation of the main source file NAME.
541:
542: If you don't define this macro, nothing special is output at the
543: end of compilation, which is correct for most machines.
544:
545: `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
546: A C statement to output DBX debugging information to the stdio
547: stream STREAM which indicates that file NAME is the current source
548: file. This output is generated each time input shifts to a
549: different source file as a result of `#include', the end of an
550: included file, or a `#line' command.
551:
552: This macro need not be defined if the standard form of output for
553: DBX debugging information is appropriate.
554:
555:
556: File: gcc.info, Node: SDB and DWARF, Prev: File Names and DBX, Up: Debugging Info
557:
558: Macros for SDB and DWARF Output
559: -------------------------------
560:
561: `SDB_DEBUGGING_INFO'
562: Define this macro if GNU CC should produce COFF-style debugging
563: output for SDB in response to the `-g' option.
564:
565: `DWARF_DEBUGGING_INFO'
566: Define this macro if GNU CC should produce dwarf format debugging
567: output in response to the `-g' option.
568:
569: `PUT_SDB_...'
570: Define these macros to override the assembler syntax for the
571: special SDB assembler directives. See `sdbout.c' for a list of
572: these macros and their arguments. If the standard syntax is used,
573: you need not define them yourself.
574:
575: `SDB_DELIM'
576: Some assemblers do not support a semicolon as a delimiter, even
577: between SDB assembler directives. In that case, define this macro
578: to be the delimiter to use (usually `\n'). It is not necessary to
579: define a new set of `PUT_SDB_OP' macros if this is the only change
580: required.
581:
582: `SDB_GENERATE_FAKE'
583: Define this macro to override the usual method of constructing a
584: dummy name for anonymous structure and union types. See
585: `sdbout.c' for more information.
586:
587: `SDB_ALLOW_UNKNOWN_REFERENCES'
588: Define this macro to allow references to unknown structure, union,
589: or enumeration tags to be emitted. Standard COFF does not allow
590: handling of unknown references, MIPS ECOFF has support for it.
591:
592: `SDB_ALLOW_FORWARD_REFERENCES'
593: Define this macro to allow references to structure, union, or
594: enumeration tags that have not yet been seen to be handled. Some
595: assemblers choke if forward tags are used, while some require it.
596:
597:
598: File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Debugging Info, Up: Target Macros
599:
600: Cross Compilation and Floating Point
601: ====================================
602:
603: While all modern machines use 2's complement representation for
604: integers, there are a variety of representations for floating point
605: numbers. This means that in a cross-compiler the representation of
606: floating point numbers in the compiled program may be different from
607: that used in the machine doing the compilation.
608:
609: Because different representation systems may offer different amounts
610: of range and precision, the cross compiler cannot safely use the host
611: machine's floating point arithmetic. Therefore, floating point
612: constants must be represented in the target machine's format. This
613: means that the cross compiler cannot use `atof' to parse a floating
614: point constant; it must have its own special routine to use instead.
615: Also, constant folding must emulate the target machine's arithmetic (or
616: must not be done at all).
617:
618: The macros in the following table should be defined only if you are
619: cross compiling between different floating point formats.
620:
621: Otherwise, don't define them. Then default definitions will be set
622: up which use `double' as the data type, `==' to test for equality, etc.
623:
624: You don't need to worry about how many times you use an operand of
625: any of these macros. The compiler never uses operands which have side
626: effects.
627:
628: `REAL_VALUE_TYPE'
629: A macro for the C data type to be used to hold a floating point
630: value in the target machine's format. Typically this would be a
631: `struct' containing an array of `int'.
632:
633: `REAL_VALUES_EQUAL (X, Y)'
634: A macro for a C expression which compares for equality the two
635: values, X and Y, both of type `REAL_VALUE_TYPE'.
636:
637: `REAL_VALUES_LESS (X, Y)'
638: A macro for a C expression which tests whether X is less than Y,
639: both values being of type `REAL_VALUE_TYPE' and interpreted as
640: floating point numbers in the target machine's representation.
641:
642: `REAL_VALUE_LDEXP (X, SCALE)'
643: A macro for a C expression which performs the standard library
644: function `ldexp', but using the target machine's floating point
645: representation. Both X and the value of the expression have type
646: `REAL_VALUE_TYPE'. The second argument, SCALE, is an integer.
647:
648: `REAL_VALUE_FIX (X)'
649: A macro whose definition is a C expression to convert the
650: target-machine floating point value X to a signed integer. X has
651: type `REAL_VALUE_TYPE'.
652:
653: `REAL_VALUE_UNSIGNED_FIX (X)'
654: A macro whose definition is a C expression to convert the
655: target-machine floating point value X to an unsigned integer. X
656: has type `REAL_VALUE_TYPE'.
657:
658: `REAL_VALUE_RNDZINT (X)'
659: A macro whose definition is a C expression to round the
660: target-machine floating point value X towards zero to an integer
661: value (but still as a floating point number). X has type
662: `REAL_VALUE_TYPE', and so does the value.
663:
664: `REAL_VALUE_UNSIGNED_RNDZINT (X)'
665: A macro whose definition is a C expression to round the
666: target-machine floating point value X towards zero to an unsigned
667: integer value (but still represented as a floating point number).
668: x has type `REAL_VALUE_TYPE', and so does the value.
669:
670: `REAL_VALUE_ATOF (STRING, MODE)'
671: A macro for a C expression which converts STRING, an expression of
672: type `char *', into a floating point number in the target machine's
673: representation for mode MODE. The value has type
674: `REAL_VALUE_TYPE'.
675:
676: `REAL_INFINITY'
677: Define this macro if infinity is a possible floating point value,
678: and therefore division by 0 is legitimate.
679:
680: `REAL_VALUE_ISINF (X)'
681: A macro for a C expression which determines whether X, a floating
682: point value, is infinity. The value has type `int'. By default,
683: this is defined to call `isinf'.
684:
685: `REAL_VALUE_ISNAN (X)'
686: A macro for a C expression which determines whether X, a floating
687: point value, is a "nan" (not-a-number). The value has type `int'.
688: By default, this is defined to call `isnan'.
689:
690: Define the following additional macros if you want to make floating
691: point constant folding work while cross compiling. If you don't define
692: them, cross compilation is still possible, but constant folding will
693: not happen for floating point values.
694:
695: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
696: A macro for a C statement which calculates an arithmetic operation
697: of the two floating point values X and Y, both of type
698: `REAL_VALUE_TYPE' in the target machine's representation, to
699: produce a result of the same type and representation which is
700: stored in OUTPUT (which will be a variable).
701:
702: The operation to be performed is specified by CODE, a tree code
703: which will always be one of the following: `PLUS_EXPR',
704: `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
705:
706: The expansion of this macro is responsible for checking for
707: overflow. If overflow happens, the macro expansion should execute
708: the statement `return 0;', which indicates the inability to
709: perform the arithmetic operation requested.
710:
711: `REAL_VALUE_NEGATE (X)'
712: A macro for a C expression which returns the negative of the
713: floating point value X. Both X and the value of the expression
714: have type `REAL_VALUE_TYPE' and are in the target machine's
715: floating point representation.
716:
717: There is no way for this macro to report overflow, since overflow
718: can't happen in the negation operation.
719:
720: `REAL_VALUE_TRUNCATE (MODE, X)'
721: A macro for a C expression which converts the floating point value
722: X to mode MODE.
723:
724: Both X and the value of the expression are in the target machine's
725: floating point representation and have type `REAL_VALUE_TYPE'.
726: However, the value should have an appropriate bit pattern to be
727: output properly as a floating constant whose precision accords
728: with mode MODE.
729:
730: There is no way for this macro to report overflow.
731:
732: `REAL_VALUE_TO_INT (LOW, HIGH, X)'
733: A macro for a C expression which converts a floating point value X
734: into a double-precision integer which is then stored into LOW and
735: HIGH, two variables of type INT.
736:
737: `REAL_VALUE_FROM_INT (X, LOW, HIGH)'
738: A macro for a C expression which converts a double-precision
739: integer found in LOW and HIGH, two variables of type INT, into a
740: floating point value which is then stored into X.
741:
742:
743: File: gcc.info, Node: Misc, Prev: Cross-compilation, Up: Target Macros
744:
745: Miscellaneous Parameters
746: ========================
747:
748: `PREDICATE_CODES'
749: Define this if you have defined special-purpose predicates in the
750: file `MACHINE.c'. This macro is called within an initializer of an
751: array of structures. The first field in the structure is the name
752: of a predicate and the second field is an array of rtl codes. For
753: each predicate, list all rtl codes that can be in expressions
754: matched by the predicate. The list should have a trailing comma.
755: Here is an example of two entries in the list for a typical RISC
756: machine:
757:
758: #define PREDICATE_CODES \
759: {"gen_reg_rtx_operand", {SUBREG, REG}}, \
760: {"reg_or_short_cint_operand", {SUBREG, REG, CONST_INT}},
761:
762: Defining this macro does not affect the generated code (however,
763: incorrect definitions that omit an rtl code that may be matched by
764: the predicate can cause the compiler to malfunction). Instead, it
765: allows the table built by `genrecog' to be more compact and
766: efficient, thus speeding up the compiler. The most important
767: predicates to include in the list specified by this macro are
768: thoses used in the most insn patterns.
769:
770: `CASE_VECTOR_MODE'
771: An alias for a machine mode name. This is the machine mode that
772: elements of a jump-table should have.
773:
774: `CASE_VECTOR_PC_RELATIVE'
775: Define this macro if jump-tables should contain relative addresses.
776:
777: `CASE_DROPS_THROUGH'
778: Define this if control falls through a `case' insn when the index
779: value is out of range. This means the specified default-label is
780: actually ignored by the `case' insn proper.
781:
782: `CASE_VALUES_THRESHOLD'
783: Define this to be the smallest number of different values for
784: which it is best to use a jump-table instead of a tree of
785: conditional branches. The default is four for machines with a
786: `casesi' instruction and five otherwise. This is best for most
787: machines.
788:
789: `BYTE_LOADS_ZERO_EXTEND'
790: Define this macro if an instruction to load a value narrower than a
791: word from memory into a register also zero-extends the value to
792: the whole register.
793:
794: `BYTE_LOADS_SIGN_EXTEND'
795: Define this macro if an instruction to load a value narrower than a
796: word from memory into a register also sign-extends the value to
797: the whole register.
798:
799: `IMPLICIT_FIX_EXPR'
800: An alias for a tree code that should be used by default for
801: conversion of floating point values to fixed point. Normally,
802: `FIX_ROUND_EXPR' is used.
803:
804: `FIXUNS_TRUNC_LIKE_FIX_TRUNC'
805: Define this macro if the same instructions that convert a floating
806: point number to a signed fixed point number also convert validly
807: to an unsigned one.
808:
809: `EASY_DIV_EXPR'
810: An alias for a tree code that is the easiest kind of division to
811: compile code for in the general case. It may be `TRUNC_DIV_EXPR',
812: `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four
813: division operators differ in how they round the result to an
814: integer. `EASY_DIV_EXPR' is used when it is permissible to use
815: any of those kinds of division and the choice should be made on
816: the basis of efficiency.
817:
818: `MOVE_MAX'
819: The maximum number of bytes that a single instruction can move
820: quickly from memory to memory.
821:
822: `SHIFT_COUNT_TRUNCATED'
823: Defining this macro causes the compiler to omit a sign-extend,
824: zero-extend, or bitwise `and' instruction that truncates the count
825: of a shift operation to a width equal to the number of bits needed
826: to represent the size of the object being shifted. On machines
827: that have instructions that act on bitfields at variable
828: positions, which may include `bit test' instructions, defining
829: `SHIFT_COUNT_TRUNCATED' also enables deletion of truncations of
830: the values that serve as arguments to bitfield instructions.
831:
832: If both types of instructions truncate the count (for shifts) and
833: position (for bitfield operations), or if no variable-position
834: bitfield instructions exist, you should define this macro.
835:
836: However, on some machines, such as the 80386 and the 680x0,
837: truncation only applies to shift operations and not the (real or
838: pretended) bitfield operations. Do not define
839: `SHIFT_COUNT_TRUNCATED' on such machines. Instead, add patterns
840: to the `md' file that include the implied truncation of the shift
841: instructions.
842:
843: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
844: A C expression which is nonzero if on this machine it is safe to
845: "convert" an integer of INPREC bits to one of OUTPREC bits (where
846: OUTPREC is smaller than INPREC) by merely operating on it as if it
847: had only OUTPREC bits.
848:
849: On many machines, this expression can be 1.
850:
851: When `TRULY_NOOP_TRUNCATION' returns 1 for a pair of sizes for
852: modes for which `MODES_TIEABLE_P' is 0, suboptimal code can result.
853: If this is the case, making `TRULY_NOOP_TRUNCATION' return 0 in
854: such cases may improve things.
855:
856: `STORE_FLAG_VALUE'
857: A C expression describing the value returned by a comparison
858: operator with an integral mode and stored by a store-flag
859: instruction (`sCOND') when the condition is true. This
860: description must apply to *all* the `sCOND' patterns and all the
861: comparison operators whose results have a `MODE_INT' mode.
862:
863: A value of 1 or -1 means that the instruction implementing the
864: comparison operator returns exactly 1 or -1 when the comparison is
865: true and 0 when the comparison is false. Otherwise, the value
866: indicates which bits of the result are guaranteed to be 1 when the
867: comparison is true. This value is interpreted in the mode of the
868: comparison operation, which is given by the mode of the first
869: operand in the `sCOND' pattern. Either the low bit or the sign
870: bit of `STORE_FLAG_VALUE' be on. Presently, only those bits are
871: used by the compiler.
872:
873: If `STORE_FLAG_VALUE' is neither 1 or -1, the compiler will
874: generate code that depends only on the specified bits. It can also
875: replace comparison operators with equivalent operations if they
876: cause the required bits to be set, even if the remaining bits are
877: undefined. For example, on a machine whose comparison operators
878: return an `SImode' value and where `STORE_FLAG_VALUE' is defined as
879: `0x80000000', saying that just the sign bit is relevant, the
880: expression
881:
882: (ne:SI (and:SI X (const_int POWER-OF-2)) (const_int 0))
883:
884: can be converted to
885:
886: (ashift:SI X (const_int N))
887:
888: where N is the appropriate shift count to move the bit being
889: tested into the sign bit.
890:
891: There is no way to describe a machine that always sets the
892: low-order bit for a true value, but does not guarantee the value
893: of any other bits, but we do not know of any machine that has such
894: an instruction. If you are trying to port GNU CC to such a
895: machine, include an instruction to perform a logical-and of the
896: result with 1 in the pattern for the comparison operators and let
897: us know (*note How to Report Bugs: Bug Reporting.).
898:
899: Often, a machine will have multiple instructions that obtain a
900: value from a comparison (or the condition codes). Here are rules
901: to guide the choice of value for `STORE_FLAG_VALUE', and hence the
902: instructions to be used:
903:
904: * Use the shortest sequence that yields a valid definition for
905: `STORE_FLAG_VALUE'. It is more efficient for the compiler to
906: "normalize" the value (convert it to, e.g., 1 or 0) than for
907: the comparison operators to do so because there may be
908: opportunities to combine the normalization with other
909: operations.
910:
911: * For equal-length sequences, use a value of 1 or -1, with -1
912: being slightly preferred on machines with expensive jumps and
913: 1 preferred on other machines.
914:
915: * As a second choice, choose a value of `0x80000001' if
916: instructions exist that set both the sign and low-order bits
917: but do not define the others.
918:
919: * Otherwise, use a value of `0x80000000'.
920:
921: Many machines can produce both the value chosen for
922: `STORE_FLAG_VALUE' and its negation in the same number of
923: instructions. On those machines, you should also define a pattern
924: for those cases, e.g., one matching
925:
926: (set A (neg:M (ne:M B C)))
927:
928: Some machines can also perform `and' or `plus' operations on
929: condition code values with less instructions than the corresponding
930: `sCOND' insn followed by `and' or `plus'. On those machines,
931: define the appropriate patterns. Use the names `incscc' and
932: `decscc', respectively, for the the patterns which perform `plus'
933: or `minus' operations on condition code values. See `rs6000.md'
934: for some examples. The GNU Superoptizer can be used to find such
935: instruction sequences on other machines.
936:
937: You need not define `STORE_FLAG_VALUE' if the machine has no
938: store-flag instructions.
939:
940: `FLOAT_STORE_FLAG_VALUE'
941: A C expression that gives a non-zero floating point value that is
942: returned when comparison operators with floating-point results are
943: true. Define this macro on machine that have comparison
944: operations that return floating-point values. If there are no
945: such operations, do not define this macro.
946:
947: `Pmode'
948: An alias for the machine mode for pointers. Normally the
949: definition can be
950:
951: #define Pmode SImode
952:
953: `FUNCTION_MODE'
954: An alias for the machine mode used for memory references to
955: functions being called, in `call' RTL expressions. On most
956: machines this should be `QImode'.
957:
958: `INTEGRATE_THRESHOLD (DECL)'
959: A C expression for the maximum number of instructions above which
960: the function DECL should not be inlined. DECL is a
961: `FUNCTION_DECL' node.
962:
963: The default definition of this macro is 64 plus 8 times the number
964: of arguments that the function accepts. Some people think a larger
965: threshold should be used on RISC machines.
966:
967: `SCCS_DIRECTIVE'
968: Define this if the preprocessor should ignore `#sccs' directives
969: and print no error message.
970:
971: `HANDLE_PRAGMA (STREAM)'
972: Define this macro if you want to implement any pragmas. If
973: defined, it should be a C statement to be executed when `#pragma'
974: is seen. The argument STREAM is the stdio input stream from which
975: the source text can be read.
976:
977: It is generally a bad idea to implement new uses of `#pragma'. The
978: only reason to define this macro is for compatibility with other
979: compilers that do support `#pragma' for the sake of any user
980: programs which already use it.
981:
982: `DOLLARS_IN_IDENTIFIERS'
983: Define this macro to control use of the character `$' in identifier
984: names. The value should be 0, 1, or 2. 0 means `$' is not allowed
985: by default; 1 means it is allowed by default if `-traditional' is
986: used; 2 means it is allowed by default provided `-ansi' is not
987: used. 1 is the default; there is no need to define this macro in
988: that case.
989:
990: `NO_DOLLAR_IN_LABEL'
991: Define this macro if the assembler does not accept the character
992: `$' in label names. By default constructors and destructors in
993: G++ have `$' in the identifiers. If this macro is defined, `.' is
994: used instead.
995:
996: `DEFAULT_MAIN_RETURN'
997: Define this macro if the target system expects every program's
998: `main' function to return a standard "success" value by default
999: (if no other value is explicitly returned).
1000:
1001: The definition should be a C statement (sans semicolon) to
1002: generate the appropriate rtl instructions. It is used only when
1003: compiling the end of `main'.
1004:
1005: `HAVE_ATEXIT'
1006: Define this if the target system supports the function `atexit'
1007: from the ANSI C standard. If this is not defined, and
1008: `INIT_SECTION_ASM_OP' is not defined, a default `exit' function
1009: will be provided to support C++.
1010:
1011: `EXIT_BODY'
1012: Define this if your `exit' function needs to do something besides
1013: calling an external function `_cleanup' before terminating with
1014: `_exit'. The `EXIT_BODY' macro is only needed if netiher
1015: `HAVE_ATEXIT' nor `INIT_SECTION_ASM_OP' are defined.
1016:
1017: `INSN_SETS_ARE_DELAYED (INSN)'
1018: Define this macro as a C expression that is nonzero if it is safe
1019: for the delay slot scheduler to place instructions in the delay
1020: slot of INSN, even if they appear to use a resource set or
1021: clobbered in INSN. INSN is always a `jump_insn' or an `insn'; GNU
1022: CC knows that every `call_insn' has this behavior. On machines
1023: where some `insn' or `jump_insn' is really a function call and
1024: hence has this behavior, you should define this macro.
1025:
1026: You need not define this macro if it would always return zero.
1027:
1028: `INSN_REFERENCES_ARE_DELAYED (INSN)'
1029: Define this macro as a C expression that is nonzero if it is safe
1030: for the delay slot scheduler to place instructions in the delay
1031: slot of INSN, even if they appear to set or clobber a resource
1032: referenced in INSN. INSN is always a `jump_insn' or an `insn'.
1033: On machines where some `insn' or `jump_insn' is really a function
1034: call and its operands are registers whose use is actually in the
1035: subroutine it calls, you should define this macro. Doing so
1036: allows the delay slot scheduler to move instructions which copy
1037: arguments into the argument registers into the delay slot of INSN.
1038:
1039: You need not define this macro if it would always return zero.
1040:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.