![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to internals-6 CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 1.x] / gcc|
Return to internals-6 CVS log | Up to [GCC 1.x] / gcc |
1.1 root 1: Info file internals, produced by Makeinfo, -*- Text -*-
2: from input file internals.texinfo.
3:
4:
5:
6: This file documents the internals of the GNU compiler.
7:
8: Copyright (C) 1988 Free Software Foundation, Inc.
9:
10: Permission is granted to make and distribute verbatim copies of
11: this manual provided the copyright notice and this permission notice
12: are preserved on all copies.
13:
14: Permission is granted to copy and distribute modified versions of this
15: manual under the conditions for verbatim copying, provided also that the
16: section entitled ``GNU CC General Public License'' is included exactly as
17: in the original, and provided that the entire resulting derived work is
18: distributed under the terms of a permission notice identical to this one.
19:
20: Permission is granted to copy and distribute translations of this manual
21: into another language, under the above conditions for modified versions,
22: except that the section entitled ``GNU CC General Public License'' and
23: this permission notice may be included in translations approved by the
24: Free Software Foundation instead of in the original English.
25:
26:
27:
28:
29:
30:
31: File: internals, Node: Misc, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros
32:
33: Miscellaneous Parameters
34: ========================
35:
36: `CASE_VECTOR_MODE'
37: An alias for a machine mode name. This is the machine mode that
38: elements of a jump-table should have.
39:
40: `CASE_VECTOR_PC_RELATIVE'
41: Define this macro if jump-tables should contain relative addresses.
42:
43: `CASE_DROPS_THROUGH'
44: Define this if control falls through a `case' insn when the index
45: value is out of range. This means the specified default-label is
46: actually ignored by the `case' insn proper.
47:
48: `IMPLICIT_FIX_EXPR'
49: An alias for a tree code that should be used by default for conversion
50: of floating point values to fixed point. Normally, `FIX_ROUND_EXPR'
51: is used.
52:
53: `FIXUNS_TRUNC_LIKE_FIX_TRUNC'
54: Define this macro if the same instructions that convert a floating
55: point number to a signed fixed point number also convert validly to an
56: unsigned one.
57:
58: `EASY_DIV_EXPR'
59: An alias for a tree code that is the easiest kind of division to
60: compile code for in the general case. It may be `TRUNC_DIV_EXPR',
61: `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or `ROUND_DIV_EXPR'. These four
62: division operators differ in how they round the result to an integer.
63: `EASY_DIV_EXPR' is used when it is permissible to use any of those
64: kinds of division and the choice should be made on the basis of
65: efficiency.
66:
67: `DEFAULT_SIGNED_CHAR'
68: An expression whose value is 1 or 0, according to whether the type
69: `char' should be signed or unsigned by default. The user can always
70: override this default with the options `-fsigned-char' and
71: `-funsigned-char'.
72:
73: `SCCS_DIRECTIVE'
74: Define this if the preprocessor should ignore `#sccs' directives with
75: no error message.
76:
77: `MOVE_MAX'
78: The maximum number of bytes that a single instruction can move quickly
79: from memory to memory.
80:
81: `INT_TYPE_SIZE'
82: A C expression for the size in bits of the type `int' on the target
83: machine.
84:
85: `SLOW_BYTE_ACCESS'
86: Define this macro as a C expression which is nonzero if accessing less
87: than a word of memory (i.e. a `char' or a `short') is slow (requires
88: more than one instruction).
89:
90: `SLOW_ZERO_EXTEND'
91: Define this macro if zero-extension (of a `char' or `short' to an
92: `int') can be done faster if the destination is a register that is
93: known to be zero.
94:
95: If you define this macro, you must have instruction patterns that
96: recognize RTL structures like this:
97:
98: (set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...)
99:
100:
101: and likewise for `HImode'.
102:
103: `SHIFT_COUNT_TRUNCATED'
104: Define this macro if shift instructions ignore all but the lowest few
105: bits of the shift count. It implies that a sign-extend or zero-extend
106: instruction for the shift count can be omitted.
107:
108: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
109: A C expression which is nonzero if on this machine it is safe to
110: ``convert'' an integer of INPREC bits to one of OUTPREC bits (where
111: OUTPREC is smaller than INPREC) by merely operating on it as if it had
112: only OUTPREC bits.
113:
114: On many machines, this expression can be 1.
115:
116: `NO_FUNCTION_CSE'
117: Define this macro if it is as good or better to call a constant
118: function address than to call an address kept in a register.
119:
120: `STORE_FLAG_VALUE'
121: A C expression for the value stored by a store-flag instruction
122: (`sCOND') when the condition is true. This is usually 1 or -1; it is
123: required to be an odd number.
124:
125: Do not define `STORE_FLAG_VALUE' if the machine has no store-flag
126: instructions.
127:
128: `Pmode'
129: An alias for the machine mode for pointers. Normally the definition
130: can be
131:
132: #define Pmode SImode
133:
134:
135: `FUNCTION_MODE'
136: An alias for the machine mode used for memory references to functions
137: being called, in `call' RTL expressions. On most machines this should
138: be `QImode'.
139:
140: `CONST_COST (X, CODE)'
141: A part of a C `switch' statement that describes the relative costs of
142: constant RTL expressions. It must contain `case' labels for
143: expression codes `const_int', `const', `symbol_ref', `label_ref' and
144: `const_double'. Each case must ultimately reach a `return' statement
145: to return the relative cost of the use of that kind of constant value
146: in an expression. The cost may depend on the precise value of the
147: constant, which is available for examination in X.
148:
149: CODE is the expression code---redundant, since it can be obtained with
150: `GET_CODE (X)'.
151:
152: `DOLLARS_IN_IDENTIFIERS'
153: Define this if the character `$' should be allowed in identifier names.
154:
155:
156: File: internals, Node: Condition Code, Next: Assembler Format, Prev: Misc, Up: Machine Macros
157:
158: Condition Code Information
159: ==========================
160:
161: The file `conditions.h' defines a variable `cc_status' to describe how the
162: condition code was computed (in case the interpretation of the condition
163: code depends on the instruction that it was set by). This variable
164: contains the RTL expressions on which the condition code is currently
165: based, and several standard flags.
166:
167: Sometimes additional machine-specific flags must be defined in the machine
168: description header file. It can also add additional machine-specific
169: information by defining `CC_STATUS_MDEP'.
170:
171: `CC_STATUS_MDEP'
172: C code for a data type which is used for declaring the `mdep'
173: component of `cc_status'. It defaults to `int'.
174:
175: `CC_STATUS_MDEP_INIT'
176: A C expression for the initial value of the `mdep' field. It defaults
177: to 0.
178:
179: `NOTICE_UPDATE_CC (EXP)'
180: A C compound statement to set the components of `cc_status'
181: appropriately for an insn whose body is EXP. It is this macro's
182: responsibility to recognize insns that set the condition code as a
183: byproduct of other activity as well as those that explicitly set
184: `(cc0)'.
185:
186: If there are insn that do not set the condition code but do alter
187: other machine registers, this macro must check to see whether they
188: invalidate the expressions that the condition code is recorded as
189: reflecting. For example, on the 68000, insns that store in address
190: registers do not set the condition code, which means that usually
191: `NOTICE_UPDATE_CC' can leave `cc_status' unaltered for such insns.
192: But suppose that the previous insn set the condition code based on
193: location `a4@(102)' and the current insn stores a new value in `a4'.
194: Although the condition code is not changed by this, it will no longer
195: be true that it reflects the contents of `a4@(102)'. Therefore,
196: `NOTICE_UPDATE_CC' must alter `cc_status' in this case to say that
197: nothing is known about the condition code value.
198:
199:
200: File: internals, Node: Assembler Format, Prev: Condition Code, Up: Machine Macros
201:
202: Output of Assembler Code
203: ========================
204:
205: `ASM_SPEC'
206: A C string constant that tells the GNU CC driver program options to
207: pass to the assembler. It can also specify how to translate options
208: you give to GNU CC into options for GNU CC to pass to the assembler.
209: See the file `tm-sun3.h' for an example of this.
210:
211: Do not define this macro if it does not need to do anything.
212:
213: `LINK_SPEC'
214: A C string constant that tells the GNU CC driver program options to
215: pass to the linker. It can also specify how to translate options you
216: give to GNU CC into options for GNU CC to pass to the linker.
217:
218: Do not define this macro if it does not need to do anything.
219:
220: `ASM_FILE_START'
221: A C string constant for text to be output at the start of each
222: assembler output file. Normally this is `"#NO_APP"', which is a
223: comment that has no effect on most assemblers but tells the GNU
224: assembler that it can save time by not checking for certain assembler
225: constructs.
226:
227: `ASM_APP_ON'
228: A C string constant for text to be output before each `asm' statement
229: or group of consecutive ones. Normally this is `"#APP"', which is a
230: comment that has no effect on most assemblers but tells the GNU
231: assembler that it must check the lines that follow for all valid
232: assembler constructs.
233:
234: `ASM_APP_OFF'
235: A C string constant for text to be output after each `asm' statement
236: or group of consecutive ones. Normally this is `"#NO_APP"', which
237: tells the GNU assembler to resume making the time-saving assumptions
238: that are valid for ordinary compiler output.
239:
240: `TEXT_SECTION_ASM_OP'
241: A C string constant for the assembler operation that should precede
242: instructions and read-only data. Normally `".text"' is right.
243:
244: `DATA_SECTION_ASM_OP'
245: A C string constant for the assembler operation to identify the
246: following data as writable initialized data. Normally `".data"' is
247: right.
248:
249: `REGISTER_NAMES'
250: A C initializer containing the assembler's names for the machine
251: registers, each one as a C string constant. This is what translates
252: register numbers in the compiler into assembler language.
253:
254: `DBX_REGISTER_NUMBER (REGNO)'
255: A C expression that returns the DBX register number for the compiler
256: register number REGNO. In simple cases, the value of this expression
257: may be REGNO itself. But sometimes there are some registers that the
258: compiler knows about and DBX does not, or vice versa. In such cases,
259: some register may need to have one number in the compiler and another
260: for DBX.
261:
262: `DBX_NO_XREFS'
263: Define this macro if DBX on your system does not support the construct
264: `xsTAGNAME'. On some systems, this construct is used to describe a
265: forward reference to a structure named TAGNAME. On other systems,
266: this construct is not supported at all.
267:
268: `DBX_CONTIN_LENGTH'
269: A symbol name in DBX-format debugging information is normally
270: continued (split into two separate `.stabs' directives) when it
271: exceeds a certain length (by default, 80 characters). On some
272: operating systems, DBX requires this splitting; on others, splitting
273: must not be done. You can inhibit splitting by defining this macro
274: with the value zero. You can override the default splitting-length by
275: defining this macro as an expression for the length you desire.
276:
277: `DBX_CONTIN_CHAR'
278: Normally continuation is indicated by adding a `\' character to the
279: end of a `.stabs' string when a continuation follows. To use a
280: different character instead, define this macro as a character constant
281: for the character you want to use. Do not define this macro if
282: backslash is correct for your system.
283:
284: `ASM_OUTPUT_LABEL (FILE, NAME)'
285: A C statement (sans semicolon) to output to the stdio stream FILE the
286: assembler definition of a label named NAME. Use the expression
287: `assemble_name (FILE, NAME)' to output the name itself; before and
288: after that, output the additional assembler syntax for defining the
289: name, and a newline.
290:
291: `ASM_DECLARE_FUNCTION_NAME (FILE, NAME)'
292: A C statement (sans semicolon) to output to the stdio stream FILE any
293: text necessary for declaring the name of a function which is being
294: defined. This macro is responsible for outputting the label
295: definition (perhaps using `ASM_OUTPUT_LABEL').
296:
297: If this macro is not defined, then the function name is defined in the
298: usual manner as a label (by means of `ASM_OUTPUT_LABEL').
299:
300: `ASM_GLOBALIZE_LABEL (FILE, NAME)'
301: A C statement (sans semicolon) to output to the stdio stream FILE some
302: commands that will make the label NAME global; that is, available for
303: reference from other files. Use the expression `assemble_name (FILE,
304: NAME)' to output the name itself; before and after that, output the
305: additional assembler syntax for making that name global, and a newline.
306:
307: `ASM_OUTPUT_EXTERNAL (FILE, NAME)'
308: A C statement (sans semicolon) to output to the stdio stream FILE any
309: text necessary for declaring the name of an external symbol which is
310: referenced in this compilation but not defined.
311:
312: This macro need not be defined if it does not need to output anything.
313: The GNU assembler and most Unix assemblers don't require anything.
314:
315: `ASM_OUTPUT_LABELREF (FILE, NAME)'
316: A C statement to output to the stdio stream FILE a reference in
317: assembler syntax to a label named NAME. The character `_' should be
318: added to the front of the name, if that is customary on your operating
319: system, as it is in most Berkeley Unix systems. This macro is used in
320: `assemble_name'.
321:
322: `ASM_OUTPUT_INTERNAL_LABEL (FILE, PREFIX, NUM)'
323: A C statement to output to the stdio stream FILE a label whose name is
324: made from the string PREFIX and the number NUM. These labels are used
325: for internal purposes, and there is no reason for them to appear in
326: the symbol table of the object file. On many systems, the letter `L'
327: at the beginning of a label has this effect. The usual definition of
328: this macro is as follows:
329:
330: fprintf (FILE, "L%s%d:\n", PREFIX, NUM)
331:
332:
333: `ASM_OUTPUT_CASE_LABEL (FILE, PREFIX, NUM, TABLE)'
334: Define this if the label before a jump-table needs to be output
335: specially. The first three arguments are the same as for
336: `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
337: which follows (a `jump_insn' containing an `addr_vec' or
338: `addr_diff_vec').
339:
340: This feature is used on system V to output a `swbeg' statement for the
341: table.
342:
343: If this macro is not defined, these labels are output with
344: `ASM_OUTPUT_INTERNAL_LABEL'.
345:
346: `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
347: A C expression to assign to OUTVAR (which is a variable of type `char
348: *') a newly allocated string made from the string NAME and the number
349: NUMBER, with some suitable punctuation added. Use `alloca' to get
350: space for the string.
351:
352: This string will be used as the argument to `ASM_OUTPUT_LABELREF' to
353: produce an assembler label for an internal static variable whose name
354: is NAME. Therefore, the string must be such as to result in valid
355: assembler code. The argument NUMBER is different each time this macro
356: is executed; it prevents conflicts between similarly-named internal
357: static variables in different scopes.
358:
359: Ideally this string should not be a valid C identifier, to prevent any
360: conflict with the user's own symbols. Most assemblers allow periods
361: or percent signs in assembler symbols; putting at least one of these
362: between the name and the number will suffice.
363:
364: `ASM_OUTPUT_ADDR_DIFF_ELT (FILE, VALUE, REL)'
365: This macro should be provided on machines where the addresses in a
366: dispatch table are relative to the table's own address.
367:
368: The definition should be a C statement to output to the stdio stream
369: FILE an assembler pseudo-instruction to generate a difference between
370: two labels. VALUE and REL are the numbers of two internal labels.
371: The definitions of these labels are output using
372: `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the same way
373: here. For example,
374:
375: fprintf (FILE, "\t.word L%d-L%d\n",
376: VALUE, REL)
377:
378:
379: `ASM_OUTPUT_ADDR_VEC_ELT (FILE, VALUE)'
380: This macro should be provided on machines where the addresses in a
381: dispatch table are absolute.
382:
383: The definition should be a C statement to output to the stdio stream
384: FILE an assembler pseudo-instruction to generate a reference to a
385: label. VALUE is the number of an internal label whose definition is
386: output using `ASM_OUTPUT_INTERNAL_LABEL'. For example,
387:
388: fprintf (FILE, "\t.word L%d\n", VALUE)
389:
390:
391: `ASM_OUTPUT_DOUBLE (FILE, VALUE)'
392: A C statement to output to the stdio stream FILE an assembler
393: instruction to assemble a `double' constant whose value is VALUE.
394: VALUE will be a C expression of type `double'.
395:
396: `ASM_OUTPUT_FLOAT (FILE, VALUE)'
397: A C statement to output to the stdio stream FILE an assembler
398: instruction to assemble a `float' constant whose value is VALUE.
399: VALUE will be a C expression of type `float'.
400:
401: `ASM_OUTPUT_INT (FILE, EXP)'
402: `ASM_OUTPUT_SHORT (FILE, EXP)'
403: `ASM_OUTPUT_CHAR (FILE, EXP)'
404: A C statement to output to the stdio stream FILE an assembler
405: instruction to assemble a `int', `short' or `char' constant whose
406: value is VALUE. The argument EXP will be an RTL expression which
407: represents a constant value. Use `output_addr_const (EXP)' to output
408: this value as an assembler expression.
409:
410: `ASM_OUTPUT_BYTE (FILE, VALUE)'
411: A C statement to output to the stdio stream FILE an assembler
412: instruction to assemble a single byte containing the number VALUE.
413:
414: `ASM_OUTPUT_ASCII (FILE, PTR, LEN)'
415: A C statement to output to the stdio stream FILE an assembler
416: instruction to assemble a string constant containing the LEN bytes at
417: PTR. PTR will be a C expression of type `char *' and LEN a C
418: expression of type `int'.
419:
420: If the assembler has a `.ascii' pseudo-op as found in the Berkeley
421: Unix assembler, do not define the macro `ASM_OUTPUT_ASCII'.
422:
423: `ASM_OUTPUT_SKIP (FILE, NBYTES)'
424: A C statement to output to the stdio stream FILE an assembler
425: instruction to advance the location counter by NBYTES bytes. NBYTES
426: will be a C expression of type `int'.
427:
428: `ASM_OUTPUT_ALIGN (FILE, POWER)'
429: A C statement to output to the stdio stream FILE an assembler
430: instruction to advance the location counter to a multiple of 2 to the
431: POWER bytes. POWER will be a C expression of type `int'.
432:
433: `ASM_OUTPUT_COMMON (FILE, NAME, SIZE)'
434: A C statement (sans semicolon) to output to the stdio stream FILE the
435: assembler definition of a common-label named NAME whose size is SIZE
436: bytes. Use the expression `assemble_name (FILE, NAME)' to output the
437: name itself; before and after that, output the additional assembler
438: syntax for defining the name, and a newline.
439:
440: This macro controls how the assembler definitions of uninitialized
441: global variables are output.
442:
443: `ASM_OUTPUT_LOCAL (FILE, NAME, SIZE)'
444: A C statement (sans semicolon) to output to the stdio stream FILE the
445: assembler definition of a local-common-label named NAME whose size is
446: SIZE bytes. Use the expression `assemble_name (FILE, NAME)' to output
447: the name itself; before and after that, output the additional
448: assembler syntax for defining the name, and a newline.
449:
450: This macro controls how the assembler definitions of uninitialized
451: static variables are output.
452:
453: `TARGET_BELL'
454: A C constant expression for the integer value for escape sequence `\a'.
455:
456: `TARGET_BS'
457: `TARGET_TAB'
458: `TARGET_NEWLINE'
459: C constant expressions for the integer values for escape sequences
460: `\b', `\t' and `\n'.
461:
462: `TARGET_VT'
463: `TARGET_FF'
464: `TARGET_CR'
465: C constant expressions for the integer values for escape sequences
466: `\v', `\f' and `\r'.
467:
468: `ASM_OUTPUT_OPCODE (FILE, PTR)'
469: Define this macro if you are using an unusual assembler that requires
470: different names for the machine instructions.
471:
472: The definition is a C statement or statements which output an
473: assembler instruction opcode to the stdio stream FILE. The
474: macro-operand PTR is a variable of type `char *' which points to the
475: opcode name in its ``internal'' form---the form that is written in the
476: machine description. The definition should output the opcode name to
477: FILE, performing any translation you desire, and increment the
478: variABLE PTR to point at the end of the opcode so that it will not be
479: output twice.
480:
481: In fact, your macro definition may process less than the entire opcode
482: name, or more than the opcode name; but if you want to process text
483: that includes `%'-sequences to substitute operands, you must take care
484: of the substitution yourself. Just be sure to increment PTR over
485: whatever text should not be output normally.
486:
487: If the macro definition does nothing, the instruction is output in the
488: usual way.
489:
490: `PRINT_OPERAND (FILE, X, CODE)'
491: A C compound statement to output to stdio stream FILE the assembler
492: syntax for an instruction operand X. X is an RTL expression.
493:
494: CODE is a value that can be used to specify one of several ways of
495: printing the operand. It is used when identical operands must be
496: printed differently depending on the context. CODE comes from the `%'
497: specification that was used to request printing of the operand. If
498: the specification was just `%DIGIT' then CODE is 0; if the
499: specification was `%LTR DIGIT' then CODE is the ASCII code for LTR.
500:
501: If X is a register, this macro should print the register's name. The
502: names can be found in an array `reg_names' whose type is `char *[]'.
503: `reg_names' is initialized from `REGISTER_NAMES'.
504:
505: When the machine description has a specification `%PUNCT' (a `%'
506: followed by a punctuation character), this macro is called with a null
507: pointer for X and the punctuation character for CODE.
508:
509: `PRINT_OPERAND_ADDRESS (FILE, X)'
510: A C compound statement to output to stdio stream FILE the assembler
511: syntax for an instruction operand that is a memory reference whose
512: address is X. X is an RTL expression.
513:
514: `ASM_OPEN_PAREN'
515: `ASM_CLOSE_PAREN'
516: These macros are defined as C string constant, describing the syntax
517: in the assembler for grouping arithmetic expressions. The following
518: definitions are correct for most assemblers:
519:
520: #define ASM_OPEN_PAREN "("
521: #define ASM_CLOSE_PAREN ")"
522:
523:
524:
525: File: internals, Node: Config, Prev: Machine Macros, Up: Top
526:
527: The Configuration File
528: **********************
529:
530: The configuration file `config-MACHINE.h' contains macro definitions that
531: describe the machine and system on which the compiler is running. Most of
532: the values in it are actually the same on all machines that GNU CC runs on,
533: so most all configuration files are identical. But there are some macros
534: that vary:
535:
536: `FAILURE_EXIT_CODE'
537: A C expression for the status code to be returned when the compiler
538: exits after serious errors.
539:
540: `SUCCESS_EXIT_CODE'
541: A C expression for the status code to be returned when the compiler
542: exits without serious errors.
543:
544:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.