| blob | 071161d64857118e35b8d911021e7610e509e215 |
1 This is Info file suif1.info, produced by Makeinfo version 1.68 from
2 the input file suif1.texi.
4 This file documents the SUIF library.
6 Copyright (C) 1994 Stanford University. All rights reserved.
8 Permission is given to use, copy, and modify this documentation for
9 any non-commercial purpose as long as this copyright notice is not
10 removed. All other uses, including redistribution in whole or in part,
11 are forbidden without prior written permission.
13 \x1f
14 File: suif1.info, Node: Function Index, Next: Concept Index, Prev: Appendix, Up: Top
16 Function, Variable, and Type Index
17 **********************************
19 * Menu:
21 * alist: Association Lists.
22 * alist_e: Association Lists.
23 * alist_iter: Association Lists.
24 * amtflist: Association Lists.
25 * ANNOTE: Flat Annote Defs.
26 * annote: Annotation Overview.
27 * annote, data: Annotation Overview.
28 * annote, immeds: Annotation Overview.
29 * annote, name: Annotation Overview.
30 * annote, print: Annotation Overview.
31 * annote, set_data: Annotation Overview.
32 * annote, set_immeds: Annotation Overview.
33 * annote, set_name: Annotation Overview.
34 * annote_def: Annotation Manager.
35 * annote_def, is_structured: Flat Annote Defs.
36 * annote_def, name: Annotation Manager.
37 * annote_def, output: Flat Annote Defs.
38 * annote_def, set_output: Flat Annote Defs.
39 * annote_list: Annote Lists.
40 * annote_list, get_annote: Annote Lists.
41 * annote_list, peek_annote: Annote Lists.
42 * array_bound: Array Types.
43 * array_bound, constant: Array Types.
44 * array_bound, is_constant: Array Types.
45 * array_bound, is_unknown: Array Types.
46 * array_bound, is_variable: Array Types.
47 * array_bound, print: Array Types.
48 * array_bound, variable: Array Types.
49 * array_type: Array Types.
50 * array_type, are_bounds_unknown: Array Types.
51 * array_type, elem_type: Array Types.
52 * array_type, lower_bound: Array Types.
53 * array_type, set_elem_type: Array Types.
54 * array_type, set_lower_bound: Array Types.
55 * array_type, set_upper_bound: Array Types.
56 * array_type, upper_bound: Array Types.
57 * assert: Error Handling.
58 * assert_msg: Error Handling.
59 * base_symtab: Symbol Table Hierarchy.
60 * base_symtab, add_child: Adding and Removing Entries.
61 * base_symtab, add_def: Adding and Removing Entries.
62 * base_symtab, add_sym: Adding and Removing Entries.
63 * base_symtab, add_type: Adding and Removing Entries.
64 * base_symtab, chain_name: Basic Symtab Features.
65 * base_symtab, children: Symbol Table Hierarchy.
66 * base_symtab, define_var: Creating New Entries.
67 * base_symtab, install_type: Adding and Removing Entries.
68 * base_symtab, is_ancestor: Symbol Table Hierarchy.
69 * base_symtab, lookup_child: Lookup Methods.
70 * base_symtab, lookup_sym: Lookup Methods.
71 * base_symtab, lookup_sym_id: Lookup Methods.
72 * base_symtab, lookup_type: Lookup Methods.
73 * base_symtab, lookup_type_id: Lookup Methods.
74 * base_symtab, lookup_var: Lookup Methods.
75 * base_symtab, lookup_var_def: Lookup Methods.
76 * base_symtab, name: Basic Symtab Features.
77 * base_symtab, new_unique_var: Creating New Entries.
78 * base_symtab, new_var: Creating New Entries.
79 * base_symtab, parent: Symbol Table Hierarchy.
80 * base_symtab, remove_child: Adding and Removing Entries.
81 * base_symtab, remove_def: Adding and Removing Entries.
82 * base_symtab, remove_sym: Adding and Removing Entries.
83 * base_symtab, remove_type: Adding and Removing Entries.
84 * base_symtab, rename_duplicates: Basic Symtab Features.
85 * base_symtab, resolve_exposed_refs: Resolving Exposed References.
86 * base_symtab, set_name: Basic Symtab Features.
87 * base_symtab, symbols: Basic Symtab Features.
88 * base_symtab, types: Basic Symtab Features.
89 * base_symtab, var_defs: Basic Symtab Features.
90 * base_type: Base Types.
91 * base_type, is_signed: Base Types.
92 * base_type, set_signed: Base Types.
93 * base_type, set_size: Base Types.
94 * bit_set: Bit Vectors.
95 * bit_set_iter: Bit Vectors.
96 * block_symtab: Block Symbol Tables.
97 * block_symtab, block: Block Symbol Tables.
98 * block_symtab, clone_helper: Copying the Objects.
99 * block_symtab, find_exposed_refs: Finding Exposed References.
100 * block_symtab, lookup_label: Lookup Methods.
101 * block_symtab, new_label: Creating New Entries.
102 * block_symtab, new_unique_child: Creating New Entries.
103 * block_symtab, new_unique_label: Creating New Entries.
104 * C_types: Target Machine Parameters.
105 * cmd_line_option: Command-Line Parser.
106 * cmd_line_option_kind: Command-Line Parser.
107 * DECLARE_DLIST_CLASS: Doubly-Linked Lists.
108 * DECLARE_LIST_CLASS: Generic Lists.
109 * DECLARE_MTFLIST_CLASS: Move-to-front Lists.
110 * DECLARE_X_ARRAY: Extensible Arrays.
111 * dlist: Doubly-Linked Lists.
112 * dlist_e: Doubly-Linked Lists.
113 * dlist_iter: Doubly-Linked Lists.
114 * enum_type: Enumerated Types.
115 * enum_type, find_member_by_name: Enumerated Types.
116 * enum_type, find_member_by_value: Enumerated Types.
117 * enum_type, member: Enumerated Types.
118 * enum_type, name: Enumerated Types.
119 * enum_type, num_values: Enumerated Types.
120 * enum_type, set_member: Enumerated Types.
121 * enum_type, set_name: Enumerated Types.
122 * enum_type, set_num_values: Enumerated Types.
123 * enum_type, set_value: Enumerated Types.
124 * enum_type, value: Enumerated Types.
125 * error_line: Error Handling.
126 * exit_suif: Initialization.
127 * file_set: File Set.
128 * file_set, add_file: File Set.
129 * file_set, file_list: File Set.
130 * file_set, globals: File Set.
131 * file_set, next_file: File Set.
132 * file_set, reset_iter: File Set.
133 * file_set_entry: File Set Entries.
134 * file_set_entry, name: File Set Entries.
135 * file_set_entry, next_proc: File Set Entries.
136 * file_set_entry, parent: File Set Entries.
137 * file_set_entry, reset_proc_iter: File Set Entries.
138 * file_set_entry, symtab: File Set Entries.
139 * file_set_entry_list: File Set Entries.
140 * file_symtab: File Symbol Tables.
141 * file_symtab, fse: File Symbol Tables.
142 * file_symtab, number_globals: Numbering Types and Symbols.
143 * fileset: File Set.
144 * func_type: Function Types.
145 * func_type, arg_type: Function Types.
146 * func_type, args_known: Function Types.
147 * func_type, has_varargs: Function Types.
148 * func_type, num_args: Function Types.
149 * func_type, return_type: Function Types.
150 * func_type, set_arg_type: Function Types.
151 * func_type, set_args_known: Function Types.
152 * func_type, set_args_unknown: Function Types.
153 * func_type, set_num_args: Function Types.
154 * func_type, set_return_type: Function Types.
155 * func_type, set_varargs: Function Types.
156 * glist: Generic Lists.
157 * glist_e: Generic Lists.
158 * glist_iter: Generic Lists.
159 * global_symtab: Global Symbol Table.
160 * global_symtab, lookup_proc: Lookup Methods.
161 * global_symtab, new_proc: Creating New Entries.
162 * hash_chain: Hash Tables.
163 * hash_e: Hash Tables.
164 * hash_table: Hash Tables.
165 * hash_table, enter: Hash Tables.
166 * hash_table, lookup: Hash Tables.
167 * if_ops: Opcodes and Formats.
168 * if_ops_name: Opcodes and Formats.
169 * immed: Immeds.
170 * immed, addr: Immeds.
171 * immed, flt: Immeds.
172 * immed, instr: Immeds.
173 * immed, integer: Immeds.
174 * immed, is_error: Immeds.
175 * immed, is_flt: Immeds.
176 * immed, is_instr: Immeds.
177 * immed, is_integer: Immeds.
178 * immed, is_op: Immeds.
179 * immed, is_string: Immeds.
180 * immed, is_symbol: Immeds.
181 * immed, is_type: Immeds.
182 * immed, offset: Immeds.
183 * immed, op: Immeds.
184 * immed, print: Immeds.
185 * immed, rawprint: Immeds.
186 * immed, string: Immeds.
187 * immed, symbol: Immeds.
188 * immed, type: Immeds.
189 * immed_kinds: Immeds.
190 * in_array: Array Instructions.
191 * in_array, base_op: Array Instructions.
192 * in_array, bound: Array Instructions.
193 * in_array, dims: Array Instructions.
194 * in_array, elem_size: Array Instructions.
195 * in_array, elem_type: Array Instructions.
196 * in_array, index: Array Instructions.
197 * in_array, offset: Array Instructions.
198 * in_array, offset_op: Array Instructions.
199 * in_array, set_base_op: Array Instructions.
200 * in_array, set_bound: Array Instructions.
201 * in_array, set_dims: Array Instructions.
202 * in_array, set_elem_size: Array Instructions.
203 * in_array, set_index: Array Instructions.
204 * in_array, set_offset: Array Instructions.
205 * in_array, set_offset_op: Array Instructions.
206 * in_bj: Branch and Jump Instructions.
207 * in_bj, set_src_op: Branch and Jump Instructions.
208 * in_bj, set_target: Branch and Jump Instructions.
209 * in_bj, src_op: Branch and Jump Instructions.
210 * in_bj, target: Branch and Jump Instructions.
211 * in_cal: Call Instructions.
212 * in_cal, addr_op: Call Instructions.
213 * in_cal, argument: Call Instructions.
214 * in_cal, num_args: Call Instructions.
215 * in_cal, set_addr_op: Call Instructions.
216 * in_cal, set_argument: Call Instructions.
217 * in_cal, set_num_args: Call Instructions.
218 * in_gen: Generic Instructions.
219 * in_gen, name: Generic Instructions.
220 * in_gen, set_name: Generic Instructions.
221 * in_gen, set_num_srcs: Generic Instructions.
222 * in_lab: Label Instructions.
223 * in_lab, label: Label Instructions.
224 * in_lab, set_label: Label Instructions.
225 * in_ldc: Load Constant Instructions.
226 * in_ldc, set_value: Load Constant Instructions.
227 * in_ldc, value: Load Constant Instructions.
228 * in_mbr: Multi-way Branch Instructions.
229 * in_mbr, default_lab: Multi-way Branch Instructions.
230 * in_mbr, label: Multi-way Branch Instructions.
231 * in_mbr, lower: Multi-way Branch Instructions.
232 * in_mbr, num_labs: Multi-way Branch Instructions.
233 * in_mbr, set_default_lab: Multi-way Branch Instructions.
234 * in_mbr, set_label: Multi-way Branch Instructions.
235 * in_mbr, set_lower: Multi-way Branch Instructions.
236 * in_mbr, set_num_labs: Multi-way Branch Instructions.
237 * in_mbr, set_src: Multi-way Branch Instructions.
238 * in_mbr, src_op: Multi-way Branch Instructions.
239 * in_rrr: Three Operand Instructions.
240 * in_rrr, dst_addr_op: Three Operand Instructions.
241 * in_rrr, is_commutative: Three Operand Instructions.
242 * in_rrr, is_unary: Three Operand Instructions.
243 * in_rrr, set_dst_addr_op: Three Operand Instructions.
244 * in_rrr, set_shift_cnt_op: Three Operand Instructions.
245 * in_rrr, set_src: Three Operand Instructions.
246 * in_rrr, set_src1: Three Operand Instructions.
247 * in_rrr, set_src2: Three Operand Instructions.
248 * in_rrr, set_src_addr_op: Three Operand Instructions.
249 * in_rrr, shift_cnt_op: Three Operand Instructions.
250 * in_rrr, src1_op: Three Operand Instructions.
251 * in_rrr, src2_op: Three Operand Instructions.
252 * in_rrr, src_addr_op: Three Operand Instructions.
253 * in_rrr, src_op: Three Operand Instructions.
254 * init_aman: Annotation Manager.
255 * init_suif: Initialization.
256 * inst_format: Opcodes and Formats.
257 * instr_map_f: Instruction Nodes.
258 * instruction: Basic Features.
259 * instruction, clear_numbers: ID Numbers.
260 * instruction, clone: Cloning.
261 * instruction, clone_helper: Copying the Objects.
262 * instruction, dst_op: Destination Operands.
263 * instruction, find_exposed_refs: Finding Exposed References.
264 * instruction, format: Opcodes and Formats.
265 * instruction, num_srcs: Source Operands.
266 * instruction, opcode: Opcodes and Formats.
267 * instruction, owner: Parent Tree Nodes.
268 * instruction, parent: Parent Tree Nodes.
269 * instruction, print: Printing Methods.
270 * instruction, remove: Source Operands.
271 * instruction, result_type: Result Types.
272 * instruction, set_dst: Destination Operands.
273 * instruction, set_opcode: Opcodes and Formats.
274 * instruction, set_result_type: Result Types.
275 * instruction, set_src_op: Source Operands.
276 * instruction, src_map: Source Operands.
277 * instruction, src_op: Source Operands.
278 * instruction_list: Basic Features.
279 * k_call_by_ref: Call-By-Ref Annotes.
280 * k_common_block: Common Block Annotes.
281 * k_enable_exceptions: Miscellaneous Annotes.
282 * k_fields: Miscellaneous Annotes.
283 * k_fill: Initial Data Annotes.
284 * k_history: Miscellaneous Annotes.
285 * k_line: Miscellaneous Annotes.
286 * k_multi_init: Initial Data Annotes.
287 * k_orig_type: Call-By-Ref Annotes.
288 * k_reg_num: Miscellaneous Annotes.
289 * k_repeat_init: Initial Data Annotes.
290 * label_sym: Label Symbols.
291 * lexicon: Lexicon.
292 * lib_exit_f: Initialization.
293 * lib_init_f: Initialization.
294 * LIBRARY: Initialization.
295 * lookup_annote: Annotation Manager.
296 * machine_params: Target Machine Parameters.
297 * make_ref_params: Call-By-Ref Parameters.
298 * modifier_type: Modifier Types.
299 * modifier_type, base: Modifier Types.
300 * modifier_type, set_base: Modifier Types.
301 * mtflist: Move-to-front Lists.
302 * object_kinds: SUIF Objects.
303 * operand: Operands.
304 * operand, clone: Cloning.
305 * operand, clone_helper: Copying the Objects.
306 * operand, find_exposed_refs: Finding Exposed References.
307 * operand, instr: Operands.
308 * operand, is_const_int: Operands.
309 * operand, is_expr: Operands.
310 * operand, is_instr: Operands.
311 * operand, is_null: Operands.
312 * operand, is_symbol: Operands.
313 * operand, print: Operands.
314 * operand, print_source: Operands.
315 * operand, remove: Source Operands.
316 * operand, set_instr: Operands.
317 * operand, set_symbol: Operands.
318 * operand, symbol: Operands.
319 * operand, type: Operands.
320 * parse_cmd_line: Command-Line Parser.
321 * print_id_number: Numbering Types and Symbols.
322 * proc_sym: Procedure Symbols.
323 * proc_sym, block: Procedure Symbols.
324 * proc_sym, file: Procedure Symbols.
325 * proc_sym, flush_proc: Procedure Symbols.
326 * proc_sym, is_in_memory: Procedure Symbols.
327 * proc_sym, is_readable: Procedure Symbols.
328 * proc_sym, is_written: Procedure Symbols.
329 * proc_sym, read_proc: Procedure Symbols.
330 * proc_sym, set_block: Procedure Symbols.
331 * proc_sym, set_src_lang: Procedure Symbols.
332 * proc_sym, set_type: Procedure Symbols.
333 * proc_sym, src_lang: Procedure Symbols.
334 * proc_sym, type: Procedure Symbols.
335 * proc_sym, write_proc: Procedure Symbols.
336 * proc_symtab: Procedure Symbol Tables.
337 * proc_symtab, clone_helper: Copying the Objects.
338 * proc_symtab, instr_num: ID Numbers.
339 * proc_symtab, next_instr_num: ID Numbers.
340 * proc_symtab, number_locals: Numbering Types and Symbols.
341 * proc_symtab, params: Procedure Symbol Tables.
342 * prociter_f: Procedure Iterators.
343 * ptr_type: Pointer Types.
344 * ptr_type, ref_type: Pointer Types.
345 * ptr_type, set_ref_type: Pointer Types.
346 * register_annote: Annotation Manager.
347 * register_library: Initialization.
348 * replacements: Cloning.
349 * src_lang_type: Procedure Symbols.
350 * src_map_f: Source Operands.
351 * start_suif: Initialization.
352 * string_e: Lexicon.
353 * string_table: Lexicon.
354 * string_table, enter: Lexicon.
355 * STRUCT_ANNOTE: Struct Annote Defs.
356 * struct_annote_def: Struct Annote Defs.
357 * struct_annote_def, free: Struct Annote Defs.
358 * struct_annote_def, from: Struct Annote Defs.
359 * struct_annote_def, print: Struct Annote Defs.
360 * struct_annote_def, to: Struct Annote Defs.
361 * struct_type: Structure Types.
362 * struct_type, field_name: Structure Types.
363 * struct_type, field_type: Structure Types.
364 * struct_type, find_field_by_name: Structure Types.
365 * struct_type, find_field_by_offset: Structure Types.
366 * struct_type, name: Structure Types.
367 * struct_type, num_fields: Structure Types.
368 * struct_type, offset: Structure Types.
369 * struct_type, set_field_name: Structure Types.
370 * struct_type, set_field_type: Structure Types.
371 * struct_type, set_name: Structure Types.
372 * struct_type, set_num_fields: Structure Types.
373 * struct_type, set_offset: Structure Types.
374 * struct_type, set_size: Structure Types.
375 * suif_object: SUIF Objects.
376 * suif_object, annotes: SUIF Objects.
377 * suif_object, append_annote: SUIF Objects.
378 * suif_object, are_annotations: SUIF Objects.
379 * suif_object, clone_annotes: Copying the Objects.
380 * suif_object, copy_annotes: SUIF Objects.
381 * suif_object, find_annote_refs: Finding Exposed References.
382 * suif_object, get_annote: SUIF Objects.
383 * suif_object, num_output_annotes: SUIF Objects.
384 * suif_object, object_kind: SUIF Objects.
385 * suif_object, peek_annote: SUIF Objects.
386 * suif_object, prepend_annote: SUIF Objects.
387 * suif_object, print_annotes: SUIF Objects.
388 * suif_object, set_annote: SUIF Objects.
389 * suif_proc_iter: Procedure Iterators.
390 * sym_addr: Symbolic Addresses.
391 * sym_addr, offset: Symbolic Addresses.
392 * sym_addr, print: Symbolic Addresses.
393 * sym_addr, symbol: Symbolic Addresses.
394 * sym_kinds: Symbols.
395 * sym_node: Symbols.
396 * sym_node, add_to_table: Symbol Features.
397 * sym_node, clear_sym_id: Numbering Types and Symbols.
398 * sym_node, copy: Symbol Features.
399 * sym_node, is_extern: Symbol Features.
400 * sym_node, is_global: Symbol Features.
401 * sym_node, is_private: Symbol Features.
402 * sym_node, is_userdef: Symbol Features.
403 * sym_node, kind: Symbols.
404 * sym_node, name: Symbol Features.
405 * sym_node, parent: Symbol Features.
406 * sym_node, print: Symbol Features.
407 * sym_node, print_full: Symbol Features.
408 * sym_node, remove_from_table: Symbol Features.
409 * sym_node, reset_userdef: Symbol Features.
410 * sym_node, set_name: Symbol Features.
411 * sym_node, set_userdef: Symbol Features.
412 * sym_node, sym_id: Numbering Types and Symbols.
413 * sym_node_list: Symbols.
414 * target: Target Machine Parameters.
415 * tree_block: Block Nodes.
416 * tree_block, body: Block Nodes.
417 * tree_block, clone: Cloning.
418 * tree_block, set_body: Block Nodes.
419 * tree_block, set_symtab: Block Nodes.
420 * tree_block, symtab: Block Nodes.
421 * tree_for: For Nodes.
422 * tree_for, body: For Nodes.
423 * tree_for, brklab: For Nodes.
424 * tree_for, clone: Cloning.
425 * tree_for, contlab: For Nodes.
426 * tree_for, index: For Nodes.
427 * tree_for, landing_pad: For Nodes.
428 * tree_for, lb_list: For Nodes.
429 * tree_for, lb_op: For Nodes.
430 * tree_for, set_body: For Nodes.
431 * tree_for, set_brklab: For Nodes.
432 * tree_for, set_contlab: For Nodes.
433 * tree_for, set_index: For Nodes.
434 * tree_for, set_landing_pad: For Nodes.
435 * tree_for, set_lb_list: For Nodes.
436 * tree_for, set_lb_op: For Nodes.
437 * tree_for, set_step_list: For Nodes.
438 * tree_for, set_step_op: For Nodes.
439 * tree_for, set_test: For Nodes.
440 * tree_for, set_ub_list: For Nodes.
441 * tree_for, set_ub_op: For Nodes.
442 * tree_for, step_list: For Nodes.
443 * tree_for, step_op: For Nodes.
444 * tree_for, test: For Nodes.
445 * tree_for, ub_list: For Nodes.
446 * tree_for, ub_op: For Nodes.
447 * tree_for_test: For Nodes.
448 * tree_if: If Nodes.
449 * tree_if, clone: Cloning.
450 * tree_if, else_part: If Nodes.
451 * tree_if, header: If Nodes.
452 * tree_if, jumpto: If Nodes.
453 * tree_if, set_else_part: If Nodes.
454 * tree_if, set_header: If Nodes.
455 * tree_if, set_jumpto: If Nodes.
456 * tree_if, set_then_part: If Nodes.
457 * tree_if, then_part: If Nodes.
458 * tree_instr: Instruction Nodes.
459 * tree_instr, clone: Cloning.
460 * tree_instr, instr: Instruction Nodes.
461 * tree_instr, instr_map: Instruction Nodes.
462 * tree_instr, remove_instr: Instruction Nodes.
463 * tree_instr, set_instr: Instruction Nodes.
464 * tree_loop: Loop Nodes.
465 * tree_loop, body: Loop Nodes.
466 * tree_loop, brklab: Loop Nodes.
467 * tree_loop, clone: Cloning.
468 * tree_loop, contlab: Loop Nodes.
469 * tree_loop, set_body: Loop Nodes.
470 * tree_loop, set_brklab: Loop Nodes.
471 * tree_loop, set_contlab: Loop Nodes.
472 * tree_loop, set_test: Loop Nodes.
473 * tree_loop, set_toplab: Loop Nodes.
474 * tree_loop, test: Loop Nodes.
475 * tree_loop, toplab: Loop Nodes.
476 * tree_node: Tree Nodes.
477 * tree_node, clear_numbers: ID Numbers.
478 * tree_node, clone: Cloning.
479 * tree_node, clone_helper: Copying the Objects.
480 * tree_node, find_exposed_refs: Finding Exposed References.
481 * tree_node, list_e: Other Node Features.
482 * tree_node, map: Mapping Subtrees.
483 * tree_node, number: ID Numbers.
484 * tree_node, parent: Other Node Features.
485 * tree_node, print: Other Node Features.
486 * tree_node, proc: Other Node Features.
487 * tree_node, scope: Other Node Features.
488 * tree_node_list: Tree Node Lists.
489 * tree_node_list, clear_numbers: ID Numbers.
490 * tree_node_list, clone: Cloning.
491 * tree_node_list, clone_helper: Copying the Objects.
492 * tree_node_list, cvt_to_trees: Expression Trees.
493 * tree_node_list, find_exposed_refs: Finding Exposed References.
494 * tree_node_list, flatten: Expression Trees.
495 * tree_node_list, is_op: Tree Node Lists.
496 * tree_node_list, map: Mapping Subtrees.
497 * tree_node_list, op: Tree Node Lists.
498 * tree_node_list, op_is_intconst: Tree Node Lists.
499 * tree_node_list, parent: Tree Node Lists.
500 * tree_node_list, print: Tree Node Lists.
501 * tree_node_list, print_expr: Tree Node Lists.
502 * tree_node_list, set_elem: Tree Node Lists.
503 * tree_node_list, set_op: Tree Node Lists.
504 * tree_proc: Procedure Nodes.
505 * tree_proc, clone: Cloning.
506 * tree_proc, number_instrs: ID Numbers.
507 * tree_proc, proc_syms: Procedure Nodes.
508 * type_char: Predefined Types.
509 * type_double: Predefined Types.
510 * type_error: Predefined Types.
511 * type_f128: Predefined Types.
512 * type_f32: Predefined Types.
513 * type_f64: Predefined Types.
514 * type_float: Predefined Types.
515 * type_longdouble: Predefined Types.
516 * type_node: Types.
517 * type_node, clear_type_id: Numbering Types and Symbols.
518 * type_node, compatible: Type Features.
519 * type_node, copy: Type Features.
520 * type_node, find_modifier: Modifier Types.
521 * type_node, is_call_by_ref: Modifier Types.
522 * type_node, is_const: Modifier Types.
523 * type_node, is_named: Type Features.
524 * type_node, is_same: Type Features.
525 * type_node, is_scalar: Types.
526 * type_node, is_volatile: Modifier Types.
527 * type_node, op: Types.
528 * type_node, parent: Type Features.
529 * type_node, print: Type Features.
530 * type_node, print_abbrev: Type Features.
531 * type_node, print_full: Type Features.
532 * type_node, size: Type Features.
533 * type_node, type_id: Numbering Types and Symbols.
534 * type_node, unqual: Modifier Types.
535 * type_node_list: Types.
536 * type_ops: Types.
537 * type_ptr: Predefined Types.
538 * type_s16: Predefined Types.
539 * type_s32: Predefined Types.
540 * type_s64: Predefined Types.
541 * type_s8: Predefined Types.
542 * type_signed: Predefined Types.
543 * type_signed_char: Predefined Types.
544 * type_signed_long: Predefined Types.
545 * type_signed_longlong: Predefined Types.
546 * type_signed_short: Predefined Types.
547 * type_u16: Predefined Types.
548 * type_u32: Predefined Types.
549 * type_u64: Predefined Types.
550 * type_u8: Predefined Types.
551 * type_unsigned: Predefined Types.
552 * type_unsigned_char: Predefined Types.
553 * type_unsigned_long: Predefined Types.
554 * type_unsigned_longlong: Predefined Types.
555 * type_unsigned_short: Predefined Types.
556 * type_v0: Predefined Types.
557 * type_void: Predefined Types.
558 * undo_ref_params: Call-By-Ref Parameters.
559 * unknown_bound: Array Types.
560 * var_def: Variable Definitions.
561 * var_def, alignment: Variable Definitions.
562 * var_def, print: Variable Definitions.
563 * var_def, set_alignment: Variable Definitions.
564 * var_def, set_variable: Variable Definitions.
565 * var_def, variable: Variable Definitions.
566 * var_sym: Variable Symbols.
567 * var_sym, add_child: Sub-Variables.
568 * var_sym, build_child: Sub-Variables.
569 * var_sym, child_var: Sub-Variables.
570 * var_sym, definition: Variable Features.
571 * var_sym, find_child: Sub-Variables.
572 * var_sym, has_var_def: Variable Features.
573 * var_sym, is_addr_taken: Variable Features.
574 * var_sym, is_auto: Variable Features.
575 * var_sym, is_param: Variable Features.
576 * var_sym, is_reg: Variable Features.
577 * var_sym, is_scalar: Variable Features.
578 * var_sym, is_spilled: Variable Features.
579 * var_sym, is_static: Variable Features.
580 * var_sym, num_children: Sub-Variables.
581 * var_sym, offset: Sub-Variables.
582 * var_sym, overlaps: Sub-Variables.
583 * var_sym, parent_var: Sub-Variables.
584 * var_sym, remove_child: Sub-Variables.
585 * var_sym, reset_addr_taken: Variable Features.
586 * var_sym, reset_param: Variable Features.
587 * var_sym, reset_reg: Variable Features.
588 * var_sym, root_ancestor: Sub-Variables.
589 * var_sym, root_offset: Sub-Variables.
590 * var_sym, set_addr_taken: Variable Features.
591 * var_sym, set_param: Variable Features.
592 * var_sym, set_reg: Variable Features.
593 * var_sym, set_type: Variable Features.
594 * var_sym, type: Variable Features.
595 * verror_line: Error Handling.
596 * vwarning_line: Error Handling.
597 * warning_line: Error Handling.
598 * which_format: Opcodes and Formats.
599 * x_array: Extensible Arrays.
600 * x_array, extend: Extensible Arrays.
601 * x_array, operator[]: Extensible Arrays.
602 * x_array, ub: Extensible Arrays.
604 \x1f
605 File: suif1.info, Node: Concept Index, Prev: Function Index, Up: Top
607 Concept Index
608 *************
610 * Menu:
612 * abstract syntax trees: Trees.
613 * addresses, symbolic: Symbolic Addresses.
614 * annotation lists: Annote Lists.
615 * annotation manager: Annotation Manager.
616 * annotations: Annotations.
617 * annotations, call-by-reference: Call-By-Ref Annotes.
618 * annotations, common block: Common Block Annotes.
619 * annotations, flat: Flat Annotes.
620 * annotations, initial data: Initial Data Annotes.
621 * annotations, predefined: Predefined Annotes.
622 * annotations, structured: Structured Annotes.
623 * annotations, unregistered: Unregistered Annotes.
624 * annotes: Annotations.
625 * arguments, command-line: Command-Line Parser.
626 * array instructions: Array Instructions.
627 * array types: Array Types.
628 * assertions: Error Handling.
629 * association lists: Association Lists.
630 * AST nodes: Tree Nodes.
631 * ASTs: Trees.
632 * base types: Base Types.
633 * bit sets: Bit Vectors.
634 * bit vectors: Bit Vectors.
635 * block nodes: Block Nodes.
636 * block symbol tables: Block Symbol Tables.
637 * branch and jump instructions: Branch and Jump Instructions.
638 * call instructions: Call Instructions.
639 * call-by-reference annotations: Call-By-Ref Annotes.
640 * call-by-reference parameters: Call-By-Ref Parameters.
641 * cloning: Cloning.
642 * command-line arguments: Command-Line Parser.
643 * common block annotations: Common Block Annotes.
644 * data structures, generic: Generics.
645 * destination operands: Destination Operands.
646 * doubly-linked lists: Doubly-Linked Lists.
647 * duplication: Cloning.
648 * enumerated types: Enumerated Types.
649 * errors: Error Handling.
650 * exception handling: Miscellaneous Annotes.
651 * expression trees: Expression Trees.
652 * extensible arrays: Extensible Arrays.
653 * fields annotations: Miscellaneous Annotes.
654 * file set: File Set.
655 * file set entries: File Set Entries.
656 * file symbol tables: File Symbol Tables.
657 * flat annotations: Flat Annotes.
658 * for nodes: For Nodes.
659 * formal parameters: Procedure Symbol Tables.
660 * Fortran form: Fortran.
661 * function types: Function Types.
662 * generic data structures: Generics.
663 * generic instructions: Generic Instructions.
664 * generic lists: Generic Lists.
665 * global symbol table: Global Symbol Table.
666 * hash tables: Hash Tables.
667 * high-SUIF: Procedure Level.
668 * ID numbers: ID Numbers.
669 * ID numbers, instruction: ID Numbers.
670 * ID numbers, symbol: Numbering Types and Symbols.
671 * ID numbers, tree node: ID Numbers.
672 * ID numbers, type: Numbering Types and Symbols.
673 * if nodes: If Nodes.
674 * immediate values: Immeds.
675 * initial data annotations: Initial Data Annotes.
676 * initialization: Initialization.
677 * instruction formats: Opcodes and Formats.
678 * instruction ID numbers: ID Numbers.
679 * instruction nodes: Instruction Nodes.
680 * instructions: Instructions.
681 * instructions, array: Array Instructions.
682 * instructions, basic features: Basic Features.
683 * instructions, branch and jump: Branch and Jump Instructions.
684 * instructions, call: Call Instructions.
685 * instructions, generic: Generic Instructions.
686 * instructions, label: Label Instructions.
687 * instructions, load constant: Load Constant Instructions.
688 * instructions, multi-way branch: Multi-way Branch Instructions.
689 * instructions, printing: Printing Methods.
690 * instructions, three operand: Three Operand Instructions.
691 * introduction: Overview.
692 * iterators, bit set: Bit Vectors.
693 * iterators, list: Generic Lists.
694 * iterators, procedure: Procedure Iterators.
695 * label instructions: Label Instructions.
696 * label symbols: Label Symbols.
697 * landing pads: For Nodes.
698 * lexicon: Lexicon.
699 * line numbers: Miscellaneous Annotes.
700 * linked lists: Generic Lists.
701 * lists, association: Association Lists.
702 * lists, doubly-linked: Doubly-Linked Lists.
703 * lists, generic: Generic Lists.
704 * lists, move-to-front: Move-to-front Lists.
705 * load constant instructions: Load Constant Instructions.
706 * loop nodes: Loop Nodes.
707 * low-SUIF: Procedure Level.
708 * machine registers: Variable Features.
709 * manager, annotations: Annotation Manager.
710 * mapping instructions: Instruction Nodes.
711 * mapping subtrees: Mapping Subtrees.
712 * modifier types: Modifier Types.
713 * move-to-front lists: Move-to-front Lists.
714 * multi-way branch instructions: Multi-way Branch Instructions.
715 * nested scopes: Block Nodes.
716 * objects, SUIF: SUIF Objects.
717 * opcodes: Opcodes and Formats.
718 * operands: Operands.
719 * operands, destination: Destination Operands.
720 * operands, source: Source Operands.
721 * options, standard: Initialization.
722 * overview: Overview.
723 * parameters, formal: Procedure Symbol Tables.
724 * pointer types: Pointer Types.
725 * predefined annotations: Predefined Annotes.
726 * predefined types: Predefined Types.
727 * procedure iterators: Procedure Iterators.
728 * procedure nodes: Procedure Nodes.
729 * procedure symbol tables: Procedure Symbol Tables.
730 * procedure symbols: Procedure Symbols.
731 * register numbers: Miscellaneous Annotes.
732 * registers, machine: Variable Features.
733 * slaving sub-variable properties: Sub-Variables.
734 * source operands: Source Operands.
735 * standard options: Initialization.
736 * string table: Lexicon.
737 * structure types: Structure Types.
738 * structured annotations: Structured Annotes.
739 * structured annotations, conversion: Struct Annote Defs.
740 * structured annotations, deallocation: Struct Annote Defs.
741 * structured annotations, printing: Struct Annote Defs.
742 * sub-variables: Sub-Variables.
743 * SUIF objects: SUIF Objects.
744 * symbol ID numbers: Numbering Types and Symbols.
745 * symbol table chain name: Basic Symtab Features.
746 * symbol table name: Basic Symtab Features.
747 * symbol table, global: Global Symbol Table.
748 * symbol tables: Symbol Tables.
749 * symbol tables, adding entries: Adding and Removing Entries.
750 * symbol tables, basic features: Basic Symtab Features.
751 * symbol tables, block: Block Symbol Tables.
752 * symbol tables, file: File Symbol Tables.
753 * symbol tables, lookup methods: Lookup Methods.
754 * symbol tables, procedure: Procedure Symbol Tables.
755 * symbol tables, removing entries: Adding and Removing Entries.
756 * symbolic addresses: Symbolic Addresses.
757 * symbols: Symbols.
758 * symbols, label: Label Symbols.
759 * symbols, procedure: Procedure Symbols.
760 * symbols, variable: Variable Symbols.
761 * target machine parameters: Target Machine Parameters.
762 * three operand instructions: Three Operand Instructions.
763 * tree blocks: Block Nodes.
764 * tree fors: For Nodes.
765 * tree ifs: If Nodes.
766 * tree instructions: Instruction Nodes.
767 * tree loops: Loop Nodes.
768 * tree node ID numbers: ID Numbers.
769 * tree node lists: Tree Node Lists.
770 * tree nodes: Tree Nodes.
771 * tree procedures: Procedure Nodes.
772 * trees: Trees.
773 * type ID numbers: Numbering Types and Symbols.
774 * types: Types.
775 * types, array: Array Types.
776 * types, base: Base Types.
777 * types, enumerated: Enumerated Types.
778 * types, function: Function Types.
779 * types, modifiers: Modifier Types.
780 * types, pointer: Pointer Types.
781 * types, predefined: Predefined Types.
782 * types, structure: Structure Types.
783 * types, union: Structure Types.
784 * union types: Structure Types.
785 * unregistered annotations: Unregistered Annotes.
786 * variable definitions: Variable Definitions.
787 * variable symbols: Variable Symbols.
788 * variables, initialization: Initial Data Annotes.
789 * warnings: Error Handling.