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