![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-21 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to gcc.info-21 CVS log | Up to [Apple XNU] / GNUtools / cc |
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: Macros for Initialization, Next: Instruction Output, Prev: Initialization, Up: Assembler Format
32:
33: Macros Controlling Initialization Routines
34: ------------------------------------------
35:
36: Here are the macros that control how the compiler handles
37: initialization and termination functions:
38:
39: `INIT_SECTION_ASM_OP'
40: If defined, a C string constant for the assembler operation to
41: identify the following data as initialization code. If not
42: defined, GNU CC will assume such a section does not exist. When
43: you are using special sections for initialization and termination
44: functions, this macro also controls how `crtstuff.c' and
45: `libgcc2.c' arrange to run the initialization functions.
46:
47: `ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)'
48: Define this macro as a C statement to output on the stream STREAM
49: the assembler code to arrange to call the function named NAME at
50: initialization time.
51:
52: Assume that NAME is the name of a C function generated
53: automatically by the compiler. This function takes no arguments.
54: Use the function `assemble_name' to output the name NAME; this
55: performs any system-specific syntactic transformations such as
56: adding an underscore.
57:
58: If you don't define this macro, nothing special is output to
59: arrange to call the function. This is correct when the function
60: will be called in some other manner--for example, by means of the
61: `collect2' program, which looks through the symbol table to find
62: these functions by their names.
63:
64: `ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)'
65: This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination
66: functions rather than initialization functions.
67:
68: If your system uses `collect2' as the means of processing
69: constructors, then that program normally uses `nm' to scan an object
70: file for constructor functions to be called. On certain kinds of
71: systems, you can define these macros to make `collect2' work faster
72: (and, in some cases, make it work at all):
73:
74: `OBJECT_FORMAT_COFF'
75: Define this macro if the system uses COFF (Common Object File
76: Format) object files, so that `collect2' can assume this format
77: and scan object files directly for dynamic constructor/destructor
78: functions.
79:
80: `OBJECT_FORMAT_ROSE'
81: Define this macro if the system uses ROSE format object files, so
82: that `collect2' can assume this format and scan object files
83: directly for dynamic constructor/destructor functions.
84:
85: These macros are effective only in a native compiler; `collect2' as
86: part of a cross compiler always uses `nm'.
87:
88: `REAL_NM_FILE_NAME'
89: Define this macro as a C string constant containing the file name
90: to use to execute `nm'. The default is to search the path
91: normally for `nm'.
92:
93:
94: File: gcc.info, Node: Instruction Output, Next: Dispatch Tables, Prev: Macros for Initialization, Up: Assembler Format
95:
96: Output of Assembler Instructions
97: --------------------------------
98:
99: `REGISTER_NAMES'
100: A C initializer containing the assembler's names for the machine
101: registers, each one as a C string constant. This is what
102: translates register numbers in the compiler into assembler
103: language.
104:
105: `ADDITIONAL_REGISTER_NAMES'
106: If defined, a C initializer for an array of structures containing
107: a name and a register number. This macro defines additional names
108: for hard registers, thus allowing the `asm' option in declarations
109: to refer to registers using alternate names.
110:
111: `ASM_OUTPUT_OPCODE (STREAM, PTR)'
112: Define this macro if you are using an unusual assembler that
113: requires different names for the machine instructions.
114:
115: The definition is a C statement or statements which output an
116: assembler instruction opcode to the stdio stream STREAM. The
117: macro-operand PTR is a variable of type `char *' which points to
118: the opcode name in its "internal" form--the form that is written
119: in the machine description. The definition should output the
120: opcode name to STREAM, performing any translation you desire, and
121: increment the variable PTR to point at the end of the opcode so
122: that it will not be output twice.
123:
124: In fact, your macro definition may process less than the entire
125: opcode name, or more than the opcode name; but if you want to
126: process text that includes `%'-sequences to substitute operands,
127: you must take care of the substitution yourself. Just be sure to
128: increment PTR over whatever text should not be output normally.
129:
130: If you need to look at the operand values, they can be found as the
131: elements of `recog_operand'.
132:
133: If the macro definition does nothing, the instruction is output in
134: the usual way.
135:
136: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
137: If defined, a C statement to be executed just prior to the output
138: of assembler code for INSN, to modify the extracted operands so
139: they will be output differently.
140:
141: Here the argument OPVEC is the vector containing the operands
142: extracted from INSN, and NOPERANDS is the number of elements of
143: the vector which contain meaningful data for this insn. The
144: contents of this vector are what will be used to convert the insn
145: template into assembler code, so you can change the assembler
146: output by changing the contents of the vector.
147:
148: This macro is useful when various assembler syntaxes share a single
149: file of instruction patterns; by defining this macro differently,
150: you can cause a large class of instructions to be output
151: differently (such as with rearranged operands). Naturally,
152: variations in assembler syntax affecting individual insn patterns
153: ought to be handled by writing conditional output routines in
154: those patterns.
155:
156: If this macro is not defined, it is equivalent to a null statement.
157:
158: `PRINT_OPERAND (STREAM, X, CODE)'
159: A C compound statement to output to stdio stream STREAM the
160: assembler syntax for an instruction operand X. X is an RTL
161: expression.
162:
163: CODE is a value that can be used to specify one of several ways of
164: printing the operand. It is used when identical operands must be
165: printed differently depending on the context. CODE comes from the
166: `%' specification that was used to request printing of the
167: operand. If the specification was just `%DIGIT' then CODE is 0;
168: if the specification was `%LTR DIGIT' then CODE is the ASCII code
169: for LTR.
170:
171: If X is a register, this macro should print the register's name.
172: The names can be found in an array `reg_names' whose type is `char
173: *[]'. `reg_names' is initialized from `REGISTER_NAMES'.
174:
175: When the machine description has a specification `%PUNCT' (a `%'
176: followed by a punctuation character), this macro is called with a
177: null pointer for X and the punctuation character for CODE.
178:
179: `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
180: A C expression which evaluates to true if CODE is a valid
181: punctuation character for use in the `PRINT_OPERAND' macro. If
182: `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
183: punctuation characters (except for the standard one, `%') are used
184: in this way.
185:
186: `PRINT_OPERAND_ADDRESS (STREAM, X)'
187: A C compound statement to output to stdio stream STREAM the
188: assembler syntax for an instruction operand that is a memory
189: reference whose address is X. X is an RTL expression.
190:
191: On some machines, the syntax for a symbolic address depends on the
192: section that the address refers to. On these machines, define the
193: macro `ENCODE_SECTION_INFO' to store the information into the
194: `symbol_ref', and then check for it here. *Note Assembler
195: Format::.
196:
197: `DBR_OUTPUT_SEQEND(FILE)'
198: A C statement, to be executed after all slot-filler instructions
199: have been output. If necessary, call `dbr_sequence_length' to
200: determine the number of slots filled in a sequence (zero if not
201: currently outputting a sequence), to decide how many no-ops to
202: output, or whatever.
203:
204: Don't define this macro if it has nothing to do, but it is helpful
205: in reading assembly output if the extent of the delay sequence is
206: made explicit (e.g. with white space).
207:
208: Note that output routines for instructions with delay slots must be
209: prepared to deal with not being output as part of a sequence (i.e.
210: when the scheduling pass is not run, or when no slot fillers could
211: be found.) The variable `final_sequence' is null when not
212: processing a sequence, otherwise it contains the `sequence' rtx
213: being output.
214:
215: `REGISTER_PREFIX'
216: `LOCAL_LABEL_PREFIX'
217: `USER_LABEL_PREFIX'
218: `IMMEDIATE_PREFIX'
219: If defined, C string expressions to be used for the `%R', `%L',
220: `%U', and `%I' options of `asm_fprintf' (see `final.c'). These
221: are useful when a single `md' file must support multiple assembler
222: formats. In that case, the various `tm.h' files can define these
223: macros differently.
224:
225: `ASSEMBLER_DIALECT'
226: If your target supports multiple dialects of assembler language
227: (such as different opcodes), define this macro as a C expression
228: that gives the numeric index of the assembler langauge dialect to
229: use, with zero as the first variant.
230:
231: When this macro is defined, you may include strings of the form
232: `{option0|option1|option2}' within output templates (*note Output
233: Template::.) or the operand to `asm_fprintf'. GNU CC will output
234: either `option0', `option1' or `option2' if the value of
235: `ASSEMBLER_DIALECT' is zero, one or two, respectively. Any
236: special characters within these strings retain their usual meaning.
237:
238: If you do not define this macro, the characters `{', `|' and `}'
239: do not have any special meaning when used in templates or operands
240: to `asm_fprintf'.
241:
242: Define the `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX',
243: `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' macros above if you can
244: express the variations in assemble language syntax with that
245: mechanism. Define `ASSEMBLER_DIALECT' and use the
246: `{option0|option1}' syntax if the syntax variant are larger and
247: involve such things as different opcodes or operand order.
248:
249: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
250: A C expression to output to STREAM some assembler code which will
251: push hard register number REGNO onto the stack. The code need not
252: be optimal, since this macro is used only when profiling.
253:
254: `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
255: A C expression to output to STREAM some assembler code which will
256: pop hard register number REGNO off of the stack. The code need
257: not be optimal, since this macro is used only when profiling.
258:
259:
260: File: gcc.info, Node: Dispatch Tables, Next: Alignment Output, Prev: Instruction Output, Up: Assembler Format
261:
262: Output of Dispatch Tables
263: -------------------------
264:
265: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
266: This macro should be provided on machines where the addresses in a
267: dispatch table are relative to the table's own address.
268:
269: The definition should be a C statement to output to the stdio
270: stream STREAM an assembler pseudo-instruction to generate a
271: difference between two labels. VALUE and REL are the numbers of
272: two internal labels. The definitions of these labels are output
273: using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the
274: same way here. For example,
275:
276: fprintf (STREAM, "\t.word L%d-L%d\n",
277: VALUE, REL)
278:
279: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
280: This macro should be provided on machines where the addresses in a
281: dispatch table are absolute.
282:
283: The definition should be a C statement to output to the stdio
284: stream STREAM an assembler pseudo-instruction to generate a
285: reference to a label. VALUE is the number of an internal label
286: whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. For
287: example,
288:
289: fprintf (STREAM, "\t.word L%d\n", VALUE)
290:
291: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
292: Define this if the label before a jump-table needs to be output
293: specially. The first three arguments are the same as for
294: `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
295: which follows (a `jump_insn' containing an `addr_vec' or
296: `addr_diff_vec').
297:
298: This feature is used on system V to output a `swbeg' statement for
299: the table.
300:
301: If this macro is not defined, these labels are output with
302: `ASM_OUTPUT_INTERNAL_LABEL'.
303:
304: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
305: Define this if something special must be output at the end of a
306: jump-table. The definition should be a C statement to be executed
307: after the assembler code for the table is written. It should write
308: the appropriate code to stdio stream STREAM. The argument TABLE
309: is the jump-table insn, and NUM is the label-number of the
310: preceding label.
311:
312: If this macro is not defined, nothing special is output at the end
313: of the jump-table.
314:
315:
316: File: gcc.info, Node: Alignment Output, Prev: Dispatch Tables, Up: Assembler Format
317:
318: Assembler Commands for Alignment
319: --------------------------------
320:
321: `ASM_OUTPUT_ALIGN_CODE (FILE)'
322: A C expression to output text to align the location counter in the
323: way that is desirable at a point in the code that is reached only
324: by jumping.
325:
326: This macro need not be defined if you don't want any special
327: alignment to be done at such a time. Most machine descriptions do
328: not currently define the macro.
329:
330: `ASM_OUTPUT_LOOP_ALIGN (FILE)'
331: A C expression to output text to align the location counter in the
332: way that is desirable at the beginning of a loop.
333:
334: This macro need not be defined if you don't want any special
335: alignment to be done at such a time. Most machine descriptions do
336: not currently define the macro.
337:
338: `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
339: A C statement to output to the stdio stream STREAM an assembler
340: instruction to advance the location counter by NBYTES bytes.
341: Those bytes should be zero when loaded. NBYTES will be a C
342: expression of type `int'.
343:
344: `ASM_NO_SKIP_IN_TEXT'
345: Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
346: text section because it fails put zeros in the bytes that are
347: skipped. This is true on many Unix systems, where the pseudo-op
348: to skip bytes produces no-op instructions rather than zeros when
349: used in the text section.
350:
351: `ASM_OUTPUT_ALIGN (STREAM, POWER)'
352: A C statement to output to the stdio stream STREAM an assembler
353: command to advance the location counter to a multiple of 2 to the
354: POWER bytes. POWER will be a C expression of type `int'.
355:
356:
357: File: gcc.info, Node: Debugging Info, Next: Cross-compilation, Prev: Assembler Format, Up: Target Macros
358:
359: Controlling Debugging Information Format
360: ========================================
361:
362: * Menu:
363:
364: * All Debuggers:: Macros that affect all debugging formats uniformly.
365: * DBX Options:: Macros enabling specific options in DBX format.
366: * DBX Hooks:: Hook macros for varying DBX format.
367: * File Names and DBX:: Macros controlling output of file names in DBX format.
368: * SDB and DWARF:: Macros for SDB (COFF) and DWARF formats.
369:
370:
371: File: gcc.info, Node: All Debuggers, Next: DBX Options, Up: Debugging Info
372:
373: Macros Affecting All Debugging Formats
374: --------------------------------------
375:
376: `DBX_REGISTER_NUMBER (REGNO)'
377: A C expression that returns the DBX register number for the
378: compiler register number REGNO. In simple cases, the value of this
379: expression may be REGNO itself. But sometimes there are some
380: registers that the compiler knows about and DBX does not, or vice
381: versa. In such cases, some register may need to have one number in
382: the compiler and another for DBX.
383:
384: If two registers have consecutive numbers inside GNU CC, and they
385: can be used as a pair to hold a multiword value, then they *must*
386: have consecutive numbers after renumbering with
387: `DBX_REGISTER_NUMBER'. Otherwise, debuggers will be unable to
388: access such a pair, because they expect register pairs to be
389: consecutive in their own numbering scheme.
390:
391: If you find yourself defining `DBX_REGISTER_NUMBER' in way that
392: does not preserve register pairs, then what you must do instead is
393: redefine the actual register numbering scheme.
394:
395: `DEBUGGER_AUTO_OFFSET (X)'
396: A C expression that returns the integer offset value for an
397: automatic variable having address X (an RTL expression). The
398: default computation assumes that X is based on the frame-pointer
399: and gives the offset from the frame-pointer. This is required for
400: targets that produce debugging output for DBX or COFF-style
401: debugging output for SDB and allow the frame-pointer to be
402: eliminated when the `-g' options is used.
403:
404: `DEBUGGER_ARG_OFFSET (OFFSET, X)'
405: A C expression that returns the integer offset value for an
406: argument having address X (an RTL expression). The nominal offset
407: is OFFSET.
408:
409: `PREFERRED_DEBUGGING_TYPE'
410: A C expression that returns the type of debugging output GNU CC
411: produces when the user specifies `-g' or `-ggdb'. Define this if
412: you have arranged for GNU CC to support more than one format of
413: debugging output. Currently, the allowable values are `DBX_DEBUG',
414: `SDB_DEBUG', `DWARF_DEBUG', and `XCOFF_DEBUG'.
415:
416: The value of this macro only affects the default debugging output;
417: the user can always get a specific type of output by using
418: `-gstabs', `-gcoff', `-gdwarf', or `-gxcoff'.
419:
420:
421: File: gcc.info, Node: DBX Options, Next: DBX Hooks, Prev: All Debuggers, Up: Debugging Info
422:
423: Specific Options for DBX Output
424: -------------------------------
425:
426: `DBX_DEBUGGING_INFO'
427: Define this macro if GNU CC should produce debugging output for DBX
428: in response to the `-g' option.
429:
430: `XCOFF_DEBUGGING_INFO'
431: Define this macro if GNU CC should produce XCOFF format debugging
432: output in response to the `-g' option. This is a variant of DBX
433: format.
434:
435: `DEFAULT_GDB_EXTENSIONS'
436: Define this macro to control whether GNU CC should by default
437: generate GDB's extended version of DBX debugging information
438: (assuming DBX-format debugging information is enabled at all). If
439: you don't define the macro, the default is 1: always generate the
440: extended information if there is any occasion to.
441:
442: `DEBUG_SYMS_TEXT'
443: Define this macro if all `.stabs' commands should be output while
444: in the text section.
445:
446: `ASM_STABS_OP'
447: A C string constant naming the assembler pseudo op to use instead
448: of `.stabs' to define an ordinary debugging symbol. If you don't
449: define this macro, `.stabs' is used. This macro applies only to
450: DBX debugging information format.
451:
452: `ASM_STABD_OP'
453: A C string constant naming the assembler pseudo op to use instead
454: of `.stabd' to define a debugging symbol whose value is the current
455: location. If you don't define this macro, `.stabd' is used. This
456: macro applies only to DBX debugging information format.
457:
458: `ASM_STABN_OP'
459: A C string constant naming the assembler pseudo op to use instead
460: of `.stabn' to define a debugging symbol with no name. If you
461: don't define this macro, `.stabn' is used. This macro applies
462: only to DBX debugging information format.
463:
464: `DBX_NO_XREFS'
465: Define this macro if DBX on your system does not support the
466: construct `xsTAGNAME'. On some systems, this construct is used to
467: describe a forward reference to a structure named TAGNAME. On
468: other systems, this construct is not supported at all.
469:
470: `DBX_CONTIN_LENGTH'
471: A symbol name in DBX-format debugging information is normally
472: continued (split into two separate `.stabs' directives) when it
473: exceeds a certain length (by default, 80 characters). On some
474: operating systems, DBX requires this splitting; on others,
475: splitting must not be done. You can inhibit splitting by defining
476: this macro with the value zero. You can override the default
477: splitting-length by defining this macro as an expression for the
478: length you desire.
479:
480: `DBX_CONTIN_CHAR'
481: Normally continuation is indicated by adding a `\' character to
482: the end of a `.stabs' string when a continuation follows. To use
483: a different character instead, define this macro as a character
484: constant for the character you want to use. Do not define this
485: macro if backslash is correct for your system.
486:
487: `DBX_STATIC_STAB_DATA_SECTION'
488: Define this macro if it is necessary to go to the data section
489: before outputting the `.stabs' pseudo-op for a non-global static
490: variable.
491:
492: `DBX_TYPE_DECL_STABS_CODE'
493: The value to use in the "code" field of the `.stabs' directive for
494: a typedef. The default is `N_LSYM'.
495:
496: `DBX_STATIC_CONST_VAR_CODE'
497: The value to use in the "code" field of the `.stabs' directive for
498: a static variable located in the text section. DBX format does not
499: provide any "right" way to do this. The default is `N_FUN'.
500:
501: `DBX_REGPARM_STABS_CODE'
502: The value to use in the "code" field of the `.stabs' directive for
503: a parameter passed in registers. DBX format does not provide any
504: "right" way to do this. The default is `N_RSYM'.
505:
506: `DBX_REGPARM_STABS_LETTER'
507: The letter to use in DBX symbol data to identify a symbol as a
508: parameter passed in registers. DBX format does not customarily
509: provide any way to do this. The default is `'P''.
510:
511: `DBX_MEMPARM_STABS_LETTER'
512: The letter to use in DBX symbol data to identify a symbol as a
513: stack parameter. The default is `'p''.
514:
515: `DBX_FUNCTION_FIRST'
516: Define this macro if the DBX information for a function and its
517: arguments should precede the assembler code for the function.
518: Normally, in DBX format, the debugging information entirely
519: follows the assembler code.
520:
521: `DBX_LBRAC_FIRST'
522: Define this macro if the `N_LBRAC' symbol for a block should
523: precede the debugging information for variables and functions
524: defined in that block. Normally, in DBX format, the `N_LBRAC'
525: symbol comes first.
526:
527:
528: File: gcc.info, Node: DBX Hooks, Next: File Names and DBX, Prev: DBX Options, Up: Debugging Info
529:
530: Open-Ended Hooks for DBX Format
531: -------------------------------
532:
533: `DBX_OUTPUT_LBRAC (STREAM, NAME)'
534: Define this macro to say how to output to STREAM the debugging
535: information for the start of a scope level for variable names. The
536: argument NAME is the name of an assembler symbol (for use with
537: `assemble_name') whose value is the address where the scope begins.
538:
539: `DBX_OUTPUT_RBRAC (STREAM, NAME)'
540: Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
541:
542: `DBX_OUTPUT_ENUM (STREAM, TYPE)'
543: Define this macro if the target machine requires special handling
544: to output an enumeration type. The definition should be a C
545: statement (sans semicolon) to output the appropriate information
546: to STREAM for the type TYPE.
547:
548: `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
549: Define this macro if the target machine requires special output at
550: the end of the debugging information for a function. The
551: definition should be a C statement (sans semicolon) to output the
552: appropriate information to STREAM. FUNCTION is the
553: `FUNCTION_DECL' node for the function.
554:
555: `DBX_OUTPUT_STANDARD_TYPES (SYMS)'
556: Define this macro if you need to control the order of output of the
557: standard data types at the beginning of compilation. The argument
558: SYMS is a `tree' which is a chain of all the predefined global
559: symbols, including names of data types.
560:
561: Normally, DBX output starts with definitions of the types for
562: integers and characters, followed by all the other predefined
563: types of the particular language in no particular order.
564:
565: On some machines, it is necessary to output different particular
566: types first. To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
567: output those symbols in the necessary order. Any predefined types
568: that you don't explicitly output will be output afterward in no
569: particular order.
570:
571: Be careful not to define this macro so that it works only for C.
572: There are no global variables to access most of the built-in
573: types, because another language may have another set of types.
574: The way to output a particular type is to look through SYMS to see
575: if you can find it. Here is an example:
576:
577: {
578: tree decl;
579: for (decl = syms; decl; decl = TREE_CHAIN (decl))
580: if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
581: "long int"))
582: dbxout_symbol (decl);
583: ...
584: }
585:
586: This does nothing if the expected type does not exist.
587:
588: See the function `init_decl_processing' in `c-decl.c' to find the
589: names to use for all the built-in C types.
590:
591: Here is another way of finding a particular type:
592:
593: {
594: tree decl;
595: for (decl = syms; decl; decl = TREE_CHAIN (decl))
596: if (TREE_CODE (decl) == TYPE_DECL
597: && (TREE_CODE (TREE_TYPE (decl))
598: == INTEGER_CST)
599: && TYPE_PRECISION (TREE_TYPE (decl)) == 16
600: && TYPE_UNSIGNED (TREE_TYPE (decl)))
601: /* This must be `unsigned short'. */
602: dbxout_symbol (decl);
603: ...
604: }
605:
606:
607: File: gcc.info, Node: File Names and DBX, Next: SDB and DWARF, Prev: DBX Hooks, Up: Debugging Info
608:
609: File Names in DBX Format
610: ------------------------
611:
612: `DBX_WORKING_DIRECTORY'
613: Define this if DBX wants to have the current directory recorded in
614: each object file.
615:
616: Note that the working directory is always recorded if GDB
617: extensions are enabled.
618:
619: `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
620: A C statement to output DBX debugging information to the stdio
621: stream STREAM which indicates that file NAME is the main source
622: file--the file specified as the input file for compilation. This
623: macro is called only once, at the beginning of compilation.
624:
625: This macro need not be defined if the standard form of output for
626: DBX debugging information is appropriate.
627:
628: `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
629: A C statement to output DBX debugging information to the stdio
630: stream STREAM which indicates that the current directory during
631: compilation is named NAME.
632:
633: This macro need not be defined if the standard form of output for
634: DBX debugging information is appropriate.
635:
636: `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
637: A C statement to output DBX debugging information at the end of
638: compilation of the main source file NAME.
639:
640: If you don't define this macro, nothing special is output at the
641: end of compilation, which is correct for most machines.
642:
643: `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
644: A C statement to output DBX debugging information to the stdio
645: stream STREAM which indicates that file NAME is the current source
646: file. This output is generated each time input shifts to a
647: different source file as a result of `#include', the end of an
648: included file, or a `#line' command.
649:
650: This macro need not be defined if the standard form of output for
651: DBX debugging information is appropriate.
652:
653:
654: File: gcc.info, Node: SDB and DWARF, Prev: File Names and DBX, Up: Debugging Info
655:
656: Macros for SDB and DWARF Output
657: -------------------------------
658:
659: `SDB_DEBUGGING_INFO'
660: Define this macro if GNU CC should produce COFF-style debugging
661: output for SDB in response to the `-g' option.
662:
663: `DWARF_DEBUGGING_INFO'
664: Define this macro if GNU CC should produce dwarf format debugging
665: output in response to the `-g' option.
666:
667: `PUT_SDB_...'
668: Define these macros to override the assembler syntax for the
669: special SDB assembler directives. See `sdbout.c' for a list of
670: these macros and their arguments. If the standard syntax is used,
671: you need not define them yourself.
672:
673: `SDB_DELIM'
674: Some assemblers do not support a semicolon as a delimiter, even
675: between SDB assembler directives. In that case, define this macro
676: to be the delimiter to use (usually `\n'). It is not necessary to
677: define a new set of `PUT_SDB_OP' macros if this is the only change
678: required.
679:
680: `SDB_GENERATE_FAKE'
681: Define this macro to override the usual method of constructing a
682: dummy name for anonymous structure and union types. See
683: `sdbout.c' for more information.
684:
685: `SDB_ALLOW_UNKNOWN_REFERENCES'
686: Define this macro to allow references to unknown structure, union,
687: or enumeration tags to be emitted. Standard COFF does not allow
688: handling of unknown references, MIPS ECOFF has support for it.
689:
690: `SDB_ALLOW_FORWARD_REFERENCES'
691: Define this macro to allow references to structure, union, or
692: enumeration tags that have not yet been seen to be handled. Some
693: assemblers choke if forward tags are used, while some require it.
694:
695:
696: File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Debugging Info, Up: Target Macros
697:
698: Cross Compilation and Floating Point
699: ====================================
700:
701: While all modern machines use 2's complement representation for
702: integers, there are a variety of representations for floating point
703: numbers. This means that in a cross-compiler the representation of
704: floating point numbers in the compiled program may be different from
705: that used in the machine doing the compilation.
706:
707: Because different representation systems may offer different amounts
708: of range and precision, the cross compiler cannot safely use the host
709: machine's floating point arithmetic. Therefore, floating point
710: constants must be represented in the target machine's format. This
711: means that the cross compiler cannot use `atof' to parse a floating
712: point constant; it must have its own special routine to use instead.
713: Also, constant folding must emulate the target machine's arithmetic (or
714: must not be done at all).
715:
716: The macros in the following table should be defined only if you are
717: cross compiling between different floating point formats.
718:
719: Otherwise, don't define them. Then default definitions will be set
720: up which use `double' as the data type, `==' to test for equality, etc.
721:
722: You don't need to worry about how many times you use an operand of
723: any of these macros. The compiler never uses operands which have side
724: effects.
725:
726: `REAL_VALUE_TYPE'
727: A macro for the C data type to be used to hold a floating point
728: value in the target machine's format. Typically this would be a
729: `struct' containing an array of `int'.
730:
731: `REAL_VALUES_EQUAL (X, Y)'
732: A macro for a C expression which compares for equality the two
733: values, X and Y, both of type `REAL_VALUE_TYPE'.
734:
735: `REAL_VALUES_LESS (X, Y)'
736: A macro for a C expression which tests whether X is less than Y,
737: both values being of type `REAL_VALUE_TYPE' and interpreted as
738: floating point numbers in the target machine's representation.
739:
740: `REAL_VALUE_LDEXP (X, SCALE)'
741: A macro for a C expression which performs the standard library
742: function `ldexp', but using the target machine's floating point
743: representation. Both X and the value of the expression have type
744: `REAL_VALUE_TYPE'. The second argument, SCALE, is an integer.
745:
746: `REAL_VALUE_FIX (X)'
747: A macro whose definition is a C expression to convert the
748: target-machine floating point value X to a signed integer. X has
749: type `REAL_VALUE_TYPE'.
750:
751: `REAL_VALUE_UNSIGNED_FIX (X)'
752: A macro whose definition is a C expression to convert the
753: target-machine floating point value X to an unsigned integer. X
754: has type `REAL_VALUE_TYPE'.
755:
756: `REAL_VALUE_RNDZINT (X)'
757: A macro whose definition is a C expression to round the
758: target-machine floating point value X towards zero to an integer
759: value (but still as a floating point number). X has type
760: `REAL_VALUE_TYPE', and so does the value.
761:
762: `REAL_VALUE_UNSIGNED_RNDZINT (X)'
763: A macro whose definition is a C expression to round the
764: target-machine floating point value X towards zero to an unsigned
765: integer value (but still represented as a floating point number).
766: x has type `REAL_VALUE_TYPE', and so does the value.
767:
768: `REAL_VALUE_ATOF (STRING, MODE)'
769: A macro for a C expression which converts STRING, an expression of
770: type `char *', into a floating point number in the target machine's
771: representation for mode MODE. The value has type
772: `REAL_VALUE_TYPE'.
773:
774: `REAL_INFINITY'
775: Define this macro if infinity is a possible floating point value,
776: and therefore division by 0 is legitimate.
777:
778: `REAL_VALUE_ISINF (X)'
779: A macro for a C expression which determines whether X, a floating
780: point value, is infinity. The value has type `int'. By default,
781: this is defined to call `isinf'.
782:
783: `REAL_VALUE_ISNAN (X)'
784: A macro for a C expression which determines whether X, a floating
785: point value, is a "nan" (not-a-number). The value has type `int'.
786: By default, this is defined to call `isnan'.
787:
788: Define the following additional macros if you want to make floating
789: point constant folding work while cross compiling. If you don't define
790: them, cross compilation is still possible, but constant folding will
791: not happen for floating point values.
792:
793: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
794: A macro for a C statement which calculates an arithmetic operation
795: of the two floating point values X and Y, both of type
796: `REAL_VALUE_TYPE' in the target machine's representation, to
797: produce a result of the same type and representation which is
798: stored in OUTPUT (which will be a variable).
799:
800: The operation to be performed is specified by CODE, a tree code
801: which will always be one of the following: `PLUS_EXPR',
802: `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
803:
804: The expansion of this macro is responsible for checking for
805: overflow. If overflow happens, the macro expansion should execute
806: the statement `return 0;', which indicates the inability to
807: perform the arithmetic operation requested.
808:
809: `REAL_VALUE_NEGATE (X)'
810: A macro for a C expression which returns the negative of the
811: floating point value X. Both X and the value of the expression
812: have type `REAL_VALUE_TYPE' and are in the target machine's
813: floating point representation.
814:
815: There is no way for this macro to report overflow, since overflow
816: can't happen in the negation operation.
817:
818: `REAL_VALUE_TRUNCATE (MODE, X)'
819: A macro for a C expression which converts the floating point value
820: X to mode MODE.
821:
822: Both X and the value of the expression are in the target machine's
823: floating point representation and have type `REAL_VALUE_TYPE'.
824: However, the value should have an appropriate bit pattern to be
825: output properly as a floating constant whose precision accords
826: with mode MODE.
827:
828: There is no way for this macro to report overflow.
829:
830: `REAL_VALUE_TO_INT (LOW, HIGH, X)'
831: A macro for a C expression which converts a floating point value X
832: into a double-precision integer which is then stored into LOW and
833: HIGH, two variables of type INT.
834:
835: `REAL_VALUE_FROM_INT (X, LOW, HIGH)'
836: A macro for a C expression which converts a double-precision
837: integer found in LOW and HIGH, two variables of type INT, into a
838: floating point value which is then stored into X.
839:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.