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