![[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:
1.1.1.4 ! root 4: This file documents the use and the internals of the GNU compiler.
1.1 root 5:
1.1.1.4 ! root 6: Copyright (C) 1988, 1989, 1990 Free Software Foundation, Inc.
1.1 root 7:
1.1.1.4 ! root 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.
1.1 root 11:
1.1.1.4 ! root 12: Permission is granted to copy and distribute modified versions of
1.1 root 13: this manual under the conditions for verbatim copying, provided also
1.1.1.2 root 14: that the sections entitled "GNU General Public License" and "Protect
15: Your Freedom--Fight `Look And Feel'" are included exactly as in the
16: original, and provided that the entire resulting derived work is
17: distributed under the terms of a permission notice identical to this
18: one.
1.1 root 19:
1.1.1.4 ! root 20: Permission is granted to copy and distribute translations of this
1.1 root 21: manual into another language, under the above conditions for modified
1.1.1.2 root 22: versions, except that the sections entitled "GNU General Public
23: License" and "Protect Your Freedom--Fight `Look And Feel'" and this
24: permission notice may be included in translations approved by the
25: Free Software Foundation instead of in the original English.
1.1 root 26:
1.1.1.4 ! root 27:
! 28: File: gcc.info, Node: Addressing Modes, Next: Delayed Branch, Prev: Library Calls, Up: Machine Macros
! 29:
! 30: Addressing Modes
! 31: ================
! 32:
! 33: `HAVE_POST_INCREMENT'
! 34: Define this macro if the machine supports post-increment
! 35: addressing.
! 36:
! 37: `HAVE_PRE_INCREMENT'
! 38: `HAVE_POST_DECREMENT'
! 39: `HAVE_PRE_DECREMENT'
! 40: Similar for other kinds of addressing.
! 41:
! 42: `CONSTANT_ADDRESS_P (X)'
! 43: A C expression that is 1 if the RTX X is a constant whose value
! 44: is an integer. This includes integers whose values are not
! 45: explicitly known, such as `symbol_ref' and `label_ref'
! 46: expressions and `const' arithmetic expressions.
! 47:
! 48: On most machines, this can be defined as `CONSTANT_P (X)', but a
! 49: few machines are more restrictive in which constant addresses
! 50: are supported.
! 51:
! 52: `MAX_REGS_PER_ADDRESS'
! 53: A number, the maximum number of registers that can appear in a
! 54: valid memory address. Note that it is up to you to specify a
! 55: value equal to the maximum number that
! 56: `go_if_legitimate_address' would ever accept.
! 57:
! 58: `GO_IF_LEGITIMATE_ADDRESS (MODE, X, LABEL)'
! 59: A C compound statement with a conditional `goto LABEL;' executed
! 60: if X (an RTX) is a legitimate memory address on the target
! 61: machine for a memory operand of mode MODE.
! 62:
! 63: It usually pays to define several simpler macros to serve as
! 64: subroutines for this one. Otherwise it may be too complicated
! 65: to understand.
! 66:
! 67: This macro must exist in two variants: a strict variant and a
! 68: non-strict one. The strict variant is used in the reload pass.
! 69: It must be defined so that any pseudo-register that has not been
! 70: allocated a hard register is considered a memory reference. In
! 71: contexts where some kind of register is required, a
! 72: pseudo-register with no hard register must be rejected.
! 73:
! 74: The non-strict variant is used in other passes. It must be
! 75: defined to accept all pseudo-registers in every context where
! 76: some kind of register is required.
! 77:
! 78: Compiler source files that want to use the strict variant of
! 79: this macro define the macro `REG_OK_STRICT'. You should use an
! 80: `#ifdef REG_OK_STRICT' conditional to define the strict variant
! 81: in that case and the non-strict variant otherwise.
! 82:
! 83: Typically among the subroutines used to define
! 84: `GO_IF_LEGITIMATE_ADDRESS' are subroutines to check for
! 85: acceptable registers for various purposes (one for base
! 86: registers, one for index registers, and so on). Then only these
! 87: subroutine macros need have two variants; the higher levels of
! 88: macros may be the same whether strict or not.
! 89:
! 90: Normally, constant addresses which are the sum of a `symbol_ref'
! 91: and an integer are stored inside a `const' RTX to mark them as
! 92: constant. Therefore, there is no need to recognize such sums as
! 93: legitimate addresses.
! 94:
! 95: Usually `PRINT_OPERAND_ADDRESS' is not prepared to handle
! 96: constant sums that are not marked with `const'. It assumes
! 97: that a naked `plus' indicates indexing. If so, then you *must*
! 98: reject such naked constant sums as illegitimate addresses, so
! 99: that none of them will be given to `PRINT_OPERAND_ADDRESS'.
! 100:
! 101: `REG_OK_FOR_BASE_P (X)'
! 102: A C expression that is nonzero if X (assumed to be a `reg' RTX)
! 103: is valid for use as a base register. For hard registers, it
! 104: should always accept those which the hardware permits and reject
! 105: the others. Whether the macro accepts or rejects pseudo
! 106: registers must be controlled by `REG_OK_STRICT' as described
! 107: above. This usually requires two variant definitions, of which
! 108: `REG_OK_STRICT' controls the one actually used.
! 109:
! 110: `REG_OK_FOR_INDEX_P (X)'
! 111: A C expression that is nonzero if X (assumed to be a `reg' RTX)
! 112: is valid for use as an index register.
! 113:
! 114: The difference between an index register and a base register is
! 115: that the index register may be scaled. If an address involves
! 116: the sum of two registers, neither one of them scaled, then
! 117: either one may be labeled the "base" and the other the "index";
! 118: but whichever labeling is used must fit the machine's
! 119: constraints of which registers may serve in each capacity. The
! 120: compiler will try both labelings, looking for one that is valid,
! 121: and will reload one or both registers only if neither labeling
! 122: works.
! 123:
! 124: `LEGITIMIZE_ADDRESS (X, OLDX, MODE, WIN)'
! 125: A C compound statement that attempts to replace X with a valid
! 126: memory address for an operand of mode MODE. WIN will be a C
! 127: statement label elsewhere in the code; the macro definition may
! 128: use
! 129:
! 130: GO_IF_LEGITIMATE_ADDRESS (MODE, X, WIN);
! 131:
! 132: to avoid further processing if the address has become legitimate.
! 133:
! 134: X will always be the result of a call to
! 135: `break_out_memory_refs', and OLDX will be the operand that was
! 136: given to that function to produce X.
! 137:
! 138: The code generated by this macro should not alter the
! 139: substructure of X. If it transforms X into a more legitimate
! 140: form, it should assign X (which will always be a C variable) a
! 141: new value.
! 142:
! 143: It is not necessary for this macro to come up with a legitimate
! 144: address. The compiler has standard ways of doing so in all
! 145: cases. In fact, it is safe for this macro to do nothing. But
! 146: often a machine-dependent strategy can generate better code.
! 147:
! 148: `GO_IF_MODE_DEPENDENT_ADDRESS (ADDR, LABEL)'
! 149: A C statement or compound statement with a conditional `goto
! 150: LABEL;' executed if memory address X (an RTX) can have different
! 151: meanings depending on the machine mode of the memory reference
! 152: it is used for.
! 153:
! 154: Autoincrement and autodecrement addresses typically have
! 155: mode-dependent effects because the amount of the increment or
! 156: decrement is the size of the operand being addressed. Some
! 157: machines have other mode-dependent addresses. Many RISC
! 158: machines have no mode-dependent addresses.
! 159:
! 160: You may assume that ADDR is a valid address for the machine.
! 161:
! 162: `LEGITIMATE_CONSTANT_P (X)'
! 163: A C expression that is nonzero if X is a legitimate constant for
! 164: an immediate operand on the target machine. You can assume that
! 165: either X is a `const_double' or it satisfies `CONSTANT_P', so
! 166: you need not check these things. In fact, `1' is a suitable
! 167: definition for this macro on machines where any `const_double'
! 168: is valid and anything `CONSTANT_P' is valid.
! 169:
! 170:
! 171: File: gcc.info, Node: Delayed Branch, Next: Condition Code, Prev: Addressing Modes, Up: Machine Macros
! 172:
! 173: Parameters for Delayed Branch Optimization
! 174: ==========================================
! 175:
! 176: `HAVE_DELAYED_BRANCH'
! 177: Define this macro if the target machine has delayed branches,
! 178: that is, a branch does not take effect immediately, and the
! 179: actual branch instruction may be followed by one or more
! 180: instructions that will be issued before the PC is actually
! 181: changed.
! 182:
! 183: If defined, this allows a special scheduling pass to be run
! 184: after the second jump optimization to attempt to reorder
! 185: instructions to exploit this. Defining this macro also requires
! 186: the definition of certain other macros described below.
! 187:
! 188: `DBR_SLOTS_AFTER (INSN)'
! 189: This macro must be defined if `HAVE_DELAYED_BRANCH' is defined.
! 190: Its definition should be a C expression returning the number of
! 191: available delay slots following the instruction(s) output by the
! 192: pattern for INSN. The definition of "slot" is
! 193: machine-dependent, and may denote instructions, bytes, or
! 194: whatever.
! 195:
! 196: `DBR_INSN_SLOTS (INSN)'
! 197: This macro must be defined if `HAVE_DELAYED_BRANCH' is defined.
! 198: It should be a C expression returning the number of slots
! 199: (typically the number of machine instructions) consumed by INSN.
! 200:
! 201: You may assume that INSN is truly an insn, not a note, label,
! 202: barrier, dispatch table, `use', or `clobber'.
! 203:
! 204: `DBR_INSN_ELIGIBLE_P (INSN, DINSN)'
! 205: A C expression whose value is non-zero if it is legitimate to
! 206: put INSN in the delay slot following DINSN.
! 207:
! 208: You do not need to take account of data flow considerations in
! 209: the definition of this macro, because the delayed branch
! 210: optimizer always does that. This macro is needed only when
! 211: certain insns may not be placed in certain delay slots for
! 212: reasons not evident from the RTL expressions themselves. If
! 213: there are no such problems, you don't need to define this macro.
! 214:
! 215: You may assume that INSN is truly an insn, not a note, label,
! 216: barrier, dispatch table, `use', or `clobber'. You may assume
! 217: that DINSN is a jump insn with a delay slot.
! 218:
! 219: `DBR_OUTPUT_SEQEND(FILE)'
! 220: A C statement, to be executed after all slot-filler instructions
! 221: have been output. If necessary, call `dbr_sequence_length' to
! 222: determine the number of slots filled in a sequence (zero if not
! 223: currently outputting a sequence), to decide how many no-ops to
! 224: output, or whatever.
! 225:
! 226: Don't define this macro if it has nothing to do, but it is
! 227: helpful in reading assembly output if the extent of the delay
! 228: sequence is made explicit (e.g. with white space).
! 229:
! 230: Note that output routines for instructions with delay slots must
! 231: be prepared to deal with not being output as part of a sequence
! 232: (i.e. when the scheduling pass is not run, or when no slot
! 233: fillers could be found.) The variable `final_sequence' is null
! 234: when not processing a sequence, otherwise it contains the
! 235: `sequence' rtx being output.
! 236:
! 237:
! 238: File: gcc.info, Node: Condition Code, Next: Cross-compilation, Prev: Delayed Branch, Up: Machine Macros
! 239:
! 240: Condition Code Information
! 241: ==========================
! 242:
! 243: The file `conditions.h' defines a variable `cc_status' to describe
! 244: how the condition code was computed (in case the interpretation of
! 245: the condition code depends on the instruction that it was set by).
! 246: This variable contains the RTL expressions on which the condition
! 247: code is currently based, and several standard flags.
! 248:
! 249: Sometimes additional machine-specific flags must be defined in the
! 250: machine description header file. It can also add additional
! 251: machine-specific information by defining `CC_STATUS_MDEP'.
! 252:
! 253: `CC_STATUS_MDEP'
! 254: C code for a data type which is used for declaring the `mdep'
! 255: component of `cc_status'. It defaults to `int'.
! 256:
! 257: `CC_STATUS_MDEP_INIT'
! 258: A C expression to initialize the `mdep' field to "empty". The
! 259: default definition does nothing, since most machines don't use
! 260: the field anyway. If you want to use the field, you should
! 261: probably define this macro to initialize it.
! 262:
! 263: `NOTICE_UPDATE_CC (EXP, INSN)'
! 264: A C compound statement to set the components of `cc_status'
! 265: appropriately for an insn INSN whose body is EXP. It is this
! 266: macro's responsibility to recognize insns that set the condition
! 267: code as a byproduct of other activity as well as those that
! 268: explicitly set `(cc0)'.
! 269:
! 270: If there are insn that do not set the condition code but do
! 271: alter other machine registers, this macro must check to see
! 272: whether they invalidate the expressions that the condition code
! 273: is recorded as reflecting. For example, on the 68000, insns
! 274: that store in address registers do not set the condition code,
! 275: which means that usually `NOTICE_UPDATE_CC' can leave
! 276: `cc_status' unaltered for such insns. But suppose that the
! 277: previous insn set the condition code based on location
! 278: `a4@(102)' and the current insn stores a new value in `a4'.
! 279: Although the condition code is not changed by this, it will no
! 280: longer be true that it reflects the contents of `a4@(102)'.
! 281: Therefore, `NOTICE_UPDATE_CC' must alter `cc_status' in this
! 282: case to say that nothing is known about the condition code value.
! 283:
! 284: The definition of `NOTICE_UPDATE_CC' must be prepared to deal
! 285: with the results of peephole optimization: insns whose patterns
! 286: are `parallel' RTXs containing various `reg', `mem' or constants
! 287: which are just the operands. The RTL structure of these insns
! 288: is not sufficient to indicate what the insns actually do. What
! 289: `NOTICE_UPDATE_CC' should do when it sees one is just to run
! 290: `CC_STATUS_INIT'.
1.1 root 291:
292:
1.1.1.3 root 293: File: gcc.info, Node: Cross-compilation, Next: Misc, Prev: Condition Code, Up: Machine Macros
294:
295: Cross Compilation and Floating-Point Format
296: ===========================================
297:
1.1.1.4 ! root 298: While all modern machines use 2's complement representation for
1.1.1.3 root 299: integers, there are a variety of representations for floating point
300: numbers. This means that in a cross-compiler the representation of
301: floating point numbers in the compiled program may be different from
302: that used in the machine doing the compilation.
303:
1.1.1.4 ! root 304: Because different representation systems may offer different
! 305: amounts of range and precision, the cross compiler cannot safely use
! 306: the host machine's floating point arithmetic. Therefore, floating
! 307: point constants must be represented in the target machine's format.
! 308: This means that the cross compiler cannot use `atof' to parse a
! 309: floating point constant; it must have its own special routine to use
! 310: instead. Also, constant folding must emulate the target machine's
! 311: arithmetic (or must not be done at all).
1.1.1.3 root 312:
1.1.1.4 ! root 313: The macros in the following table should be defined only if you
! 314: are cross compiling between different floating point formats.
1.1.1.3 root 315:
1.1.1.4 ! root 316: Otherwise, don't define them. Then default definitions will be set
! 317: up which use `double' as the data type, `==' to test for equality, etc.
1.1.1.3 root 318:
1.1.1.4 ! root 319: You don't need to worry about how many times you use an operand of
1.1.1.3 root 320: any of these macros. The compiler never uses operands which have
321: side effects.
322:
323: `REAL_VALUE_TYPE'
324: A macro for the C data type to be used to hold a floating point
325: value in the target machine's format. Typically this would be a
326: `struct' containing an array of `int'.
327:
328: `REAL_VALUES_EQUAL (X, Y)'
329: A macro for a C expression which compares for equality the two
330: values, X and Y, both of type `REAL_VALUE_TYPE'.
331:
332: `REAL_VALUES_LESS (X, Y)'
333: A macro for a C expression which tests whether X is less than Y,
334: both values being of type `REAL_VALUE_TYPE' and interpreted as
335: floating point numbers in the target machine's representation.
336:
337: `REAL_VALUE_LDEXP (X, SCALE)'
338: A macro for a C expression which performs the standard library
339: function `ldexp', but using the target machine's floating point
340: representation. Both X and the value of the expression have
341: type `REAL_VALUE_TYPE'. The second argument, SCALE, is an
342: integer.
343:
344: `REAL_VALUE_ATOF (STRING)'
345: A macro for a C expression which converts STRING, an expression
346: of type `char *', into a floating point number in the target
347: machine's representation. The value has type `REAL_VALUE_TYPE'.
348:
1.1.1.4 ! root 349: Define the following additional macros if you want to make
! 350: floating point constant folding work while cross compiling. If you
! 351: don't define them, cross compilation is still possible, but constant
1.1.1.3 root 352: folding will not happen for floating point values.
353:
354: `REAL_ARITHMETIC (OUTPUT, CODE, X, Y)'
355: A macro for a C statement which calculates an arithmetic
356: operation of the two floating point values X and Y, both of type
357: `REAL_VALUE_TYPE' in the target machine's representation, to
358: produce a result of the same type and representation which is
359: stored in OUTPUT (which will be a variable).
360:
361: The operation to be performed is specified by CODE, a tree code
362: which will always be one of the following: `PLUS_EXPR',
363: `MINUS_EXPR', `MULT_EXPR', `RDIV_EXPR', `MAX_EXPR', `MIN_EXPR'.
364:
365: The expansion of this macro is responsible for checking for
366: overflow. If overflow happens, the macro expansion should
367: execute the statement `return 0;', which indicates the inability
368: to perform the arithmetic operation requested.
369:
370: `REAL_VALUE_NEGATE (X)'
371: A macro for a C expression which returns the negative of the
372: floating point value X. Both X and the value of the expression
373: have type `REAL_VALUE_TYPE' and are in the target machine's
374: floating point representation.
375:
376: There is no way for this macro to report overflow, since
377: overflow can't happen in the negation operation.
378:
379: `REAL_VALUE_TO_INT (LOW, HIGH, X)'
380: A macro for a C expression which converts a floating point value
381: X into a double-precision integer which is then stored into LOW
382: and HIGH, two variables of type INT.
383:
384: `REAL_VALUE_FROM_INT (X, LOW, HIGH)'
385: A macro for a C expression which converts a double-precision
386: integer found in LOW and HIGH, two variables of type INT, into a
387: floating point value which is then stored into X.
388:
389:
390: File: gcc.info, Node: Misc, Next: Assembler Format, Prev: Cross-compilation, Up: Machine Macros
391:
392: Miscellaneous Parameters
393: ========================
394:
395: `CASE_VECTOR_MODE'
396: An alias for a machine mode name. This is the machine mode that
397: elements of a jump-table should have.
398:
399: `CASE_VECTOR_PC_RELATIVE'
400: Define this macro if jump-tables should contain relative
401: addresses.
402:
403: `CASE_DROPS_THROUGH'
404: Define this if control falls through a `case' insn when the
405: index value is out of range. This means the specified
406: default-label is actually ignored by the `case' insn proper.
407:
408: `IMPLICIT_FIX_EXPR'
409: An alias for a tree code that should be used by default for
410: conversion of floating point values to fixed point. Normally,
411: `FIX_ROUND_EXPR' is used.
412:
413: `FIXUNS_TRUNC_LIKE_FIX_TRUNC'
414: Define this macro if the same instructions that convert a
415: floating point number to a signed fixed point number also
416: convert validly to an unsigned one.
417:
418: `EASY_DIV_EXPR'
419: An alias for a tree code that is the easiest kind of division to
420: compile code for in the general case. It may be
421: `TRUNC_DIV_EXPR', `FLOOR_DIV_EXPR', `CEIL_DIV_EXPR' or
422: `ROUND_DIV_EXPR'. These four division operators differ in how
423: they round the result to an integer. `EASY_DIV_EXPR' is used
424: when it is permissible to use any of those kinds of division and
425: the choice should be made on the basis of efficiency.
426:
427: `DEFAULT_SIGNED_CHAR'
428: An expression whose value is 1 or 0, according to whether the
429: type `char' should be signed or unsigned by default. The user
430: can always override this default with the options
431: `-fsigned-char' and `-funsigned-char'.
432:
433: `SCCS_DIRECTIVE'
434: Define this if the preprocessor should ignore `#sccs' directives
435: and print no error message.
436:
437: `HAVE_VPRINTF'
438: Define this if the library function `vprintf' is available on
439: your system.
440:
441: `MOVE_MAX'
442: The maximum number of bytes that a single instruction can move
443: quickly from memory to memory.
444:
445: `INT_TYPE_SIZE'
446: A C expression for the size in bits of the type `int' on the
447: target machine. If you don't define this, the default is one
448: word.
449:
450: `SHORT_TYPE_SIZE'
451: A C expression for the size in bits of the type `short' on the
452: target machine. If you don't define this, the default is half a
453: word. (If this would be less than one storage unit, it is
454: rounded up to one unit.)
455:
456: `LONG_TYPE_SIZE'
457: A C expression for the size in bits of the type `long' on the
458: target machine. If you don't define this, the default is one
459: word.
460:
461: `LONG_LONG_TYPE_SIZE'
462: A C expression for the size in bits of the type `long long' on
463: the target machine. If you don't define this, the default is
464: two words.
465:
466: `CHAR_TYPE_SIZE'
467: A C expression for the size in bits of the type `char' on the
468: target machine. If you don't define this, the default is one
469: quarter of a word. (If this would be less than one storage
470: unit, it is rounded up to one unit.)
471:
472: `FLOAT_TYPE_SIZE'
473: A C expression for the size in bits of the type `float' on the
474: target machine. If you don't define this, the default is one
475: word.
476:
477: `DOUBLE_TYPE_SIZE'
478: A C expression for the size in bits of the type `double' on the
479: target machine. If you don't define this, the default is two
480: words.
481:
482: `LONG_DOUBLE_TYPE_SIZE'
483: A C expression for the size in bits of the type `long double' on
484: the target machine. If you don't define this, the default is
485: two words.
486:
487: `SLOW_BYTE_ACCESS'
488: Define this macro as a C expression which is nonzero if
489: accessing less than a word of memory (i.e. a `char' or a
490: `short') is slow (requires more than one instruction).
491:
492: `SLOW_ZERO_EXTEND'
493: Define this macro if zero-extension (of a `char' or `short' to
494: an `int') can be done faster if the destination is a register
495: that is known to be zero.
496:
497: If you define this macro, you must have instruction patterns
498: that recognize RTL structures like this:
499:
500: (set (strict-low-part (subreg:QI (reg:SI ...) 0)) ...)
501:
502: and likewise for `HImode'.
503:
504: `SHIFT_COUNT_TRUNCATED'
505: Define this macro if shift instructions ignore all but the
506: lowest few bits of the shift count. It implies that a
507: sign-extend or zero-extend instruction for the shift count can
508: be omitted.
509:
510: `TRULY_NOOP_TRUNCATION (OUTPREC, INPREC)'
511: A C expression which is nonzero if on this machine it is safe to
512: "convert" an integer of INPREC bits to one of OUTPREC bits
513: (where OUTPREC is smaller than INPREC) by merely operating on it
514: as if it had only OUTPREC bits.
515:
516: On many machines, this expression can be 1.
517:
518: `NO_FUNCTION_CSE'
519: Define this macro if it is as good or better to call a constant
520: function address than to call an address kept in a register.
521:
522: `PROMOTE_PROTOTYPES'
523: Define this macro if an argument declared as `char' or `short'
524: in a prototype should actually be passed as an `int'. In
525: addition to avoiding errors in certain cases of mismatch, it
526: also makes for better code on certain machines.
527:
528: `STORE_FLAG_VALUE'
529: A C expression for the value stored by a store-flag instruction
530: (`sCOND') when the condition is true. This is usually 1 or -1;
531: it is required to be an odd number or a negative number.
532:
533: Do not define `STORE_FLAG_VALUE' if the machine has no
534: store-flag instructions.
535:
536: `Pmode'
537: An alias for the machine mode for pointers. Normally the
538: definition can be
539:
540: #define Pmode SImode
541:
542: `FUNCTION_MODE'
543: An alias for the machine mode used for memory references to
544: functions being called, in `call' RTL expressions. On most
545: machines this should be `QImode'.
546:
547: `INSN_MACHINE_INFO'
548: This macro should expand into a C structure type to use for the
549: machine-dependent info field specified with the optional last
550: argument in `define_insn' and `define_peephole' patterns. For
551: example, it might expand into `struct machine_info'; then it
552: would be up to you to define this structure in the `tm.h' file.
553:
554: You do not need to define this macro if you do not write the
555: optional last argument in any of the patterns in the machine
556: description.
557:
558: `DEFAULT_MACHINE_INFO'
559: This macro should expand into a C initializer to use to
560: initialize the machine-dependent info for one insn pattern. It
561: is used for patterns that do not specify the machine-dependent
562: info.
563:
564: If you do not define this macro, zero is used.
565:
566: `CONST_COSTS (X, CODE)'
567: A part of a C `switch' statement that describes the relative
568: costs of constant RTL expressions. It must contain `case'
569: labels for expression codes `const_int', `const', `symbol_ref',
570: `label_ref' and `const_double'. Each case must ultimately reach
571: a `return' statement to return the relative cost of the use of
572: that kind of constant value in an expression. The cost may
573: depend on the precise value of the constant, which is available
574: for examination in X.
575:
576: CODE is the expression code--redundant, since it can be obtained
577: with `GET_CODE (X)'.
578:
579: `DOLLARS_IN_IDENTIFIERS'
580: Define this to be nonzero if the character `$' should be allowed
581: by default in identifier names.
582:
583:
1.1 root 584: File: gcc.info, Node: Assembler Format, Prev: Misc, Up: Machine Macros
585:
586: Output of Assembler Code
587: ========================
588:
589: `ASM_SPEC'
590: A C string constant that tells the GNU CC driver program options
591: to pass to the assembler. It can also specify how to translate
592: options you give to GNU CC into options for GNU CC to pass to
593: the assembler. See the file `tm-sun3.h' for an example of this.
594:
595: Do not define this macro if it does not need to do anything.
596:
597: `LINK_SPEC'
598: A C string constant that tells the GNU CC driver program options
599: to pass to the linker. It can also specify how to translate
600: options you give to GNU CC into options for GNU CC to pass to
601: the linker.
602:
603: Do not define this macro if it does not need to do anything.
604:
605: `LIB_SPEC'
606: Another C string constant used much like `LINK_SPEC'. The
607: difference between the two is that `LIBS_SPEC' is used at the
608: end of the command given to the linker.
609:
610: If this macro is not defined, a default is provided that loads
611: the standard C library from the usual place. See `gcc.c'.
612:
1.1.1.4 ! root 613: `LIBG_SPEC'
! 614: Another C string constant used much like `LINK_SPEC'. This
! 615: controls whether to link `libg.a' when debugging. Some systems
! 616: expect this; others do not have any `libg.a'.
! 617:
! 618: If this macro is not defined, a default is provided that loads
! 619: the `libg.a' provided `-g' is specified. See `gcc.c'.
! 620:
1.1 root 621: `STARTFILE_SPEC'
622: Another C string constant used much like `LINK_SPEC'. The
623: difference between the two is that `STARTFILE_SPEC' is used at
624: the very beginning of the command given to the linker.
625:
626: If this macro is not defined, a default is provided that loads
627: the standard C startup file from the usual place. See `gcc.c'.
628:
629: `STANDARD_EXEC_PREFIX'
630: Define this macro as a C string constant if you wish to override
631: the standard choice of `/usr/local/lib/gcc-' as the default
632: prefix to try when searching for the executable files of the
633: compiler.
634:
635: The prefix specified by the `-B' option, if any, is tried before
636: the default prefix. After the default prefix, if the executable
637: is not found that way, `/usr/lib/gcc-' is tried next; then the
638: directories in your search path for shell commands are searched.
639:
640: `STANDARD_STARTFILE_PREFIX'
641: Define this macro as a C string constant if you wish to override
642: the standard choice of `/usr/local/lib/' as the default prefix
643: to try when searching for startup files such as `crt0.o'.
644:
645: In this search, all the prefixes tried for executable files are
646: tried first. Then comes the default startfile prefix specified
647: by this macro, followed by the prefixes `/lib/' and `/usr/lib/'
648: as last resorts.
649:
650: `ASM_FILE_START (STREAM)'
651: A C expression which outputs to the stdio stream STREAM some
652: appropriate text to go at the start of an assembler file.
653:
654: Normally this macro is defined to output a line containing
655: `#NO_APP', which is a comment that has no effect on most
656: assemblers but tells the GNU assembler that it can save time by
657: not checking for certain assembler constructs.
658:
659: On systems that use SDB, it is necessary to output certain
660: commands; see `tm-attasm.h'.
661:
662: `ASM_FILE_END (STREAM)'
663: A C expression which outputs to the stdio stream STREAM some
664: appropriate text to go at the end of an assembler file.
665:
666: If this macro is not defined, the default is to output nothing
667: special at the end of the file. Most systems don't require any
668: definition.
669:
670: On systems that use SDB, it is necessary to output certain
671: commands; see `tm-attasm.h'.
672:
673: `ASM_IDENTIFY_GCC (FILE)'
674: A C statement to output assembler commands which will identify
675: the object file as having been compiled with GNU CC (or another
676: GNU compiler).
677:
678: If you don't define this macro, the string `gcc_compiled.:' is
679: output. This string is calculated to define a symbol which, on
680: BSD systems, will never be defined for any other reason. GDB
681: checks for the presence of this symbol when reading the symbol
682: table of an executable.
683:
684: On non-BSD systems, you must arrange communication with GDB in
685: some other fashion. If GDB is not used on your system, you can
686: define this macro with an empty body.
687:
688: `ASM_APP_ON'
689: A C string constant for text to be output before each `asm'
690: statement or group of consecutive ones. Normally this is
691: `"#APP"', which is a comment that has no effect on most
692: assemblers but tells the GNU assembler that it must check the
693: lines that follow for all valid assembler constructs.
694:
695: `ASM_APP_OFF'
696: A C string constant for text to be output after each `asm'
697: statement or group of consecutive ones. Normally this is
698: `"#NO_APP"', which tells the GNU assembler to resume making the
699: time-saving assumptions that are valid for ordinary compiler
700: output.
701:
702: `TEXT_SECTION_ASM_OP'
703: A C string constant for the assembler operation that should
704: precede instructions and read-only data. Normally `".text"' is
705: right.
706:
707: `DATA_SECTION_ASM_OP'
708: A C string constant for the assembler operation to identify the
709: following data as writable initialized data. Normally `".data"'
710: is right.
711:
712: `EXTRA_SECTIONS'
713: A list of names for sections other than the standard two, which
714: are `in_text' and `in_data'. You need not define this macro on
715: a system with no other sections (that GCC needs to use).
716:
717: `EXTRA_SECTION_FUNCTIONS'
718: One or more functions to be defined in `varasm.c'. These
719: functions should do jobs analogous to those of `text_section'
720: and `data_section', for your additional sections. Do not define
721: this macro if you do not define `EXTRA_SECTIONS'.
722:
723: `SELECT_SECTION (EXP)'
724: A C statement or statements to switch to the appropriate section
725: for output of EXP. You can assume that EXP is either a
726: `VAR_DECL' node or a constant of some sort. Select the section
727: by calling `text_section' or one of the alternatives for other
728: sections.
729:
730: Do not define this macro if you use only the standard two
731: sections and put all read-only variables and constants in the
732: text section.
733:
734: `SELECT_RTX_SECTION (MODE, RTX)'
735: A C statement or statements to switch to the appropriate section
736: for output of RTX in mode MODE. You can assume that RTX is some
737: kind of constant in RTL. The argument MODE is redundant except
738: in the case of a `const_int' rtx. Select the section by calling
739: `text_section' or one of the alternatives for other sections.
740:
741: Do not define this macro if you use only the standard two
742: sections and put all constants in the text section.
743:
744: `REGISTER_NAMES'
745: A C initializer containing the assembler's names for the machine
746: registers, each one as a C string constant. This is what
747: translates register numbers in the compiler into assembler
748: language.
749:
750: `DBX_REGISTER_NUMBER (REGNO)'
751: A C expression that returns the DBX register number for the
752: compiler register number REGNO. In simple cases, the value of
753: this expression may be REGNO itself. But sometimes there are
754: some registers that the compiler knows about and DBX does not,
755: or vice versa. In such cases, some register may need to have
756: one number in the compiler and another for DBX.
757:
758: `DBX_DEBUGGING_INFO'
759: Define this macro if GNU CC should produce debugging output for
760: DBX in response to the `-g' option.
761:
762: `SDB_DEBUGGING_INFO'
763: Define this macro if GNU CC should produce debugging output for
764: SDB in response to the `-g' option.
765:
766: `PUT_SDB_OP'
767: Define these macros to override the assembler syntax for the
768: special SDB assembler directives. See `sdbout.c' for a list of
769: these macros and their arguments. If the standard syntax is
770: used, you need not define them yourself.
771:
772: `SDB_GENERATE_FAKE'
773: Define this macro to override the usual method of constructing a
774: dummy name for anonymous structure and union types. See
775: `sdbout.c' for more information.
776:
777: `DBX_NO_XREFS'
778: Define this macro if DBX on your system does not support the
779: construct `xsTAGNAME'. On some systems, this construct is used
780: to describe a forward reference to a structure named TAGNAME.
781: On other systems, this construct is not supported at all.
782:
783: `DBX_CONTIN_LENGTH'
784: A symbol name in DBX-format debugging information is normally
785: continued (split into two separate `.stabs' directives) when it
786: exceeds a certain length (by default, 80 characters). On some
787: operating systems, DBX requires this splitting; on others,
788: splitting must not be done. You can inhibit splitting by
789: defining this macro with the value zero. You can override the
790: default splitting-length by defining this macro as an expression
791: for the length you desire.
792:
793: `DBX_CONTIN_CHAR'
794: Normally continuation is indicated by adding a `\' character to
795: the end of a `.stabs' string when a continuation follows. To
796: use a different character instead, define this macro as a
797: character constant for the character you want to use. Do not
798: define this macro if backslash is correct for your system.
799:
800: `DBX_STATIC_STAB_DATA_SECTION'
801: Define this macro if it is necessary to go to the data section
802: before outputting the `.stabs' pseudo-op for a non-global static
803: variable.
804:
805: `ASM_OUTPUT_LABEL (STREAM, NAME)'
806: A C statement (sans semicolon) to output to the stdio stream
807: STREAM the assembler definition of a label named NAME. Use the
808: expression `assemble_name (STREAM, NAME)' to output the name
809: itself; before and after that, output the additional assembler
810: syntax for defining the name, and a newline.
811:
812: `ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)'
813: A C statement (sans semicolon) to output to the stdio stream
814: STREAM any text necessary for declaring the name NAME of a
815: function which is being defined. This macro is responsible for
816: outputting the label definition (perhaps using
817: `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL'
818: tree node representing the function.
819:
820: If this macro is not defined, then the function name is defined
821: in the usual manner as a label (by means of `ASM_OUTPUT_LABEL').
822:
823: `ASM_GLOBALIZE_LABEL (STREAM, NAME)'
824: A C statement (sans semicolon) to output to the stdio stream
825: STREAM some commands that will make the label NAME global; that
826: is, available for reference from other files. Use the
827: expression `assemble_name (STREAM, NAME)' to output the name
828: itself; before and after that, output the additional assembler
829: syntax for making that name global, and a newline.
830:
831: `ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)'
832: A C statement (sans semicolon) to output to the stdio stream
833: STREAM any text necessary for declaring the name of an external
834: symbol named NAME which is referenced in this compilation but
835: not defined. The value of DECL is the tree node for the
836: declaration.
837:
838: This macro need not be defined if it does not need to output
839: anything. The GNU assembler and most Unix assemblers don't
840: require anything.
841:
842: `ASM_OUTPUT_LABELREF (STREAM, NAME)'
843: A C statement to output to the stdio stream STREAM a reference
844: in assembler syntax to a label named NAME. The character `_'
845: should be added to the front of the name, if that is customary
846: on your operating system, as it is in most Berkeley Unix
847: systems. This macro is used in `assemble_name'.
848:
849: `ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)'
850: A C statement to store into the string STRING a label whose name
851: is made from the string PREFIX and the number NUM.
852:
853: This string, when output subsequently by `ASM_OUTPUT_LABELREF',
854: should produce the same output that `ASM_OUTPUT_INTERNAL_LABEL'
855: would produce with the same PREFIX and NUM.
856:
857: `ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)'
858: A C statement to output to the stdio stream STREAM a label whose
859: name is made from the string PREFIX and the number NUM. These
860: labels are used for internal purposes, and there is no reason
861: for them to appear in the symbol table of the object file. On
862: many systems, the letter `L' at the beginning of a label has
863: this effect. The usual definition of this macro is as follows:
864:
865: fprintf (STREAM, "L%s%d:\n", PREFIX, NUM)
866:
867: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
868: Define this if the label before a jump-table needs to be output
869: specially. The first three arguments are the same as for
870: `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the
871: jump-table which follows (a `jump_insn' containing an `addr_vec'
872: or `addr_diff_vec').
873:
874: This feature is used on system V to output a `swbeg' statement
875: for the table.
876:
877: If this macro is not defined, these labels are output with
878: `ASM_OUTPUT_INTERNAL_LABEL'.
879:
880: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
881: Define this if something special must be output at the end of a
882: jump-table. The definition should be a C statement to be
883: executed after the assembler code for the table is written. It
884: should write the appropriate code to stdio stream STREAM. The
885: argument TABLE is the jump-table insn, and NUM is the
886: label-number of the preceding label.
887:
888: If this macro is not defined, nothing special is output at the
889: end of the jump-table.
890:
891: `ASM_OUTPUT_ALIGN_CODE (FILE)'
892: A C expression to output text to align the location counter in
893: the way that is desirable at a point in the code that is reached
894: only by jumping.
895:
896: This macro need not be defined if you don't want any special
897: alignment to be done at such a time. Most machine descriptions
898: do not currently define the macro.
899:
900: `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
901: A C expression to assign to OUTVAR (which is a variable of type
902: `char *') a newly allocated string made from the string NAME and
903: the number NUMBER, with some suitable punctuation added. Use
904: `alloca' to get space for the string.
905:
906: This string will be used as the argument to
907: `ASM_OUTPUT_LABELREF' to produce an assembler label for an
908: internal static variable whose name is NAME. Therefore, the
909: string must be such as to result in valid assembler code. The
910: argument NUMBER is different each time this macro is executed;
911: it prevents conflicts between similarly-named internal static
912: variables in different scopes.
913:
914: Ideally this string should not be a valid C identifier, to
915: prevent any conflict with the user's own symbols. Most
916: assemblers allow periods or percent signs in assembler symbols;
917: putting at least one of these between the name and the number
918: will suffice.
919:
920: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
921: A C expression to output to STREAM some assembler code which
922: will push hard register number REGNO onto the stack. The code
923: need not be optimal, since this macro is used only when profiling.
924:
925: `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
926: A C expression to output to STREAM some assembler code which
927: will pop hard register number REGNO off of the stack. The code
928: need not be optimal, since this macro is used only when profiling.
929:
930: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
931: This macro should be provided on machines where the addresses in
932: a dispatch table are relative to the table's own address.
933:
934: The definition should be a C statement to output to the stdio
935: stream STREAM an assembler pseudo-instruction to generate a
936: difference between two labels. VALUE and REL are the numbers of
937: two internal labels. The definitions of these labels are output
938: using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in
939: the same way here. For example,
940:
941: fprintf (STREAM, "\t.word L%d-L%d\n",
942: VALUE, REL)
943:
944: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
945: This macro should be provided on machines where the addresses in
946: a dispatch table are absolute.
947:
948: The definition should be a C statement to output to the stdio
949: stream STREAM an assembler pseudo-instruction to generate a
950: reference to a label. VALUE is the number of an internal label
951: whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'.
952: For example,
953:
954: fprintf (STREAM, "\t.word L%d\n", VALUE)
955:
956: `ASM_OUTPUT_DOUBLE (STREAM, VALUE)'
957: A C statement to output to the stdio stream STREAM an assembler
958: instruction to assemble a `double' constant whose value is
959: VALUE. VALUE will be a C expression of type `double'.
960:
961: `ASM_OUTPUT_FLOAT (STREAM, VALUE)'
962: A C statement to output to the stdio stream STREAM an assembler
963: instruction to assemble a `float' constant whose value is VALUE.
964: vALUE will be a C expression of type `float'.
965:
966: `ASM_OUTPUT_INT (STREAM, EXP)'
967: `ASM_OUTPUT_SHORT (STREAM, EXP)'
968: `ASM_OUTPUT_CHAR (STREAM, EXP)'
969: A C statement to output to the stdio stream STREAM an assembler
970: instruction to assemble a `int', `short' or `char' constant
971: whose value is VALUE. The argument EXP will be an RTL
972: expression which represents a constant value. Use
1.1.1.2 root 973: `output_addr_const (STREAM, EXP)' to output this value as an
974: assembler expression.
1.1 root 975:
976: `ASM_OUTPUT_DOUBLE_INT (STREAM, EXP)'
977: A C statement to output to the stdio stream STREAM an assembler
978: instruction to assemble a `long long' constant whose value is
979: EXP. The argument EXP will be an RTL expression which
980: represents a constant value. It may be a `const_double' RTX, or
981: it may be an ordinary single-precision constant. In the latter
982: case, you should zero-extend it.
983:
984: `ASM_OUTPUT_BYTE (STREAM, VALUE)'
985: A C statement to output to the stdio stream STREAM an assembler
986: instruction to assemble a single byte containing the number VALUE.
987:
988: `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)'
989: A C statement to output to the stdio stream STREAM an assembler
990: instruction to assemble a string constant containing the LEN
991: bytes at PTR. PTR will be a C expression of type `char *' and
992: LEN a C expression of type `int'.
993:
994: If the assembler has a `.ascii' pseudo-op as found in the
995: Berkeley Unix assembler, do not define the macro
996: `ASM_OUTPUT_ASCII'.
997:
998: `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
999: A C statement to output to the stdio stream STREAM an assembler
1000: instruction to advance the location counter by NBYTES bytes.
1001: NBYTES will be a C expression of type `int'.
1002:
1003: `ASM_OUTPUT_ALIGN (STREAM, POWER)'
1004: A C statement to output to the stdio stream STREAM an assembler
1005: instruction to advance the location counter to a multiple of 2
1006: to the POWER bytes. POWER will be a C expression of type `int'.
1007:
1008: `ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)'
1009: A C statement (sans semicolon) to output to the stdio stream
1010: STREAM the assembler definition of a common-label named NAME
1011: whose size is SIZE bytes. The variable ROUNDED is the size
1012: rounded up to whatever alignment the caller wants.
1013:
1014: Use the expression `assemble_name (STREAM, NAME)' to output the
1015: name itself; before and after that, output the additional
1016: assembler syntax for defining the name, and a newline.
1017:
1018: This macro controls how the assembler definitions of
1019: uninitialized global variables are output.
1020:
1021: `ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
1022: A C statement (sans semicolon) to output to the stdio stream
1023: STREAM the assembler definition of a local-common-label named
1024: NAME whose size is SIZE bytes. The variable ROUNDED is the size
1025: rounded up to whatever alignment the caller wants.
1026:
1027: Use the expression `assemble_name (STREAM, NAME)' to output the
1028: name itself; before and after that, output the additional
1029: assembler syntax for defining the name, and a newline.
1030:
1031: This macro controls how the assembler definitions of
1032: uninitialized static variables are output.
1033:
1034: `ASM_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
1035: A C statment to output DBX or SDB debugging information which
1036: indicates that filename NAME is the current source file to the
1037: stdio stream STREAM.
1038:
1039: This macro need not be defined if the standard form of debugging
1040: information for the debugger in use is appropriate.
1041:
1042: `ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)'
1043: A C statment to output DBX or SDB debugging information before
1044: code for line number LINE of the current source file to the
1045: stdio stream STREAM.
1046:
1047: This macro need not be defined if the standard form of debugging
1048: information for the debugger in use is appropriate.
1049:
1050: `ASM_OUTPUT_IDENT (STREAM, STRING)'
1051: A C statement to output something to the assembler file to
1052: handle a `#ident' directive containing the text STRING. If this
1053: macro is not defined, nothing is output for a `#ident' directive.
1054:
1055: `TARGET_BELL'
1056: A C constant expression for the integer value for escape
1057: sequence `\a'.
1058:
1059: `TARGET_BS'
1060: `TARGET_TAB'
1061: `TARGET_NEWLINE'
1062: C constant expressions for the integer values for escape
1063: sequences `\b', `\t' and `\n'.
1064:
1065: `TARGET_VT'
1066: `TARGET_FF'
1067: `TARGET_CR'
1068: C constant expressions for the integer values for escape
1069: sequences `\v', `\f' and `\r'.
1070:
1071: `ASM_OUTPUT_OPCODE (STREAM, PTR)'
1072: Define this macro if you are using an unusual assembler that
1073: requires different names for the machine instructions.
1074:
1075: The definition is a C statement or statements which output an
1076: assembler instruction opcode to the stdio stream STREAM. The
1077: macro-operand PTR is a variable of type `char *' which points to
1.1.1.2 root 1078: the opcode name in its "internal" form--the form that is written
1079: in the machine description. The definition should output the
1080: opcode name to STREAM, performing any translation you desire,
1081: and increment the variable PTR to point at the end of the opcode
1082: so that it will not be output twice.
1.1 root 1083:
1084: In fact, your macro definition may process less than the entire
1085: opcode name, or more than the opcode name; but if you want to
1086: process text that includes `%'-sequences to substitute operands,
1087: you must take care of the substitution yourself. Just be sure
1088: to increment PTR over whatever text should not be output normally.
1089:
1090: If you need to look at the operand values, they can be found as
1091: the elements of `recog_operand'.
1092:
1093: If the macro definition does nothing, the instruction is output
1094: in the usual way.
1095:
1096: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
1097: If defined, a C statement to be executed just prior to the
1098: output of assembler code for INSN, to modify the extracted
1099: operands so they will be output differently.
1100:
1101: Here the argument OPVEC is the vector containing the operands
1102: extracted from INSN, and NOPERANDS is the number of elements of
1103: the vector which contain meaningful data for this insn. The
1104: contents of this vector are what will be used to convert the
1105: insn template into assembler code, so you can change the
1106: assembler output by changing the contents of the vector.
1107:
1108: This macro is useful when various assembler syntaxes share a
1109: single file of instruction patterns; by defining this macro
1110: differently, you can cause a large class of instructions to be
1111: output differently (such as with rearranged operands).
1112: Naturally, variations in assembler syntax affecting individual
1113: insn patterns ought to be handled by writing conditional output
1114: routines in those patterns.
1115:
1116: If this macro is not defined, it is equivalent to a null
1117: statement.
1118:
1119: `PRINT_OPERAND (STREAM, X, CODE)'
1120: A C compound statement to output to stdio stream STREAM the
1121: assembler syntax for an instruction operand X. X is an RTL
1122: expression.
1123:
1124: CODE is a value that can be used to specify one of several ways
1125: of printing the operand. It is used when identical operands
1126: must be printed differently depending on the context. CODE
1127: comes from the `%' specification that was used to request
1128: printing of the operand. If the specification was just `%DIGIT'
1129: then CODE is 0; if the specification was `%LTR DIGIT' then CODE
1130: is the ASCII code for LTR.
1131:
1132: If X is a register, this macro should print the register's name.
1133: The names can be found in an array `reg_names' whose type is
1134: `char *[]'. `reg_names' is initialized from `REGISTER_NAMES'.
1135:
1136: When the machine description has a specification `%PUNCT' (a `%'
1137: followed by a punctuation character), this macro is called with
1138: a null pointer for X and the punctuation character for CODE.
1139:
1140: `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
1141: A C expression which evaluates to true if CODE is a valid
1142: punctuation character for use in the `PRINT_OPERAND' macro. If
1143: `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
1144: punctuation characters (except for the standard one, `%') are
1145: used in this way.
1146:
1147: `PRINT_OPERAND_ADDRESS (STREAM, X)'
1148: A C compound statement to output to stdio stream STREAM the
1149: assembler syntax for an instruction operand that is a memory
1150: reference whose address is X. X is an RTL expression.
1151:
1152: `ASM_OPEN_PAREN'
1153: `ASM_CLOSE_PAREN'
1154: These macros are defined as C string constant, describing the
1155: syntax in the assembler for grouping arithmetic expressions.
1156: The following definitions are correct for most assemblers:
1157:
1158: #define ASM_OPEN_PAREN "("
1159: #define ASM_CLOSE_PAREN ")"
1160:
1.1.1.4 ! root 1161:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.