fixing stuff
[dyninst.git] / codeCoverage / sparc-sun-solaris2.8 / tests / cc1 / 1integrate.i
1
2 extern  struct  _iobuf {
3         int     _cnt;
4         unsigned char *_ptr;
5         unsigned char *_base;
6         int     _bufsiz;
7         short   _flag;
8         char    _file;           
9 } _iob[];
10
11 extern struct _iobuf    *fopen();
12 extern struct _iobuf    *fdopen();
13 extern struct _iobuf    *freopen();
14 extern struct _iobuf    *popen();
15 extern struct _iobuf    *tmpfile();
16 extern long     ftell();
17 extern char     *fgets();
18 extern char     *gets();
19
20 extern char     *ctermid();
21 extern char     *cuserid();
22 extern char     *tempnam();
23 extern char     *tmpnam();
24
25 extern int target_flags;
26
27 enum reg_class { NO_REGS, LO_FPA_REGS, FPA_REGS, FP_REGS,
28   FP_OR_FPA_REGS, DATA_REGS, DATA_OR_FPA_REGS, DATA_OR_FP_REGS,
29   DATA_OR_FP_OR_FPA_REGS, ADDR_REGS, GENERAL_REGS,
30   GENERAL_OR_FPA_REGS, GENERAL_OR_FP_REGS, ALL_REGS,
31   LIM_REG_CLASSES };
32
33 extern enum reg_class regno_reg_class[];
34
35 enum rtx_code  {
36
37   UNKNOWN , 
38
39   NIL , 
40
41   EXPR_LIST , 
42
43   INSN_LIST , 
44
45   MATCH_OPERAND , 
46
47   MATCH_DUP , 
48
49   MATCH_OPERATOR , 
50
51   DEFINE_INSN , 
52
53   DEFINE_PEEPHOLE , 
54
55   DEFINE_COMBINE , 
56
57   DEFINE_EXPAND , 
58
59   SEQUENCE , 
60
61   ADDRESS , 
62
63   INSN , 
64
65   JUMP_INSN , 
66
67   CALL_INSN , 
68
69   BARRIER , 
70
71   CODE_LABEL , 
72
73   NOTE , 
74
75   INLINE_HEADER , 
76
77   PARALLEL , 
78
79   ASM_INPUT , 
80
81   ASM_OPERANDS , 
82
83   ADDR_VEC , 
84
85   ADDR_DIFF_VEC , 
86
87   SET , 
88
89   USE , 
90
91   CLOBBER , 
92
93   CALL , 
94
95   RETURN , 
96
97   CONST_INT , 
98
99   CONST_DOUBLE , 
100
101   CONST , 
102
103   PC , 
104
105   REG , 
106
107   SUBREG , 
108
109   STRICT_LOW_PART , 
110
111   MEM , 
112
113   LABEL_REF , 
114
115   SYMBOL_REF , 
116
117   CC0 , 
118
119   QUEUED , 
120
121   IF_THEN_ELSE , 
122
123   COMPARE , 
124
125   PLUS , 
126
127   MINUS , 
128
129   NEG , 
130
131   MULT , 
132
133   DIV , 
134   MOD , 
135
136   UMULT , 
137   UDIV , 
138   UMOD , 
139
140   AND , 
141
142   IOR , 
143
144   XOR , 
145
146   NOT , 
147
148   LSHIFT , 
149   ASHIFT , 
150   ROTATE , 
151
152   ASHIFTRT , 
153   LSHIFTRT , 
154   ROTATERT , 
155
156   PRE_DEC , 
157   PRE_INC , 
158   POST_DEC , 
159   POST_INC , 
160
161   NE , 
162   EQ , 
163   GE , 
164   GT , 
165   LE , 
166   LT , 
167   GEU , 
168   GTU , 
169   LEU , 
170   LTU , 
171
172   SIGN_EXTEND , 
173
174   ZERO_EXTEND , 
175
176   TRUNCATE , 
177
178   FLOAT_EXTEND , 
179   FLOAT_TRUNCATE , 
180
181   FLOAT , 
182
183   FIX , 
184
185   UNSIGNED_FLOAT , 
186
187   UNSIGNED_FIX , 
188
189   ABS , 
190
191   SQRT , 
192
193   FFS , 
194
195   SIGN_EXTRACT , 
196
197   ZERO_EXTRACT , 
198
199   LAST_AND_UNUSED_RTX_CODE};     
200
201 extern int rtx_length[];
202
203 extern char *rtx_name[];
204
205 extern char *rtx_format[];
206
207 enum machine_mode {
208
209  VOIDmode, 
210
211  QImode,                 
212  HImode, 
213
214  PSImode, 
215  SImode, 
216  PDImode, 
217  DImode, 
218  TImode, 
219  QFmode, 
220  HFmode,                 
221  SFmode, 
222  DFmode, 
223  XFmode,         
224  TFmode, 
225  CQImode, 
226  CHImode,        
227  CSImode, 
228  CDImode, 
229  CTImode, 
230  CQFmode, 
231  CHFmode,        
232  CSFmode, 
233  CDFmode, 
234  CXFmode, 
235  CTFmode, 
236
237  BImode,         
238
239  BLKmode, 
240
241  EPmode, 
242
243 MAX_MACHINE_MODE };
244
245 extern char *mode_name[];
246
247 enum mode_class { MODE_RANDOM, MODE_INT, MODE_FLOAT,
248                   MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MODE_FUNCTION };
249
250 extern enum mode_class mode_class[];
251
252 extern int mode_size[];
253
254 extern int mode_unit_size[];
255
256 typedef union rtunion_def
257 {
258   int rtint;
259   char *rtstr;
260   struct rtx_def *rtx;
261   struct rtvec_def *rtvec;
262   enum machine_mode rttype;
263 } rtunion;
264
265 typedef struct rtx_def
266 {
267
268   enum rtx_code code : 16;
269
270   enum machine_mode mode : 8;
271
272   unsigned int jump : 1;
273   unsigned int call : 1;
274
275   unsigned int unchanging : 1;
276
277   unsigned int volatil : 1;
278
279   unsigned int in_struct : 1;
280
281   unsigned int used : 1;
282
283   unsigned integrated : 1;
284
285   rtunion fld[1];
286 } *rtx;
287
288 typedef struct rtvec_def{
289   unsigned num_elem;             
290   rtunion elem[1];
291 } *rtvec;
292
293 enum reg_note { REG_DEAD = 1, REG_INC = 2, REG_EQUIV = 3, REG_WAS_0 = 4,
294                 REG_EQUAL = 5, REG_RETVAL = 6, REG_LIBCALL = 7,
295                 REG_NONNEG = 8 };
296
297 extern char *reg_note_name[];
298
299 extern char *note_insn_name[];
300
301 extern rtx rtx_alloc ();
302 extern rtvec rtvec_alloc ();
303 extern rtx find_reg_note ();
304 extern rtx gen_rtx ();
305 extern rtx copy_rtx ();
306 extern rtvec gen_rtvec ();
307 extern rtvec gen_rtvec_v ();
308 extern rtx gen_reg_rtx ();
309 extern rtx gen_label_rtx ();
310 extern rtx gen_inline_header_rtx ();
311 extern rtx gen_lowpart ();
312 extern rtx gen_highpart ();
313 extern int subreg_lowpart_p ();
314 extern rtx make_safe_from ();
315 extern rtx memory_address ();
316 extern rtx get_insns ();
317 extern rtx get_last_insn ();
318 extern rtx start_sequence ();
319 extern rtx gen_sequence ();
320 extern rtx expand_expr ();
321 extern rtx output_constant_def ();
322 extern rtx immed_real_const ();
323 extern rtx immed_real_const_1 ();
324 extern rtx immed_double_const ();
325 extern rtx force_const_double_mem ();
326 extern rtx force_const_mem ();
327 extern rtx get_parm_real_loc ();
328 extern rtx assign_stack_local ();
329 extern rtx protect_from_queue ();
330 extern void emit_queue ();
331 extern rtx emit_move_insn ();
332 extern rtx emit_insn ();
333 extern rtx emit_jump_insn ();
334 extern rtx emit_call_insn ();
335 extern rtx emit_call_insn_before ();
336 extern rtx emit_insn_before ();
337 extern rtx emit_insn_after ();
338 extern rtx emit_label ();
339 extern rtx emit_barrier ();
340 extern rtx emit_note ();
341 extern rtx emit_line_note ();
342 extern rtx emit_line_note_force ();
343 extern rtx prev_real_insn ();
344 extern rtx next_real_insn ();
345 extern rtx next_nondeleted_insn ();
346 extern rtx plus_constant ();
347 extern rtx find_equiv_reg ();
348 extern rtx delete_insn ();
349 extern rtx adj_offsetable_operand ();
350
351 extern int max_parallel;
352
353 extern int asm_noperands ();
354 extern char *decode_asm_operands ();
355
356 extern enum reg_class reg_preferred_class ();
357
358 extern rtx get_first_nonparm_insn ();
359
360 extern rtx pc_rtx;
361 extern rtx cc0_rtx;
362 extern rtx const0_rtx;
363 extern rtx const1_rtx;
364 extern rtx fconst0_rtx;
365 extern rtx dconst0_rtx;
366
367 extern rtx stack_pointer_rtx;
368 extern rtx frame_pointer_rtx;
369 extern rtx arg_pointer_rtx;
370 extern rtx struct_value_rtx;
371 extern rtx struct_value_incoming_rtx;
372 extern rtx static_chain_rtx;
373 extern rtx static_chain_incoming_rtx;
374
375 enum tree_code {
376
377   ERROR_MARK, 
378
379   IDENTIFIER_NODE, 
380
381   OP_IDENTIFIER, 
382
383   TREE_LIST, 
384
385   VOID_TYPE,     
386
387   INTEGER_TYPE, 
388
389   REAL_TYPE, 
390
391   COMPLEX_TYPE, 
392
393   ENUMERAL_TYPE, 
394
395   BOOLEAN_TYPE, 
396
397   CHAR_TYPE, 
398
399   POINTER_TYPE, 
400
401   OFFSET_TYPE, 
402
403   REFERENCE_TYPE, 
404
405   METHOD_TYPE, 
406
407   FILE_TYPE, 
408
409   ARRAY_TYPE, 
410
411   SET_TYPE, 
412
413   STRING_TYPE, 
414
415   RECORD_TYPE, 
416
417   UNION_TYPE,    
418
419   FUNCTION_TYPE, 
420
421   LANG_TYPE, 
422
423   LABEL_STMT, 
424
425   GOTO_STMT, 
426
427   RETURN_STMT, 
428
429   EXPR_STMT, 
430
431   WITH_STMT, 
432
433   LET_STMT, 
434
435   IF_STMT, 
436
437   EXIT_STMT, 
438
439   CASE_STMT, 
440
441   LOOP_STMT, 
442
443   COMPOUND_STMT, 
444
445   ASM_STMT, 
446
447   INTEGER_CST, 
448
449   REAL_CST, 
450
451   COMPLEX_CST, 
452
453   STRING_CST, 
454
455   FUNCTION_DECL, 
456   LABEL_DECL, 
457   CONST_DECL, 
458   TYPE_DECL, 
459   VAR_DECL, 
460   PARM_DECL, 
461   RESULT_DECL, 
462   FIELD_DECL, 
463   FRIEND_DECL, 
464
465   COMPONENT_REF, 
466
467   INDIRECT_REF, 
468
469   OFFSET_REF, 
470
471   BUFFER_REF, 
472
473   ARRAY_REF, 
474
475   CONSTRUCTOR, 
476
477   COMPOUND_EXPR, 
478
479   MODIFY_EXPR, 
480
481   INIT_EXPR, 
482
483   NEW_EXPR, 
484
485   DELETE_EXPR, 
486
487   COND_EXPR, 
488
489   CALL_EXPR, 
490
491   METHOD_CALL_EXPR, 
492
493   WITH_CLEANUP_EXPR, 
494
495   PLUS_EXPR, 
496   MINUS_EXPR, 
497   MULT_EXPR, 
498
499   TRUNC_DIV_EXPR, 
500
501   CEIL_DIV_EXPR, 
502
503   FLOOR_DIV_EXPR, 
504
505   ROUND_DIV_EXPR, 
506
507   TRUNC_MOD_EXPR, 
508   CEIL_MOD_EXPR, 
509   FLOOR_MOD_EXPR, 
510   ROUND_MOD_EXPR, 
511
512   RDIV_EXPR, 
513
514   FIX_TRUNC_EXPR, 
515   FIX_CEIL_EXPR, 
516   FIX_FLOOR_EXPR, 
517   FIX_ROUND_EXPR, 
518
519   FLOAT_EXPR, 
520
521   EXPON_EXPR, 
522
523   NEGATE_EXPR, 
524
525   MIN_EXPR, 
526   MAX_EXPR, 
527   ABS_EXPR, 
528   FFS_EXPR, 
529
530   LSHIFT_EXPR, 
531   RSHIFT_EXPR, 
532   LROTATE_EXPR, 
533   RROTATE_EXPR, 
534
535   BIT_IOR_EXPR, 
536   BIT_XOR_EXPR, 
537   BIT_AND_EXPR, 
538   BIT_ANDTC_EXPR, 
539   BIT_NOT_EXPR, 
540
541   TRUTH_ANDIF_EXPR, 
542   TRUTH_ORIF_EXPR, 
543   TRUTH_AND_EXPR, 
544   TRUTH_OR_EXPR, 
545   TRUTH_NOT_EXPR, 
546
547   LT_EXPR, 
548   LE_EXPR, 
549   GT_EXPR, 
550   GE_EXPR, 
551   EQ_EXPR, 
552   NE_EXPR, 
553
554   IN_EXPR, 
555   SET_LE_EXPR, 
556   CARD_EXPR, 
557   RANGE_EXPR, 
558
559   CONVERT_EXPR, 
560
561   NOP_EXPR, 
562
563   SAVE_EXPR, 
564
565   RTL_EXPR, 
566
567   ADDR_EXPR, 
568
569   REFERENCE_EXPR, 
570
571   WRAPPER_EXPR, 
572   ANTI_WRAPPER_EXPR, 
573
574   ENTRY_VALUE_EXPR, 
575
576   COMPLEX_EXPR, 
577
578   CONJ_EXPR, 
579
580   REALPART_EXPR, 
581   IMAGPART_EXPR, 
582
583   PREDECREMENT_EXPR, 
584   PREINCREMENT_EXPR, 
585   POSTDECREMENT_EXPR, 
586   POSTINCREMENT_EXPR, 
587
588   LAST_AND_UNUSED_TREE_CODE      
589
590 };
591
592 extern char *tree_code_type[];
593
594 extern int tree_code_length[];
595
596 enum built_in_function
597 {
598   NOT_BUILT_IN,
599   BUILT_IN_ALLOCA,
600   BUILT_IN_ABS,
601   BUILT_IN_FABS,
602   BUILT_IN_LABS,
603   BUILT_IN_FFS,
604   BUILT_IN_DIV,
605   BUILT_IN_LDIV,
606   BUILT_IN_FFLOOR,
607   BUILT_IN_FCEIL,
608   BUILT_IN_FMOD,
609   BUILT_IN_FREM,
610   BUILT_IN_MEMCPY,
611   BUILT_IN_MEMCMP,
612   BUILT_IN_MEMSET,
613   BUILT_IN_FSQRT,
614   BUILT_IN_GETEXP,
615   BUILT_IN_GETMAN,
616   BUILT_IN_SAVEREGS,
617
618   BUILT_IN_NEW,
619   BUILT_IN_VEC_NEW,
620   BUILT_IN_DELETE,
621   BUILT_IN_VEC_DELETE,
622 };
623
624 typedef union tree_node *tree;
625
626 struct tree_common
627 {
628   int uid;
629   union tree_node *chain;
630   union tree_node *type;
631   enum tree_code code : 8;
632
633   unsigned external_attr : 1;
634   unsigned public_attr : 1;
635   unsigned static_attr : 1;
636   unsigned volatile_attr : 1;
637   unsigned packed_attr : 1;
638   unsigned readonly_attr : 1;
639   unsigned literal_attr : 1;
640   unsigned nonlocal_attr : 1;
641   unsigned permanent_attr : 1;
642   unsigned addressable_attr : 1;
643   unsigned regdecl_attr : 1;
644   unsigned this_vol_attr : 1;
645   unsigned unsigned_attr : 1;
646   unsigned asm_written_attr: 1;
647   unsigned inline_attr : 1;
648   unsigned used_attr : 1;
649   unsigned lang_flag_1 : 1;
650   unsigned lang_flag_2 : 1;
651   unsigned lang_flag_3 : 1;
652   unsigned lang_flag_4 : 1;
653 };
654
655 struct tree_int_cst
656 {
657   char common[sizeof (struct tree_common)];
658   long int_cst_low;
659   long int_cst_high;
660 };
661
662 extern double ldexp ();
663
664 extern double atof ();
665
666 union real_extract 
667 {
668   double  d;
669   int i[sizeof (double ) / sizeof (int)];
670 };
671
672 struct tree_real_cst
673 {
674   char common[sizeof (struct tree_common)];
675   struct rtx_def *rtl;   
676
677   double  real_cst;
678 };
679
680 struct tree_string
681 {
682   char common[sizeof (struct tree_common)];
683   struct rtx_def *rtl;   
684
685   int length;
686   char *pointer;
687 };
688
689 struct tree_complex
690 {
691   char common[sizeof (struct tree_common)];
692   struct rtx_def *rtl;   
693
694   union tree_node *real;
695   union tree_node *imag;
696 };
697
698 struct tree_identifier
699 {
700   char common[sizeof (struct tree_common)];
701   int length;
702   char *pointer;
703   union tree_node *global_value;
704   union tree_node *local_value;
705   union tree_node *label_value;
706   union tree_node *implicit_decl;
707   union tree_node *error_locus;
708 };
709
710 struct tree_list
711 {
712   char common[sizeof (struct tree_common)];
713   union tree_node *purpose;
714   union tree_node *value;
715 };
716
717 struct tree_exp
718 {
719   char common[sizeof (struct tree_common)];
720   int complexity;
721   union tree_node *operands[1];
722 };
723
724 struct tree_type
725 {
726   char common[sizeof (struct tree_common)];
727   union tree_node *values;
728   union tree_node *sep;
729   union tree_node *size;
730
731   enum machine_mode mode : 8;
732   unsigned char size_unit;
733   unsigned char align;
734   unsigned char sep_unit;
735
736   union tree_node *pointer_to;
737   union tree_node *reference_to;
738   int parse_info;
739   int symtab_address;
740   union tree_node *name;
741   union tree_node *max;
742   union tree_node *next_variant;
743   union tree_node *main_variant;
744   union tree_node *basetypes;
745   union tree_node *noncopied_parts;
746   struct lang_type *lang_specific;
747 };
748
749 struct tree_decl
750 {
751   char common[sizeof (struct tree_common)];
752   char *filename;
753   int linenum;
754   union tree_node *size;
755   enum machine_mode mode;
756   unsigned char size_unit;
757   unsigned char align;
758   unsigned char voffset_unit;
759   union tree_node *name;
760   union tree_node *context;
761   int offset;
762   union tree_node *voffset;
763   union tree_node *arguments;
764   union tree_node *result;
765   union tree_node *initial;
766   struct rtx_def *rtl;   
767
768   int frame_size;                
769   struct rtx_def *saved_insns;   
770
771   int block_symtab_address;
772   struct lang_decl *lang_specific;
773 };
774
775 struct tree_stmt
776 {
777   char common[sizeof (struct tree_common)];
778   char *filename;
779   int linenum;
780   union tree_node *body;
781 };
782
783 struct tree_if_stmt
784 {
785   char common[sizeof (struct tree_common)];
786   char *filename;
787   int linenum;
788   union tree_node *cond, *thenpart, *elsepart;
789 };
790
791 struct tree_bind_stmt
792 {
793   char common[sizeof (struct tree_common)];
794   char *filename;
795   int linenum;
796   union tree_node *body, *vars, *supercontext, *bind_size, *type_tags;
797 };
798
799 struct tree_case_stmt
800 {
801   char common[sizeof (struct tree_common)];
802   char *filename;
803   int linenum;
804   union tree_node *index, *case_list;
805 };
806
807 union tree_node
808 {
809   struct tree_common common;
810   struct tree_int_cst int_cst;
811   struct tree_real_cst real_cst;
812   struct tree_string string;
813   struct tree_complex complex;
814   struct tree_identifier identifier;
815   struct tree_decl decl;
816   struct tree_type type;
817   struct tree_list list;
818   struct tree_exp exp;
819   struct tree_stmt stmt;
820   struct tree_if_stmt if_stmt;
821   struct tree_bind_stmt bind_stmt;
822   struct tree_case_stmt case_stmt;
823 };
824 extern char *oballoc ();
825 extern char *permalloc ();
826
827 extern tree make_node ();
828
829 extern tree copy_node ();
830
831 extern tree get_identifier ();
832
833 extern tree build_int_2 ();
834 extern tree build_real ();
835 extern tree build_real_from_string ();
836 extern tree build_real_from_int_cst ();
837 extern tree build_complex ();
838 extern tree build_string ();
839 extern tree build ();
840 extern tree build_nt ();
841 extern tree build_tree_list ();
842 extern tree build_op_identifier ();
843 extern tree build_decl ();
844 extern tree build_let ();
845
846 extern tree make_signed_type ();
847 extern tree make_unsigned_type ();
848 extern void fixup_unsigned_type ();
849 extern tree build_pointer_type ();
850 extern tree build_reference_type ();
851 extern tree build_index_type ();
852 extern tree build_array_type ();
853 extern tree build_function_type ();
854 extern tree build_method_type ();
855 extern tree build_offset_type ();
856 extern tree array_type_nelts ();
857
858 extern tree build_binary_op ();
859 extern tree build_indirect_ref ();
860 extern tree build_unary_op ();
861
862 extern tree build_type_variant ();
863
864 extern void layout_type ();
865
866 extern tree type_hash_canon ();
867
868 extern void layout_decl ();
869
870 extern tree fold ();
871
872 extern tree combine ();
873
874 extern tree convert ();
875 extern tree convert_units ();
876 extern tree size_in_bytes ();
877 extern tree genop ();
878 extern tree build_int ();
879 extern tree get_pending_sizes ();
880
881 extern tree sizetype;
882
883 extern tree chainon ();
884
885 extern tree tree_cons (), perm_tree_cons (), temp_tree_cons ();
886 extern tree saveable_tree_cons ();
887
888 extern tree tree_last ();
889
890 extern tree nreverse ();
891
892 extern int list_length ();
893
894 extern int integer_zerop ();
895
896 extern int integer_onep ();
897
898 extern int integer_all_onesp ();
899
900 extern int type_unsigned_p ();
901
902 extern int staticp ();
903
904 extern int lvalue_or_else ();
905
906 extern tree save_expr ();
907
908 extern tree stabilize_reference ();
909
910 extern tree get_unwidened ();
911
912 extern tree get_narrower ();
913
914 extern tree type_for_size ();
915
916 extern tree unsigned_type ();
917
918 extern tree signed_type ();
919
920 extern tree get_floating_type ();
921
922 extern char *function_cannot_inline_p ();
923
924 extern tree integer_zero_node;
925
926 extern tree integer_one_node;
927
928 extern tree size_zero_node;
929
930 extern tree size_one_node;
931
932 extern tree null_pointer_node;
933
934 extern tree error_mark_node;
935
936 extern tree void_type_node;
937
938 extern tree integer_type_node;
939
940 extern tree unsigned_type_node;
941
942 extern tree char_type_node;
943
944 extern char *input_filename;
945
946 extern int pedantic;
947
948 extern int immediate_size_expand;
949
950 extern tree current_function_decl;
951
952 extern int current_function_calls_setjmp;
953
954 extern int all_types_permanent;
955
956 extern tree expand_start_stmt_expr ();
957 extern tree expand_end_stmt_expr ();
958 extern void expand_expr_stmt(), clear_last_expr();
959 extern void expand_label(), expand_goto(), expand_asm();
960 extern void expand_start_cond(), expand_end_cond();
961 extern void expand_start_else(), expand_end_else();
962 extern void expand_start_loop(), expand_start_loop_continue_elsewhere();
963 extern void expand_loop_continue_here();
964 extern void expand_end_loop();
965 extern int expand_continue_loop();
966 extern int expand_exit_loop(), expand_exit_loop_if_false();
967 extern int expand_exit_something();
968
969 extern void expand_start_delayed_expr ();
970 extern tree expand_end_delayed_expr ();
971 extern void expand_emit_delayed_expr ();
972
973 extern void expand_null_return(), expand_return();
974 extern void expand_start_bindings(), expand_end_bindings();
975 extern void expand_start_case(), expand_end_case();
976 extern int pushcase(), pushcase_range ();
977 extern void expand_start_function(), expand_end_function();
978
979 extern char *main_input_filename;
980
981 enum debugger { NO_DEBUG = 0, GDB_DEBUG = 1, DBX_DEBUG = 2, SDB_DEBUG = 3,
982                 EXTENDED_DBX_DEBUG = 4 };
983
984 extern enum debugger write_symbols;
985
986 extern int use_gdb_dbx_extensions;
987
988 extern int optimize;
989
990 extern int obey_regdecls;
991
992 extern int quiet_flag;
993
994 extern int inhibit_warnings;
995
996 extern int extra_warnings;
997
998 extern int warn_unused;
999
1000 extern int warn_shadow;
1001
1002 extern int warn_switch;
1003
1004 extern int warn_id_clash;
1005 extern int id_clash_len;
1006
1007 extern int profile_flag;
1008
1009 extern int profile_block_flag;
1010
1011 extern int pedantic;
1012
1013 extern int flag_caller_saves;
1014
1015 extern int flag_pcc_struct_return;
1016
1017 extern int flag_force_mem;
1018
1019 extern int flag_force_addr;
1020
1021 extern int flag_defer_pop;
1022
1023 extern int flag_float_store;
1024
1025 extern int flag_combine_regs;
1026
1027 extern int flag_strength_reduce;
1028
1029 extern int flag_writable_strings;
1030
1031 extern int flag_no_function_cse;
1032
1033 extern int flag_omit_frame_pointer;
1034
1035 extern int frame_pointer_needed;
1036
1037 extern int flag_no_peephole;
1038
1039 extern int flag_volatile;
1040
1041 extern int flag_inline_functions;
1042
1043 extern int flag_keep_inline_functions;
1044
1045 extern int flag_syntax_only;
1046
1047 extern int flag_shared_data;
1048
1049 extern rtx gen_tstsi ();
1050
1051 extern rtx gen_tsthi ();
1052
1053 extern rtx gen_tstqi ();
1054
1055 extern rtx gen_tstsf ();
1056
1057 extern rtx gen_tstdf ();
1058
1059 extern rtx gen_cmpsi ();
1060
1061 extern rtx gen_cmphi ();
1062
1063 extern rtx gen_cmpqi ();
1064
1065 extern rtx gen_cmpdf ();
1066
1067 extern rtx gen_cmpsf ();
1068
1069 extern rtx gen_movsi ();
1070
1071 extern rtx gen_movhi ();
1072
1073 extern rtx gen_movstricthi ();
1074
1075 extern rtx gen_movqi ();
1076
1077 extern rtx gen_movstrictqi ();
1078
1079 extern rtx gen_movsf ();
1080
1081 extern rtx gen_movdf ();
1082
1083 extern rtx gen_movdi ();
1084
1085 extern rtx gen_pushasi ();
1086
1087 extern rtx gen_truncsiqi2 ();
1088
1089 extern rtx gen_trunchiqi2 ();
1090
1091 extern rtx gen_truncsihi2 ();
1092
1093 extern rtx gen_zero_extendhisi2 ();
1094
1095 extern rtx gen_zero_extendqihi2 ();
1096
1097 extern rtx gen_zero_extendqisi2 ();
1098
1099 extern rtx gen_extendhisi2 ();
1100
1101 extern rtx gen_extendqihi2 ();
1102
1103 extern rtx gen_extendqisi2 ();
1104
1105 extern rtx gen_extendsfdf2 ();
1106
1107 extern rtx gen_truncdfsf2 ();
1108
1109 extern rtx gen_floatsisf2 ();
1110
1111 extern rtx gen_floatsidf2 ();
1112
1113 extern rtx gen_floathisf2 ();
1114
1115 extern rtx gen_floathidf2 ();
1116
1117 extern rtx gen_floatqisf2 ();
1118
1119 extern rtx gen_floatqidf2 ();
1120
1121 extern rtx gen_ftruncdf2 ();
1122
1123 extern rtx gen_ftruncsf2 ();
1124
1125 extern rtx gen_fixsfqi2 ();
1126
1127 extern rtx gen_fixsfhi2 ();
1128
1129 extern rtx gen_fixsfsi2 ();
1130
1131 extern rtx gen_fixdfqi2 ();
1132
1133 extern rtx gen_fixdfhi2 ();
1134
1135 extern rtx gen_fixdfsi2 ();
1136
1137 extern rtx gen_fix_truncsfsi2 ();
1138
1139 extern rtx gen_fix_truncdfsi2 ();
1140
1141 extern rtx gen_addsi3 ();
1142
1143 extern rtx gen_addhi3 ();
1144
1145 extern rtx gen_addqi3 ();
1146
1147 extern rtx gen_adddf3 ();
1148
1149 extern rtx gen_addsf3 ();
1150
1151 extern rtx gen_subsi3 ();
1152
1153 extern rtx gen_subhi3 ();
1154
1155 extern rtx gen_subqi3 ();
1156
1157 extern rtx gen_subdf3 ();
1158
1159 extern rtx gen_subsf3 ();
1160
1161 extern rtx gen_mulhi3 ();
1162
1163 extern rtx gen_mulhisi3 ();
1164
1165 extern rtx gen_mulsi3 ();
1166
1167 extern rtx gen_umulhi3 ();
1168
1169 extern rtx gen_umulhisi3 ();
1170
1171 extern rtx gen_umulsi3 ();
1172
1173 extern rtx gen_muldf3 ();
1174
1175 extern rtx gen_mulsf3 ();
1176
1177 extern rtx gen_divhi3 ();
1178
1179 extern rtx gen_divhisi3 ();
1180
1181 extern rtx gen_divsi3 ();
1182
1183 extern rtx gen_udivhi3 ();
1184
1185 extern rtx gen_udivhisi3 ();
1186
1187 extern rtx gen_udivsi3 ();
1188
1189 extern rtx gen_divdf3 ();
1190
1191 extern rtx gen_divsf3 ();
1192
1193 extern rtx gen_modhi3 ();
1194
1195 extern rtx gen_modhisi3 ();
1196
1197 extern rtx gen_umodhi3 ();
1198
1199 extern rtx gen_umodhisi3 ();
1200
1201 extern rtx gen_divmodsi4 ();
1202
1203 extern rtx gen_udivmodsi4 ();
1204
1205 extern rtx gen_andsi3 ();
1206
1207 extern rtx gen_andhi3 ();
1208
1209 extern rtx gen_andqi3 ();
1210
1211 extern rtx gen_iorsi3 ();
1212
1213 extern rtx gen_iorhi3 ();
1214
1215 extern rtx gen_iorqi3 ();
1216
1217 extern rtx gen_xorsi3 ();
1218
1219 extern rtx gen_xorhi3 ();
1220
1221 extern rtx gen_xorqi3 ();
1222
1223 extern rtx gen_negsi2 ();
1224
1225 extern rtx gen_neghi2 ();
1226
1227 extern rtx gen_negqi2 ();
1228
1229 extern rtx gen_negsf2 ();
1230
1231 extern rtx gen_negdf2 ();
1232
1233 extern rtx gen_abssf2 ();
1234
1235 extern rtx gen_absdf2 ();
1236
1237 extern rtx gen_one_cmplsi2 ();
1238
1239 extern rtx gen_one_cmplhi2 ();
1240
1241 extern rtx gen_one_cmplqi2 ();
1242
1243 extern rtx gen_ashlsi3 ();
1244
1245 extern rtx gen_ashlhi3 ();
1246
1247 extern rtx gen_ashlqi3 ();
1248
1249 extern rtx gen_ashrsi3 ();
1250
1251 extern rtx gen_ashrhi3 ();
1252
1253 extern rtx gen_ashrqi3 ();
1254
1255 extern rtx gen_lshlsi3 ();
1256
1257 extern rtx gen_lshlhi3 ();
1258
1259 extern rtx gen_lshlqi3 ();
1260
1261 extern rtx gen_lshrsi3 ();
1262
1263 extern rtx gen_lshrhi3 ();
1264
1265 extern rtx gen_lshrqi3 ();
1266
1267 extern rtx gen_rotlsi3 ();
1268
1269 extern rtx gen_rotlhi3 ();
1270
1271 extern rtx gen_rotlqi3 ();
1272
1273 extern rtx gen_rotrsi3 ();
1274
1275 extern rtx gen_rotrhi3 ();
1276
1277 extern rtx gen_rotrqi3 ();
1278
1279 extern rtx gen_extv ();
1280
1281 extern rtx gen_extzv ();
1282
1283 extern rtx gen_insv ();
1284
1285 extern rtx gen_seq ();
1286
1287 extern rtx gen_sne ();
1288
1289 extern rtx gen_sgt ();
1290
1291 extern rtx gen_sgtu ();
1292
1293 extern rtx gen_slt ();
1294
1295 extern rtx gen_sltu ();
1296
1297 extern rtx gen_sge ();
1298
1299 extern rtx gen_sgeu ();
1300
1301 extern rtx gen_sle ();
1302
1303 extern rtx gen_sleu ();
1304
1305 extern rtx gen_beq ();
1306
1307 extern rtx gen_bne ();
1308
1309 extern rtx gen_bgt ();
1310
1311 extern rtx gen_bgtu ();
1312
1313 extern rtx gen_blt ();
1314
1315 extern rtx gen_bltu ();
1316
1317 extern rtx gen_bge ();
1318
1319 extern rtx gen_bgeu ();
1320
1321 extern rtx gen_ble ();
1322
1323 extern rtx gen_bleu ();
1324
1325 extern rtx gen_casesi_1 ();
1326
1327 extern rtx gen_casesi_2 ();
1328
1329 extern rtx gen_casesi ();
1330
1331 extern rtx gen_jump ();
1332
1333 extern rtx gen_call ();
1334
1335 extern rtx gen_call_value ();
1336
1337 extern rtx gen_return ();
1338
1339 enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM, EXPAND_CONST_ADDRESS};
1340
1341 extern int cse_not_expected;
1342
1343 extern rtx save_expr_regs;
1344
1345 struct args_size
1346 {
1347   int constant;
1348   tree var;
1349 };
1350
1351 enum direction {none, upward, downward};   
1352
1353 enum insn_code {
1354   CODE_FOR_tstsi = 2,
1355   CODE_FOR_tsthi = 3,
1356   CODE_FOR_tstqi = 4,
1357   CODE_FOR_tstsf = 5,
1358   CODE_FOR_tstdf = 8,
1359   CODE_FOR_cmpsi = 11,
1360   CODE_FOR_cmphi = 12,
1361   CODE_FOR_cmpqi = 13,
1362   CODE_FOR_cmpdf = 14,
1363   CODE_FOR_cmpsf = 17,
1364   CODE_FOR_movsi = 31,
1365   CODE_FOR_movhi = 32,
1366   CODE_FOR_movstricthi = 33,
1367   CODE_FOR_movqi = 34,
1368   CODE_FOR_movstrictqi = 35,
1369   CODE_FOR_movsf = 36,
1370   CODE_FOR_movdf = 37,
1371   CODE_FOR_movdi = 38,
1372   CODE_FOR_pushasi = 39,
1373   CODE_FOR_truncsiqi2 = 40,
1374   CODE_FOR_trunchiqi2 = 41,
1375   CODE_FOR_truncsihi2 = 42,
1376   CODE_FOR_zero_extendhisi2 = 43,
1377   CODE_FOR_zero_extendqihi2 = 44,
1378   CODE_FOR_zero_extendqisi2 = 45,
1379   CODE_FOR_extendhisi2 = 49,
1380   CODE_FOR_extendqihi2 = 50,
1381   CODE_FOR_extendqisi2 = 51,
1382   CODE_FOR_extendsfdf2 = 52,
1383   CODE_FOR_truncdfsf2 = 55,
1384   CODE_FOR_floatsisf2 = 58,
1385   CODE_FOR_floatsidf2 = 61,
1386   CODE_FOR_floathisf2 = 64,
1387   CODE_FOR_floathidf2 = 65,
1388   CODE_FOR_floatqisf2 = 66,
1389   CODE_FOR_floatqidf2 = 67,
1390   CODE_FOR_ftruncdf2 = 68,
1391   CODE_FOR_ftruncsf2 = 69,
1392   CODE_FOR_fixsfqi2 = 70,
1393   CODE_FOR_fixsfhi2 = 71,
1394   CODE_FOR_fixsfsi2 = 72,
1395   CODE_FOR_fixdfqi2 = 73,
1396   CODE_FOR_fixdfhi2 = 74,
1397   CODE_FOR_fixdfsi2 = 75,
1398   CODE_FOR_fix_truncsfsi2 = 76,
1399   CODE_FOR_fix_truncdfsi2 = 77,
1400   CODE_FOR_addsi3 = 78,
1401   CODE_FOR_addhi3 = 80,
1402   CODE_FOR_addqi3 = 82,
1403   CODE_FOR_adddf3 = 84,
1404   CODE_FOR_addsf3 = 87,
1405   CODE_FOR_subsi3 = 90,
1406   CODE_FOR_subhi3 = 92,
1407   CODE_FOR_subqi3 = 94,
1408   CODE_FOR_subdf3 = 96,
1409   CODE_FOR_subsf3 = 99,
1410   CODE_FOR_mulhi3 = 102,
1411   CODE_FOR_mulhisi3 = 103,
1412   CODE_FOR_mulsi3 = 104,
1413   CODE_FOR_umulhi3 = 105,
1414   CODE_FOR_umulhisi3 = 106,
1415   CODE_FOR_umulsi3 = 107,
1416   CODE_FOR_muldf3 = 108,
1417   CODE_FOR_mulsf3 = 111,
1418   CODE_FOR_divhi3 = 114,
1419   CODE_FOR_divhisi3 = 115,
1420   CODE_FOR_divsi3 = 116,
1421   CODE_FOR_udivhi3 = 117,
1422   CODE_FOR_udivhisi3 = 118,
1423   CODE_FOR_udivsi3 = 119,
1424   CODE_FOR_divdf3 = 120,
1425   CODE_FOR_divsf3 = 123,
1426   CODE_FOR_modhi3 = 126,
1427   CODE_FOR_modhisi3 = 127,
1428   CODE_FOR_umodhi3 = 128,
1429   CODE_FOR_umodhisi3 = 129,
1430   CODE_FOR_divmodsi4 = 130,
1431   CODE_FOR_udivmodsi4 = 131,
1432   CODE_FOR_andsi3 = 132,
1433   CODE_FOR_andhi3 = 133,
1434   CODE_FOR_andqi3 = 134,
1435   CODE_FOR_iorsi3 = 137,
1436   CODE_FOR_iorhi3 = 138,
1437   CODE_FOR_iorqi3 = 139,
1438   CODE_FOR_xorsi3 = 140,
1439   CODE_FOR_xorhi3 = 141,
1440   CODE_FOR_xorqi3 = 142,
1441   CODE_FOR_negsi2 = 143,
1442   CODE_FOR_neghi2 = 144,
1443   CODE_FOR_negqi2 = 145,
1444   CODE_FOR_negsf2 = 146,
1445   CODE_FOR_negdf2 = 149,
1446   CODE_FOR_abssf2 = 152,
1447   CODE_FOR_absdf2 = 155,
1448   CODE_FOR_one_cmplsi2 = 158,
1449   CODE_FOR_one_cmplhi2 = 159,
1450   CODE_FOR_one_cmplqi2 = 160,
1451   CODE_FOR_ashlsi3 = 167,
1452   CODE_FOR_ashlhi3 = 168,
1453   CODE_FOR_ashlqi3 = 169,
1454   CODE_FOR_ashrsi3 = 170,
1455   CODE_FOR_ashrhi3 = 171,
1456   CODE_FOR_ashrqi3 = 172,
1457   CODE_FOR_lshlsi3 = 173,
1458   CODE_FOR_lshlhi3 = 174,
1459   CODE_FOR_lshlqi3 = 175,
1460   CODE_FOR_lshrsi3 = 176,
1461   CODE_FOR_lshrhi3 = 177,
1462   CODE_FOR_lshrqi3 = 178,
1463   CODE_FOR_rotlsi3 = 179,
1464   CODE_FOR_rotlhi3 = 180,
1465   CODE_FOR_rotlqi3 = 181,
1466   CODE_FOR_rotrsi3 = 182,
1467   CODE_FOR_rotrhi3 = 183,
1468   CODE_FOR_rotrqi3 = 184,
1469   CODE_FOR_extv = 188,
1470   CODE_FOR_extzv = 189,
1471   CODE_FOR_insv = 193,
1472   CODE_FOR_seq = 205,
1473   CODE_FOR_sne = 206,
1474   CODE_FOR_sgt = 207,
1475   CODE_FOR_sgtu = 208,
1476   CODE_FOR_slt = 209,
1477   CODE_FOR_sltu = 210,
1478   CODE_FOR_sge = 211,
1479   CODE_FOR_sgeu = 212,
1480   CODE_FOR_sle = 213,
1481   CODE_FOR_sleu = 214,
1482   CODE_FOR_beq = 215,
1483   CODE_FOR_bne = 216,
1484   CODE_FOR_bgt = 217,
1485   CODE_FOR_bgtu = 218,
1486   CODE_FOR_blt = 219,
1487   CODE_FOR_bltu = 220,
1488   CODE_FOR_bge = 221,
1489   CODE_FOR_bgeu = 222,
1490   CODE_FOR_ble = 223,
1491   CODE_FOR_bleu = 224,
1492   CODE_FOR_casesi_1 = 235,
1493   CODE_FOR_casesi_2 = 236,
1494   CODE_FOR_casesi = 237,
1495   CODE_FOR_jump = 239,
1496   CODE_FOR_call = 243,
1497   CODE_FOR_call_value = 244,
1498   CODE_FOR_return = 245,
1499   CODE_FOR_nothing };
1500
1501 typedef struct optab
1502 {
1503   enum rtx_code code;
1504   struct {
1505     enum insn_code insn_code;
1506     char *lib_call;
1507   } handlers [(int) MAX_MACHINE_MODE ];
1508 } * optab;
1509
1510 extern rtx (*insn_gen_function[]) ();
1511
1512 extern optab add_optab;
1513 extern optab sub_optab;
1514 extern optab smul_optab;         
1515 extern optab umul_optab;         
1516 extern optab smul_widen_optab;   
1517
1518 extern optab umul_widen_optab;
1519 extern optab sdiv_optab;         
1520 extern optab sdivmod_optab;      
1521 extern optab udiv_optab;
1522 extern optab udivmod_optab;
1523 extern optab smod_optab;         
1524 extern optab umod_optab;
1525 extern optab flodiv_optab;       
1526 extern optab ftrunc_optab;       
1527 extern optab and_optab;          
1528 extern optab andcb_optab;        
1529 extern optab ior_optab;          
1530 extern optab xor_optab;          
1531 extern optab ashl_optab;         
1532 extern optab ashr_optab;         
1533 extern optab lshl_optab;         
1534 extern optab lshr_optab;         
1535 extern optab rotl_optab;         
1536 extern optab rotr_optab;         
1537
1538 extern optab mov_optab;          
1539 extern optab movstrict_optab;    
1540
1541 extern optab cmp_optab;          
1542 extern optab tst_optab;          
1543
1544 extern optab neg_optab;          
1545 extern optab abs_optab;          
1546 extern optab one_cmpl_optab;     
1547 extern optab ffs_optab;          
1548
1549 enum optab_methods
1550 {
1551   OPTAB_DIRECT,
1552   OPTAB_LIB,
1553   OPTAB_WIDEN,
1554   OPTAB_LIB_WIDEN,
1555 };
1556 typedef rtx (*rtxfun) ();
1557
1558 extern rtxfun bcc_gen_fctn[((int)LAST_AND_UNUSED_RTX_CODE) ];
1559
1560 extern rtxfun setcc_gen_fctn[((int)LAST_AND_UNUSED_RTX_CODE) ];
1561
1562 rtx expand_binop ();
1563
1564 rtx sign_expand_binop ();
1565
1566 rtx expand_unop ();
1567
1568 rtx negate_rtx ();
1569
1570 void init_fixtab ();
1571 void init_floattab ();
1572
1573 void expand_fix ();
1574
1575 void expand_float ();
1576
1577 rtx gen_add2_insn ();
1578 rtx gen_sub2_insn ();
1579 rtx gen_move_insn ();
1580
1581 void emit_clr_insn ();
1582
1583 void emit_0_to_1_insn ();
1584
1585 void emit_cmp_insn ();
1586
1587 void convert_move ();
1588
1589 rtx convert_to_mode ();
1590
1591 void emit_library_call ();
1592
1593 rtx force_operand ();
1594
1595 rtx expr_size ();
1596
1597 rtx plus_constant ();
1598
1599 rtx lookup_static_chain ();
1600
1601 rtx eliminate_constant_term ();
1602
1603 rtx memory_address ();
1604
1605 rtx memory_address_noforce ();
1606
1607 rtx change_address ();
1608
1609 int rtx_equal_p ();
1610
1611 rtx stabilize ();
1612
1613 rtx copy_all_regs ();
1614
1615 rtx copy_to_reg ();
1616
1617 rtx copy_addr_to_reg ();
1618
1619 rtx copy_to_mode_reg ();
1620
1621 rtx copy_to_suggested_reg ();
1622
1623 rtx force_reg ();
1624
1625 rtx force_not_mem ();
1626
1627 void adjust_stack ();
1628
1629 void anti_adjust_stack ();
1630
1631 rtx function_value ();
1632
1633 rtx hard_function_value ();
1634
1635 rtx hard_libcall_value ();
1636
1637 void copy_function_value ();
1638
1639 rtx round_push ();
1640
1641 rtx store_bit_field ();
1642 rtx extract_bit_field ();
1643 rtx expand_shift ();
1644 rtx expand_bit_and ();
1645 rtx expand_mult ();
1646 rtx expand_divmod ();
1647 rtx get_structure_value_addr ();
1648 rtx expand_stmt_expr ();
1649
1650 void jumpifnot ();
1651 void jumpif ();
1652 void do_jump ();
1653
1654 rtx assemble_static_space ();
1655
1656 struct _obstack_chunk            
1657 {
1658   char  *limit;                  
1659   struct _obstack_chunk *prev;   
1660   char  contents[4];             
1661 };
1662
1663 struct obstack           
1664 {
1665   long  chunk_size;              
1666   struct _obstack_chunk* chunk;  
1667   char  *object_base;            
1668   char  *next_free;              
1669   char  *chunk_limit;            
1670   int   temp;                    
1671   int   alignment_mask;          
1672   struct _obstack_chunk *(*chunkfun) ();  
1673   void (*freefun) ();            
1674 };
1675
1676 void obstack_init (struct obstack *obstack);
1677
1678 void * obstack_alloc (struct obstack *obstack, int size);
1679
1680 void * obstack_copy (struct obstack *obstack, void *address, int size);
1681 void * obstack_copy0 (struct obstack *obstack, void *address, int size);
1682
1683 void obstack_free (struct obstack *obstack, void *block);
1684
1685 void obstack_blank (struct obstack *obstack, int size);
1686
1687 void obstack_grow (struct obstack *obstack, void *data, int size);
1688 void obstack_grow0 (struct obstack *obstack, void *data, int size);
1689
1690 void obstack_1grow (struct obstack *obstack, int data_char);
1691
1692 void * obstack_finish (struct obstack *obstack);
1693
1694 int obstack_object_size (struct obstack *obstack);
1695
1696 int obstack_room (struct obstack *obstack);
1697 void obstack_1grow_fast (struct obstack *obstack, int data_char);
1698 void obstack_blank_fast (struct obstack *obstack, int size);
1699
1700 void * obstack_base (struct obstack *obstack);
1701 void * obstack_next_free (struct obstack *obstack);
1702 int obstack_alignment_mask (struct obstack *obstack);
1703 int obstack_chunk_size (struct obstack *obstack);
1704
1705 extern int xmalloc ();
1706 extern void free ();
1707
1708 extern struct obstack permanent_obstack, maybepermanent_obstack;
1709 extern struct obstack *rtl_obstack, *saveable_obstack, *current_obstack;
1710
1711 extern tree pushdecl ();
1712
1713 static rtx inline_target;
1714
1715 static rtx inline_fp_rtx;
1716
1717 static rtx *parm_map;
1718
1719 static char *fp_addr_p;
1720
1721 static int fp_delta;
1722
1723 static rtvec orig_asm_operands_vector;
1724
1725 static rtvec copy_asm_operands_vector;
1726
1727 static rtx copy_rtx_and_substitute ();
1728 static rtx copy_address ();
1729
1730 static void copy_parm_decls ();
1731 static void copy_decl_tree ();
1732
1733 static rtx try_fold_cc0 ();
1734
1735 static rtx fold_out_const_cc0 ();
1736
1737 char *
1738 function_cannot_inline_p (fndecl)
1739      register tree fndecl;
1740 {
1741   register rtx insn;
1742   tree last = tree_last (((((fndecl)->common.type) )->type.values) );
1743   int max_insns = (8 * (8 + list_length (((fndecl)->decl.arguments)  ) + 16*((fndecl)->common.inline_attr) )) ;
1744   register int ninsns = 0;
1745   register tree parms;
1746
1747   if (last && ((last)->list.value)  != void_type_node)
1748     return "varargs function cannot be inline";
1749
1750   if (get_max_uid () > 2 * max_insns)
1751     return "function too large to be inline";
1752
1753   for (parms = ((fndecl)->decl.arguments)  ; parms; parms = ((parms)->common.chain) )
1754     {
1755       if (((((parms)->common.type) )->type.mode)  == BLKmode)
1756         return "function with large aggregate parameter cannot be inline";
1757       if (last == (tree) 0   && ((parms)->common.addressable_attr) )
1758         return "no prototype, and parameter address used; cannot be inline";
1759
1760       if ((((((parms)->common.type) )->common.code)  == RECORD_TYPE
1761            || ((((parms)->common.type) )->common.code)  == UNION_TYPE)
1762           &&    ((((parms)->decl.rtl) )->code)  == MEM)
1763         return "address of an aggregate parameter is used; cannot be inline";
1764     }
1765
1766   if (get_max_uid () > max_insns)
1767     {
1768       for (ninsns = 0, insn = get_first_nonparm_insn (); insn && ninsns < max_insns;
1769            insn = ((insn)->fld[2].rtx) )
1770         {
1771           if (  ((insn)->code)  == INSN
1772               ||        ((insn)->code)  == JUMP_INSN
1773               ||        ((insn)->code)  == CALL_INSN)
1774             ninsns++;
1775         }
1776
1777       if (ninsns >= max_insns)
1778         return "function too large to be inline";
1779     }
1780
1781   return 0;
1782 }
1783
1784 static rtx *reg_map;
1785
1786 static rtx *label_map;
1787
1788 static rtx *insn_map;
1789
1790 static tree *parmdecl_map;
1791
1792 static int max_parm_reg;
1793
1794 static int first_parm_offset;
1795
1796 extern rtx return_label;
1797
1798 static rtx copy_for_inline ();
1799
1800 void
1801 save_for_inline (fndecl)
1802      tree fndecl;
1803 {
1804   extern rtx *regno_reg_rtx;     
1805   extern current_function_args_size;
1806
1807   rtx first_insn, last_insn, insn;
1808   rtx head, copy;
1809   tree parms;
1810   int max_labelno, min_labelno, i, len;
1811   int max_reg;
1812   int max_uid;
1813
1814   if (return_label == 0)
1815     {
1816       return_label = gen_label_rtx ();
1817       emit_label (return_label);
1818     }
1819
1820   max_labelno = max_label_num ();
1821   min_labelno = get_first_label_num ();
1822   max_parm_reg = max_parm_reg_num ();
1823   max_reg = max_reg_num ();
1824
1825   parmdecl_map = (tree *) __builtin_alloca  (max_parm_reg * sizeof (tree));
1826   memset (parmdecl_map,0, max_parm_reg * sizeof (tree)) ;
1827
1828   for (parms = ((fndecl)->decl.arguments)  ; parms; parms = ((parms)->common.chain) )
1829     {
1830       rtx p = ((parms)->decl.rtl) ;
1831
1832       if (      ((p)->code)  == REG)
1833         {
1834           parmdecl_map[((p)->fld[0].rtint) ] = parms;
1835           ((parms)->common.volatile_attr)  = 0;
1836         }
1837       else
1838         ((parms)->common.volatile_attr)  = 1;
1839       ((parms)->common.readonly_attr)  = 1;
1840     }
1841
1842   head = gen_inline_header_rtx (0 , 0 , min_labelno, max_labelno,
1843                                 max_parm_reg, max_reg,
1844                                 current_function_args_size);
1845   max_uid = ((head)->fld[0].rtint) ;
1846
1847   preserve_data ();
1848
1849   insn = get_insns ();
1850   if (  ((insn)->code)  != NOTE)
1851     abort ();
1852   first_insn = rtx_alloc (NOTE);
1853    ((first_insn)->fld[3].rtstr)  =  ((insn)->fld[3].rtstr) ;
1854   ((first_insn)->fld[4].rtint)  = ((insn)->fld[4].rtint) ;
1855   ((first_insn)->fld[0].rtint)  = ((insn)->fld[0].rtint) ;
1856   ((first_insn)->fld[1].rtx)  = 0 ;
1857   ((first_insn)->fld[2].rtx)  = 0 ;
1858   last_insn = first_insn;
1859
1860   reg_map = (rtx *) __builtin_alloca  ((max_reg + 1) * sizeof (rtx));
1861
1862   len = sizeof (struct rtx_def) + (     (rtx_length[(int)(REG)])  - 1) * sizeof (rtunion);
1863   for (i = max_reg - 1; i >= 56 ; i--)
1864     reg_map[i] = (rtx)({ struct obstack *__h = (&maybepermanent_obstack);       ({ struct obstack *__o = (__h); int __len = ( ( len));  ((__o->next_free + __len > __o->chunk_limit)    ? _obstack_newchunk (__o, __len) : 0);  memcpy ( __o->next_free, ( regno_reg_rtx[i]), __len) ;  __o->next_free += __len;        (void) 0; }) ;  ({ struct obstack *__o = (__h); void *value = (void *) __o->object_base;        __o->next_free  = (((((__o->next_free) - (char *)0) +__o->alignment_mask)       & ~ (__o->alignment_mask)) + (char *)0) ;       ((__o->next_free - (char *)__o->chunk   > __o->chunk_limit - (char *)__o->chunk)        ? (__o->next_free = __o->chunk_limit) : 0);     __o->object_base = __o->next_free;      value; }) ; }) ;
1865   memcpy (
1866          regno_reg_rtx + 56 ,reg_map + 56 ,
1867          (max_reg - 56 ) * sizeof (rtx)) ;
1868
1869   label_map = (rtx *)__builtin_alloca  ((max_labelno - min_labelno) * sizeof (rtx));
1870   label_map -= min_labelno;
1871
1872   for (i = min_labelno; i < max_labelno; i++)
1873     label_map[i] = gen_label_rtx ();
1874
1875   insn_map = (rtx *) __builtin_alloca  (max_uid * sizeof (rtx));
1876   memset (insn_map,0, max_uid * sizeof (rtx)) ;
1877
1878   for (insn = ((insn)->fld[2].rtx) ; insn; insn = ((insn)->fld[2].rtx) )
1879     {
1880       orig_asm_operands_vector = 0;
1881       copy_asm_operands_vector = 0;
1882
1883       switch (  ((insn)->code) )
1884         {
1885         case NOTE:
1886           if (((insn)->fld[4].rtint)  == -6 )
1887             continue;
1888
1889           copy = rtx_alloc (NOTE);
1890            ((copy)->fld[3].rtstr)  =  ((insn)->fld[3].rtstr) ;
1891           ((copy)->fld[4].rtint)  = ((insn)->fld[4].rtint) ;
1892           break;
1893
1894         case INSN:
1895         case CALL_INSN:
1896         case JUMP_INSN:
1897           copy = rtx_alloc (    ((insn)->code) );
1898           ((copy)->fld[3].rtx)  = copy_for_inline (((insn)->fld[3].rtx) );
1899           ((copy)->fld[4].rtint)  = -1;
1900                 ((copy)->fld[5].rtx)  = 0 ;
1901           ((copy)->fld[6].rtx)  = copy_for_inline (((insn)->fld[6].rtx) );
1902           break;
1903
1904         case CODE_LABEL:
1905           copy = label_map[((insn)->fld[3].rtint) ];
1906           break;
1907
1908         case BARRIER:
1909           copy = rtx_alloc (BARRIER);
1910           break;
1911
1912         default:
1913           abort ();
1914         }
1915       ((copy)->fld[0].rtint)  = ((insn)->fld[0].rtint) ;
1916       insn_map[((insn)->fld[0].rtint) ] = copy;
1917       ((last_insn)->fld[2].rtx)  = copy;
1918       ((copy)->fld[1].rtx)  = last_insn;
1919       last_insn = copy;
1920     }
1921
1922   ((last_insn)->fld[2].rtx)  = 0 ;
1923
1924   ((head)->fld[2].rtx)  = get_first_nonparm_insn ();
1925   ((head)->fld[3].rtx)  = get_insns ();
1926   ((fndecl)->decl.saved_insns)  = head;
1927   ((fndecl)->decl.frame_size)  = get_frame_size ();
1928   ((fndecl)->common.inline_attr)  = 1;
1929
1930   parmdecl_map = 0;
1931   label_map = 0;
1932   reg_map = 0;
1933   return_label = 0;
1934
1935   set_new_first_and_last_insn (first_insn, last_insn);
1936 }
1937
1938 static rtx
1939 copy_for_inline (orig)
1940      rtx orig;
1941 {
1942   register rtx x = orig;
1943   register int i;
1944   register enum rtx_code code;
1945   register char *format_ptr;
1946
1947   if (x == 0)
1948     return x;
1949
1950   code =        ((x)->code) ;
1951
1952   switch (code)
1953     {
1954     case QUEUED:
1955     case CONST_INT:
1956     case CONST_DOUBLE:
1957     case SYMBOL_REF:
1958     case PC:
1959     case CC0:
1960       return x;
1961
1962     case ASM_OPERANDS:
1963
1964       if (orig_asm_operands_vector == ((orig)->fld[ 3].rtvec) )
1965         {
1966           x = rtx_alloc (ASM_OPERANDS);
1967           ((x)->fld[ 0].rtstr)  = ((orig)->fld[ 0].rtstr) ;
1968           ((x)->fld[ 1].rtstr)  = ((orig)->fld[ 1].rtstr) ;
1969           ((x)->fld[ 2].rtint)  = ((orig)->fld[ 2].rtint) ;
1970           ((x)->fld[ 3].rtvec)  = copy_asm_operands_vector;
1971           ((x)->fld[ 4].rtvec)  = ((orig)->fld[ 4].rtvec) ;
1972           return x;
1973         }
1974       break;
1975
1976     case MEM:
1977
1978       if ( (    ((((x)->fld[ 0].rtx) )->code)  == LABEL_REF ||  ((((x)->fld[ 0].rtx) )->code)  == SYMBOL_REF    ||      ((((x)->fld[ 0].rtx) )->code)  == CONST_INT     ||      ((((x)->fld[ 0].rtx) )->code)  == CONST)  )
1979         return x;
1980       if (      ((((x)->fld[ 0].rtx) )->code)  == PLUS
1981           &&    ((((((x)->fld[ 0].rtx) )->fld[ 0].rtx) )->code)  == REG
1982           && (((((((x)->fld[ 0].rtx) )->fld[ 0].rtx) )->fld[0].rtint)  == 14 
1983               || ((((((x)->fld[ 0].rtx) )->fld[ 0].rtx) )->fld[0].rtint)  == 14 )
1984           &&  ( ((((((x)->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == LABEL_REF ||        ((((((x)->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == SYMBOL_REF  ||      ((((((x)->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == CONST_INT   ||      ((((((x)->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == CONST)  )
1985         if (    ((((x)->fld[ 0].rtx) )->code)  == REG
1986             && (((((x)->fld[ 0].rtx) )->fld[0].rtint)  == 14 
1987                 || ((((x)->fld[ 0].rtx) )->fld[0].rtint)  == 14 )
1988             &&  (       ((((x)->fld[ 1].rtx) )->code)  == LABEL_REF ||  ((((x)->fld[ 1].rtx) )->code)  == SYMBOL_REF    ||      ((((x)->fld[ 1].rtx) )->code)  == CONST_INT     ||      ((((x)->fld[ 1].rtx) )->code)  == CONST)  )
1989         return x;
1990       break;
1991
1992     case LABEL_REF:
1993       {
1994         return gen_rtx (LABEL_REF,      ((orig)->mode) ,
1995                         label_map[((((orig)->fld[ 0].rtx) )->fld[3].rtint) ]);
1996       }
1997
1998     case REG:
1999       if (((x)->fld[0].rtint)  >= 56 )
2000         return reg_map [((x)->fld[0].rtint) ];
2001       else
2002         return x;
2003
2004     case SET:
2005       {
2006         rtx dest = ((x)->fld[0].rtx) ;
2007
2008         if (    ((dest)->code)  == REG
2009             && ((dest)->fld[0].rtint)  < max_parm_reg
2010             && ((dest)->fld[0].rtint)  >= 56 
2011             && parmdecl_map[((dest)->fld[0].rtint) ] != 0)
2012           ((parmdecl_map[((dest)->fld[0].rtint) ])->common.readonly_attr)  = 0;
2013       }
2014       break;
2015     }
2016
2017   x = rtx_alloc (code);
2018   memcpy ( x,orig, sizeof (int) * (     (rtx_length[(int)(code)])  + 1)) ;
2019
2020   format_ptr =  (rtx_format[(int)(code)]) ;
2021
2022   for (i = 0; i <       (rtx_length[(int)(code)]) ; i++)
2023     {
2024       switch (*format_ptr++)
2025         {
2026         case 'e':
2027           ((x)->fld[ i].rtx)  = copy_for_inline (((x)->fld[ i].rtx) );
2028           break;
2029
2030         case 'u':
2031
2032           return insn_map[((((x)->fld[ i].rtx) )->fld[0].rtint) ];
2033
2034         case 'E':
2035           if (((x)->fld[ i].rtvec)  != 0  && ((x)->fld[ i].rtvec->num_elem)  != 0)
2036             {
2037               register int j;
2038
2039               ((x)->fld[ i].rtvec)  = gen_rtvec_v (((x)->fld[ i].rtvec->num_elem) , &((x)->fld[ i].rtvec->elem[ 0].rtx) );
2040               for (j = 0; j < ((x)->fld[ i].rtvec->num_elem) ; j++)
2041                 ((x)->fld[ i].rtvec->elem[ j].rtx) 
2042                   = copy_for_inline (((x)->fld[ i].rtvec->elem[ j].rtx) );
2043             }
2044           break;
2045         }
2046     }
2047
2048   if (code == ASM_OPERANDS && orig_asm_operands_vector == 0)
2049     {
2050       orig_asm_operands_vector = ((orig)->fld[ 3].rtvec) ;
2051       copy_asm_operands_vector = ((x)->fld[ 3].rtvec) ;
2052     }
2053
2054   return x;
2055 }
2056
2057 rtx
2058 expand_inline_function (fndecl, parms, target, ignore, type, structure_value_addr)
2059      tree fndecl, parms;
2060      rtx target;
2061      int ignore;
2062      tree type;
2063      rtx structure_value_addr;
2064 {
2065   tree formal, actual;
2066   rtx header = ((fndecl)->decl.saved_insns) ;
2067   rtx insns = ((header)->fld[2].rtx) ;
2068   rtx insn;
2069   int max_regno = ((header)->fld[7].rtint)  + 1;
2070   register int i;
2071   int min_labelno = ((header)->fld[4].rtint) ;
2072   int max_labelno = ((header)->fld[5].rtint) ;
2073   int nargs;
2074   rtx *arg_vec;
2075   rtx local_return_label = 0;
2076   rtx follows_call = 0;
2077   rtx this_struct_value_rtx = 0;
2078
2079   if (max_regno < 56 )
2080     abort ();
2081
2082   nargs = list_length (((fndecl)->decl.arguments)  );
2083
2084   first_parm_offset = 8 ;
2085
2086   if (list_length (parms) != nargs)
2087     return (rtx)-1;
2088
2089   for (formal = ((fndecl)->decl.arguments)  ,
2090        actual = parms;
2091        formal;
2092        formal = ((formal)->common.chain) ,
2093        actual = ((actual)->common.chain) )
2094     {
2095       tree arg = ((actual)->list.value) ;
2096       enum machine_mode mode = ((((formal)->decl.arguments)   )->type.mode) ;
2097       if (mode != ((((arg)->common.type) )->type.mode) )
2098         return (rtx)-1;
2099       if (mode == BLKmode && ((arg)->common.type)  != ((formal)->common.type) )
2100         return (rtx)-1;
2101     }
2102
2103   pushlevel (0);
2104   expand_start_bindings (0);
2105
2106   arg_vec = (rtx *)__builtin_alloca  (nargs * sizeof (rtx));
2107
2108   for (formal = ((fndecl)->decl.arguments)  ,
2109        actual = parms,
2110        i = 0;
2111        formal;
2112        formal = ((formal)->common.chain) ,
2113        actual = ((actual)->common.chain) ,
2114        i++)
2115     {
2116       tree arg = ((actual)->list.value) ;  
2117       enum machine_mode tmode = ((((formal)->decl.arguments)   )->type.mode) ;
2118       enum machine_mode imode = ((((formal)->common.type) )->type.mode) ;
2119       rtx copy;
2120
2121       emit_note (((formal)->decl.filename) , ((formal)->decl.linenum) );
2122
2123       if (((formal)->common.addressable_attr) )
2124         {
2125           int size = int_size_in_bytes (((formal)->common.type) );
2126           copy = assign_stack_local (tmode, size);
2127           if (!memory_address_p (((formal)->decl.mode) , ((copy)->fld[ 0].rtx) ))
2128             copy = change_address (copy, VOIDmode, copy_rtx (((copy)->fld[ 0].rtx) ));
2129           store_expr (arg, copy, 0);
2130         }
2131       else if (! ((formal)->common.readonly_attr) 
2132                || ((formal)->common.volatile_attr) )
2133         {
2134
2135           copy = gen_reg_rtx (tmode);
2136           store_expr (arg, copy, 0);
2137         }
2138       else
2139         {
2140           copy = expand_expr (arg, 0, tmode, 0);
2141
2142           if (  ((copy)->code)  != REG && ! (   ((copy)->code)  == LABEL_REF ||         ((copy)->code)  == SYMBOL_REF   ||      ((copy)->code)  == CONST_INT    ||      ((copy)->code)  == CONST) )
2143             copy = copy_to_reg (copy);
2144         }
2145
2146       if (tmode != imode)
2147         copy = convert_to_mode (imode, copy);
2148       arg_vec[i] = copy;
2149     }
2150
2151   copy_parm_decls (((fndecl)->decl.arguments)  , arg_vec);
2152
2153   emit_queue ();
2154
2155   do_pending_stack_adjust ();
2156
2157   if (structure_value_addr)
2158     {
2159       if (      ((struct_value_rtx)->code)  == MEM)
2160         {
2161           this_struct_value_rtx = force_reg (SImode , structure_value_addr);
2162         }
2163       else
2164         {
2165           this_struct_value_rtx = struct_value_rtx;
2166           emit_move_insn (this_struct_value_rtx, structure_value_addr);
2167         }
2168     }
2169
2170   reg_map = (rtx *) __builtin_alloca  (max_regno * sizeof (rtx));
2171   memset (reg_map,0, max_regno * sizeof (rtx)) ;
2172
2173   if (((fndecl)->decl.arguments)  )
2174     {
2175       tree decl = ((fndecl)->decl.arguments)  ;
2176       int offset = ((header)->fld[8].rtint) ;
2177
2178       parm_map =
2179         (rtx *)__builtin_alloca  ((offset / 4 ) * sizeof (rtx));
2180       memset (parm_map,0, (offset / 4 ) * sizeof (rtx)) ;
2181       parm_map -= first_parm_offset / 4 ;
2182
2183       for (formal = decl, i = 0; formal; formal = ((formal)->common.chain) , i++)
2184         {
2185
2186           if (((formal)->decl.offset)  >= 0)
2187             {
2188               parm_map[((formal)->decl.offset)  / 32 ] = arg_vec[i];
2189             }
2190           else
2191             {
2192
2193               rtx frtx = ((formal)->decl.rtl) ;
2194               rtx offset = 0;
2195               if (      ((frtx)->code)  == MEM)
2196                 {
2197                   frtx = ((frtx)->fld[ 0].rtx) ;
2198                   if (  ((frtx)->code)  == PLUS)
2199                     {
2200                       if (((frtx)->fld[ 0].rtx)  == frame_pointer_rtx
2201                           &&    ((((frtx)->fld[ 1].rtx) )->code)  == CONST_INT)
2202                         offset = ((frtx)->fld[ 1].rtx) ;
2203                       else if (((frtx)->fld[ 1].rtx)  == frame_pointer_rtx
2204                                &&       ((((frtx)->fld[ 0].rtx) )->code)  == CONST_INT)
2205                         offset = ((frtx)->fld[ 0].rtx) ;
2206                     }
2207                   if (offset)
2208                     parm_map[((offset)->fld[0].rtint)  / 4 ] = arg_vec[i];
2209                   else abort ();
2210                 }
2211               else if ( ((frtx)->code)  != REG)
2212                 abort ();
2213             }
2214
2215           if (  ((((formal)->decl.rtl) )->code)  == REG)
2216             reg_map[((((formal)->decl.rtl) )->fld[0].rtint) ] = arg_vec[i];
2217         }
2218
2219       if (this_struct_value_rtx == 0
2220           ||    ((struct_value_incoming_rtx)->code)  == REG)
2221         ;
2222       else if ( ((struct_value_incoming_rtx)->code)  == MEM
2223                && ((((struct_value_incoming_rtx)->fld[ 0].rtx) )->fld[ 0].rtx)  == frame_pointer_rtx
2224                &&       ((((((struct_value_incoming_rtx)->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == CONST_INT)
2225         parm_map[((((((struct_value_incoming_rtx)->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint)  / 4 ]
2226           = this_struct_value_rtx;
2227       else
2228         abort ();
2229     }
2230   else
2231     {
2232       parm_map = 0 ;
2233     }
2234
2235   label_map = (rtx *)__builtin_alloca  ((max_labelno - min_labelno) * sizeof (rtx));
2236   label_map -= min_labelno;
2237
2238   for (i = min_labelno; i < max_labelno; i++)
2239     label_map[i] = gen_label_rtx ();
2240
2241   insn_map = (rtx *) __builtin_alloca  (((header)->fld[0].rtint)  * sizeof (rtx));
2242   memset (insn_map,0, ((header)->fld[0].rtint)  * sizeof (rtx)) ;
2243
2244   if (structure_value_addr != 0 || ((type)->type.mode)  == VOIDmode)
2245     inline_target = 0;
2246   else
2247     {
2248       enum machine_mode departing_mode = ((type)->type.mode) ;
2249
2250       enum machine_mode arriving_mode
2251         = ((((fndecl)->decl.voffset) )->type.mode) ;
2252
2253       if (target &&     ((target)->code)  == REG
2254           &&    ((target)->mode)  == departing_mode)
2255         inline_target = target;
2256       else
2257         inline_target = target = gen_reg_rtx (departing_mode);
2258
2259       if (arriving_mode != departing_mode)
2260         inline_target = gen_rtx (SUBREG, arriving_mode, target, 0);
2261     }
2262
2263   fp_delta = get_frame_size ();
2264
2265   fp_delta = - fp_delta;
2266
2267   fp_delta -= 0 ;
2268
2269   inline_fp_rtx
2270     = copy_to_mode_reg (SImode ,
2271                         plus_constant (frame_pointer_rtx, fp_delta));
2272
2273   assign_stack_local (VOIDmode, ((fndecl)->decl.frame_size) );
2274
2275   for (insn = insns; insn; insn = ((insn)->fld[2].rtx) )
2276     {
2277       rtx copy, pattern, next = 0;
2278
2279       orig_asm_operands_vector = 0;
2280       copy_asm_operands_vector = 0;
2281
2282       switch (  ((insn)->code) )
2283         {
2284         case INSN:
2285           pattern = ((insn)->fld[3].rtx) ;
2286
2287           if (follows_call
2288
2289               && ! (    ((pattern)->code)  == SET
2290                     && ((pattern)->fld[0].rtx)  == stack_pointer_rtx))
2291             {
2292               if (      ((pattern)->code)  == SET
2293                   && rtx_equal_p (((pattern)->fld[1].rtx) , follows_call))
2294
2295                 {
2296                   copy = emit_insn (gen_rtx (SET, VOIDmode,
2297                                              copy_rtx_and_substitute (((pattern)->fld[0].rtx) ),
2298                                              follows_call));
2299                   ((copy)->integrated)  = 1;
2300                   follows_call = 0;
2301                   break;
2302                 }
2303               else if ( ((pattern)->code)  == USE
2304                        && rtx_equal_p (((pattern)->fld[ 0].rtx) , follows_call))
2305
2306                 {
2307                   copy = emit_insn (gen_rtx (SET, VOIDmode, inline_target,
2308                                              follows_call));
2309                   ((copy)->integrated)  = 1;
2310                   follows_call = 0;
2311                   break;
2312                 }
2313               follows_call = 0;
2314             }
2315
2316           copy = 0;
2317           if (  ((pattern)->code)  == USE
2318               &&        ((((pattern)->fld[ 0].rtx) )->code)  == REG
2319               && ((((pattern)->fld[ 0].rtx) )->integrated) )
2320             break;
2321
2322           if (  ((pattern)->code)  == SET
2323               && ((pattern)->fld[0].rtx)  == cc0_rtx)
2324             next = try_fold_cc0 (insn);
2325
2326           if (next != 0)
2327             {
2328               insn = next;
2329             }
2330           else
2331             {
2332               copy = emit_insn (copy_rtx_and_substitute (pattern));
2333               ((copy)->integrated)  = 1;
2334             }
2335           break;
2336
2337         case JUMP_INSN:
2338           follows_call = 0;
2339           if (  ((((insn)->fld[3].rtx) )->code)  == RETURN)
2340             {
2341               if (local_return_label == 0)
2342                 local_return_label = gen_label_rtx ();
2343               emit_jump (local_return_label);
2344               break;
2345             }
2346           copy = emit_jump_insn (copy_rtx_and_substitute (((insn)->fld[3].rtx) ));
2347           ((copy)->integrated)  = 1;
2348           break;
2349
2350         case CALL_INSN:
2351
2352           copy = emit_call_insn (copy_rtx_and_substitute (((insn)->fld[3].rtx) ));
2353
2354           ((copy)->integrated)  = 1;
2355
2356           if (  ((((insn)->fld[3].rtx) )->code)  == SET)
2357             follows_call = ((((insn)->fld[3].rtx) )->fld[0].rtx) ;
2358           break;
2359
2360         case CODE_LABEL:
2361           copy = emit_label (label_map[((insn)->fld[3].rtint) ]);
2362           follows_call = 0;
2363           break;
2364
2365         case BARRIER:
2366           copy = emit_barrier ();
2367           break;
2368
2369         case NOTE:
2370           if (((insn)->fld[4].rtint)  != -6 )
2371             copy = emit_note ( ((insn)->fld[3].rtstr) , ((insn)->fld[4].rtint) );
2372           else
2373             copy = 0;
2374           break;
2375
2376         default:
2377           abort ();
2378           break;
2379         }
2380
2381       insn_map[((insn)->fld[0].rtint) ] = copy;
2382     }
2383
2384   if (local_return_label)
2385     emit_label (local_return_label);
2386
2387   copy_decl_tree (((fndecl)->decl.initial) , 0);
2388
2389   expand_end_bindings (getdecls (), 1, 1);
2390   poplevel (1, 1, 0);
2391
2392   reg_map = 0 ;
2393   label_map = 0 ;
2394
2395   if (ignore || ((type)->type.mode)  == VOIDmode)
2396     return 0;
2397
2398   if (structure_value_addr)
2399     {
2400       if (target)
2401         return target;
2402       return gen_rtx (MEM, BLKmode,
2403                       memory_address (BLKmode, structure_value_addr));
2404     }
2405
2406   return target;
2407 }
2408
2409 static void
2410 copy_parm_decls (args, vec)
2411      tree args;
2412      rtx *vec;
2413 {
2414   register tree tail;
2415   register int i;
2416
2417   for (tail = args, i = 0; tail; tail = ((tail)->common.chain) , i++)
2418     {
2419       register tree decl = pushdecl (build_decl (VAR_DECL, ((tail)->decl.name) ,
2420                                                  ((tail)->common.type) ));
2421       ((decl)->common.used_attr)  = 1;
2422       ((decl)->decl.rtl)  = vec[i];
2423     }
2424 }
2425
2426 static void
2427 copy_decl_tree (let, level)
2428      tree let;
2429      int level;
2430 {
2431   tree t;
2432
2433   pushlevel (0);
2434   for (t = ((let)->bind_stmt.vars) ; t; t = ((t)->common.chain) )
2435     {
2436       tree d = build_decl (((t)->common.code) , ((t)->decl.name) , ((t)->common.type) );
2437       ((d)->decl.linenum)  = ((t)->decl.linenum) ;
2438       ((d)->decl.filename)  = ((t)->decl.filename) ;
2439       if (((t)->decl.rtl)  != 0)
2440         {
2441           if (  ((((t)->decl.rtl) )->code)  == MEM
2442               &&  (     ((((((t)->decl.rtl) )->fld[ 0].rtx) )->code)  == LABEL_REF ||   ((((((t)->decl.rtl) )->fld[ 0].rtx) )->code)  == SYMBOL_REF     ||      ((((((t)->decl.rtl) )->fld[ 0].rtx) )->code)  == CONST_INT      ||      ((((((t)->decl.rtl) )->fld[ 0].rtx) )->code)  == CONST)  )
2443
2444             ((d)->decl.rtl)  = ((t)->decl.rtl) ;
2445           else
2446             ((d)->decl.rtl)  = copy_rtx_and_substitute (((t)->decl.rtl) );
2447         }
2448       ((d)->common.external_attr)  = ((t)->common.external_attr) ;
2449       ((d)->common.static_attr)  = ((t)->common.static_attr) ;
2450       ((d)->common.public_attr)  = ((t)->common.public_attr) ;
2451       ((d)->common.literal_attr)  = ((t)->common.literal_attr) ;
2452       ((d)->common.addressable_attr)  = ((t)->common.addressable_attr) ;
2453       ((d)->common.readonly_attr)  = ((t)->common.readonly_attr) ;
2454       ((d)->common.volatile_attr)  = ((t)->common.volatile_attr) ;
2455       ((d)->common.used_attr)  = 1;
2456       pushdecl (d);
2457     }
2458
2459   for (t = ((let)->stmt.body) ; t; t = ((t)->common.chain) )
2460     copy_decl_tree (t, level + 1);
2461
2462   poplevel (level > 0, 0, 0);
2463 }
2464
2465 static rtx
2466 copy_rtx_and_substitute (orig)
2467      register rtx orig;
2468 {
2469   register rtx copy, temp;
2470   register int i, j;
2471   register enum rtx_code  code;
2472   register enum machine_mode mode;
2473   register char *format_ptr;
2474   int regno;
2475
2476   if (orig == 0)
2477     return 0;
2478
2479   code =        ((orig)->code) ;
2480   mode =        ((orig)->mode) ;
2481
2482   switch (code)
2483     {
2484     case REG:
2485
2486       regno = ((orig)->fld[0].rtint) ;
2487       if (regno < 56 )
2488         {
2489           if (((orig)->integrated) )
2490             {
2491
2492               if (inline_target == 0)
2493                 abort ();
2494               if (mode ==       ((inline_target)->mode) )
2495                 return inline_target;
2496               return gen_rtx (SUBREG, mode, inline_target, 0);
2497             }
2498           if (regno == 14 )
2499             return plus_constant (orig, fp_delta);
2500           return orig;
2501         }
2502       if (reg_map[regno] == 0 )
2503         reg_map[regno] = gen_reg_rtx (mode);
2504       return reg_map[regno];
2505
2506     case CODE_LABEL:
2507       return label_map[((orig)->fld[3].rtint) ];
2508
2509     case LABEL_REF:
2510       copy = rtx_alloc (LABEL_REF);
2511       ((copy)->mode = ( mode)) ;
2512       ((copy)->fld[ 0].rtx)  = label_map[((((orig)->fld[ 0].rtx) )->fld[3].rtint) ];
2513       return copy;
2514
2515     case PC:
2516     case CC0:
2517     case CONST_INT:
2518     case CONST_DOUBLE:
2519     case SYMBOL_REF:
2520       return orig;
2521
2522     case ASM_OPERANDS:
2523
2524       if (orig_asm_operands_vector == ((orig)->fld[ 3].rtvec) )
2525         {
2526           copy = rtx_alloc (ASM_OPERANDS);
2527           ((copy)->fld[ 0].rtstr)  = ((orig)->fld[ 0].rtstr) ;
2528           ((copy)->fld[ 1].rtstr)  = ((orig)->fld[ 1].rtstr) ;
2529           ((copy)->fld[ 2].rtint)  = ((orig)->fld[ 2].rtint) ;
2530           ((copy)->fld[ 3].rtvec)  = copy_asm_operands_vector;
2531           ((copy)->fld[ 4].rtvec)  = ((orig)->fld[ 4].rtvec) ;
2532           return copy;
2533         }
2534       break;
2535
2536     case CALL:
2537
2538       if (! (optimize && ! flag_no_function_cse))
2539
2540         return gen_rtx (CALL,   ((orig)->mode) ,
2541                         gen_rtx (MEM,   ((((orig)->fld[ 0].rtx) )->mode) ,
2542                                  copy_rtx_and_substitute (((((orig)->fld[ 0].rtx) )->fld[ 0].rtx) )),
2543                         copy_rtx_and_substitute (((orig)->fld[ 1].rtx) ));
2544       break;
2545
2546     case PLUS:
2547
2548       if (((orig)->fld[ 0].rtx)  == frame_pointer_rtx
2549           || ((orig)->fld[ 1].rtx)  == frame_pointer_rtx
2550           || (14  != 14 
2551               && (((orig)->fld[ 0].rtx)  == arg_pointer_rtx
2552                   || ((orig)->fld[ 1].rtx)  == arg_pointer_rtx)))
2553         {
2554           if (((orig)->fld[ 0].rtx)  == frame_pointer_rtx
2555               || ((orig)->fld[ 0].rtx)  == arg_pointer_rtx)
2556             copy = ((orig)->fld[ 1].rtx) ;
2557           else
2558             copy = ((orig)->fld[ 0].rtx) ;
2559
2560           if (  ((copy)->code)  == CONST_INT)
2561             {
2562               int c = ((copy)->fld[0].rtint) ;
2563
2564               if (c > 0)
2565                 {
2566                   copy = parm_map[c / 4 ];
2567                   return ((copy)->fld[ 0].rtx) ;
2568                 }
2569               return gen_rtx (PLUS, mode,
2570                               frame_pointer_rtx,
2571                               gen_rtx (CONST_INT, SImode,
2572                                        c + fp_delta));
2573             }
2574           copy = copy_rtx_and_substitute (copy);
2575           temp = force_reg (mode, gen_rtx (PLUS, mode, frame_pointer_rtx, copy));
2576           return plus_constant (temp, fp_delta);
2577         }
2578       else if (reg_mentioned_p (frame_pointer_rtx, orig)
2579                || (14  != 14 
2580                    && reg_mentioned_p (arg_pointer_rtx, orig)))
2581         {
2582
2583           if (memory_address_p (mode, orig))
2584             {
2585               if (      ((((orig)->fld[ 0].rtx) )->code)  == CONST_INT)
2586                 {
2587                   copy = copy_rtx_and_substitute (((orig)->fld[ 1].rtx) );
2588                   temp = plus_constant (copy, ((((orig)->fld[ 0].rtx) )->fld[0].rtint) );
2589                 }
2590               else if ( ((((orig)->fld[ 1].rtx) )->code)  == CONST_INT)
2591                 {
2592                   copy = copy_rtx_and_substitute (((orig)->fld[ 0].rtx) );
2593                   temp = plus_constant (copy, ((((orig)->fld[ 1].rtx) )->fld[0].rtint) );
2594                 }
2595               else
2596                 {
2597                   temp = gen_rtx (PLUS,         ((orig)->mode) ,
2598                                   copy_rtx_and_substitute (((orig)->fld[ 0].rtx) ),
2599                                   copy_rtx_and_substitute (((orig)->fld[ 1].rtx) ));
2600                 }
2601               temp = memory_address (mode, temp);
2602             }
2603           else
2604             temp = gen_rtx (PLUS,       ((orig)->mode) ,
2605                             copy_rtx_and_substitute (((orig)->fld[ 0].rtx) ),
2606                             copy_rtx_and_substitute (((orig)->fld[ 1].rtx) ));
2607         }
2608       else
2609         temp = gen_rtx (PLUS,   ((orig)->mode) ,
2610                         copy_rtx_and_substitute (((orig)->fld[ 0].rtx) ),
2611                         copy_rtx_and_substitute (((orig)->fld[ 1].rtx) ));
2612
2613       return temp;
2614
2615     case MEM:
2616       copy = ((orig)->fld[ 0].rtx) ;
2617       if (copy == frame_pointer_rtx || copy == arg_pointer_rtx)
2618         return gen_rtx (MEM, mode,
2619                         plus_constant (frame_pointer_rtx, fp_delta));
2620
2621       if (      ((copy)->code)  == PRE_DEC && ((copy)->fld[ 0].rtx)  == stack_pointer_rtx)
2622         return gen_rtx (MEM, mode, copy_rtx_and_substitute (copy));
2623
2624       if (! memory_address_p (mode, copy))
2625         return gen_rtx (MEM, mode, copy_address (copy));
2626
2627       if (      ((copy)->code)  == PLUS)
2628         {
2629           if (((copy)->fld[ 0].rtx)  == frame_pointer_rtx
2630               || ((copy)->fld[ 1].rtx)  == frame_pointer_rtx
2631               || (14  != 14 
2632                   && (((copy)->fld[ 0].rtx)  == arg_pointer_rtx
2633                       || ((copy)->fld[ 1].rtx)  == arg_pointer_rtx)))
2634             {
2635               rtx reg;
2636               if (((copy)->fld[ 0].rtx)  == frame_pointer_rtx
2637                   || ((copy)->fld[ 0].rtx)  == arg_pointer_rtx)
2638                 reg = ((copy)->fld[ 0].rtx) , copy = ((copy)->fld[ 1].rtx) ;
2639               else
2640                 reg = ((copy)->fld[ 1].rtx) , copy = ((copy)->fld[ 0].rtx) ;
2641
2642               if (      ((copy)->code)  == CONST_INT)
2643                 {
2644                   int c = ((copy)->fld[0].rtint) ;
2645
2646                   if (reg == arg_pointer_rtx && c >= first_parm_offset)
2647                     {
2648                       int index = c / 4 ;
2649                       int offset = c % 4 ;
2650
2651                       while (parm_map[index] == 0)
2652                         {
2653                           index--;
2654                           if (index < first_parm_offset / 4 )
2655
2656                             abort ();
2657                           offset += 4 ;
2658                         }
2659
2660                       copy = parm_map[index];
2661
2662                       if (      (mode_size[(int)(       ((copy)->mode) )])  < 4 )
2663                         offset
2664                           -= (4 
2665                               -         (mode_size[(int)(       ((copy)->mode) )]) );
2666
2667                       if ((     ((copy)->mode)  != mode
2668                            &&   ((copy)->mode)  != VOIDmode))
2669                         {
2670                           if (  ((copy)->code)  == MEM)
2671                             return change_address (copy, mode,
2672                                                    plus_constant (((copy)->fld[ 0].rtx) ,
2673                                                                   offset));
2674                           if (  ((copy)->code)  == REG)
2675                             {
2676
2677                               if (offset +      (mode_size[(int)(mode)]) 
2678                                   !=    (mode_size[(int)(       ((copy)->mode) )]) )
2679                                 abort ();
2680
2681                               return gen_rtx (SUBREG, mode, copy, 0);
2682                             }
2683
2684                           abort ();
2685                         }
2686                       return copy;
2687                     }
2688                   temp = gen_rtx (PLUS, SImode ,
2689                                   frame_pointer_rtx,
2690                                   gen_rtx (CONST_INT, SImode,
2691                                            c + fp_delta));
2692                   if (! memory_address_p (SImode , temp))
2693                     return gen_rtx (MEM, mode, plus_constant (inline_fp_rtx, c));
2694                 }
2695               copy =  copy_rtx_and_substitute (copy);
2696               temp = gen_rtx (PLUS, SImode , frame_pointer_rtx, copy);
2697               temp = plus_constant (temp, fp_delta);
2698               temp = memory_address (SImode , temp);
2699             }
2700           else if (reg_mentioned_p (frame_pointer_rtx, copy)
2701                    || (14  != 14 
2702                        && reg_mentioned_p (arg_pointer_rtx, copy)))
2703             {
2704               if (      ((((copy)->fld[ 0].rtx) )->code)  == CONST_INT)
2705                 {
2706                   temp = copy_rtx_and_substitute (((copy)->fld[ 1].rtx) );
2707                   temp = plus_constant (temp, ((((copy)->fld[ 0].rtx) )->fld[0].rtint) );
2708                 }
2709               else if ( ((((copy)->fld[ 1].rtx) )->code)  == CONST_INT)
2710                 {
2711                   temp = copy_rtx_and_substitute (((copy)->fld[ 0].rtx) );
2712                   temp = plus_constant (temp, ((((copy)->fld[ 1].rtx) )->fld[0].rtint) );
2713                 }
2714               else
2715                 {
2716                   temp = gen_rtx (PLUS,         ((copy)->mode) ,
2717                                   copy_rtx_and_substitute (((copy)->fld[ 0].rtx) ),
2718                                   copy_rtx_and_substitute (((copy)->fld[ 1].rtx) ));
2719                 }
2720             }
2721           else
2722             {
2723               if (      ((((copy)->fld[ 1].rtx) )->code)  == CONST_INT)
2724                 temp = plus_constant (copy_rtx_and_substitute (((copy)->fld[ 0].rtx) ),
2725                                       ((((copy)->fld[ 1].rtx) )->fld[0].rtint) );
2726               else if ( ((((copy)->fld[ 0].rtx) )->code)  == CONST_INT)
2727                 temp = plus_constant (copy_rtx_and_substitute (((copy)->fld[ 1].rtx) ),
2728                                       ((((copy)->fld[ 0].rtx) )->fld[0].rtint) );
2729               else
2730                 {
2731                   rtx left = copy_rtx_and_substitute (((copy)->fld[ 0].rtx) );
2732                   rtx right = copy_rtx_and_substitute (((copy)->fld[ 1].rtx) );
2733
2734                   temp = gen_rtx (PLUS,         ((copy)->mode) , left, right);
2735                 }
2736             }
2737         }
2738       else
2739         temp = copy_rtx_and_substitute (copy);
2740
2741       return change_address (orig, mode, temp);
2742
2743     case RETURN:
2744       abort ();
2745     }
2746
2747   copy = rtx_alloc (code);
2748   ((copy)->mode = ( mode)) ;
2749   copy->in_struct = orig->in_struct;
2750   copy->volatil = orig->volatil;
2751   copy->unchanging = orig->unchanging;
2752
2753   format_ptr =  (rtx_format[(int)(      ((copy)->code) )]) ;
2754
2755   for (i = 0; i <       (rtx_length[(int)(      ((copy)->code) )]) ; i++)
2756     {
2757       switch (*format_ptr++)
2758         {
2759         case '0':
2760           break;
2761
2762         case 'e':
2763           ((copy)->fld[ i].rtx)  = copy_rtx_and_substitute (((orig)->fld[ i].rtx) );
2764           break;
2765
2766         case 'u':
2767
2768           ((copy)->fld[ i].rtx)  = insn_map[((((orig)->fld[ i].rtx) )->fld[0].rtint) ];
2769           break;
2770
2771         case 'E':
2772           ((copy)->fld[ i].rtvec)  = ((orig)->fld[ i].rtvec) ;
2773           if (((orig)->fld[ i].rtvec)  != 0  && ((orig)->fld[ i].rtvec->num_elem)  != 0)
2774             {
2775               ((copy)->fld[ i].rtvec)  = rtvec_alloc (((orig)->fld[ i].rtvec->num_elem) );
2776               for (j = 0; j < ((copy)->fld[ i].rtvec->num_elem) ; j++)
2777                 ((copy)->fld[ i].rtvec->elem[ j].rtx)  = copy_rtx_and_substitute (((orig)->fld[ i].rtvec->elem[ j].rtx) );
2778             }
2779           break;
2780
2781         case 'i':
2782           ((copy)->fld[ i].rtint)  = ((orig)->fld[ i].rtint) ;
2783           break;
2784
2785         case 's':
2786           ((copy)->fld[ i].rtstr)  = ((orig)->fld[ i].rtstr) ;
2787           break;
2788
2789         default:
2790           abort ();
2791         }
2792     }
2793
2794   if (code == ASM_OPERANDS && orig_asm_operands_vector == 0)
2795     {
2796       orig_asm_operands_vector = ((orig)->fld[ 3].rtvec) ;
2797       copy_asm_operands_vector = ((copy)->fld[ 3].rtvec) ;
2798     }
2799
2800   return copy;
2801 }
2802
2803 static rtx
2804 copy_address (orig)
2805      register rtx orig;
2806 {
2807   register rtx copy;
2808   register int i, j;
2809   register enum rtx_code  code;
2810   register enum machine_mode mode;
2811   register char *format_ptr;
2812
2813   if (orig == 0)
2814     return 0;
2815
2816   code =        ((orig)->code) ;
2817   mode =        ((orig)->mode) ;
2818
2819   switch (code)
2820     {
2821     case REG:
2822       if (((orig)->fld[0].rtint)  != 14 )
2823         return copy_rtx_and_substitute (orig);
2824       return plus_constant (frame_pointer_rtx, fp_delta);
2825
2826     case PLUS:
2827       if (      ((((orig)->fld[ 0].rtx) )->code)  == REG
2828           && ((((orig)->fld[ 0].rtx) )->fld[0].rtint)  == 14 )
2829         return plus_constant (orig, fp_delta);
2830       break;
2831
2832     case MEM:
2833       return copy_to_reg (copy_rtx_and_substitute (orig));
2834
2835     case CODE_LABEL:
2836     case LABEL_REF:
2837       return copy_rtx_and_substitute (orig);
2838
2839     case PC:
2840     case CC0:
2841     case CONST_INT:
2842     case CONST_DOUBLE:
2843     case SYMBOL_REF:
2844       return orig;
2845     }
2846
2847   copy = rtx_alloc (code);
2848   ((copy)->mode = ( mode)) ;
2849   copy->in_struct = orig->in_struct;
2850   copy->volatil = orig->volatil;
2851   copy->unchanging = orig->unchanging;
2852
2853   format_ptr =  (rtx_format[(int)(      ((copy)->code) )]) ;
2854
2855   for (i = 0; i <       (rtx_length[(int)(      ((copy)->code) )]) ; i++)
2856     {
2857       switch (*format_ptr++)
2858         {
2859         case '0':
2860           break;
2861
2862         case 'e':
2863           ((copy)->fld[ i].rtx)  = copy_rtx_and_substitute (((orig)->fld[ i].rtx) );
2864           break;
2865
2866         case 'u':
2867
2868           ((copy)->fld[ i].rtx)  = insn_map[((((orig)->fld[ i].rtx) )->fld[0].rtint) ];
2869           break;
2870
2871         case 'E':
2872           ((copy)->fld[ i].rtvec)  = ((orig)->fld[ i].rtvec) ;
2873           if (((orig)->fld[ i].rtvec)  != 0  && ((orig)->fld[ i].rtvec->num_elem)  != 0)
2874             {
2875               ((copy)->fld[ i].rtvec)  = rtvec_alloc (((orig)->fld[ i].rtvec->num_elem) );
2876               for (j = 0; j < ((copy)->fld[ i].rtvec->num_elem) ; j++)
2877                 ((copy)->fld[ i].rtvec->elem[ j].rtx)  = copy_rtx_and_substitute (((orig)->fld[ i].rtvec->elem[ j].rtx) );
2878             }
2879           break;
2880
2881         case 'i':
2882           ((copy)->fld[ i].rtint)  = ((orig)->fld[ i].rtint) ;
2883           break;
2884
2885         case 's':
2886           ((copy)->fld[ i].rtstr)  = ((orig)->fld[ i].rtstr) ;
2887           break;
2888
2889         default:
2890           abort ();
2891         }
2892     }
2893   return copy;
2894 }
2895
2896 static rtx
2897 try_fold_cc0 (insn)
2898      rtx insn;
2899 {
2900   rtx cnst = copy_rtx_and_substitute (((((insn)->fld[3].rtx) )->fld[1].rtx) );
2901   rtx pat, copy;
2902
2903   if (( ((cnst)->code)  == LABEL_REF ||         ((cnst)->code)  == SYMBOL_REF   ||      ((cnst)->code)  == CONST_INT    ||      ((cnst)->code)  == CONST) 
2904       && ((insn)->fld[2].rtx) 
2905       &&        ((pat = ((((insn)->fld[2].rtx) )->fld[3].rtx) )->code)  == SET
2906       && ((pat)->fld[0].rtx)  == pc_rtx
2907       &&        ((pat = ((pat)->fld[1].rtx) )->code)  == IF_THEN_ELSE
2908       &&        (rtx_length[(int)(      ((((pat)->fld[ 0].rtx) )->code) )])  == 2)
2909     {
2910       rtx cnst2;
2911       rtx cond = ((pat)->fld[ 0].rtx) ;
2912
2913       if ((((cond)->fld[ 0].rtx)  == cc0_rtx
2914            && ( ((((cond)->fld[ 1].rtx) )->code)  == LABEL_REF ||       ((((cond)->fld[ 1].rtx) )->code)  == SYMBOL_REF ||      ((((cond)->fld[ 1].rtx) )->code)  == CONST_INT  ||      ((((cond)->fld[ 1].rtx) )->code)  == CONST) 
2915            && (cnst2 = ((cond)->fld[ 1].rtx) ))
2916           || (((cond)->fld[ 1].rtx)  == cc0_rtx
2917               && (      ((((cond)->fld[ 0].rtx) )->code)  == LABEL_REF ||       ((((cond)->fld[ 0].rtx) )->code)  == SYMBOL_REF ||      ((((cond)->fld[ 0].rtx) )->code)  == CONST_INT  ||      ((((cond)->fld[ 0].rtx) )->code)  == CONST) 
2918               && (cnst2 = ((cond)->fld[ 0].rtx) )))
2919         {
2920           copy = fold_out_const_cc0 (cond, ((pat)->fld[ 1].rtx) , ((pat)->fld[ 2].rtx) ,
2921                                      cnst, cnst2);
2922           if (copy)
2923             {
2924               if (      ((copy)->code)  == LABEL_REF)
2925                 {
2926
2927                   rtx tmp = ((insn)->fld[2].rtx) ;
2928                   while (tmp &&         ((tmp)->code)  != CODE_LABEL)
2929                     tmp = ((tmp)->fld[2].rtx) ;
2930                   if (! tmp)
2931                     abort ();
2932                   if (label_map[((tmp)->fld[3].rtint) ] == ((copy)->fld[ 0].rtx) )
2933                     {
2934                       return ((tmp)->fld[1].rtx) ;
2935                     }
2936                   else
2937                     {
2938
2939                       emit_jump (copy);
2940                       return ((insn)->fld[2].rtx) ;
2941                     }
2942                 }
2943               else if (copy == pc_rtx)
2944                 {
2945
2946                   return ((insn)->fld[2].rtx) ;
2947                 }
2948               else
2949                 abort ();
2950             }
2951         }
2952     }
2953   return 0;
2954 }
2955
2956 static rtx
2957 fold_out_const_cc0 (cond_rtx, then_rtx, else_rtx, cnst1, cnst2)
2958      rtx cond_rtx, then_rtx, else_rtx;
2959      rtx cnst1, cnst2;
2960 {
2961   int value1, value2;
2962   int int1 =    ((cnst1)->code)  == CONST_INT;
2963   int int2 =    ((cnst2)->code)  == CONST_INT;
2964   if (int1)
2965     value1 = ((cnst1)->fld[0].rtint) ;
2966   else
2967     value1 = 1;
2968   if (int2)
2969     value2 = ((cnst2)->fld[0].rtint) ;
2970   else
2971     value2 = 1;
2972
2973   switch (      ((cond_rtx)->code) )
2974     {
2975     case NE:
2976       if (int1 && int2)
2977         if (value1 != value2)
2978           return copy_rtx_and_substitute (then_rtx);
2979         else
2980           return copy_rtx_and_substitute (else_rtx);
2981       if (value1 == 0 || value2 == 0)
2982         return copy_rtx_and_substitute (then_rtx);
2983       if (int1 == 0 && int2 == 0)
2984         if (rtx_equal_p (cnst1, cnst2))
2985           return copy_rtx_and_substitute (else_rtx);
2986       break;
2987     case EQ:
2988       if (int1 && int2)
2989         if (value1 == value2)
2990           return copy_rtx_and_substitute (then_rtx);
2991         else
2992           return copy_rtx_and_substitute (else_rtx);
2993       if (value1 == 0 || value2 == 0)
2994         return copy_rtx_and_substitute (else_rtx);
2995       if (int1 == 0 && int2 == 0)
2996         if (rtx_equal_p (cnst1, cnst2))
2997           return copy_rtx_and_substitute (then_rtx);
2998       break;
2999     case GE:
3000       if (int1 && int2)
3001         if (value1 >= value2)
3002           return copy_rtx_and_substitute (then_rtx);
3003         else
3004           return copy_rtx_and_substitute (else_rtx);
3005       if (value1 == 0)
3006         return copy_rtx_and_substitute (else_rtx);
3007       if (value2 == 0)
3008         return copy_rtx_and_substitute (then_rtx);
3009       break;
3010     case GT:
3011       if (int1 && int2)
3012         if (value1 > value2)
3013           return copy_rtx_and_substitute (then_rtx);
3014         else
3015           return copy_rtx_and_substitute (else_rtx);
3016       if (value1 == 0)
3017         return copy_rtx_and_substitute (else_rtx);
3018       if (value2 == 0)
3019         return copy_rtx_and_substitute (then_rtx);
3020       break;
3021     case LE:
3022       if (int1 && int2)
3023         if (value1 <= value2)
3024           return copy_rtx_and_substitute (then_rtx);
3025         else
3026           return copy_rtx_and_substitute (else_rtx);
3027       if (value1 == 0)
3028         return copy_rtx_and_substitute (then_rtx);
3029       if (value2 == 0)
3030         return copy_rtx_and_substitute (else_rtx);
3031       break;
3032     case LT:
3033       if (int1 && int2)
3034         if (value1 < value2)
3035           return copy_rtx_and_substitute (then_rtx);
3036         else
3037           return copy_rtx_and_substitute (else_rtx);
3038       if (value1 == 0)
3039         return copy_rtx_and_substitute (then_rtx);
3040       if (value2 == 0)
3041         return copy_rtx_and_substitute (else_rtx);
3042       break;
3043     case GEU:
3044       if (int1 && int2)
3045         if ((unsigned)value1 >= (unsigned)value2)
3046           return copy_rtx_and_substitute (then_rtx);
3047         else
3048           return copy_rtx_and_substitute (else_rtx);
3049       if (value1 == 0)
3050         return copy_rtx_and_substitute (else_rtx);
3051       if (value2 == 0)
3052         return copy_rtx_and_substitute (then_rtx);
3053       break;
3054     case GTU:
3055       if (int1 && int2)
3056         if ((unsigned)value1 > (unsigned)value2)
3057           return copy_rtx_and_substitute (then_rtx);
3058         else
3059           return copy_rtx_and_substitute (else_rtx);
3060       if (value1 == 0)
3061         return copy_rtx_and_substitute (else_rtx);
3062       if (value2 == 0)
3063         return copy_rtx_and_substitute (then_rtx);
3064       break;
3065     case LEU:
3066       if (int1 && int2)
3067         if ((unsigned)value1 <= (unsigned)value2)
3068           return copy_rtx_and_substitute (then_rtx);
3069         else
3070           return copy_rtx_and_substitute (else_rtx);
3071       if (value1 == 0)
3072         return copy_rtx_and_substitute (then_rtx);
3073       if (value2 == 0)
3074         return copy_rtx_and_substitute (else_rtx);
3075       break;
3076     case LTU:
3077       if (int1 && int2)
3078         if ((unsigned)value1 < (unsigned)value2)
3079           return copy_rtx_and_substitute (then_rtx);
3080         else
3081           return copy_rtx_and_substitute (else_rtx);
3082       if (value1 == 0)
3083         return copy_rtx_and_substitute (then_rtx);
3084       if (value2 == 0)
3085         return copy_rtx_and_substitute (else_rtx);
3086       break;
3087     }
3088   return 0;
3089 }
3090
3091 void
3092 output_inline_function (fndecl)
3093      tree fndecl;
3094 {
3095   rtx head = ((fndecl)->decl.saved_insns) ;
3096   rtx last;
3097
3098   temporary_allocation ();
3099
3100   current_function_decl = fndecl;
3101
3102   expand_function_start (fndecl);
3103
3104   assign_stack_local (BLKmode, ((fndecl)->decl.frame_size) );
3105
3106   restore_reg_data (((head)->fld[3].rtx) );
3107
3108   expand_function_end (((fndecl)->decl.filename) , ((fndecl)->decl.linenum) );
3109
3110   for (last = head; ((last)->fld[2].rtx) ; last = ((last)->fld[2].rtx) )
3111     ;
3112
3113   set_new_first_and_last_insn (((head)->fld[3].rtx) , last);
3114
3115   rest_of_compilation (fndecl);
3116
3117   current_function_decl = 0;
3118
3119   permanent_allocation ();
3120 }
3121