![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-10 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to gcc.info-10 CVS log | Up to [GCC 1.x] / gcc |
1.1 root 1: Info file gcc.info, produced by Makeinfo, -*- Text -*- from input
2: file gcc.texinfo.
3:
4: This file documents the use and the internals of the GNU compiler.
5:
6: Copyright (C) 1988, 1989 Free Software Foundation, Inc.
7:
8: Permission is granted to make and distribute verbatim copies of this
9: manual provided the copyright notice and this permission notice are
10: preserved on all copies.
11:
12: Permission is granted to copy and distribute modified versions of
13: this manual under the conditions for verbatim copying, provided also
14: that the sections entitled ``GNU General Public License'' and
15: ``Protect Your Freedom--Fight `Look And Feel''' are included exactly
16: as in the original, and provided that the entire resulting derived
17: work is distributed under the terms of a permission notice identical
18: to this one.
19:
20: Permission is granted to copy and distribute translations of this
21: manual into another language, under the above conditions for modified
22: versions, except that the sections entitled ``GNU General Public
23: License'' and ``Protect Your Freedom--Fight `Look And Feel''' and
24: this permission notice may be included in translations approved by
25: the Free Software Foundation instead of in the original English.
26:
27:
28:
29: File: gcc.info, Node: Assembler Format, Prev: Misc, Up: Machine Macros
30:
31: Output of Assembler Code
32: ========================
33:
34: `ASM_SPEC'
35: A C string constant that tells the GNU CC driver program options
36: to pass to the assembler. It can also specify how to translate
37: options you give to GNU CC into options for GNU CC to pass to
38: the assembler. See the file `tm-sun3.h' for an example of this.
39:
40: Do not define this macro if it does not need to do anything.
41:
42: `LINK_SPEC'
43: A C string constant that tells the GNU CC driver program options
44: to pass to the linker. It can also specify how to translate
45: options you give to GNU CC into options for GNU CC to pass to
46: the linker.
47:
48: Do not define this macro if it does not need to do anything.
49:
50: `LIB_SPEC'
51: Another C string constant used much like `LINK_SPEC'. The
52: difference between the two is that `LIBS_SPEC' is used at the
53: end of the command given to the linker.
54:
55: If this macro is not defined, a default is provided that loads
56: the standard C library from the usual place. See `gcc.c'.
57:
58: `STARTFILE_SPEC'
59: Another C string constant used much like `LINK_SPEC'. The
60: difference between the two is that `STARTFILE_SPEC' is used at
61: the very beginning of the command given to the linker.
62:
63: If this macro is not defined, a default is provided that loads
64: the standard C startup file from the usual place. See `gcc.c'.
65:
66: `STANDARD_EXEC_PREFIX'
67: Define this macro as a C string constant if you wish to override
68: the standard choice of `/usr/local/lib/gcc-' as the default
69: prefix to try when searching for the executable files of the
70: compiler.
71:
72: The prefix specified by the `-B' option, if any, is tried before
73: the default prefix. After the default prefix, if the executable
74: is not found that way, `/usr/lib/gcc-' is tried next; then the
75: directories in your search path for shell commands are searched.
76:
77: `STANDARD_STARTFILE_PREFIX'
78: Define this macro as a C string constant if you wish to override
79: the standard choice of `/usr/local/lib/' as the default prefix
80: to try when searching for startup files such as `crt0.o'.
81:
82: In this search, all the prefixes tried for executable files are
83: tried first. Then comes the default startfile prefix specified
84: by this macro, followed by the prefixes `/lib/' and `/usr/lib/'
85: as last resorts.
86:
87: `ASM_FILE_START (STREAM)'
88: A C expression which outputs to the stdio stream STREAM some
89: appropriate text to go at the start of an assembler file.
90:
91: Normally this macro is defined to output a line containing
92: `#NO_APP', which is a comment that has no effect on most
93: assemblers but tells the GNU assembler that it can save time by
94: not checking for certain assembler constructs.
95:
96: On systems that use SDB, it is necessary to output certain
97: commands; see `tm-attasm.h'.
98:
99: `ASM_FILE_END (STREAM)'
100: A C expression which outputs to the stdio stream STREAM some
101: appropriate text to go at the end of an assembler file.
102:
103: If this macro is not defined, the default is to output nothing
104: special at the end of the file. Most systems don't require any
105: definition.
106:
107: On systems that use SDB, it is necessary to output certain
108: commands; see `tm-attasm.h'.
109:
110: `ASM_IDENTIFY_GCC (FILE)'
111: A C statement to output assembler commands which will identify
112: the object file as having been compiled with GNU CC (or another
113: GNU compiler).
114:
115: If you don't define this macro, the string `gcc_compiled.:' is
116: output. This string is calculated to define a symbol which, on
117: BSD systems, will never be defined for any other reason. GDB
118: checks for the presence of this symbol when reading the symbol
119: table of an executable.
120:
121: On non-BSD systems, you must arrange communication with GDB in
122: some other fashion. If GDB is not used on your system, you can
123: define this macro with an empty body.
124:
125: `ASM_APP_ON'
126: A C string constant for text to be output before each `asm'
127: statement or group of consecutive ones. Normally this is
128: `"#APP"', which is a comment that has no effect on most
129: assemblers but tells the GNU assembler that it must check the
130: lines that follow for all valid assembler constructs.
131:
132: `ASM_APP_OFF'
133: A C string constant for text to be output after each `asm'
134: statement or group of consecutive ones. Normally this is
135: `"#NO_APP"', which tells the GNU assembler to resume making the
136: time-saving assumptions that are valid for ordinary compiler
137: output.
138:
139: `TEXT_SECTION_ASM_OP'
140: A C string constant for the assembler operation that should
141: precede instructions and read-only data. Normally `".text"' is
142: right.
143:
144: `DATA_SECTION_ASM_OP'
145: A C string constant for the assembler operation to identify the
146: following data as writable initialized data. Normally `".data"'
147: is right.
148:
149: `EXTRA_SECTIONS'
150: A list of names for sections other than the standard two, which
151: are `in_text' and `in_data'. You need not define this macro on
152: a system with no other sections (that GCC needs to use).
153:
154: `EXTRA_SECTION_FUNCTIONS'
155: One or more functions to be defined in `varasm.c'. These
156: functions should do jobs analogous to those of `text_section'
157: and `data_section', for your additional sections. Do not define
158: this macro if you do not define `EXTRA_SECTIONS'.
159:
160: `SELECT_SECTION (EXP)'
161: A C statement or statements to switch to the appropriate section
162: for output of EXP. You can assume that EXP is either a
163: `VAR_DECL' node or a constant of some sort. Select the section
164: by calling `text_section' or one of the alternatives for other
165: sections.
166:
167: Do not define this macro if you use only the standard two
168: sections and put all read-only variables and constants in the
169: text section.
170:
171: `SELECT_RTX_SECTION (MODE, RTX)'
172: A C statement or statements to switch to the appropriate section
173: for output of RTX in mode MODE. You can assume that RTX is some
174: kind of constant in RTL. The argument MODE is redundant except
175: in the case of a `const_int' rtx. Select the section by calling
176: `text_section' or one of the alternatives for other sections.
177:
178: Do not define this macro if you use only the standard two
179: sections and put all constants in the text section.
180:
181: `REGISTER_NAMES'
182: A C initializer containing the assembler's names for the machine
183: registers, each one as a C string constant. This is what
184: translates register numbers in the compiler into assembler
185: language.
186:
187: `DBX_REGISTER_NUMBER (REGNO)'
188: A C expression that returns the DBX register number for the
189: compiler register number REGNO. In simple cases, the value of
190: this expression may be REGNO itself. But sometimes there are
191: some registers that the compiler knows about and DBX does not,
192: or vice versa. In such cases, some register may need to have
193: one number in the compiler and another for DBX.
194:
195: `DBX_DEBUGGING_INFO'
196: Define this macro if GNU CC should produce debugging output for
197: DBX in response to the `-g' option.
198:
199: `SDB_DEBUGGING_INFO'
200: Define this macro if GNU CC should produce debugging output for
201: SDB in response to the `-g' option.
202:
203: `PUT_SDB_OP'
204: Define these macros to override the assembler syntax for the
205: special SDB assembler directives. See `sdbout.c' for a list of
206: these macros and their arguments. If the standard syntax is
207: used, you need not define them yourself.
208:
209: `SDB_GENERATE_FAKE'
210: Define this macro to override the usual method of constructing a
211: dummy name for anonymous structure and union types. See
212: `sdbout.c' for more information.
213:
214: `DBX_NO_XREFS'
215: Define this macro if DBX on your system does not support the
216: construct `xsTAGNAME'. On some systems, this construct is used
217: to describe a forward reference to a structure named TAGNAME.
218: On other systems, this construct is not supported at all.
219:
220: `DBX_CONTIN_LENGTH'
221: A symbol name in DBX-format debugging information is normally
222: continued (split into two separate `.stabs' directives) when it
223: exceeds a certain length (by default, 80 characters). On some
224: operating systems, DBX requires this splitting; on others,
225: splitting must not be done. You can inhibit splitting by
226: defining this macro with the value zero. You can override the
227: default splitting-length by defining this macro as an expression
228: for the length you desire.
229:
230: `DBX_CONTIN_CHAR'
231: Normally continuation is indicated by adding a `\' character to
232: the end of a `.stabs' string when a continuation follows. To
233: use a different character instead, define this macro as a
234: character constant for the character you want to use. Do not
235: define this macro if backslash is correct for your system.
236:
237: `DBX_STATIC_STAB_DATA_SECTION'
238: Define this macro if it is necessary to go to the data section
239: before outputting the `.stabs' pseudo-op for a non-global static
240: variable.
241:
242: `ASM_OUTPUT_LABEL (STREAM, NAME)'
243: A C statement (sans semicolon) to output to the stdio stream
244: STREAM the assembler definition of a label named NAME. Use the
245: expression `assemble_name (STREAM, NAME)' to output the name
246: itself; before and after that, output the additional assembler
247: syntax for defining the name, and a newline.
248:
249: `ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)'
250: A C statement (sans semicolon) to output to the stdio stream
251: STREAM any text necessary for declaring the name NAME of a
252: function which is being defined. This macro is responsible for
253: outputting the label definition (perhaps using
254: `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL'
255: tree node representing the function.
256:
257: If this macro is not defined, then the function name is defined
258: in the usual manner as a label (by means of `ASM_OUTPUT_LABEL').
259:
260: `ASM_GLOBALIZE_LABEL (STREAM, NAME)'
261: A C statement (sans semicolon) to output to the stdio stream
262: STREAM some commands that will make the label NAME global; that
263: is, available for reference from other files. Use the
264: expression `assemble_name (STREAM, NAME)' to output the name
265: itself; before and after that, output the additional assembler
266: syntax for making that name global, and a newline.
267:
268: `ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)'
269: A C statement (sans semicolon) to output to the stdio stream
270: STREAM any text necessary for declaring the name of an external
271: symbol named NAME which is referenced in this compilation but
272: not defined. The value of DECL is the tree node for the
273: declaration.
274:
275: This macro need not be defined if it does not need to output
276: anything. The GNU assembler and most Unix assemblers don't
277: require anything.
278:
279: `ASM_OUTPUT_LABELREF (STREAM, NAME)'
280: A C statement to output to the stdio stream STREAM a reference
281: in assembler syntax to a label named NAME. The character `_'
282: should be added to the front of the name, if that is customary
283: on your operating system, as it is in most Berkeley Unix
284: systems. This macro is used in `assemble_name'.
285:
286: `ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)'
287: A C statement to store into the string STRING a label whose name
288: is made from the string PREFIX and the number NUM.
289:
290: This string, when output subsequently by `ASM_OUTPUT_LABELREF',
291: should produce the same output that `ASM_OUTPUT_INTERNAL_LABEL'
292: would produce with the same PREFIX and NUM.
293:
294: `ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)'
295: A C statement to output to the stdio stream STREAM a label whose
296: name is made from the string PREFIX and the number NUM. These
297: labels are used for internal purposes, and there is no reason
298: for them to appear in the symbol table of the object file. On
299: many systems, the letter `L' at the beginning of a label has
300: this effect. The usual definition of this macro is as follows:
301:
302: fprintf (STREAM, "L%s%d:\n", PREFIX, NUM)
303:
304: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
305: Define this if the label before a jump-table needs to be output
306: specially. The first three arguments are the same as for
307: `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the
308: jump-table which follows (a `jump_insn' containing an `addr_vec'
309: or `addr_diff_vec').
310:
311: This feature is used on system V to output a `swbeg' statement
312: for the table.
313:
314: If this macro is not defined, these labels are output with
315: `ASM_OUTPUT_INTERNAL_LABEL'.
316:
317: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
318: Define this if something special must be output at the end of a
319: jump-table. The definition should be a C statement to be
320: executed after the assembler code for the table is written. It
321: should write the appropriate code to stdio stream STREAM. The
322: argument TABLE is the jump-table insn, and NUM is the
323: label-number of the preceding label.
324:
325: If this macro is not defined, nothing special is output at the
326: end of the jump-table.
327:
328: `ASM_OUTPUT_ALIGN_CODE (FILE)'
329: A C expression to output text to align the location counter in
330: the way that is desirable at a point in the code that is reached
331: only by jumping.
332:
333: This macro need not be defined if you don't want any special
334: alignment to be done at such a time. Most machine descriptions
335: do not currently define the macro.
336:
337: `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
338: A C expression to assign to OUTVAR (which is a variable of type
339: `char *') a newly allocated string made from the string NAME and
340: the number NUMBER, with some suitable punctuation added. Use
341: `alloca' to get space for the string.
342:
343: This string will be used as the argument to
344: `ASM_OUTPUT_LABELREF' to produce an assembler label for an
345: internal static variable whose name is NAME. Therefore, the
346: string must be such as to result in valid assembler code. The
347: argument NUMBER is different each time this macro is executed;
348: it prevents conflicts between similarly-named internal static
349: variables in different scopes.
350:
351: Ideally this string should not be a valid C identifier, to
352: prevent any conflict with the user's own symbols. Most
353: assemblers allow periods or percent signs in assembler symbols;
354: putting at least one of these between the name and the number
355: will suffice.
356:
357: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
358: A C expression to output to STREAM some assembler code which
359: will push hard register number REGNO onto the stack. The code
360: need not be optimal, since this macro is used only when profiling.
361:
362: `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
363: A C expression to output to STREAM some assembler code which
364: will pop hard register number REGNO off of the stack. The code
365: need not be optimal, since this macro is used only when profiling.
366:
367: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
368: This macro should be provided on machines where the addresses in
369: a dispatch table are relative to the table's own address.
370:
371: The definition should be a C statement to output to the stdio
372: stream STREAM an assembler pseudo-instruction to generate a
373: difference between two labels. VALUE and REL are the numbers of
374: two internal labels. The definitions of these labels are output
375: using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in
376: the same way here. For example,
377:
378: fprintf (STREAM, "\t.word L%d-L%d\n",
379: VALUE, REL)
380:
381: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
382: This macro should be provided on machines where the addresses in
383: a dispatch table are absolute.
384:
385: The definition should be a C statement to output to the stdio
386: stream STREAM an assembler pseudo-instruction to generate a
387: reference to a label. VALUE is the number of an internal label
388: whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'.
389: For example,
390:
391: fprintf (STREAM, "\t.word L%d\n", VALUE)
392:
393: `ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
394: A C statement to output to the stdio stream STREAM an assembler
395: instruction to assemble a `double' constant whose value is
396: VALUE. VALUE will be a C expression of type `double'.
397:
398: `ASM_OUTPUT_FLOAT (STREAM, VALUE)'
399: A C statement to output to the stdio stream STREAM an assembler
400: instruction to assemble a `float' constant whose value is VALUE.
401: vALUE will be a C expression of type `float'.
402:
403: `ASM_OUTPUT_INT (STREAM, EXP)'
404: `ASM_OUTPUT_SHORT (STREAM, EXP)'
405: `ASM_OUTPUT_CHAR (STREAM, EXP)'
406: A C statement to output to the stdio stream STREAM an assembler
407: instruction to assemble a `int', `short' or `char' constant
408: whose value is VALUE. The argument EXP will be an RTL
409: expression which represents a constant value. Use
410: `output_addr_const (EXP)' to output this value as an assembler
411: expression.
412:
413: `ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
414: A C statement to output to the stdio stream STREAM an assembler
415: instruction to assemble a `long long' constant whose value is
416: EXP. The argument EXP will be an RTL expression which
417: represents a constant value. It may be a `const_double' RTX, or
418: it may be an ordinary single-precision constant. In the latter
419: case, you should zero-extend it.
420:
421: `ASM_OUTPUT_BYTE (STREAM, VALUE)'
422: A C statement to output to the stdio stream STREAM an assembler
423: instruction to assemble a single byte containing the number VALUE.
424:
425: `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
426: A C statement to output to the stdio stream STREAM an assembler
427: instruction to assemble a string constant containing the LEN
428: bytes at PTR. PTR will be a C expression of type `char *' and
429: LEN a C expression of type `int'.
430:
431: If the assembler has a `.ascii' pseudo-op as found in the
432: Berkeley Unix assembler, do not define the macro
433: `ASM_OUTPUT_ASCII'.
434:
435: `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
436: A C statement to output to the stdio stream STREAM an assembler
437: instruction to advance the location counter by NBYTES bytes.
438: NBYTES will be a C expression of type `int'.
439:
440: `ASM_OUTPUT_ALIGN (STREAM, POWER)'
441: A C statement to output to the stdio stream STREAM an assembler
442: instruction to advance the location counter to a multiple of 2
443: to the POWER bytes. POWER will be a C expression of type `int'.
444:
445: `ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)'
446: A C statement (sans semicolon) to output to the stdio stream
447: STREAM the assembler definition of a common-label named NAME
448: whose size is SIZE bytes. The variable ROUNDED is the size
449: rounded up to whatever alignment the caller wants.
450:
451: Use the expression `assemble_name (STREAM, NAME)' to output the
452: name itself; before and after that, output the additional
453: assembler syntax for defining the name, and a newline.
454:
455: This macro controls how the assembler definitions of
456: uninitialized global variables are output.
457:
458: `ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
459: A C statement (sans semicolon) to output to the stdio stream
460: STREAM the assembler definition of a local-common-label named
461: NAME whose size is SIZE bytes. The variable ROUNDED is the size
462: rounded up to whatever alignment the caller wants.
463:
464: Use the expression `assemble_name (STREAM, NAME)' to output the
465: name itself; before and after that, output the additional
466: assembler syntax for defining the name, and a newline.
467:
468: This macro controls how the assembler definitions of
469: uninitialized static variables are output.
470:
471: `ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
472: A C statment to output DBX or SDB debugging information which
473: indicates that filename NAME is the current source file to the
474: stdio stream STREAM.
475:
476: This macro need not be defined if the standard form of debugging
477: information for the debugger in use is appropriate.
478:
479: `ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
480: A C statment to output DBX or SDB debugging information before
481: code for line number LINE of the current source file to the
482: stdio stream STREAM.
483:
484: This macro need not be defined if the standard form of debugging
485: information for the debugger in use is appropriate.
486:
487: `ASM_OUTPUT_IDENT (STREAM, STRING)'
488: A C statement to output something to the assembler file to
489: handle a `#ident' directive containing the text STRING. If this
490: macro is not defined, nothing is output for a `#ident' directive.
491:
492: `TARGET_BELL'
493: A C constant expression for the integer value for escape
494: sequence `\a'.
495:
496: `TARGET_BS'
497: `TARGET_TAB'
498: `TARGET_NEWLINE'
499: C constant expressions for the integer values for escape
500: sequences `\b', `\t' and `\n'.
501:
502: `TARGET_VT'
503: `TARGET_FF'
504: `TARGET_CR'
505: C constant expressions for the integer values for escape
506: sequences `\v', `\f' and `\r'.
507:
508: `ASM_OUTPUT_OPCODE (STREAM, PTR)'
509: Define this macro if you are using an unusual assembler that
510: requires different names for the machine instructions.
511:
512: The definition is a C statement or statements which output an
513: assembler instruction opcode to the stdio stream STREAM. The
514: macro-operand PTR is a variable of type `char *' which points to
515: the opcode name in its ``internal'' form--the form that is
516: written in the machine description. The definition should
517: output the opcode name to STREAM, performing any translation you
518: desire, and increment the variable PTR to point at the end of
519: the opcode so that it will not be output twice.
520:
521: In fact, your macro definition may process less than the entire
522: opcode name, or more than the opcode name; but if you want to
523: process text that includes `%'-sequences to substitute operands,
524: you must take care of the substitution yourself. Just be sure
525: to increment PTR over whatever text should not be output normally.
526:
527: If you need to look at the operand values, they can be found as
528: the elements of `recog_operand'.
529:
530: If the macro definition does nothing, the instruction is output
531: in the usual way.
532:
533: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
534: If defined, a C statement to be executed just prior to the
535: output of assembler code for INSN, to modify the extracted
536: operands so they will be output differently.
537:
538: Here the argument OPVEC is the vector containing the operands
539: extracted from INSN, and NOPERANDS is the number of elements of
540: the vector which contain meaningful data for this insn. The
541: contents of this vector are what will be used to convert the
542: insn template into assembler code, so you can change the
543: assembler output by changing the contents of the vector.
544:
545: This macro is useful when various assembler syntaxes share a
546: single file of instruction patterns; by defining this macro
547: differently, you can cause a large class of instructions to be
548: output differently (such as with rearranged operands).
549: Naturally, variations in assembler syntax affecting individual
550: insn patterns ought to be handled by writing conditional output
551: routines in those patterns.
552:
553: If this macro is not defined, it is equivalent to a null
554: statement.
555:
556: `PRINT_OPERAND (STREAM, X, CODE)'
557: A C compound statement to output to stdio stream STREAM the
558: assembler syntax for an instruction operand X. X is an RTL
559: expression.
560:
561: CODE is a value that can be used to specify one of several ways
562: of printing the operand. It is used when identical operands
563: must be printed differently depending on the context. CODE
564: comes from the `%' specification that was used to request
565: printing of the operand. If the specification was just `%DIGIT'
566: then CODE is 0; if the specification was `%LTR DIGIT' then CODE
567: is the ASCII code for LTR.
568:
569: If X is a register, this macro should print the register's name.
570: The names can be found in an array `reg_names' whose type is
571: `char *[]'. `reg_names' is initialized from `REGISTER_NAMES'.
572:
573: When the machine description has a specification `%PUNCT' (a `%'
574: followed by a punctuation character), this macro is called with
575: a null pointer for X and the punctuation character for CODE.
576:
577: `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
578: A C expression which evaluates to true if CODE is a valid
579: punctuation character for use in the `PRINT_OPERAND' macro. If
580: `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
581: punctuation characters (except for the standard one, `%') are
582: used in this way.
583:
584: `PRINT_OPERAND_ADDRESS (STREAM, X)'
585: A C compound statement to output to stdio stream STREAM the
586: assembler syntax for an instruction operand that is a memory
587: reference whose address is X. X is an RTL expression.
588:
589: `ASM_OPEN_PAREN'
590: `ASM_CLOSE_PAREN'
591: These macros are defined as C string constant, describing the
592: syntax in the assembler for grouping arithmetic expressions.
593: The following definitions are correct for most assemblers:
594:
595: #define ASM_OPEN_PAREN "("
596: #define ASM_CLOSE_PAREN ")"
597:
598:
599:
600: File: gcc.info, Node: Config, Prev: Machine Macros, Up: Top
601:
602: The Configuration File
603: **********************
604:
605: The configuration file `xm-MACHINE.h' contains macro definitions that
606: describe the machine and system on which the compiler is running.
607: Most of the values in it are actually the same on all machines that
608: GNU CC runs on, so large parts of all configuration files are
609: identical. But there are some macros that vary:
610:
611: `FAILURE_EXIT_CODE'
612: A C expression for the status code to be returned when the
613: compiler exits after serious errors.
614:
615: `SUCCESS_EXIT_CODE'
616: A C expression for the status code to be returned when the
617: compiler exits without serious errors.
618:
619: In addition, configuration files for system V define `bcopy', `bzero'
620: and `bcmp' as aliases. Some files define `alloca' as a macro when
621: compiled with GNU CC, in order to take advantage of the benefit of
622: GNU CC's built-in `alloca'.
623:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.