![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gcc.info-8 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-8 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 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: gcc.info, Node: Assembler Format, Prev: Condition Code, Up: Machine Macros ! 29: ! 30: Output of Assembler Code ! 31: ======================== ! 32: ! 33: `ASM_SPEC' ! 34: A C string constant that tells the GNU CC driver program options ! 35: to pass to the assembler. It can also specify how to translate ! 36: options you give to GNU CC into options for GNU CC to pass to ! 37: the assembler. See the file `tm-sun3.h' for an example of this. ! 38: ! 39: Do not define this macro if it does not need to do anything. ! 40: ! 41: `LINK_SPEC' ! 42: A C string constant that tells the GNU CC driver program options ! 43: to pass to the linker. It can also specify how to translate ! 44: options you give to GNU CC into options for GNU CC to pass to ! 45: the linker. ! 46: ! 47: Do not define this macro if it does not need to do anything. ! 48: ! 49: `LIB_SPEC' ! 50: Another C string constant used much like `LINK_SPEC'. The ! 51: difference between the two is that `LIBS_SPEC' is used at the ! 52: end of the command given to the linker. ! 53: ! 54: If this macro is not defined, a default is provided that loads ! 55: the standard C library from the usual place. See `gcc.c'. ! 56: ! 57: `STARTFILE_SPEC' ! 58: Another C string constant used much like `LINK_SPEC'. The ! 59: difference between the two is that `STARTFILE_SPEC' is used at ! 60: the very beginning of the command given to the linker. ! 61: ! 62: If this macro is not defined, a default is provided that loads ! 63: the standard C startup file from the usual place. See `gcc.c'. ! 64: ! 65: `ASM_FILE_START (STREAM)' ! 66: A C expression which outputs to the stdio stream STREAM some ! 67: appropriate text to go at the start of an assembler file. ! 68: ! 69: Normally this macro is defined to output a line containing ! 70: `#NO_APP', which is a comment that has no effect on most ! 71: assemblers but tells the GNU assembler that it can save time by ! 72: not checking for certain assembler constructs. ! 73: ! 74: On systems that use SDB, it is necessary to output certain ! 75: commands; see `tm-attasm.h'. ! 76: ! 77: `ASM_APP_ON' ! 78: A C string constant for text to be output before each `asm' ! 79: statement or group of consecutive ones. Normally this is ! 80: `"#APP"', which is a comment that has no effect on most ! 81: assemblers but tells the GNU assembler that it must check the ! 82: lines that follow for all valid assembler constructs. ! 83: ! 84: `ASM_APP_OFF' ! 85: A C string constant for text to be output after each `asm' ! 86: statement or group of consecutive ones. Normally this is ! 87: `"#NO_APP"', which tells the GNU assembler to resume making the ! 88: time-saving assumptions that are valid for ordinary compiler ! 89: output. ! 90: ! 91: `TEXT_SECTION_ASM_OP' ! 92: A C string constant for the assembler operation that should ! 93: precede instructions and read-only data. Normally `".text"' is ! 94: right. ! 95: ! 96: `DATA_SECTION_ASM_OP' ! 97: A C string constant for the assembler operation to identify the ! 98: following data as writable initialized data. Normally `".data"' ! 99: is right. ! 100: ! 101: `REGISTER_NAMES' ! 102: A C initializer containing the assembler's names for the machine ! 103: registers, each one as a C string constant. This is what ! 104: translates register numbers in the compiler into assembler ! 105: language. ! 106: ! 107: `DBX_REGISTER_NUMBER (REGNO)' ! 108: A C expression that returns the DBX register number for the ! 109: compiler register number REGNO. In simple cases, the value of ! 110: this expression may be REGNO itself. But sometimes there are ! 111: some registers that the compiler knows about and DBX does not, ! 112: or vice versa. In such cases, some register may need to have ! 113: one number in the compiler and another for DBX. ! 114: ! 115: `DBX_DEBUGGING_INFO' ! 116: Define this macro if GNU CC should produce debugging output for ! 117: DBX in response to the `-g' option. ! 118: ! 119: `SDB_DEBUGGING_INFO' ! 120: Define this macro if GNU CC should produce debugging output for ! 121: SDB in response to the `-g' option. ! 122: ! 123: `PUT_SDB_OP' ! 124: Define these macros to override the assembler syntax for the ! 125: special SDB assembler directives. See `sdbout.c' for a list of ! 126: these macros and their arguments. If the standard syntax is ! 127: used, you need not define them yourself. ! 128: ! 129: `SDB_GENERATE_FAKE' ! 130: Define this macro to override the usual method of constructing a ! 131: dummy name for anonymous structure and union types. See ! 132: `sdbout.c' for more infomation. ! 133: ! 134: `DBX_NO_XREFS' ! 135: Define this macro if DBX on your system does not support the ! 136: construct `xsTAGNAME'. On some systems, this construct is used ! 137: to describe a forward reference to a structure named TAGNAME. ! 138: On other systems, this construct is not supported at all. ! 139: ! 140: `DBX_CONTIN_LENGTH' ! 141: A symbol name in DBX-format debugging information is normally ! 142: continued (split into two separate `.stabs' directives) when it ! 143: exceeds a certain length (by default, 80 characters). On some ! 144: operating systems, DBX requires this splitting; on others, ! 145: splitting must not be done. You can inhibit splitting by ! 146: defining this macro with the value zero. You can override the ! 147: default splitting-length by defining this macro as an expression ! 148: for the length you desire. ! 149: ! 150: `DBX_CONTIN_CHAR' ! 151: Normally continuation is indicated by adding a `\' character to ! 152: the end of a `.stabs' string when a continuation follows. To ! 153: use a different character instead, define this macro as a ! 154: character constant for the character you want to use. Do not ! 155: define this macro if backslash is correct for your system. ! 156: ! 157: `ASM_OUTPUT_LABEL (STREAM, NAME)' ! 158: A C statement (sans semicolon) to output to the stdio stream ! 159: STREAM the assembler definition of a label named NAME. Use the ! 160: expression `assemble_name (STREAM, NAME)' to output the name ! 161: itself; before and after that, output the additional assembler ! 162: syntax for defining the name, and a newline. ! 163: ! 164: `ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)' ! 165: A C statement (sans semicolon) to output to the stdio stream ! 166: STREAM any text necessary for declaring the name NAME of a ! 167: function which is being defined. This macro is responsible for ! 168: outputting the label definition (perhaps using ! 169: `ASM_OUTPUT_LABEL'). The argument DECL is the `FUNCTION_DECL' ! 170: tree node representing the function. ! 171: ! 172: If this macro is not defined, then the function name is defined ! 173: in the usual manner as a label (by means of `ASM_OUTPUT_LABEL'). ! 174: ! 175: `ASM_GLOBALIZE_LABEL (STREAM, NAME)' ! 176: A C statement (sans semicolon) to output to the stdio stream ! 177: STREAM some commands that will make the label NAME global; that ! 178: is, available for reference from other files. Use the ! 179: expression `assemble_name (STREAM, NAME)' to output the name ! 180: itself; before and after that, output the additional assembler ! 181: syntax for making that name global, and a newline. ! 182: ! 183: `ASM_OUTPUT_EXTERNAL (STREAM, NAME, DECL)' ! 184: A C statement (sans semicolon) to output to the stdio stream ! 185: STREAM any text necessary for declaring the name of an external ! 186: symbol named NAME which is referenced in this compilation but ! 187: not defined. The value of DECL is the tree node for the ! 188: declaration. ! 189: ! 190: This macro need not be defined if it does not need to output ! 191: anything. The GNU assembler and most Unix assemblers don't ! 192: require anything. ! 193: ! 194: `ASM_OUTPUT_LABELREF (STREAM, NAME)' ! 195: A C statement to output to the stdio stream STREAM a reference ! 196: in assembler syntax to a label named NAME. The character `_' ! 197: should be added to the front of the name, if that is customary ! 198: on your operating system, as it is in most Berkeley Unix ! 199: systems. This macro is used in `assemble_name'. ! 200: ! 201: `ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)' ! 202: A C statement to store into the string STRING a label whose name ! 203: is made from the string PREFIX and the number NUM. ! 204: ! 205: This string, when output subsequently by `ASM_OUTPUT_LABELREF', ! 206: should produce the same output that `ASM_OUTPUT_INTERNAL_LABEL' ! 207: would produce with the same PREFIX and NUM. ! 208: ! 209: `ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)' ! 210: A C statement to output to the stdio stream STREAM a label whose ! 211: name is made from the string PREFIX and the number NUM. These ! 212: labels are used for internal purposes, and there is no reason ! 213: for them to appear in the symbol table of the object file. On ! 214: many systems, the letter `L' at the beginning of a label has ! 215: this effect. The usual definition of this macro is as follows: ! 216: ! 217: fprintf (STREAM, "L%s%d:\n", PREFIX, NUM) ! 218: ! 219: `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)' ! 220: Define this if the label before a jump-table needs to be output ! 221: specially. The first three arguments are the same as for ! 222: `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the ! 223: jump-table which follows (a `jump_insn' containing an `addr_vec' ! 224: or `addr_diff_vec'). ! 225: ! 226: This feature is used on system V to output a `swbeg' statement ! 227: for the table. ! 228: ! 229: If this macro is not defined, these labels are output with ! 230: `ASM_OUTPUT_INTERNAL_LABEL'. ! 231: ! 232: `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)' ! 233: Define this if something special must be output at the end of a ! 234: jump-table. The definition should be a C statement to be ! 235: executed after the assembler code for the table is written. It ! 236: should write the appropriate code to stdio stream STREAM. The ! 237: argument TABLE is the jump-table insn, and NUM is the ! 238: label-number of the preceding label. ! 239: ! 240: If this macro is not defined, nothing special is output at the ! 241: end of the jump-table. ! 242: ! 243: `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)' ! 244: A C expression to assign to OUTVAR (which is a variable of type ! 245: `char *') a newly allocated string made from the string NAME and ! 246: the number NUMBER, with some suitable punctuation added. Use ! 247: `alloca' to get space for the string. ! 248: ! 249: This string will be used as the argument to ! 250: `ASM_OUTPUT_LABELREF' to produce an assembler label for an ! 251: internal static variable whose name is NAME. Therefore, the ! 252: string must be such as to result in valid assembler code. The ! 253: argument NUMBER is different each time this macro is executed; ! 254: it prevents conflicts between similarly-named internal static ! 255: variables in different scopes. ! 256: ! 257: Ideally this string should not be a valid C identifier, to ! 258: prevent any conflict with the user's own symbols. Most ! 259: assemblers allow periods or percent signs in assembler symbols; ! 260: putting at least one of these between the name and the number ! 261: will suffice. ! 262: ! 263: `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)' ! 264: A C expression to output to STREAM some assembler code which ! 265: will push hard register number REGNO onto the stack. The code ! 266: need not be optimal, since this macro is used only when profiling. ! 267: ! 268: `ASM_OUTPUT_REG_POP (STREAM, REGNO)' ! 269: A C expression to output to STREAM some assembler code which ! 270: will pop hard register number REGNO off of the stack. The code ! 271: need not be optimal, since this macro is used only when profiling. ! 272: ! 273: `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)' ! 274: This macro should be provided on machines where the addresses in ! 275: a dispatch table are relative to the table's own address. ! 276: ! 277: The definition should be a C statement to output to the stdio ! 278: stream STREAM an assembler pseudo-instruction to generate a ! 279: difference between two labels. VALUE and REL are the numbers of ! 280: two internal labels. The definitions of these labels are output ! 281: using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in ! 282: the same way here. For example, ! 283: ! 284: fprintf (STREAM, "\t.word L%d-L%d\n", ! 285: VALUE, REL) ! 286: ! 287: `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)' ! 288: This macro should be provided on machines where the addresses in ! 289: a dispatch table are absolute. ! 290: ! 291: The definition should be a C statement to output to the stdio ! 292: stream STREAM an assembler pseudo-instruction to generate a ! 293: reference to a label. VALUE is the number of an internal label ! 294: whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'. ! 295: For example, ! 296: ! 297: fprintf (STREAM, "\t.word L%d\n", VALUE) ! 298: ! 299: `ASM_OUTPUT_DOUBLE (STREAM, VALUE)' ! 300: A C statement to output to the stdio stream STREAM an assembler ! 301: instruction to assemble a `double' constant whose value is ! 302: VALUE. VALUE will be a C expression of type `double'. ! 303: ! 304: `ASM_OUTPUT_FLOAT (STREAM, VALUE)' ! 305: A C statement to output to the stdio stream STREAM an assembler ! 306: instruction to assemble a `float' constant whose value is VALUE. ! 307: vALUE will be a C expression of type `float'. ! 308: ! 309: `ASM_OUTPUT_INT (STREAM, EXP)' ! 310: `ASM_OUTPUT_SHORT (STREAM, EXP)' ! 311: `ASM_OUTPUT_CHAR (STREAM, EXP)' ! 312: A C statement to output to the stdio stream STREAM an assembler ! 313: instruction to assemble a `int', `short' or `char' constant ! 314: whose value is VALUE. The argument EXP will be an RTL ! 315: expression which represents a constant value. Use ! 316: `output_addr_const (EXP)' to output this value as an assembler ! 317: expression. ! 318: ! 319: `ASM_OUTPUT_BYTE (STREAM, VALUE)' ! 320: A C statement to output to the stdio stream STREAM an assembler ! 321: instruction to assemble a single byte containing the number VALUE. ! 322: ! 323: `ASM_OUTPUT_ASCII (STREAM, PTR, LEN)' ! 324: A C statement to output to the stdio stream STREAM an assembler ! 325: instruction to assemble a string constant containing the LEN ! 326: bytes at PTR. PTR will be a C expression of type `char *' and ! 327: LEN a C expression of type `int'. ! 328: ! 329: If the assembler has a `.ascii' pseudo-op as found in the ! 330: Berkeley Unix assembler, do not define the macro ! 331: `ASM_OUTPUT_ASCII'. ! 332: ! 333: `ASM_OUTPUT_SKIP (STREAM, NBYTES)' ! 334: A C statement to output to the stdio stream STREAM an assembler ! 335: instruction to advance the location counter by NBYTES bytes. ! 336: NBYTES will be a C expression of type `int'. ! 337: ! 338: `ASM_OUTPUT_ALIGN (STREAM, POWER)' ! 339: A C statement to output to the stdio stream STREAM an assembler ! 340: instruction to advance the location counter to a multiple of 2 ! 341: to the POWER bytes. POWER will be a C expression of type `int'. ! 342: ! 343: `ASM_OUTPUT_COMMON (STREAM, NAME, SIZE)' ! 344: A C statement (sans semicolon) to output to the stdio stream ! 345: STREAM the assembler definition of a common-label named NAME ! 346: whose size is SIZE bytes. Use the expression `assemble_name ! 347: (STREAM, NAME)' to output the name itself; before and after ! 348: that, output the additional assembler syntax for defining the ! 349: name, and a newline. ! 350: ! 351: This macro controls how the assembler definitions of ! 352: uninitialized global variables are output. ! 353: ! 354: `ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE)' ! 355: A C statement (sans semicolon) to output to the stdio stream ! 356: STREAM the assembler definition of a local-common-label named ! 357: NAME whose size is SIZE bytes. Use the expression ! 358: `assemble_name (STREAM, NAME)' to output the name itself; before ! 359: and after that, output the additional assembler syntax for ! 360: defining the name, and a newline. ! 361: ! 362: This macro controls how the assembler definitions of ! 363: uninitialized static variables are output. ! 364: ! 365: `ASM_OUTPUT_SOURCE_LINE (STREAM, LINE)' ! 366: A C statment to output DBX or SDB debugging information before ! 367: code for line number LINE of the current source file to the ! 368: stdio stream STREAM. ! 369: ! 370: This macro need not be defined if the standard form of debugging ! 371: information for the debugger in use is appropriate. ! 372: ! 373: `ASM_OUTPUT_IDENT (STREAM, STRING)' ! 374: A C statement to output something to the assembler file to ! 375: handle a `#ident' directive containing the text STRING. If this ! 376: macro is not defined, the assembler code `.ident "STRING"' will ! 377: be output by default. ! 378: ! 379: This macro is significant only if `IDENT_DIRECTIVE' is defined. ! 380: ! 381: `TARGET_BELL' ! 382: A C constant expression for the integer value for escape ! 383: sequence `\a'. ! 384: ! 385: `TARGET_BS' ! 386: `TARGET_TAB' ! 387: `TARGET_NEWLINE' ! 388: C constant expressions for the integer values for escape ! 389: sequences `\b', `\t' and `\n'. ! 390: ! 391: `TARGET_VT' ! 392: `TARGET_FF' ! 393: `TARGET_CR' ! 394: C constant expressions for the integer values for escape ! 395: sequences `\v', `\f' and `\r'. ! 396: ! 397: `ASM_OUTPUT_OPCODE (STREAM, PTR)' ! 398: Define this macro if you are using an unusual assembler that ! 399: requires different names for the machine instructions. ! 400: ! 401: The definition is a C statement or statements which output an ! 402: assembler instruction opcode to the stdio stream STREAM. The ! 403: macro-operand PTR is a variable of type `char *' which points to ! 404: the opcode name in its ``internal'' form--the form that is ! 405: written in the machine description. The definition should ! 406: output the opcode name to STREAM, performing any translation you ! 407: desire, and increment the variable PTR to point at the end of ! 408: the opcode so that it will not be output twice. ! 409: ! 410: In fact, your macro definition may process less than the entire ! 411: opcode name, or more than the opcode name; but if you want to ! 412: process text that includes `%'-sequences to substitute operands, ! 413: you must take care of the substitution yourself. Just be sure ! 414: to increment PTR over whatever text should not be output normally. ! 415: ! 416: If the macro definition does nothing, the instruction is output ! 417: in the usual way. ! 418: ! 419: `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)' ! 420: If defined, a C statement to be executed just prior to the ! 421: output of assembler code for INSN, to modify the extracted ! 422: operands so they will be output differently. ! 423: ! 424: Here the argument OPVEC is the vector containing the operands ! 425: extracted from INSN, and NOPERANDS is the number of elements of ! 426: the vector which contain meaningful data for this insn. The ! 427: contents of this vector are what will be used to convert the ! 428: insn template into assembler code, so you can change the ! 429: assembler output by changing the contents of the vector. ! 430: ! 431: This macro is useful when various assembler syntaxes share a ! 432: single file of instruction patterns; by defining this macro ! 433: differently, you can cause a large class of instructions to be ! 434: output differently (such as with rearranged operands). ! 435: Naturally, variations in assembler syntax affecting individual ! 436: insn patterns ought to be handled by writing conditional output ! 437: routines in those patterns. ! 438: ! 439: If this macro is not defined, it is equivalent to a null ! 440: statement. ! 441: ! 442: `PRINT_OPERAND (STREAM, X, CODE)' ! 443: A C compound statement to output to stdio stream STREAM the ! 444: assembler syntax for an instruction operand X. X is an RTL ! 445: expression. ! 446: ! 447: CODE is a value that can be used to specify one of several ways ! 448: of printing the operand. It is used when identical operands ! 449: must be printed differently depending on the context. CODE ! 450: comes from the `%' specification that was used to request ! 451: printing of the operand. If the specification was just `%DIGIT' ! 452: then CODE is 0; if the specification was `%LTR DIGIT' then CODE ! 453: is the ASCII code for LTR. ! 454: ! 455: If X is a register, this macro should print the register's name. ! 456: The names can be found in an array `reg_names' whose type is ! 457: `char *[]'. `reg_names' is initialized from `REGISTER_NAMES'. ! 458: ! 459: When the machine description has a specification `%PUNCT' (a `%' ! 460: followed by a punctuation character), this macro is called with ! 461: a null pointer for X and the punctuation character for CODE. ! 462: ! 463: `PRINT_OPERAND_ADDRESS (STREAM, X)' ! 464: A C compound statement to output to stdio stream STREAM the ! 465: assembler syntax for an instruction operand that is a memory ! 466: reference whose address is X. X is an RTL expression. ! 467: ! 468: `ASM_OPEN_PAREN' ! 469: `ASM_CLOSE_PAREN' ! 470: These macros are defined as C string constant, describing the ! 471: syntax in the assembler for grouping arithmetic expressions. ! 472: The following definitions are correct for most assemblers: ! 473: ! 474: #define ASM_OPEN_PAREN "(" ! 475: #define ASM_CLOSE_PAREN ")" ! 476: ! 477: ! 478: ! 479: File: gcc.info, Node: Config, Prev: Machine Macros, Up: Top ! 480: ! 481: The Configuration File ! 482: ********************** ! 483: ! 484: The configuration file `xm-MACHINE.h' contains macro definitions that ! 485: describe the machine and system on which the compiler is running. ! 486: Most of the values in it are actually the same on all machines that ! 487: GNU CC runs on, so large parts of all configuration files are ! 488: identical. But there are some macros that vary: ! 489: ! 490: `FAILURE_EXIT_CODE' ! 491: A C expression for the status code to be returned when the ! 492: compiler exits after serious errors. ! 493: ! 494: `SUCCESS_EXIT_CODE' ! 495: A C expression for the status code to be returned when the ! 496: compiler exits without serious errors. ! 497: ! 498: In addition, configuration files for system V define `bcopy', `bzero' ! 499: and `bcmp' as aliases. Some files define `alloca' as a macro when ! 500: compiled with GNU CC, in order to take advantage of the benefit of ! 501: GNU CC's built-in `alloca'. ! 502:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.