home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / gcc.info-19 (.txt) < prev    next >
GNU Info File  |  1994-02-06  |  91KB  |  1,684 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.49 from the input
  2. file gcc.texi.
  3.    This file documents the use and the internals of the GNU compiler.
  4.    Copyright (C) 1988, 1989, 1992 Free Software Foundation, Inc.
  5.    Permission is granted to make and distribute verbatim copies of this
  6. manual provided the copyright notice and this permission notice are
  7. preserved on all copies.
  8.    Permission is granted to copy and distribute modified versions of
  9. this manual under the conditions for verbatim copying, provided also
  10. that the sections entitled "GNU General Public License" and "Protect
  11. Your Freedom--Fight `Look And Feel'" are included exactly as in the
  12. original, and provided that the entire resulting derived work is
  13. distributed under the terms of a permission notice identical to this
  14.    Permission is granted to copy and distribute translations of this
  15. manual into another language, under the above conditions for modified
  16. versions, except that the sections entitled "GNU General Public
  17. License" and "Protect Your Freedom--Fight `Look And Feel'", and this
  18. permission notice, may be included in translations approved by the Free
  19. Software Foundation instead of in the original English.
  20. File: gcc.info,  Node: Index,  Prev: Config,  Up: Top
  21. Index
  22. *****
  23. * Menu:
  24. * #pragma:                              Misc.
  25. * $:                                    Dollar Signs.
  26. * ':                                    Incompatibilities.
  27. * (nil):                                RTL Objects.
  28. * 3b1 installation:                     3b1 Install.
  29. * ?: side effect:                       Conditionals.
  30. * #pragma, reason for not using:        Function Attributes.
  31. * * in template:                        Output Statement.
  32. * ?: extensions:                        Conditionals.
  33. * ?: extensions:                        Lvalues.
  34. * absM2 instruction pattern:            Standard Names.
  35. * abs and attributes:                   Expressions.
  36. * ACCUMULATE_OUTGOING_ARGS and stack frames: Function Entry.
  37. * addM3 instruction pattern:            Standard Names.
  38. * addr_diff_vec, length of:             Insn Lengths.
  39. * addr_vec, length of:                  Insn Lengths.
  40. * aligned attribute:                    Variable Attributes.
  41. * allocate_stack instruction pattern:   Standard Names.
  42. * alloca and SunOs:                     Installation.
  43. * alloca vs variable-length arrays:     Variable Length.
  44. * alloca, for SunOs:                    Sun Install.
  45. * alloca, for Unos:                     Unos Install.
  46. * andM3 instruction pattern:            Standard Names.
  47. * and and attributes:                   Expressions.
  48. * and, canonicalization of:             Insn Canonicalizations.
  49. * ARG_POINTER_REGNUM and virtual registers: Regs and Memory.
  50. * ashiftrt and attributes:              Expressions.
  51. * ashift and attributes:                Expressions.
  52. * ashlM3 instruction pattern:           Standard Names.
  53. * ashrM3 instruction pattern:           Standard Names.
  54. * asm_operands, RTL sharing:            Sharing.
  55. * asm_operands, usage:                  Assembler.
  56. * asm expressions:                      Extended Asm.
  57. * bCOND instruction pattern:            Standard Names.
  58. * bcopy, implicit usage:                Library Calls.
  59. * BITS_BIG_ENDIAN, effect on sign_extract: Bit Fields.
  60. * BLKmode, and function return values:  Calls.
  61. * bzero, implicit usage:                Library Calls.
  62. * call_insn and /u:                     Flags.
  63. * call_pop instruction pattern:         Standard Names.
  64. * call_value_pop instruction pattern:   Standard Names.
  65. * call_value instruction pattern:       Standard Names.
  66. * call instruction pattern:             Standard Names.
  67. * call usage:                           Calls.
  68. * casesi instruction pattern:           Standard Names.
  69. * cc0, RTL sharing:                     Sharing.
  70. * cmpM instruction pattern:             Standard Names.
  71. * cmpstrM instruction pattern:          Standard Names.
  72. * code_label and /i:                    Flags.
  73. * compare, canonicalization of:         Insn Canonicalizations.
  74. * cond and attributes:                  Expressions.
  75. * const_double, RTL sharing:            Sharing.
  76. * const_int and attribute tests:        Expressions.
  77. * const_int and attributes:             Expressions.
  78. * const_int, RTL sharing:               Sharing.
  79. * const_string and attributes:          Expressions.
  80. * const applied to function:            Function Attributes.
  81. * define_insn example:                  Example.
  82. * divM3 instruction pattern:            Standard Names.
  83. * divmodM4 instruction pattern:         Standard Names.
  84. * div and attributes:                   Expressions.
  85. * EDOM, implicit usage:                 Library Calls.
  86. * ENCODE_SECTION_INFO and address validation: Addressing Modes.
  87. * ENCODE_SECTION_INFO usage:            Instruction Output.
  88. * eq and attributes:                    Expressions.
  89. * errno, implicit usage:                Library Calls.
  90. * extendMN instruction pattern:         Standard Names.
  91. * extv instruction pattern:             Standard Names.
  92. * extzv instruction pattern:            Standard Names.
  93. * ffsM2 instruction pattern:            Standard Names.
  94. * FIRST_PARM_OFFSET and virtual registers: Regs and Memory.
  95. * fixMN2 instruction pattern:           Standard Names.
  96. * fixunsMN2 instruction pattern:        Standard Names.
  97. * fixuns_truncMN2 instruction pattern:  Standard Names.
  98. * fix_truncMN2 instruction pattern:     Standard Names.
  99. * floatMN2 instruction pattern:         Standard Names.
  100. * floatunsMN2 instruction pattern:      Standard Names.
  101. * float as function value type:         Incompatibilities.
  102. * format attribute:                     Function Attributes.
  103. * FRAME_GROWS_DOWNWARD and virtual registers: Regs and Memory.
  104. * FRAME_POINTER_REGNUM and virtual registers: Regs and Memory.
  105. * fscanf, and constant strings:         Incompatibilities.
  106. * ftruncM2 instruction pattern:         Standard Names.
  107. * FUNCTION_EPILOGUE and trampolines:    Trampolines.
  108. * FUNCTION_PROLOGUE and trampolines:    Trampolines.
  109. * genflags, crash on Sun 4:             Installation Problems.
  110. * geu and attributes:                   Expressions.
  111. * ge and attributes:                    Expressions.
  112. * gprof:                                Debugging Options.
  113. * gtu and attributes:                   Expressions.
  114. * gt and attributes:                    Expressions.
  115. * HImode, in insn:                      Insns.
  116. * if_then_else and attributes:          Expressions.
  117. * if_then_else usage:                   Side Effects.
  118. * indirect_jump instruction pattern:    Standard Names.
  119. * insn and /i:                          Flags.
  120. * insn and /s:                          Flags.
  121. * insn and /u:                          Flags.
  122. * insv instruction pattern:             Standard Names.
  123. * integrated, in insn:                  Flags.
  124. * integrated, in reg:                   Flags.
  125. * in_struct, in code_label:             Flags.
  126. * in_struct, in insn:                   Flags.
  127. * in_struct, in insn:                   Flags.
  128. * in_struct, in label_ref:              Flags.
  129. * in_struct, in mem:                    Flags.
  130. * in_struct, in reg:                    Flags.
  131. * in_struct, in subreg:                 Flags.
  132. * iorM3 instruction pattern:            Standard Names.
  133. * ior and attributes:                   Expressions.
  134. * ior, canonicalization of:             Insn Canonicalizations.
  135. * label_ref and /s:                     Flags.
  136. * label_ref, RTL sharing:               Sharing.
  137. * leu and attributes:                   Expressions.
  138. * le and attributes:                    Expressions.
  139. * load_multiple instruction pattern:    Standard Names.
  140. * long long data types:                 Long Long.
  141. * longjmp and automatic variables:      Dialect Options.
  142. * longjmp and automatic variables:      Interface.
  143. * longjmp incompatibilities:            Incompatibilities.
  144. * longjmp warnings:                     Warning Options.
  145. * lshiftrt and attributes:              Expressions.
  146. * lshift and attributes:                Expressions.
  147. * lshlM3 instruction pattern:           Standard Names.
  148. * lshrM3 instruction pattern:           Standard Names.
  149. * lt and attributes:                    Expressions.
  150. * main and the exit status:             VMS Misc.
  151. * match_dup and attributes:             Insn Lengths.
  152. * match_operand and attributes:         Expressions.
  153. * maxM3 instruction pattern:            Standard Names.
  154. * memcpy, implicit usage:               Library Calls.
  155. * memset, implicit usage:               Library Calls.
  156. * mem and /s:                           Flags.
  157. * mem and /u:                           Flags.
  158. * mem and /v:                           Flags.
  159. * mem, RTL sharing:                     Sharing.
  160. * minM3 instruction pattern:            Standard Names.
  161. * minus and attributes:                 Expressions.
  162. * minus, canonicalization of:           Insn Canonicalizations.
  163. * mktemp, and constant strings:         Incompatibilities.
  164. * modM3 instruction pattern:            Standard Names.
  165. * mode attribute:                       Variable Attributes.
  166. * mod and attributes:                   Expressions.
  167. * movM instruction pattern:             Standard Names.
  168. * movstrM instruction pattern:          Standard Names.
  169. * movstrictM instruction pattern:       Standard Names.
  170. * mulM3 instruction pattern:            Standard Names.
  171. * mulhisi3 instruction pattern:         Standard Names.
  172. * mulqihi3 instruction pattern:         Standard Names.
  173. * mulsidi3 instruction pattern:         Standard Names.
  174. * mult and attributes:                  Expressions.
  175. * mult, canonicalization of:            Insn Canonicalizations.
  176. * MUST_PASS_IN_STACK, and FUNCTION_ARG: Register Arguments.
  177. * negM2 instruction pattern:            Standard Names.
  178. * neg and attributes:                   Expressions.
  179. * neg, canonicalization of:             Insn Canonicalizations.
  180. * ne and attributes:                    Expressions.
  181. * nop instruction pattern:              Standard Names.
  182. * not and attributes:                   Expressions.
  183. * not, canonicalization of:             Insn Canonicalizations.
  184. * one_cmplM2 instruction pattern:       Standard Names.
  185. * packed attribute:                     Variable Attributes.
  186. * pc and attributes:                    Insn Lengths.
  187. * pc, RTL sharing:                      Sharing.
  188. * plus and attributes:                  Expressions.
  189. * plus, canonicalization of:            Insn Canonicalizations.
  190. * prof:                                 Debugging Options.
  191. * PUSH_ROUNDING, interaction with STACK_BOUNDARY: Storage Layout.
  192. * QImode, in insn:                      Insns.
  193. * qsort, and global register variables: Global Reg Vars.
  194. * REG_PARM_STACK_SPACE, and FUNCTION_ARG: Register Arguments.
  195. * reg and /i:                           Flags.
  196. * reg and /s:                           Flags.
  197. * reg and /u:                           Flags.
  198. * reg and /v:                           Flags.
  199. * reg, RTL sharing:                     Sharing.
  200. * reload_in instruction pattern:        Standard Names.
  201. * reload_out instruction pattern:       Standard Names.
  202. * restore_stack_block instruction pattern: Standard Names.
  203. * restore_stack_function instruction pattern: Standard Names.
  204. * restore_stack_nonlocal instruction pattern: Standard Names.
  205. * return instruction pattern:           Standard Names.
  206. * rotlM3 instruction pattern:           Standard Names.
  207. * rotrM3 instruction pattern:           Standard Names.
  208. * sCOND instruction pattern:            Standard Names.
  209. * save_stack_block instruction pattern: Standard Names.
  210. * save_stack_function instruction pattern: Standard Names.
  211. * save_stack_nonlocal instruction pattern: Standard Names.
  212. * scanf, and constant strings:          Incompatibilities.
  213. * scratch, RTL sharing:                 Sharing.
  214. * setjmp incompatibilities:             Incompatibilities.
  215. * sign_extract, canonicalization of:    Insn Canonicalizations.
  216. * sqrtM2 instruction pattern:           Standard Names.
  217. * sscanf, and constant strings:         Incompatibilities.
  218. * STACK_DYNAMIC_OFFSET and virtual registers: Regs and Memory.
  219. * STACK_POINTER_OFFSET and virtual registers: Regs and Memory.
  220. * STACK_POINTER_REGNUM and virtual registers: Regs and Memory.
  221. * STARTING_FRAME_OFFSET and virtual registers: Regs and Memory.
  222. * subM3 instruction pattern:            Standard Names.
  223. * subreg and /s:                        Flags.
  224. * subreg and /u:                        Flags.
  225. * subreg, in strict_low_part:           RTL Declarations.
  226. * subreg, special reload handling:      Regs and Memory.
  227. * SYMBOL_REF_FLAG, in ENCODE_SECTION_INFO: Sections.
  228. * symbol_ref and /u:                    Flags.
  229. * symbol_ref and /v:                    Flags.
  230. * symbol_ref, RTL sharing:              Sharing.
  231. * tablejump instruction pattern:        Standard Names.
  232. * tcov:                                 Debugging Options.
  233. * truncMN instruction pattern:          Standard Names.
  234. * tstM instruction pattern:             Standard Names.
  235. * udivM3 instruction pattern:           Standard Names.
  236. * udivmodM4 instruction pattern:        Standard Names.
  237. * umaxM3 instruction pattern:           Standard Names.
  238. * uminM3 instruction pattern:           Standard Names.
  239. * umodM3 instruction pattern:           Standard Names.
  240. * umulhisi3 instruction pattern:        Standard Names.
  241. * umulqihi3 instruction pattern:        Standard Names.
  242. * umulsidi3 instruction pattern:        Standard Names.
  243. * unchanging, in call_insn:             Flags.
  244. * unchanging, in insn:                  Flags.
  245. * unchanging, in reg and mem:           Flags.
  246. * unchanging, in subreg:                Flags.
  247. * unchanging, in symbol_ref:            Flags.
  248. * used, in symbol_ref:                  Flags.
  249. * volatile applied to function:         Function Attributes.
  250. * volatil, in insn:                     Flags.
  251. * volatil, in mem:                      Flags.
  252. * volatil, in reg:                      Flags.
  253. * volatil, in symbol_ref:               Flags.
  254. * WORDS_BIG_ENDIAN, effect on subreg:   Regs and Memory.
  255. * xorM3 instruction pattern:            Standard Names.
  256. * xor, canonicalization of:             Insn Canonicalizations.
  257. * zero_extendMN instruction pattern:    Standard Names.
  258. * zero_extract, canonicalization of:    Insn Canonicalizations.
  259. * libgcc.a:                             Library Calls.
  260. * stdarg.h and register arguments:      Register Arguments.
  261. * stdarg.h and RT PC:                   RT Options.
  262. * tm.h macros:                          Target Macros.
  263. * varargs.h and RT PC:                  RT Options.
  264. * VAXCRTL:                              VMS Misc.
  265. * xm-MACHINE.h:                         Config.
  266. * ! in constraint:                      Multi-Alternative.
  267. * # in constraint:                      Modifiers.
  268. * % in constraint:                      Modifiers.
  269. * % in template:                        Output Template.
  270. * & in constraint:                      Modifiers.
  271. * * in constraint:                      Modifiers.
  272. * + in constraint:                      Modifiers.
  273. * /i in RTL dump:                       Flags.
  274. * /s in RTL dump:                       Flags.
  275. * /s in RTL dump:                       Flags.
  276. * /u in RTL dump:                       Flags.
  277. * /v in RTL dump:                       Flags.
  278. * 0 in constraint:                      Simple Constraints.
  279. * < in constraint:                      Simple Constraints.
  280. * = in constraint:                      Modifiers.
  281. * > in constraint:                      Simple Constraints.
  282. * ? in constraint:                      Multi-Alternative.
  283. * d in constraint:                      Simple Constraints.
  284. * E in constraint:                      Simple Constraints.
  285. * F in constraint:                      Simple Constraints.
  286. * g in constraint:                      Simple Constraints.
  287. * G in constraint:                      Simple Constraints.
  288. * H in constraint:                      Simple Constraints.
  289. * i in constraint:                      Simple Constraints.
  290. * I in constraint:                      Simple Constraints.
  291. * m in constraint:                      Simple Constraints.
  292. * n in constraint:                      Simple Constraints.
  293. * o in constraint:                      Simple Constraints.
  294. * p in constraint:                      Simple Constraints.
  295. * Q, in constraint:                     Simple Constraints.
  296. * r in constraint:                      Simple Constraints.
  297. * store_multiple instruction pattern:   Standard Names.
  298. * s in constraint:                      Simple Constraints.
  299. * V in constraint:                      Simple Constraints.
  300. * X in constraint:                      Simple Constraints.
  301. * _ in variables in macros:             Naming Types.
  302. * abort:                                Portability.
  303. * abs:                                  Arithmetic.
  304. * absolute value:                       Arithmetic.
  305. * access to operands:                   Accessors.
  306. * accessors:                            Accessors.
  307. * ACCUMULATE_OUTGOING_ARGS:             Stack Arguments.
  308. * ADDITIONAL_REGISTER_NAMES:            Instruction Output.
  309. * address:                              RTL Template.
  310. * address constraints:                  Simple Constraints.
  311. * address of a label:                   Labels as Values.
  312. * addressing modes:                     Addressing Modes.
  313. * ADDRESS_COST:                         Costs.
  314. * address_operand:                      Simple Constraints.
  315. * addr_diff_vec:                        Side Effects.
  316. * addr_vec:                             Side Effects.
  317. * ADJUST_COST:                          Costs.
  318. * ADJUST_INSN_LENGTH:                   Insn Lengths.
  319. * aggregates as return values:          Aggregate Return.
  320. * alignment:                            Alignment.
  321. * Alliant:                              Interoperation.
  322. * ALLOCATE_TRAMPOLINE:                  Trampolines.
  323. * ALL_REGS:                             Register Classes.
  324. * alternate keywords:                   Alternate Keywords.
  325. * AMD29K options:                       AMD29K Options.
  326. * analysis, data flow:                  Passes.
  327. * and:                                  Arithmetic.
  328. * ANSI support:                         Dialect Options.
  329. * apostrophes:                          Incompatibilities.
  330. * ARGS_GROW_DOWNWARD:                   Frame Layout.
  331. * argument passing:                     Interface.
  332. * arguments in frame (88k):             M88K Options.
  333. * arguments in registers:               Register Arguments.
  334. * arguments on stack:                   Stack Arguments.
  335. * ARG_POINTER_REGNUM:                   Frame Registers.
  336. * arg_pointer_rtx:                      Frame Registers.
  337. * arithmetic libraries:                 Interface.
  338. * arithmetic shift:                     Arithmetic.
  339. * arithmetic simplifications:           Passes.
  340. * arithmetic, in RTL:                   Arithmetic.
  341. * arrays of length zero:                Zero Length.
  342. * arrays of variable length:            Variable Length.
  343. * arrays, non-lvalue:                   Subscripting.
  344. * ashift:                               Arithmetic.
  345. * ashiftrt:                             Arithmetic.
  346. * ASM_APP_OFF:                          File Framework.
  347. * ASM_APP_ON:                           File Framework.
  348. * ASM_BYTE_OP:                          Data Output.
  349. * ASM_CLOSE_PAREN:                      Data Output.
  350. * ASM_COMMENT_START:                    File Framework.
  351. * ASM_DECLARE_FUNCTION_NAME:            Label Output.
  352. * ASM_DECLARE_FUNCTION_SIZE:            Label Output.
  353. * ASM_DECLARE_OBJECT_NAME:              Label Output.
  354. * ASM_FILE_END:                         File Framework.
  355. * ASM_FILE_START:                       File Framework.
  356. * ASM_FINAL_SPEC:                       Driver.
  357. * ASM_FORMAT_PRIVATE_NAME:              Label Output.
  358. * asm_fprintf:                          Instruction Output.
  359. * ASM_GENERATE_INTERNAL_LABEL:          Label Output.
  360. * ASM_GLOBALIZE_LABEL:                  Label Output.
  361. * ASM_IDENTIFY_GCC:                     File Framework.
  362. * asm_input:                            Side Effects.
  363. * asm_noperands:                        Insns.
  364. * ASM_NO_SKIP_IN_TEXT:                  Alignment Output.
  365. * ASM_OPEN_PAREN:                       Data Output.
  366. * ASM_OUTPUT_ADDR_DIFF_ELT:             Dispatch Tables.
  367. * ASM_OUTPUT_ADDR_VEC_ELT:              Dispatch Tables.
  368. * ASM_OUTPUT_ALIGN:                     Alignment Output.
  369. * ASM_OUTPUT_ALIGNED_COMMON:            Uninitialized Data.
  370. * ASM_OUTPUT_ALIGNED_LOCAL:             Uninitialized Data.
  371. * ASM_OUTPUT_ALIGN_CODE:                Alignment Output.
  372. * ASM_OUTPUT_ASCII:                     Data Output.
  373. * ASM_OUTPUT_BYTE:                      Data Output.
  374. * ASM_OUTPUT_CASE_END:                  Dispatch Tables.
  375. * ASM_OUTPUT_CASE_LABEL:                Dispatch Tables.
  376. * ASM_OUTPUT_CHAR:                      Data Output.
  377. * ASM_OUTPUT_COMMON:                    Uninitialized Data.
  378. * ASM_OUTPUT_CONSTRUCTOR:               Macros for Initialization.
  379. * ASM_OUTPUT_DESTRUCTOR:                Macros for Initialization.
  380. * ASM_OUTPUT_DOUBLE:                    Data Output.
  381. * ASM_OUTPUT_DOUBLE_INT:                Data Output.
  382. * ASM_OUTPUT_EXTERNAL:                  Label Output.
  383. * ASM_OUTPUT_EXTERNAL_LIBCALL:          Label Output.
  384. * ASM_OUTPUT_FLOAT:                     Data Output.
  385. * ASM_OUTPUT_IDENT:                     File Framework.
  386. * ASM_OUTPUT_INT:                       Data Output.
  387. * ASM_OUTPUT_INTERNAL_LABEL:            Label Output.
  388. * ASM_OUTPUT_LABEL:                     Label Output.
  389. * ASM_OUTPUT_LABELREF:                  Label Output.
  390. * ASM_OUTPUT_LABELREF_AS_INT:           Label Output.
  391. * ASM_OUTPUT_LOCAL:                     Uninitialized Data.
  392. * ASM_OUTPUT_LONG_DOUBLE:               Data Output.
  393. * ASM_OUTPUT_LOOP_ALIGN:                Alignment Output.
  394. * ASM_OUTPUT_OPCODE:                    Instruction Output.
  395. * ASM_OUTPUT_POOL_PROLOGUE:             Data Output.
  396. * ASM_OUTPUT_QUADRUPLE_INT:             Data Output.
  397. * ASM_OUTPUT_REG_POP:                   Instruction Output.
  398. * ASM_OUTPUT_REG_PUSH:                  Instruction Output.
  399. * ASM_OUTPUT_SHARED_COMMON:             Uninitialized Data.
  400. * ASM_OUTPUT_SHARED_LOCAL:              Uninitialized Data.
  401. * ASM_OUTPUT_SHORT:                     Data Output.
  402. * ASM_OUTPUT_SKIP:                      Alignment Output.
  403. * ASM_OUTPUT_SOURCE_FILENAME:           File Framework.
  404. * ASM_OUTPUT_SOURCE_LINE:               File Framework.
  405. * ASM_OUTPUT_SPECIAL_POOL_ENTRY:        Data Output.
  406. * ASM_SPEC:                             Driver.
  407. * ASM_STABD_OP:                         DBX Options.
  408. * ASM_STABN_OP:                         DBX Options.
  409. * ASM_STABS_OP:                         DBX Options.
  410. * assembler format:                     File Framework.
  411. * assembler instructions:               Extended Asm.
  412. * assembler instructions in RTL:        Assembler.
  413. * assembler names for identifiers:      Asm Labels.
  414. * assembler syntax, 88k:                M88K Options.
  415. * assemble_name:                        Label Output.
  416. * assembly code, invalid:               Bug Criteria.
  417. * assigning attribute values to insns:  Tagging Insns.
  418. * asterisk in template:                 Output Statement.
  419. * atof:                                 Cross-compilation.
  420. * attr:                                 Tagging Insns.
  421. * attribute expressions:                Expressions.
  422. * attribute of variables:               Variable Attributes.
  423. * attribute specifications:             Attr Example.
  424. * attribute specifications example:     Attr Example.
  425. * attributes, defining:                 Defining Attributes.
  426. * autoincrement addressing, availability: Portability.
  427. * autoincrement/decrement addressing:   Simple Constraints.
  428. * autoincrement/decrement analysis:     Passes.
  429. * backslash:                            Output Template.
  430. * backtrace for bug reports:            Bug Reporting.
  431. * barrier:                              Insns.
  432. * BASE_REG_CLASS:                       Register Classes.
  433. * basic blocks:                         Passes.
  434. * bcmp:                                 Config.
  435. * BIGGEST_ALIGNMENT:                    Storage Layout.
  436. * BIGGEST_FIELD_ALIGNMENT:              Storage Layout.
  437. * Bison parser generator:               Installation.
  438. * bit fields:                           Bit Fields.
  439. * bit shift overflow (88k):             M88K Options.
  440. * BITFIELD_NBYTES_LIMITED:              Storage Layout.
  441. * BITS_BIG_ENDIAN:                      Storage Layout.
  442. * BITS_PER_UNIT:                        Storage Layout.
  443. * BITS_PER_WORD:                        Storage Layout.
  444. * bitwise complement:                   Arithmetic.
  445. * bitwise exclusive-or:                 Arithmetic.
  446. * bitwise inclusive-or:                 Arithmetic.
  447. * bitwise logical-and:                  Arithmetic.
  448. * BLKmode:                              Machine Modes.
  449. * BLOCK_PROFILER:                       Profiling.
  450. * BRANCH_COST:                          Costs.
  451. * break_out_memory_refs:                Addressing Modes.
  452. * bug criteria:                         Bug Criteria.
  453. * bug report mailing lists:             Bug Lists.
  454. * bugs:                                 Bugs.
  455. * bugs, known:                          Trouble.
  456. * BYTES_BIG_ENDIAN:                     Storage Layout.
  457. * BYTE_LOADS_SIGN_EXTEND:               Misc.
  458. * BYTE_LOADS_ZERO_EXTEND:               Misc.
  459. * byte_mode:                            Machine Modes.
  460. * bzero:                                Config.
  461. * C language extensions:                Extensions.
  462. * C language, traditional:              Dialect Options.
  463. * C statements for assembler output:    Output Statement.
  464. * call:                                 Side Effects.
  465. * call-clobbered register:              Register Basics.
  466. * call-saved register:                  Register Basics.
  467. * call-used register:                   Register Basics.
  468. * CALLER_SAVE_PROFITABLE:               Caller Saves.
  469. * calling conventions:                  Stack and Calling.
  470. * calling functions in RTL:             Calls.
  471. * call_insn:                            Insns.
  472. * CALL_USED_REGISTERS:                  Register Basics.
  473. * call_used_regs:                       Register Basics.
  474. * canonicalization of instructions:     Insn Canonicalizations.
  475. * CAN_ELIMINATE:                        Elimination.
  476. * case labels in initializers:          Labeled Elements.
  477. * case ranges:                          Case Ranges.
  478. * case sensitivity and VMS:             VMS Misc.
  479. * CASE_DROPS_THROUGH:                   Misc.
  480. * CASE_VALUES_THRESHOLD:                Misc.
  481. * CASE_VECTOR_MODE:                     Misc.
  482. * CASE_VECTOR_PC_RELATIVE:              Misc.
  483. * cast to a union:                      Cast to Union.
  484. * casts as lvalues:                     Lvalues.
  485. * cc0:                                  Regs and Memory.
  486. * cc0_rtx:                              Regs and Memory.
  487. * CC1PLUS_SPEC:                         Driver.
  488. * CC1_SPEC:                             Driver.
  489. * CCmode:                               Machine Modes.
  490. * cc_status:                            Condition Code.
  491. * CC_STATUS_MDEP:                       Condition Code.
  492. * CC_STATUS_MDEP_INIT:                  Condition Code.
  493. * change_address:                       Standard Names.
  494. * CHAR_TYPE_SIZE:                       Type Layout.
  495. * CHECK_FLOAT_VALUE:                    Storage Layout.
  496. * class definitions, register:          Register Classes.
  497. * class preference constraints:         Class Preferences.
  498. * classes of RTX codes:                 Accessors.
  499. * CLASS_MAX_NREGS:                      Register Classes.
  500. * clobber:                              Side Effects.
  501. * code generation conventions:          Code Gen Options.
  502. * code generation RTL sequences:        Expander Definitions.
  503. * code motion:                          Passes.
  504. * codes, RTL expression:                RTL Objects.
  505. * code_label:                           Insns.
  506. * CODE_LABEL_NUMBER:                    Insns.
  507. * combiner pass:                        Regs and Memory.
  508. * command options:                      Invoking GCC.
  509. * common subexpression elimination:     Passes.
  510. * compare:                              Arithmetic.
  511. * compilation in a separate directory:  Other Dir.
  512. * compiler bugs, reporting:             Bug Reporting.
  513. * compiler passes and files:            Passes.
  514. * compiler version, specifying:         Target Options.
  515. * COMPILER_PATH:                        Environment Variables.
  516. * complement, bitwise:                  Arithmetic.
  517. * compound expressions as lvalues:      Lvalues.
  518. * computed gotos:                       Labels as Values.
  519. * computing the length of an insn:      Insn Lengths.
  520. * cond:                                 Comparisons.
  521. * condition code register:              Regs and Memory.
  522. * condition code status:                Condition Code.
  523. * condition codes:                      Comparisons.
  524. * conditional expressions as lvalues:   Lvalues.
  525. * conditional expressions, extensions:  Conditionals.
  526. * CONDITIONAL_REGISTER_USAGE:           Register Basics.
  527. * conditions, in patterns:              Patterns.
  528. * configuration file:                   Config.
  529. * conflicting types:                    Disappointments.
  530. * CONST0_RTX:                           Constants.
  531. * const0_rtx:                           Constants.
  532. * CONST1_RTX:                           Constants.
  533. * const1_rtx:                           Constants.
  534. * CONST2_RTX:                           Constants.
  535. * const2_rtx:                           Constants.
  536. * constant attributes:                  Constant Attributes.
  537. * constant folding:                     Passes.
  538. * constant folding and floating point:  Cross-compilation.
  539. * constant propagation:                 Passes.
  540. * constants in constraints:             Simple Constraints.
  541. * CONSTANT_ADDRESS_P:                   Addressing Modes.
  542. * CONSTANT_ALIGNMENT:                   Storage Layout.
  543. * CONSTANT_P:                           Addressing Modes.
  544. * CONSTANT_POOL_ADDRESS_P:              Flags.
  545. * constm1_rtx:                          Constants.
  546. * constraint modifier characters:       Modifiers.
  547. * constraint, matching:                 Simple Constraints.
  548. * constraints:                          Constraints.
  549. * constructor expressions:              Constructors.
  550. * constructors, output of:              Initialization.
  551. * CONST_CALL_P:                         Flags.
  552. * CONST_COSTS:                          Costs.
  553. * const_double:                         Constants.
  554. * CONST_DOUBLE_CHAIN:                   Constants.
  555. * CONST_DOUBLE_LOW:                     Constants.
  556. * CONST_DOUBLE_MEM:                     Constants.
  557. * CONST_DOUBLE_OK_FOR_LETTER_P:         Register Classes.
  558. * const_int:                            Constants.
  559. * CONST_OK_FOR_LETTER_P:                Register Classes.
  560. * const_string:                         Constants.
  561. * const_true_rtx:                       Constants.
  562. * contributors:                         Contributors.
  563. * controlling register usage:           Register Basics.
  564. * controlling the compilation driver:   Driver.
  565. * conventions, run-time:                Interface.
  566. * conversions:                          Conversions.
  567. * Convex options:                       Convex Options.
  568. * copy_rtx_if_shared:                   Sharing.
  569. * core dump:                            Bug Criteria.
  570. * costs of instructions:                Costs.
  571. * COSTS_N_INSNS:                        Costs.
  572. * CPLUS_INCLUDE_PATH:                   Environment Variables.
  573. * CPP_PREDEFINES:                       Run-time Target.
  574. * CPP_SPEC:                             Driver.
  575. * cross compilation and floating point: Cross-compilation.
  576. * cross compiling:                      Target Options.
  577. * cross-compiler, installation:         Cross-Compiler.
  578. * cross-jumping:                        Passes.
  579. * CUMULATIVE_ARGS:                      Register Arguments.
  580. * current_function_epilogue_delay_list: Function Entry.
  581. * current_function_outgoing_args_size:  Stack Arguments.
  582. * current_function_pops_args:           Function Entry.
  583. * current_function_pretend_args_size:   Function Entry.
  584. * C_INCLUDE_PATH:                       Environment Variables.
  585. * data flow analysis:                   Passes.
  586. * DATA_ALIGNMENT:                       Storage Layout.
  587. * data_section:                         Sections.
  588. * DATA_SECTION_ASM_OP:                  Sections.
  589. * DBR_OUTPUT_SEQEND:                    Instruction Output.
  590. * dbr_sequence_length:                  Instruction Output.
  591. * DBX:                                  Interoperation.
  592. * DBX_CONTIN_CHAR:                      DBX Options.
  593. * DBX_CONTIN_LENGTH:                    DBX Options.
  594. * DBX_DEBUGGING_INFO:                   DBX Options.
  595. * DBX_FUNCTION_FIRST:                   DBX Options.
  596. * DBX_LBRAC_FIRST:                      DBX Options.
  597. * DBX_MEMPARM_STABS_LETTER:             DBX Options.
  598. * DBX_NO_XREFS:                         DBX Options.
  599. * DBX_OUTPUT_ENUM:                      DBX Hooks.
  600. * DBX_OUTPUT_FUNCTION_END:              DBX Hooks.
  601. * DBX_OUTPUT_LBRAC:                     DBX Hooks.
  602. * DBX_OUTPUT_MAIN_SOURCE_DIRECTORY:     File Names and DBX.
  603. * DBX_OUTPUT_MAIN_SOURCE_FILENAME:      File Names and DBX.
  604. * DBX_OUTPUT_MAIN_SOURCE_FILE_END:      File Names and DBX.
  605. * DBX_OUTPUT_RBRAC:                     DBX Hooks.
  606. * DBX_OUTPUT_SOURCE_FILENAME:           File Names and DBX.
  607. * DBX_OUTPUT_STANDARD_TYPES:            DBX Hooks.
  608. * DBX_REGISTER_NUMBER:                  All Debuggers.
  609. * DBX_REGPARM_STABS_CODE:               DBX Options.
  610. * DBX_REGPARM_STABS_LETTER:             DBX Options.
  611. * DBX_STATIC_CONST_VAR_CODE:            DBX Options.
  612. * DBX_STATIC_STAB_DATA_SECTION:         DBX Options.
  613. * DBX_TYPE_DECL_STABS_CODE:             DBX Options.
  614. * DBX_WORKING_DIRECTORY:                File Names and DBX.
  615. * DCmode:                               Machine Modes.
  616. * De Morgan's law:                      Insn Canonicalizations.
  617. * dead code:                            Passes.
  618. * dead_or_set_p:                        Peephole Definitions.
  619. * deallocating variable length arrays:  Variable Length.
  620. * death notes:                          Obsolete Register Macros.
  621. * DEBUGGER_ARG_OFFSET:                  All Debuggers.
  622. * DEBUGGER_AUTO_OFFSET:                 All Debuggers.
  623. * debugging information generation:     Passes.
  624. * debugging information options:        Debugging Options.
  625. * debugging, 88k OCS:                   M88K Options.
  626. * debug_rtx:                            Bug Reporting.
  627. * DEBUG_SYMS_TEXT:                      DBX Options.
  628. * declaration scope:                    Incompatibilities.
  629. * declarations inside expressions:      Statement Exprs.
  630. * declarations, RTL:                    RTL Declarations.
  631. * declaring attributes of functions:    Function Attributes.
  632. * DEFAULT_CALLER_SAVES:                 Caller Saves.
  633. * DEFAULT_GDB_EXTENSIONS:               DBX Options.
  634. * DEFAULT_MAIN_RETURN:                  Misc.
  635. * DEFAULT_SHORT_ENUMS:                  Type Layout.
  636. * DEFAULT_SIGNED_CHAR:                  Type Layout.
  637. * define_asm_attributes:                Tagging Insns.
  638. * define_attr:                          Defining Attributes.
  639. * define_delay:                         Delay Slots.
  640. * define_expand:                        Expander Definitions.
  641. * define_function_unit:                 Function Units.
  642. * define_insn:                          Patterns.
  643. * define_peephole:                      Expander Definitions.
  644. * define_split:                         Insn Splitting.
  645. * defining attributes and their values: Defining Attributes.
  646. * defining jump instruction patterns:   Jump Patterns.
  647. * defining peephole optimizers:         Peephole Definitions.
  648. * defining RTL sequences for code generation: Expander Definitions.
  649. * delay slots, defining:                Delay Slots.
  650. * delayed branch scheduling:            Passes.
  651. * DELAY_SLOTS_FOR_EPILOGUE:             Function Entry.
  652. * dependencies for make as output:      Environment Variables.
  653. * dependencies, make:                   Preprocessor Options.
  654. * DEPENDENCIES_OUTPUT:                  Environment Variables.
  655. * Dependent Patterns:                   Dependent Patterns.
  656. * destructors, output of:               Initialization.
  657. * DFmode:                               Machine Modes.
  658. * dialect options:                      Dialect Options.
  659. * digits in constraint:                 Simple Constraints.
  660. * DImode:                               Machine Modes.
  661. * directory options:                    Directory Options.
  662. * disabling certain registers:          Register Basics.
  663. * dispatch table:                       Dispatch Tables.
  664. * div:                                  Arithmetic.
  665. * DIVDI3_LIBCALL:                       Library Calls.
  666. * divide instruction, 88k:              M88K Options.
  667. * division:                             Arithmetic.
  668. * division:                             Arithmetic.
  669. * division:                             Arithmetic.
  670. * DIVSI3_LIBCALL:                       Library Calls.
  671. * dollar signs in identifier names:     Dollar Signs.
  672. * DOLLARS_IN_IDENTIFIERS:               Misc.
  673. * DONE:                                 Expander Definitions.
  674. * DONT_REDUCE_ADDR:                     Costs.
  675. * double-word arithmetic:               Long Long.
  676. * DOUBLE_TYPE_SIZE:                     Type Layout.
  677. * downward funargs:                     Nested Functions.
  678. * driver:                               Driver.
  679. * DWARF_DEBUGGING_INFO:                 SDB and DWARF.
  680. * DYNAMIC_CHAIN_ADDRESS:                Frame Layout.
  681. * EASY_DIV_EXPR:                        Misc.
  682. * ELIGIBLE_FOR_EPILOGUE_DELAY:          Function Entry.
  683. * ELIMINABLE_REGS:                      Elimination.
  684. * empty constraints:                    No Constraints.
  685. * EMPTY_FIELD_BOUNDARY:                 Storage Layout.
  686. * ENCODE_SECTION_INFO:                  Sections.
  687. * ENDFILE_SPEC:                         Driver.
  688. * endianness:                           Portability.
  689. * enum machine_mode:                    Machine Modes.
  690. * enum reg_class:                       Register Classes.
  691. * environment variables:                Environment Variables.
  692. * epilogue:                             Function Entry.
  693. * eq:                                   Comparisons.
  694. * equal:                                Comparisons.
  695. * eq_attr:                              Expressions.
  696. * error:                                Storage Layout.
  697. * exclamation point:                    Multi-Alternative.
  698. * exclusive-or, bitwise:                Arithmetic.
  699. * EXECUTABLE_SUFFIX:                    Config.
  700. * exit status and VMS:                  VMS Misc.
  701. * EXIT_BODY:                            Misc.
  702. * EXIT_IGNORE_STACK:                    Function Entry.
  703. * expander definitions:                 Expander Definitions.
  704. * EXPAND_BUILTIN_SAVEREGS:              Varargs.
  705. * explicit register variables:          Explicit Reg Vars.
  706. * expression codes:                     RTL Objects.
  707. * expressions containing statements:    Statement Exprs.
  708. * expressions, compound, as lvalues:    Lvalues.
  709. * expressions, conditional, as lvalues: Lvalues.
  710. * expressions, constructor:             Constructors.
  711. * expr_list:                            Insns.
  712. * extended asm:                         Extended Asm.
  713. * extensible constraints:               Simple Constraints.
  714. * extensions, ?::                       Conditionals.
  715. * extensions, ?::                       Lvalues.
  716. * extensions, C language:               Extensions.
  717. * extern int target_flags:              Run-time Target.
  718. * external declaration scope:           Incompatibilities.
  719. * EXTRA_CC_MODES:                       Condition Code.
  720. * EXTRA_CC_NAMES:                       Condition Code.
  721. * EXTRA_CONSTRAINT:                     Register Classes.
  722. * EXTRA_SECTIONS:                       Sections.
  723. * EXTRA_SECTION_FUNCTIONS:              Sections.
  724. * FAIL:                                 Expander Definitions.
  725. * FAILURE_EXIT_CODE:                    Config.
  726. * fatal signal:                         Bug Criteria.
  727. * features, optional, in system conventions: Run-time Target.
  728. * ffs:                                  Arithmetic.
  729. * file name suffix:                     Overall Options.
  730. * file names:                           Link Options.
  731. * files and passes of the compiler:     Passes.
  732. * final pass:                           Passes.
  733. * FINALIZE_PIC:                         PIC.
  734. * FINAL_PRESCAN_INSN:                   Instruction Output.
  735. * FINAL_REG_PARM_STACK_SPACE:           Stack Arguments.
  736. * final_scan_insn:                      Function Entry.
  737. * final_sequence:                       Instruction Output.
  738. * FIRST_INSN_ADDRESS:                   Insn Lengths.
  739. * FIRST_PARM_OFFSET:                    Frame Layout.
  740. * FIRST_PSEUDO_REGISTER:                Register Basics.
  741. * FIRST_STACK_REG:                      Stack Registers.
  742. * FIRST_VIRTUAL_REGISTER:               Regs and Memory.
  743. * fix:                                  Conversions.
  744. * fix:                                  Conversions.
  745. * fixed register:                       Register Basics.
  746. * FIXED_REGISTERS:                      Register Basics.
  747. * fixed_regs:                           Register Basics.
  748. * FIXUNS_TRUNC_LIKE_FIX_TRUNC:          Misc.
  749. * flags in RTL expression:              Flags.
  750. * float:                                Conversions.
  751. * FLOATIFY:                             Library Calls.
  752. * floating point format and cross compilation: Cross-compilation.
  753. * FLOAT_ARG_TYPE:                       Library Calls.
  754. * float_extend:                         Conversions.
  755. * FLOAT_STORE_FLAG_VALUE:               Misc.
  756. * float_truncate:                       Conversions.
  757. * FLOAT_TYPE_SIZE:                      Type Layout.
  758. * FLOAT_VALUE_TYPE:                     Library Calls.
  759. * force_reg:                            Standard Names.
  760. * frame layout:                         Frame Layout.
  761. * FRAME_GROWS_DOWNWARD:                 Frame Layout.
  762. * frame_pointer_needed:                 Function Entry.
  763. * FRAME_POINTER_REGNUM:                 Frame Registers.
  764. * FRAME_POINTER_REQUIRED:               Elimination.
  765. * frame_pointer_rtx:                    Frame Registers.
  766. * function attributes:                  Function Attributes.
  767. * function call conventions:            Interface.
  768. * function entry and exit:              Function Entry.
  769. * function pointers, arithmetic:        Pointer Arith.
  770. * function prototype declarations:      Function Prototypes.
  771. * function units, for scheduling:       Function Units.
  772. * function, size of pointer to:         Pointer Arith.
  773. * function-call insns:                  Calls.
  774. * functions that have no side effects:  Function Attributes.
  775. * functions that never return:          Function Attributes.
  776. * functions, leaf:                      Leaf Functions.
  777. * FUNCTION_ARG:                         Register Arguments.
  778. * FUNCTION_ARG_ADVANCE:                 Register Arguments.
  779. * FUNCTION_ARG_BOUNDARY:                Register Arguments.
  780. * FUNCTION_ARG_PADDING:                 Register Arguments.
  781. * FUNCTION_ARG_PARTIAL_NREGS:           Register Arguments.
  782. * FUNCTION_ARG_PASS_BY_REFERENCE:       Register Arguments.
  783. * FUNCTION_ARG_REGNO_P:                 Register Arguments.
  784. * FUNCTION_BLOCK_PROFILER:              Profiling.
  785. * FUNCTION_BOUNDARY:                    Storage Layout.
  786. * FUNCTION_CONVERSION_BUG:              Config.
  787. * FUNCTION_EPILOGUE:                    Function Entry.
  788. * FUNCTION_INCOMING_ARG:                Register Arguments.
  789. * FUNCTION_MODE:                        Misc.
  790. * FUNCTION_OUTGOING_VALUE:              Scalar Return.
  791. * FUNCTION_PROFILER:                    Profiling.
  792. * FUNCTION_PROLOGUE:                    Function Entry.
  793. * FUNCTION_VALUE:                       Scalar Return.
  794. * FUNCTION_VALUE_REGNO_P:               Scalar Return.
  795. * GCC_EXEC_PREFIX:                      Environment Variables.
  796. * ge:                                   Comparisons.
  797. * gencodes:                             Passes.
  798. * genconfig:                            Passes.
  799. * generalized lvalues:                  Lvalues.
  800. * general_operand:                      RTL Template.
  801. * GENERAL_REGS:                         Register Classes.
  802. * generating assembler output:          Output Statement.
  803. * generating insns:                     RTL Template.
  804. * genflags:                             Passes.
  805. * GEN_ERRNO_RTX:                        Library Calls.
  806. * get_attr:                             Expressions.
  807. * get_attr_length:                      Insn Lengths.
  808. * GET_CLASS_NARROWEST_MODE:             Machine Modes.
  809. * GET_CODE:                             RTL Objects.
  810. * get_frame_size:                       Elimination.
  811. * get_insns:                            Insns.
  812. * get_last_insn:                        Insns.
  813. * GET_MODE:                             Machine Modes.
  814. * GET_MODE_ALIGNMENT:                   Machine Modes.
  815. * GET_MODE_BITSIZE:                     Machine Modes.
  816. * GET_MODE_CLASS:                       Machine Modes.
  817. * GET_MODE_MASK:                        Machine Modes.
  818. * GET_MODE_NAME:                        Machine Modes.
  819. * GET_MODE_NUNITS:                      Machine Modes.
  820. * GET_MODE_SIZE:                        Machine Modes.
  821. * GET_MODE_UNIT_SIZE:                   Machine Modes.
  822. * GET_MODE_WIDER_MODE:                  Machine Modes.
  823. * GET_RTX_CLASS:                        Accessors.
  824. * GET_RTX_FORMAT:                       Accessors.
  825. * GET_RTX_LENGTH:                       Accessors.
  826. * geu:                                  Comparisons.
  827. * global offset table:                  Code Gen Options.
  828. * global register after longjmp:        Global Reg Vars.
  829. * global register allocation:           Passes.
  830. * global register variables:            Global Reg Vars.
  831. * GLOBALDEF:                            Global Declarations.
  832. * GLOBALREF:                            Global Declarations.
  833. * GLOBALVALUEDEF:                       Global Declarations.
  834. * GLOBALVALUEREF:                       Global Declarations.
  835. * GNU CC and portability:               Portability.
  836. * GNU CC command options:               Invoking GCC.
  837. * GNU extensions to the C language:     Extensions.
  838. * goto with computed label:             Labels as Values.
  839. * GO_IF_LEGITIMATE_ADDRESS:             Addressing Modes.
  840. * GO_IF_MODE_DEPENDENT_ADDRESS:         Addressing Modes.
  841. * gp-relative references (MIPS):        MIPS Options.
  842. * greater than:                         Comparisons.
  843. * greater than:                         Comparisons.
  844. * greater than:                         Comparisons.
  845. * grouping options:                     Invoking GCC.
  846. * gt:                                   Comparisons.
  847. * gtu:                                  Comparisons.
  848. * HANDLE_PRAGMA:                        Misc.
  849. * hard registers:                       Regs and Memory.
  850. * hardware models and configurations, specifying: Submodel Options.
  851. * HARD_REGNO_MODE_OK:                   Values in Registers.
  852. * HARD_REGNO_NREGS:                     Values in Registers.
  853. * HAVE_ATEXIT:                          Misc.
  854. * HAVE_POST_DECREMENT:                  Addressing Modes.
  855. * HAVE_POST_INCREMENT:                  Addressing Modes.
  856. * HAVE_PRE_DECREMENT:                   Addressing Modes.
  857. * HAVE_PRE_INCREMENT:                   Addressing Modes.
  858. * HAVE_PUTENV:                          Config.
  859. * HAVE_VPRINTF:                         Config.
  860. * header files and VMS:                 Include Files and VMS.
  861. * high:                                 Constants.
  862. * HImode:                               Machine Modes.
  863. * HOST_BITS_PER_CHAR:                   Config.
  864. * HOST_BITS_PER_INT:                    Config.
  865. * HOST_BITS_PER_LONG:                   Config.
  866. * HOST_BITS_PER_SHORT:                  Config.
  867. * HOST_FLOAT_FORMAT:                    Config.
  868. * HOST_WORDS_BIG_ENDIAN:                Config.
  869. * HPPA Options:                         HPPA Options.
  870. * i386 Options:                         i386 Options.
  871. * IBM RS/6000 Options:                  RS/6000 Options.
  872. * IBM RT options:                       RT Options.
  873. * IBM RT PC:                            Interoperation.
  874. * identifier names, dollar signs in:    Dollar Signs.
  875. * identifiers, names in assembler code: Asm Labels.
  876. * identifying source, compiler (88k):   M88K Options.
  877. * IEEE_FLOAT_FORMAT:                    Storage Layout.
  878. * if_then_else:                         Comparisons.
  879. * immediate_operand:                    RTL Template.
  880. * IMMEDIATE_PREFIX:                     Instruction Output.
  881. * IMPLICIT_FIX_EXPR:                    Misc.
  882. * include files and VMS:                Include Files and VMS.
  883. * INCLUDE_DEFAULTS:                     Driver.
  884. * inclusive-or, bitwise:                Arithmetic.
  885. * incompatibilities of GNU CC:          Incompatibilities.
  886. * increment operators:                  Bug Criteria.
  887. * INDEX_REG_CLASS:                      Register Classes.
  888. * initialization routines:              Initialization.
  889. * initializations in expressions:       Constructors.
  890. * initializers with labeled elements:   Labeled Elements.
  891. * initializers, non-constant:           Initializers.
  892. * INITIALIZE_TRAMPOLINE:                Trampolines.
  893. * INITIAL_ELIMINATION_OFFSET:           Elimination.
  894. * INITIAL_FRAME_POINTER_OFFSET:         Elimination.
  895. * INIT_CUMULATIVE_ARGS:                 Register Arguments.
  896. * INIT_CUMULATIVE_INCOMING_ARGS:        Register Arguments.
  897. * INIT_SECTION_ASM_OP:                  Sections.
  898. * INIT_SECTION_ASM_OP:                  Macros for Initialization.
  899. * inline functions:                     Inline.
  900. * inline functions, omission of:        Inline.
  901. * inline, automatic:                    Passes.
  902. * insn:                                 Insns.
  903. * insn attributes:                      Insn Attributes.
  904. * insn canonicalization:                Insn Canonicalizations.
  905. * insn lengths, computing:              Insn Lengths.
  906. * insn splitting:                       Insn Splitting.
  907. * insn-attr.h:                          Defining Attributes.
  908. * insns:                                Insns.
  909. * insns, generating:                    RTL Template.
  910. * insns, recognizing:                   RTL Template.
  911. * INSN_ANNULLED_BRANCH_P:               Flags.
  912. * INSN_CACHE_DEPTH:                     Trampolines.
  913. * INSN_CACHE_LINE_WIDTH:                Trampolines.
  914. * INSN_CACHE_SIZE:                      Trampolines.
  915. * INSN_CLOBBERS_REGNO_P:                Obsolete Register Macros.
  916. * INSN_CODE:                            Insns.
  917. * INSN_DELETED_P:                       Flags.
  918. * INSN_FROM_TARGET_P:                   Flags.
  919. * insn_list:                            Insns.
  920. * INSN_UID:                             Insns.
  921. * installation trouble:                 Trouble.
  922. * installing GNU CC:                    Installation.
  923. * installing GNU CC on the 3b1:         3b1 Install.
  924. * installing GNU CC on the Sun:         Sun Install.
  925. * installing GNU CC on Unos:            Unos Install.
  926. * installing GNU CC on VMS:             VMS Install.
  927. * instruction attributes:               Insn Attributes.
  928. * instruction combination:              Passes.
  929. * instruction patterns:                 Patterns.
  930. * instruction recognizer:               Passes.
  931. * instruction scheduling:               Passes.
  932. * instruction scheduling:               Passes.
  933. * instruction splitting:                Insn Splitting.
  934. * integrated:                           Flags.
  935. * INTEGRATE_THRESHOLD:                  Misc.
  936. * integrating function code:            Inline.
  937. * Intel 386 Options:                    i386 Options.
  938. * Interdependence of Patterns:          Dependent Patterns.
  939. * interfacing to GNU CC output:         Interface.
  940. * INTIFY:                               Library Calls.
  941. * introduction:                         Top.
  942. * INT_TYPE_SIZE:                        Type Layout.
  943. * invalid assembly code:                Bug Criteria.
  944. * invalid input:                        Bug Criteria.
  945. * in_data:                              Sections.
  946. * in_struct:                            Flags.
  947. * in_text:                              Sections.
  948. * ior:                                  Arithmetic.
  949. * isinf:                                Cross-compilation.
  950. * isnan:                                Cross-compilation.
  951. * jump instruction patterns:            Jump Patterns.
  952. * jump instructions and set:            Side Effects.
  953. * jump optimization:                    Passes.
  954. * jump threading:                       Passes.
  955. * jump_insn:                            Insns.
  956. * JUMP_LABEL:                           Insns.
  957. * JUMP_TABLES_IN_TEXT_SECTION:          Sections.
  958. * keywords, alternate:                  Alternate Keywords.
  959. * known causes of trouble:              Trouble.
  960. * labeled elements in initializers:     Labeled Elements.
  961. * labels as values:                     Labels as Values.
  962. * LABEL_NUSES:                          Insns.
  963. * LABEL_OUTSIDE_LOOP_P:                 Flags.
  964. * LABEL_PRESERVE_P:                     Flags.
  965. * label_ref:                            Constants.
  966. * language dialect options:             Dialect Options.
  967. * large bit shifts (88k):               M88K Options.
  968. * large return values:                  Aggregate Return.
  969. * LAST_STACK_REG:                       Stack Registers.
  970. * LAST_VIRTUAL_REGISTER:                Regs and Memory.
  971. * ldexp:                                Cross-compilation.
  972. * le:                                   Comparisons.
  973. * leaf functions:                       Leaf Functions.
  974. * leaf_function:                        Leaf Functions.
  975. * leaf_function_p:                      Standard Names.
  976. * LEAF_REGISTERS:                       Leaf Functions.
  977. * LEAF_REG_REMAP:                       Leaf Functions.
  978. * left rotate:                          Arithmetic.
  979. * left shift:                           Arithmetic.
  980. * left shift:                           Arithmetic.
  981. * LEGITIMATE_CONSTANT_P:                Addressing Modes.
  982. * LEGITIMATE_PIC_OPERAND_P:             PIC.
  983. * LEGITIMIZE_ADDRESS:                   Addressing Modes.
  984. * length-zero arrays:                   Zero Length.
  985. * less than:                            Comparisons.
  986. * less than or equal:                   Comparisons.
  987. * leu:                                  Comparisons.
  988. * LIBCALL_VALUE:                        Scalar Return.
  989. * LIBGCC_NEEDS_DOUBLE:                  Library Calls.
  990. * Libraries:                            Link Options.
  991. * library subroutine names:             Library Calls.
  992. * LIBRARY_PATH:                         Environment Variables.
  993. * LIB_SPEC:                             Driver.
  994. * LIMIT_RELOAD_CLASS:                   Register Classes.
  995. * link options:                         Link Options.
  996. * LINK_LIBGCC_SPECIAL:                  Driver.
  997. * LINK_SPEC:                            Driver.
  998. * load address instruction:             Simple Constraints.
  999. * local labels:                         Local Labels.
  1000. * local register allocation:            Passes.
  1001. * local variables in macros:            Naming Types.
  1002. * local variables, specifying registers: Local Reg Vars.
  1003. * LOCAL_INCLUDE_DIR:                    Driver.
  1004. * LOCAL_LABEL_PREFIX:                   Instruction Output.
  1005. * logical shift:                        Arithmetic.
  1006. * logical-and, bitwise:                 Arithmetic.
  1007. * LOG_LINKS:                            Insns.
  1008. * longjmp:                              Global Reg Vars.
  1009. * LONGJMP_RESTORE_FROM_STACK:           Elimination.
  1010. * LONG_DOUBLE_TYPE_SIZE:                Type Layout.
  1011. * LONG_LONG_TYPE_SIZE:                  Type Layout.
  1012. * LONG_TYPE_SIZE:                       Type Layout.
  1013. * loop optimization:                    Passes.
  1014. * lo_sum:                               Arithmetic.
  1015. * lshift:                               Arithmetic.
  1016. * lshiftrt:                             Arithmetic.
  1017. * lt:                                   Comparisons.
  1018. * ltu:                                  Comparisons.
  1019. * lvalues, generalized:                 Lvalues.
  1020. * M680x0 options:                       M680x0 Options.
  1021. * M88k options:                         M88K Options.
  1022. * machine dependent options:            Submodel Options.
  1023. * machine description macros:           Target Macros.
  1024. * machine descriptions:                 Machine Desc.
  1025. * machine mode conversions:             Conversions.
  1026. * machine modes:                        Machine Modes.
  1027. * macro with variable arguments:        Macro Varargs.
  1028. * macros containing asm:                Extended Asm.
  1029. * macros, inline alternative:           Inline.
  1030. * macros, local labels:                 Local Labels.
  1031. * macros, local variables in:           Naming Types.
  1032. * macros, statements in expressions:    Statement Exprs.
  1033. * macros, target description:           Target Macros.
  1034. * macros, types of arguments:           Typeof.
  1035. * make:                                 Preprocessor Options.
  1036. * make_safe_from:                       Expander Definitions.
  1037. * matching constraint:                  Simple Constraints.
  1038. * matching operands:                    Output Template.
  1039. * match_dup:                            RTL Template.
  1040. * match_operand:                        RTL Template.
  1041. * match_operator:                       RTL Template.
  1042. * match_op_dup:                         RTL Template.
  1043. * match_parallel:                       RTL Template.
  1044. * match_par_dup:                        RTL Template.
  1045. * match_scratch:                        RTL Template.
  1046. * math libraries:                       Interface.
  1047. * math, in RTL:                         Arithmetic.
  1048. * MAX_BITS_PER_WORD:                    Storage Layout.
  1049. * MAX_FIXED_MODE_SIZE:                  Storage Layout.
  1050. * MAX_OFILE_ALIGNMENT:                  Storage Layout.
  1051. * MAX_REGS_PER_ADDRESS:                 Addressing Modes.
  1052. * MAYBE_REG_PARM_STACK_SPACE:           Stack Arguments.
  1053. * mcount:                               Profiling.
  1054. * MD_CALL_PROTOTYPES:                   Config.
  1055. * MD_EXEC_PREFIX:                       Driver.
  1056. * MD_STARTFILE_PREFIX:                  Driver.
  1057. * MD_STARTFILE_PREFIX_1:                Driver.
  1058. * mem:                                  Regs and Memory.
  1059. * memory reference, nonoffsettable:     Simple Constraints.
  1060. * memory references in constraints:     Simple Constraints.
  1061. * MEMORY_MOVE_COST:                     Costs.
  1062. * MEM_IN_STRUCT_P:                      Flags.
  1063. * MEM_VOLATILE_P:                       Flags.
  1064. * messages, warning:                    Warning Options.
  1065. * middle-operands, omitted:             Conditionals.
  1066. * minus:                                Arithmetic.
  1067. * MIPS options:                         MIPS Options.
  1068. * mod:                                  Arithmetic.
  1069. * MODDI3_LIBCALL:                       Library Calls.
  1070. * mode classes:                         Machine Modes.
  1071. * MODES_TIEABLE_P:                      Values in Registers.
  1072. * MODE_CC:                              Machine Modes.
  1073. * MODE_COMPLEX_FLOAT:                   Machine Modes.
  1074. * MODE_COMPLEX_INT:                     Machine Modes.
  1075. * MODE_FLOAT:                           Machine Modes.
  1076. * MODE_FUNCTION:                        Machine Modes.
  1077. * MODE_INT:                             Machine Modes.
  1078. * MODE_PARTIAL_INT:                     Machine Modes.
  1079. * MODE_RANDOM:                          Machine Modes.
  1080. * modifiers in constraints:             Modifiers.
  1081. * MODSI3_LIBCALL:                       Library Calls.
  1082. * MOVE_MAX:                             Misc.
  1083. * MOVE_RATIO:                           Costs.
  1084. * MULDI3_LIBCALL:                       Library Calls.
  1085. * MULSI3_LIBCALL:                       Library Calls.
  1086. * mult:                                 Arithmetic.
  1087. * MULTIBYTE_CHARS:                      Config.
  1088. * multiple alternative constraints:     Multi-Alternative.
  1089. * multiplication:                       Arithmetic.
  1090. * multiprecision arithmetic:            Long Long.
  1091. * name augmentation:                    VMS Misc.
  1092. * named patterns and conditions:        Patterns.
  1093. * names used in assembler code:         Asm Labels.
  1094. * names, pattern:                       Standard Names.
  1095. * naming types:                         Naming Types.
  1096. * ne:                                   Comparisons.
  1097. * neg:                                  Arithmetic.
  1098. * nested functions:                     Nested Functions.
  1099. * nested functions, trampolines for:    Trampolines.
  1100. * next_cc0_user:                        Jump Patterns.
  1101. * NEXT_INSN:                            Insns.
  1102. * NEXT_OBJC_RUNTIME:                    Library Calls.
  1103. * nil:                                  RTL Objects.
  1104. * no constraints:                       No Constraints.
  1105. * no-op move instructions:              Passes.
  1106. * non-constant initializers:            Initializers.
  1107. * non-static inline function:           Inline.
  1108. * nongcc_SI_type:                       Library Calls.
  1109. * nonoffsettable memory reference:      Simple Constraints.
  1110. * NON_SAVING_SETJMP:                    Register Basics.
  1111. * not:                                  Arithmetic.
  1112. * not equal:                            Comparisons.
  1113. * not using constraints:                No Constraints.
  1114. * note:                                 Insns.
  1115. * NOTE_INSN_BLOCK_BEG:                  Insns.
  1116. * NOTE_INSN_BLOCK_END:                  Insns.
  1117. * NOTE_INSN_DELETED:                    Insns.
  1118. * NOTE_INSN_FUNCTION_END:               Insns.
  1119. * NOTE_INSN_LOOP_BEG:                   Insns.
  1120. * NOTE_INSN_LOOP_CONT:                  Insns.
  1121. * NOTE_INSN_LOOP_END:                   Insns.
  1122. * NOTE_INSN_LOOP_VTOP:                  Insns.
  1123. * NOTE_INSN_SETJMP:                     Insns.
  1124. * NOTE_LINE_NUMBER:                     Insns.
  1125. * NOTE_SOURCE_FILE:                     Insns.
  1126. * NOTICE_UPDATE_CC:                     Condition Code.
  1127. * NO_DOLLAR_IN_LABEL:                   Misc.
  1128. * NO_FUNCTION_CSE:                      Costs.
  1129. * NO_MD_PROTOTYPES:                     Config.
  1130. * NO_RECURSIVE_FUNCTION_CSE:            Costs.
  1131. * NO_REGS:                              Register Classes.
  1132. * NO_STAB_H:                            Config.
  1133. * NO_SYS_SIGLIST:                       Config.
  1134. * NUM_MACHINE_MODES:                    Machine Modes.
  1135. * N_REG_CLASSES:                        Register Classes.
  1136. * OBJC_GEN_METHOD_LABEL:                Label Output.
  1137. * OBJC_INCLUDE_PATH:                    Environment Variables.
  1138. * OBJC_INT_SELECTORS:                   Type Layout.
  1139. * OBJC_PROLOGUE:                        File Framework.
  1140. * OBJC_SELECTORS_WITHOUT_LABELS:        Type Layout.
  1141. * OBJECT_FORMAT_COFF:                   Macros for Initialization.
  1142. * OBJECT_FORMAT_ROSE:                   Macros for Initialization.
  1143. * OBSTACK_CHUNK_ALLOC:                  Config.
  1144. * OBSTACK_CHUNK_FREE:                   Config.
  1145. * OBSTACK_CHUNK_SIZE:                   Config.
  1146. * obstack_free:                         3b1 Install.
  1147. * OCS (88k):                            M88K Options.
  1148. * offsettable address:                  Simple Constraints.
  1149. * old-style function definitions:       Function Prototypes.
  1150. * omitted middle-operands:              Conditionals.
  1151. * ONLY_INT_FIELDS:                      Config.
  1152. * open coding:                          Inline.
  1153. * operand access:                       Accessors.
  1154. * operand constraints:                  Constraints.
  1155. * operand substitution:                 Output Template.
  1156. * operands:                             Patterns.
  1157. * OPTIMIZATION_OPTIONS:                 Run-time Target.
  1158. * optimize options:                     Optimize Options.
  1159. * optional hardware or system features: Run-time Target.
  1160. * options to control warnings:          Warning Options.
  1161. * options, code generation:             Code Gen Options.
  1162. * options, debugging:                   Debugging Options.
  1163. * options, dialect:                     Dialect Options.
  1164. * options, directory search:            Directory Options.
  1165. * options, GNU CC command:              Invoking GCC.
  1166. * options, grouping:                    Invoking GCC.
  1167. * options, linking:                     Link Options.
  1168. * options, optimization:                Optimize Options.
  1169. * options, order:                       Invoking GCC.
  1170. * options, preprocessor:                Preprocessor Options.
  1171. * order of options:                     Invoking GCC.
  1172. * order of register allocation:         Allocation Order.
  1173. * Ordering of Patterns:                 Pattern Ordering.
  1174. * ORDER_REGS_FOR_LOCAL_ALLOC:           Allocation Order.
  1175. * other directory, compilation in:      Other Dir.
  1176. * OUTGOING_REG_PARM_STACK_SPACE:        Stack Arguments.
  1177. * output file option:                   Overall Options.
  1178. * output of assembler code:             File Framework.
  1179. * output statements:                    Output Statement.
  1180. * output templates:                     Output Template.
  1181. * output_addr_const:                    Data Output.
  1182. * output_asm_insn:                      Output Statement.
  1183. * overflow while constant folding:      Cross-compilation.
  1184. * OVERLAPPING_REGNO_P:                  Obsolete Register Macros.
  1185. * OVERRIDE_OPTIONS:                     Run-time Target.
  1186. * parallel:                             Side Effects.
  1187. * parameter forward declaration:        Variable Length.
  1188. * parameters, miscellaneous:            Misc.
  1189. * PARM_BOUNDARY:                        Storage Layout.
  1190. * parser generator, Bison:              Installation.
  1191. * parsing pass:                         Passes.
  1192. * passes and files of the compiler:     Passes.
  1193. * passing arguments:                    Interface.
  1194. * PATTERN:                              Insns.
  1195. * pattern conditions:                   Patterns.
  1196. * pattern names:                        Standard Names.
  1197. * Pattern Ordering:                     Pattern Ordering.
  1198. * patterns:                             Patterns.
  1199. * pc:                                   Regs and Memory.
  1200. * PCC_BITFIELD_TYPE_MATTERS:            Storage Layout.
  1201. * PCC_STATIC_STRUCT_RETURN:             Aggregate Return.
  1202. * pc_rtx:                               Regs and Memory.
  1203. * PDImode:                              Machine Modes.
  1204. * peephole optimization:                Passes.
  1205. * peephole optimization, RTL representation: Side Effects.
  1206. * peephole optimizer definitions:       Peephole Definitions.
  1207. * percent sign:                         Output Template.
  1208. * perform_...:                          Library Calls.
  1209. * PIC:                                  Code Gen Options.
  1210. * PIC:                                  PIC.
  1211. * PIC_OFFSET_TABLE_REGNUM:              PIC.
  1212. * plus:                                 Arithmetic.
  1213. * Pmode:                                Misc.
  1214. * pointer arguments:                    Function Attributes.
  1215. * POINTER_SIZE:                         Storage Layout.
  1216. * portability:                          Portability.
  1217. * position independent code:            PIC.
  1218. * post_dec:                             Incdec.
  1219. * post_inc:                             Incdec.
  1220. * pragma:                               Misc.
  1221. * pragma, reason for not using:         Function Attributes.
  1222. * predefined macros:                    Run-time Target.
  1223. * PREDICATE_CODES:                      Misc.
  1224. * PREFERRED_OUTPUT_RELOAD_CLASS:        Register Classes.
  1225. * PREFERRED_RELOAD_CLASS:               Register Classes.
  1226. * preprocessor options:                 Preprocessor Options.
  1227. * PRESERVE_DEATH_INFO_REGNO_P:          Obsolete Register Macros.
  1228. * prev_cc0_setter:                      Jump Patterns.
  1229. * PREV_INSN:                            Insns.
  1230. * prev_nonnote_insn:                    Peephole Definitions.
  1231. * pre_dec:                              Incdec.
  1232. * pre_inc:                              Incdec.
  1233. * PRINT_OPERAND:                        Instruction Output.
  1234. * PRINT_OPERAND_ADDRESS:                Instruction Output.
  1235. * PRINT_OPERAND_PUNCT_VALID_P:          Instruction Output.
  1236. * product:                              Arithmetic.
  1237. * PROFILE_BEFORE_PROLOGUE:              Profiling.
  1238. * profiling, code generation:           Profiling.
  1239. * program counter:                      Regs and Memory.
  1240. * prologue:                             Function Entry.
  1241. * PROMOTE_FUNCTION_ARGS:                Storage Layout.
  1242. * PROMOTE_FUNCTION_RETURN:              Storage Layout.
  1243. * PROMOTE_MODE:                         Storage Layout.
  1244. * PROMOTE_PROTOTYPES:                   Stack Arguments.
  1245. * promotion of formal parameters:       Function Prototypes.
  1246. * pseudo registers:                     Regs and Memory.
  1247. * PSImode:                              Machine Modes.
  1248. * PTRDIFF_TYPE:                         Type Layout.
  1249. * push address instruction:             Simple Constraints.
  1250. * PUSH_ROUNDING:                        Stack Arguments.
  1251. * putenv:                               Config.
  1252. * PUT_CODE:                             RTL Objects.
  1253. * PUT_MODE:                             Machine Modes.
  1254. * PUT_REG_NOTE_KIND:                    Insns.
  1255. * PUT_SDB_...:                          SDB and DWARF.
  1256. * QImode:                               Machine Modes.
  1257. * question mark:                        Multi-Alternative.
  1258. * quotient:                             Arithmetic.
  1259. * r0-relative references (88k):         M88K Options.
  1260. * ranges in case statements:            Case Ranges.
  1261. * read-only strings:                    Incompatibilities.
  1262. * READONLY_DATA_SECTION:                Sections.
  1263. * REAL_ARITHMETIC:                      Cross-compilation.
  1264. * REAL_INFINITY:                        Cross-compilation.
  1265. * REAL_NM_FILE_NAME:                    Macros for Initialization.
  1266. * REAL_VALUES_EQUAL:                    Cross-compilation.
  1267. * REAL_VALUES_LESS:                     Cross-compilation.
  1268. * REAL_VALUE_ATOF:                      Cross-compilation.
  1269. * REAL_VALUE_FIX:                       Cross-compilation.
  1270. * REAL_VALUE_FIX_TRUNCATE:              Cross-compilation.
  1271. * REAL_VALUE_FROM_INT:                  Cross-compilation.
  1272. * REAL_VALUE_ISINF:                     Cross-compilation.
  1273. * REAL_VALUE_ISNAN:                     Cross-compilation.
  1274. * REAL_VALUE_LDEXP:                     Cross-compilation.
  1275. * REAL_VALUE_NEGATE:                    Cross-compilation.
  1276. * REAL_VALUE_TO_INT:                    Cross-compilation.
  1277. * REAL_VALUE_TRUNCATE:                  Cross-compilation.
  1278. * REAL_VALUE_TYPE:                      Cross-compilation.
  1279. * REAL_VALUE_UNSIGNED_FIX:              Cross-compilation.
  1280. * REAL_VALUE_UNSIGNED_FIX_TRUNCATE:     Cross-compilation.
  1281. * recognizing insns:                    RTL Template.
  1282. * recog_operand:                        Instruction Output.
  1283. * reg:                                  Regs and Memory.
  1284. * register allocation:                  Passes.
  1285. * register allocation order:            Allocation Order.
  1286. * register allocation, stupid:          Passes.
  1287. * register class definitions:           Register Classes.
  1288. * register class preference constraints: Class Preferences.
  1289. * register class preference pass:       Passes.
  1290. * register pairs:                       Values in Registers.
  1291. * register positions in frame (88k):    M88K Options.
  1292. * register positions in frame (88k):    M88K Options.
  1293. * Register Transfer Language (RTL):     RTL.
  1294. * register usage:                       Registers.
  1295. * register use analysis:                Passes.
  1296. * register variable after longjmp:      Global Reg Vars.
  1297. * register-to-stack conversion:         Passes.
  1298. * registers:                            Extended Asm.
  1299. * registers arguments:                  Register Arguments.
  1300. * registers for local variables:        Local Reg Vars.
  1301. * registers in constraints:             Simple Constraints.
  1302. * registers, global allocation:         Explicit Reg Vars.
  1303. * registers, global variables in:       Global Reg Vars.
  1304. * REGISTER_MOVE_COST:                   Costs.
  1305. * REGISTER_NAMES:                       Instruction Output.
  1306. * register_operand:                     RTL Template.
  1307. * REGISTER_PREFIX:                      Instruction Output.
  1308. * REGNO_OK_FOR_BASE_P:                  Register Classes.
  1309. * REGNO_OK_FOR_INDEX_P:                 Register Classes.
  1310. * REGNO_REG_CLASS:                      Register Classes.
  1311. * regs_ever_live:                       Function Entry.
  1312. * REG_ALLOC_ORDER:                      Allocation Order.
  1313. * REG_CC_SETTER:                        Insns.
  1314. * REG_CC_USER:                          Insns.
  1315. * REG_CLASS_CONTENTS:                   Register Classes.
  1316. * REG_CLASS_FROM_LETTER:                Register Classes.
  1317. * REG_CLASS_NAMES:                      Register Classes.
  1318. * REG_DEAD:                             Insns.
  1319. * REG_DEP_ANTI:                         Insns.
  1320. * REG_DEP_OUTPUT:                       Insns.
  1321. * REG_EQUAL:                            Insns.
  1322. * REG_EQUIV:                            Insns.
  1323. * REG_FUNCTION_VALUE_P:                 Flags.
  1324. * REG_INC:                              Insns.
  1325. * REG_LABEL:                            Insns.
  1326. * REG_LEAF_ALLOC_ORDER:                 Leaf Functions.
  1327. * REG_LIBCALL:                          Insns.
  1328. * REG_LOOP_TEST_P:                      Flags.
  1329. * reg_names:                            Instruction Output.
  1330. * REG_NONNEG:                           Insns.
  1331. * REG_NOTES:                            Insns.
  1332. * REG_NOTE_KIND:                        Insns.
  1333. * REG_NO_CONFLICT:                      Insns.
  1334. * REG_OK_FOR_BASE_P:                    Addressing Modes.
  1335. * REG_OK_FOR_INDEX_P:                   Addressing Modes.
  1336. * REG_OK_STRICT:                        Addressing Modes.
  1337. * REG_PARM_STACK_SPACE:                 Stack Arguments.
  1338. * REG_RETVAL:                           Insns.
  1339. * REG_UNUSED:                           Insns.
  1340. * REG_USERVAR_P:                        Flags.
  1341. * REG_WAS_0:                            Insns.
  1342. * relative costs:                       Costs.
  1343. * RELATIVE_PREFIX_NOT_LINKDIR:          Driver.
  1344. * reload pass:                          Regs and Memory.
  1345. * reloading:                            Passes.
  1346. * reload_completed:                     Standard Names.
  1347. * reload_in_progress:                   Standard Names.
  1348. * remainder:                            Arithmetic.
  1349. * reporting bugs:                       Bugs.
  1350. * representation of RTL:                RTL.
  1351. * rest argument (in macro):             Macro Varargs.
  1352. * rest_of_compilation:                  Passes.
  1353. * rest_of_decl_compilation:             Passes.
  1354. * return:                               Side Effects.
  1355. * return value of main:                 VMS Misc.
  1356. * return values in registers:           Scalar Return.
  1357. * returning aggregate values:           Aggregate Return.
  1358. * returning structures and unions:      Interface.
  1359. * RETURN_IN_MEMORY:                     Aggregate Return.
  1360. * RETURN_POPS_ARGS:                     Stack Arguments.
  1361. * right rotate:                         Arithmetic.
  1362. * right shift:                          Arithmetic.
  1363. * rotate:                               Arithmetic.
  1364. * rotate:                               Arithmetic.
  1365. * rotatert:                             Arithmetic.
  1366. * ROUND_TYPE_ALIGN:                     Storage Layout.
  1367. * ROUND_TYPE_SIZE:                      Storage Layout.
  1368. * RS/6000 Options:                      RS/6000 Options.
  1369. * RT options:                           RT Options.
  1370. * RT PC:                                Interoperation.
  1371. * RTL addition:                         Arithmetic.
  1372. * RTL comparison:                       Arithmetic.
  1373. * RTL comparison operations:            Comparisons.
  1374. * RTL constant expression types:        Constants.
  1375. * RTL constants:                        Constants.
  1376. * RTL declarations:                     RTL Declarations.
  1377. * RTL difference:                       Arithmetic.
  1378. * RTL expression:                       RTL Objects.
  1379. * RTL expressions for arithmetic:       Arithmetic.
  1380. * RTL format:                           Accessors.
  1381. * RTL format characters:                Accessors.
  1382. * RTL function-call insns:              Calls.
  1383. * RTL generation:                       Passes.
  1384. * RTL insn template:                    RTL Template.
  1385. * RTL integers:                         RTL Objects.
  1386. * RTL memory expressions:               Regs and Memory.
  1387. * RTL object types:                     RTL Objects.
  1388. * RTL postdecrement:                    Incdec.
  1389. * RTL postincrement:                    Incdec.
  1390. * RTL predecrement:                     Incdec.
  1391. * RTL preincrement:                     Incdec.
  1392. * RTL register expressions:             Regs and Memory.
  1393. * RTL representation:                   RTL.
  1394. * RTL side effect expressions:          Side Effects.
  1395. * RTL strings:                          RTL Objects.
  1396. * RTL structure sharing assumptions:    Sharing.
  1397. * RTL subtraction:                      Arithmetic.
  1398. * RTL sum:                              Arithmetic.
  1399. * RTL vectors:                          RTL Objects.
  1400. * RTX (See RTL):                        RTL Objects.
  1401. * RTX_COSTS:                            Costs.
  1402. * RTX_INTEGRATED_P:                     Flags.
  1403. * RTX_UNCHANGING_P:                     Flags.
  1404. * run-time conventions:                 Interface.
  1405. * run-time options:                     Code Gen Options.
  1406. * run-time target specification:        Run-time Target.
  1407. * saveable_obstack:                     Addressing Modes.
  1408. * scalars, returned as values:          Scalar Return.
  1409. * SCCS_DIRECTIVE:                       Misc.
  1410. * scheduling, delayed branch:           Passes.
  1411. * scheduling, instruction:              Passes.
  1412. * scheduling, instruction:              Passes.
  1413. * SCHED_GROUP_P:                        Flags.
  1414. * SCmode:                               Machine Modes.
  1415. * scope of a variable length array:     Variable Length.
  1416. * scope of declaration:                 Disappointments.
  1417. * scope of external declarations:       Incompatibilities.
  1418. * scratch:                              Regs and Memory.
  1419. * scratch operands:                     Regs and Memory.
  1420. * SDB_ALLOW_FORWARD_REFERENCES:         SDB and DWARF.
  1421. * SDB_ALLOW_UNKNOWN_REFERENCES:         SDB and DWARF.
  1422. * SDB_DEBUGGING_INFO:                   SDB and DWARF.
  1423. * SDB_DELIM:                            SDB and DWARF.
  1424. * SDB_GENERATE_FAKE:                    SDB and DWARF.
  1425. * search path:                          Directory Options.
  1426. * SECONDARY_INPUT_RELOAD_CLASS:         Register Classes.
  1427. * SECONDARY_MEMORY_NEEDED:              Register Classes.
  1428. * SECONDARY_OUTPUT_RELOAD_CLASS:        Register Classes.
  1429. * SECONDARY_RELOAD_CLASS:               Register Classes.
  1430. * SELECT_CC_MODE:                       Condition Code.
  1431. * SELECT_RTX_SECTION:                   Sections.
  1432. * SELECT_SECTION:                       Sections.
  1433. * separate directory, compilation in:   Other Dir.
  1434. * sequence:                             Side Effects.
  1435. * sequential consistency on 88k:        M88K Options.
  1436. * set:                                  Side Effects.
  1437. * setjmp:                               Global Reg Vars.
  1438. * SETUP_INCOMING_VARARGS:               Varargs.
  1439. * set_attr:                             Tagging Insns.
  1440. * set_attr_alternative:                 Tagging Insns.
  1441. * SET_DEST:                             Side Effects.
  1442. * SET_SRC:                              Side Effects.
  1443. * SFmode:                               Machine Modes.
  1444. * shared strings:                       Incompatibilities.
  1445. * shared VMS run time system:           VMS Misc.
  1446. * SHARED_SECTION_ASM_OP:                Sections.
  1447. * sharing of RTL components:            Sharing.
  1448. * shift:                                Arithmetic.
  1449. * SHIFT_COUNT_TRUNCATED:                Misc.
  1450. * SHORT_TYPE_SIZE:                      Type Layout.
  1451. * side effect in ?::                    Conditionals.
  1452. * side effects, macro argument:         Statement Exprs.
  1453. * signed division:                      Arithmetic.
  1454. * signed maximum:                       Arithmetic.
  1455. * signed minimum:                       Arithmetic.
  1456. * SIGNED_CHAR_SPEC:                     Driver.
  1457. * sign_extend:                          Conversions.
  1458. * sign_extract:                         Bit Fields.
  1459. * SImode:                               Machine Modes.
  1460. * simple constraints:                   Simple Constraints.
  1461. * simplifications, arithmetic:          Passes.
  1462. * sizeof:                               Typeof.
  1463. * SIZE_TYPE:                            Type Layout.
  1464. * SLOW_BYTE_ACCESS:                     Costs.
  1465. * SLOW_UNALIGNED_ACCESS:                Costs.
  1466. * SLOW_ZERO_EXTEND:                     Costs.
  1467. * smaller data references (88k):        M88K Options.
  1468. * smaller data references (MIPS):       MIPS Options.
  1469. * SMALL_REGISTER_CLASSES:               Register Classes.
  1470. * smax:                                 Arithmetic.
  1471. * smin:                                 Arithmetic.
  1472. * SPARC options:                        Sparc Options.
  1473. * specified registers:                  Explicit Reg Vars.
  1474. * specifying compiler version and target machine: Target Options.
  1475. * specifying hardware config:           Submodel Options.
  1476. * specifying machine version:           Target Options.
  1477. * specifying registers for local variables: Local Reg Vars.
  1478. * speed of instructions:                Costs.
  1479. * splitting instructions:               Insn Splitting.
  1480. * sqrt:                                 Arithmetic.
  1481. * square root:                          Arithmetic.
  1482. * stack arguments:                      Stack Arguments.
  1483. * stack frame layout:                   Frame Layout.
  1484. * STACK_BOUNDARY:                       Storage Layout.
  1485. * STACK_DYNAMIC_OFFSET:                 Frame Layout.
  1486. * STACK_GROWS_DOWNWARD:                 Frame Layout.
  1487. * STACK_PARMS_IN_REG_PARM_AREA:         Stack Arguments.
  1488. * STACK_POINTER_OFFSET:                 Frame Layout.
  1489. * STACK_POINTER_REGNUM:                 Frame Registers.
  1490. * stack_pointer_rtx:                    Frame Registers.
  1491. * STACK_REGS:                           Stack Registers.
  1492. * stage1:                               Installation.
  1493. * standard pattern names:               Standard Names.
  1494. * STANDARD_EXEC_PREFIX:                 Driver.
  1495. * STANDARD_INCLUDE_DIR:                 Driver.
  1496. * STANDARD_STARTFILE_PREFIX:            Driver.
  1497. * STARTFILE_SPEC:                       Driver.
  1498. * STARTING_FRAME_OFFSET:                Frame Layout.
  1499. * statements inside expressions:        Statement Exprs.
  1500. * STATIC_CHAIN:                         Frame Registers.
  1501. * STATIC_CHAIN_INCOMING:                Frame Registers.
  1502. * STATIC_CHAIN_INCOMING_REGNUM:         Frame Registers.
  1503. * STATIC_CHAIN_REGNUM:                  Frame Registers.
  1504. * STDC_VALUE:                           Run-time Target.
  1505. * storage layout:                       Storage Layout.
  1506. * STORE_FLAG_VALUE:                     Misc.
  1507. * strcpy:                               Storage Layout.
  1508. * strength-reduction:                   Passes.
  1509. * STRICT_ALIGNMENT:                     Storage Layout.
  1510. * strict_low_part:                      RTL Declarations.
  1511. * string constants:                     Incompatibilities.
  1512. * STRIP_NAME_ENCODING:                  Sections.
  1513. * structure passing (88k):              M88K Options.
  1514. * structure value address:              Aggregate Return.
  1515. * structures:                           Incompatibilities.
  1516. * structures, constructor expression:   Constructors.
  1517. * structures, returning:                Interface.
  1518. * STRUCTURE_SIZE_BOUNDARY:              Storage Layout.
  1519. * STRUCT_VALUE:                         Aggregate Return.
  1520. * STRUCT_VALUE_INCOMING:                Aggregate Return.
  1521. * STRUCT_VALUE_INCOMING_REGNUM:         Aggregate Return.
  1522. * STRUCT_VALUE_REGNUM:                  Aggregate Return.
  1523. * stupid register allocation:           Passes.
  1524. * submodel options:                     Submodel Options.
  1525. * subreg:                               Regs and Memory.
  1526. * SUBREG_PROMOTED_UNSIGNED_P:           Flags.
  1527. * SUBREG_PROMOTED_VAR_P:                Flags.
  1528. * SUBREG_REG:                           Regs and Memory.
  1529. * SUBREG_WORD:                          Regs and Memory.
  1530. * subscripting:                         Subscripting.
  1531. * subscripting and function values:     Subscripting.
  1532. * SUCCESS_EXIT_CODE:                    Config.
  1533. * Sun installation:                     Sun Install.
  1534. * suppressing warnings:                 Warning Options.
  1535. * SVr4:                                 M88K Options.
  1536. * SWITCHES_NEED_SPACES:                 Driver.
  1537. * SWITCH_TAKES_ARG:                     Driver.
  1538. * symbolic label:                       Sharing.
  1539. * symbol_ref:                           Constants.
  1540. * SYMBOL_REF_FLAG:                      Flags.
  1541. * SYMBOL_REF_USED:                      Flags.
  1542. * syntax checking:                      Warning Options.
  1543. * SYSTEM_INCLUDE_DIR:                   Driver.
  1544. * sys_siglist:                          Config.
  1545. * tagging insns:                        Tagging Insns.
  1546. * tail recursion optimization:          Passes.
  1547. * target description macros:            Target Macros.
  1548. * target machine, specifying:           Target Options.
  1549. * target options:                       Target Options.
  1550. * target specifications:                Run-time Target.
  1551. * target-parameter-dependent code:      Passes.
  1552. * TARGET_BELL:                          Type Layout.
  1553. * TARGET_BS:                            Type Layout.
  1554. * TARGET_CR:                            Type Layout.
  1555. * TARGET_EDOM:                          Library Calls.
  1556. * TARGET_FF:                            Type Layout.
  1557. * TARGET_FLOAT_FORMAT:                  Storage Layout.
  1558. * TARGET_MEM_FUNCTIONS:                 Library Calls.
  1559. * TARGET_NEWLINE:                       Type Layout.
  1560. * TARGET_OPTIONS:                       Run-time Target.
  1561. * TARGET_SWITCHES:                      Run-time Target.
  1562. * TARGET_TAB:                           Type Layout.
  1563. * TARGET_VERSION:                       Run-time Target.
  1564. * TARGET_VT:                            Type Layout.
  1565. * TCmode:                               Machine Modes.
  1566. * termination routines:                 Initialization.
  1567. * text_section:                         Sections.
  1568. * TEXT_SECTION_ASM_OP:                  Sections.
  1569. * TFmode:                               Machine Modes.
  1570. * thunks:                               Nested Functions.
  1571. * TImode:                               Machine Modes.
  1572. * TMPDIR:                               Environment Variables.
  1573. * top level of compiler:                Passes.
  1574. * traditional C language:               Dialect Options.
  1575. * TRADITIONAL_RETURN_FLOAT:             Scalar Return.
  1576. * trampolines for nested functions:     Trampolines.
  1577. * TRAMPOLINE_ALIGNMENT:                 Trampolines.
  1578. * TRAMPOLINE_SECTION:                   Trampolines.
  1579. * TRAMPOLINE_SIZE:                      Trampolines.
  1580. * TRAMPOLINE_TEMPLATE:                  Trampolines.
  1581. * TRANSFER_FROM_TRAMPOLINE:             Trampolines.
  1582. * TRULY_NOOP_TRUNCATION:                Misc.
  1583. * truncate:                             Conversions.
  1584. * type alignment:                       Alignment.
  1585. * typedef names as function parameters: Incompatibilities.
  1586. * typeof:                               Typeof.
  1587. * udiv:                                 Arithmetic.
  1588. * UDIVDI3_LIBCALL:                      Library Calls.
  1589. * UDIVSI3_LIBCALL:                      Library Calls.
  1590. * Ultrix calling convention:            Interoperation.
  1591. * umax:                                 Arithmetic.
  1592. * umin:                                 Arithmetic.
  1593. * umod:                                 Arithmetic.
  1594. * UMODDI3_LIBCALL:                      Library Calls.
  1595. * UMODSI3_LIBCALL:                      Library Calls.
  1596. * unchanging:                           Flags.
  1597. * undefined behavior:                   Bug Criteria.
  1598. * undefined function value:             Bug Criteria.
  1599. * underscores in variables in macros:   Naming Types.
  1600. * underscores, avoiding (88k):          M88K Options.
  1601. * union, casting to a:                  Cast to Union.
  1602. * unions:                               Incompatibilities.
  1603. * unions, returning:                    Interface.
  1604. * UNITS_PER_WORD:                       Storage Layout.
  1605. * UNKNOWN_FLOAT_FORMAT:                 Storage Layout.
  1606. * Unos installation:                    Unos Install.
  1607. * unreachable code:                     Passes.
  1608. * unshare_all_rtl:                      Sharing.
  1609. * unsigned division:                    Arithmetic.
  1610. * unsigned greater than:                Comparisons.
  1611. * unsigned greater than:                Comparisons.
  1612. * unsigned less than:                   Comparisons.
  1613. * unsigned less than:                   Comparisons.
  1614. * unsigned minimum and maximum:         Arithmetic.
  1615. * unsigned_fix:                         Conversions.
  1616. * unsigned_float:                       Conversions.
  1617. * unspec:                               Side Effects.
  1618. * unspec_volatile:                      Side Effects.
  1619. * use:                                  Side Effects.
  1620. * used:                                 Flags.
  1621. * USER_LABEL_PREFIX:                    Instruction Output.
  1622. * USE_C_ALLOCA:                         Config.
  1623. * USE_PROTOTYPES:                       Config.
  1624. * USG:                                  Config.
  1625. * value after longjmp:                  Global Reg Vars.
  1626. * values, returned by functions:        Scalar Return.
  1627. * varargs implementation:               Varargs.
  1628. * variable alignment:                   Alignment.
  1629. * variable attributes:                  Variable Attributes.
  1630. * variable number of arguments:         Macro Varargs.
  1631. * variable-length array scope:          Variable Length.
  1632. * variable-length arrays:               Variable Length.
  1633. * variables in specified registers:     Explicit Reg Vars.
  1634. * variables, local, in macros:          Naming Types.
  1635. * Vax calling convention:               Interoperation.
  1636. * VAX options:                          VAX Options.
  1637. * VAX_FLOAT_FORMAT:                     Storage Layout.
  1638. * VIRTUAL_INCOMING_ARGS_REGNUM:         Regs and Memory.
  1639. * VIRTUAL_OUTGOING_ARGS_REGNUM:         Regs and Memory.
  1640. * VIRTUAL_STACK_DYNAMIC_REGNUM:         Regs and Memory.
  1641. * VIRTUAL_STACK_VARS_REGNUM:            Regs and Memory.
  1642. * VMS:                                  Config.
  1643. * VMS and case sensitivity:             VMS Misc.
  1644. * VMS and include files:                Include Files and VMS.
  1645. * VMS installation:                     VMS Install.
  1646. * void pointers, arithmetic:            Pointer Arith.
  1647. * void, size of pointer to:             Pointer Arith.
  1648. * VOIDmode:                             Machine Modes.
  1649. * volatil:                              Flags.
  1650. * volatile memory references:           Flags.
  1651. * voting between constraint alternatives: Class Preferences.
  1652. * vprintf:                              Config.
  1653. * warning messages:                     Warning Options.
  1654. * WCHAR_TYPE:                           Type Layout.
  1655. * WCHAR_TYPE_SIZE:                      Type Layout.
  1656. * which_alternative:                    Output Statement.
  1657. * whitespace:                           Incompatibilities.
  1658. * WORDS_BIG_ENDIAN:                     Storage Layout.
  1659. * word_mode:                            Machine Modes.
  1660. * WORD_SWITCH_TAKES_ARG:                Driver.
  1661. * XCmode:                               Machine Modes.
  1662. * XCOFF_DEBUGGING_INFO:                 DBX Options.
  1663. * XEXP:                                 Accessors.
  1664. * XFmode:                               Machine Modes.
  1665. * XINT:                                 Accessors.
  1666. * xor:                                  Arithmetic.
  1667. * XSTR:                                 Accessors.
  1668. * XVEC:                                 Accessors.
  1669. * XVECEXP:                              Accessors.
  1670. * XVECLEN:                              Accessors.
  1671. * XWINT:                                Accessors.
  1672. * zero division on 88k:                 M88K Options.
  1673. * zero-length arrays:                   Zero Length.
  1674. * zero_extend:                          Conversions.
  1675. * zero_extract:                         Bit Fields.
  1676. * \:                                    Output Template.
  1677. * __bb_init_func:                       Profiling.
  1678. * __builtin_args_info:                  Varargs.
  1679. * __builtin_classify_type:              Varargs.
  1680. * __builtin_next_arg:                   Varargs.
  1681. * __builtin_saveregs:                   Varargs.
  1682. * __CTOR_LIST__:                        Initialization.
  1683. * __DTOR_LIST__:                        Initialization.
  1684.