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