fixing stuff
[dyninst.git] / codeCoverage / sparc-sun-solaris2.9 / tests / cc1 / 1stmt.i
1
2 extern int target_flags;
3
4 enum reg_class { NO_REGS, LO_FPA_REGS, FPA_REGS, FP_REGS,
5   FP_OR_FPA_REGS, DATA_REGS, DATA_OR_FPA_REGS, DATA_OR_FP_REGS,
6   DATA_OR_FP_OR_FPA_REGS, ADDR_REGS, GENERAL_REGS,
7   GENERAL_OR_FPA_REGS, GENERAL_OR_FP_REGS, ALL_REGS,
8   LIM_REG_CLASSES };
9
10 extern enum reg_class regno_reg_class[];
11
12 extern  struct  _iobuf {
13         int     _cnt;
14         unsigned char *_ptr;
15         unsigned char *_base;
16         int     _bufsiz;
17         short   _flag;
18         char    _file;           
19 } _iob[];
20
21 extern struct _iobuf    *fopen();
22 extern struct _iobuf    *fdopen();
23 extern struct _iobuf    *freopen();
24 extern struct _iobuf    *popen();
25 extern struct _iobuf    *tmpfile();
26 extern long     ftell();
27 extern char     *fgets();
28 extern char     *gets();
29
30 extern char     *ctermid();
31 extern char     *cuserid();
32 extern char     *tempnam();
33 extern char     *tmpnam();
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 extern int max_regno;
1657
1658 extern short *reg_n_refs;
1659
1660 extern short *reg_n_sets;
1661
1662 extern short *reg_n_deaths;
1663
1664 extern int *reg_n_calls_crossed;
1665
1666 extern int *reg_live_length;
1667
1668 extern short *reg_renumber;
1669
1670 extern char regs_ever_live[56 ];
1671
1672 extern char *reg_names[56 ];
1673
1674 extern short *regno_first_uid;
1675
1676 extern short *regno_last_uid;
1677
1678 extern char *regno_pointer_flag;
1679
1680 extern rtx *regno_reg_rtx;
1681
1682 extern int caller_save_needed;
1683
1684 int current_function_pops_args;
1685
1686 int current_function_returns_struct;
1687
1688 int current_function_returns_pcc_struct;
1689
1690 int current_function_needs_context;
1691
1692 int current_function_calls_setjmp;
1693
1694 int current_function_args_size;
1695
1696 int current_function_pretend_args_size;
1697
1698 char *current_function_name;
1699
1700 rtx return_label;
1701
1702 rtx save_expr_regs;
1703
1704 rtx stack_slot_list;
1705
1706 char *emit_filename;
1707 int emit_lineno;
1708
1709 static rtx parm_birth_insn;
1710
1711 static tree this_function;
1712
1713 static int frame_offset;
1714
1715 static int invalid_stack_slot;
1716
1717 static rtx tail_recursion_label;
1718
1719 static rtx tail_recursion_reentry;
1720
1721 static tree last_expr_type;
1722 static rtx last_expr_value;
1723
1724 static tree rtl_expr_chain;
1725
1726 static rtx last_parm_insn;
1727
1728 static void expand_goto_internal ();
1729 static int expand_fixup ();
1730 static void fixup_gotos ();
1731 static void expand_cleanups ();
1732 static void fixup_cleanups ();
1733 static void expand_null_return_1 ();
1734 static int tail_recursion_args ();
1735 static void fixup_stack_slots ();
1736 static rtx fixup_stack_1 ();
1737 static rtx fixup_memory_subreg ();
1738 static rtx walk_fixup_memory_subreg ();
1739 static void fixup_var_refs ();
1740 static void fixup_var_refs_insns ();
1741 static rtx fixup_var_refs_1 ();
1742 static rtx parm_stack_loc ();
1743 static void optimize_bit_field ();
1744 static void do_jump_if_equal ();
1745
1746 static void balance_case_nodes ();
1747 static void emit_case_nodes ();
1748 static void group_case_nodes ();
1749 static void emit_jump_if_reachable ();
1750
1751 struct case_node
1752 {
1753   struct case_node      *left;
1754   struct case_node      *right;
1755   struct case_node      *parent;
1756   tree                  low;
1757   tree                  high;
1758   tree                  test_label;
1759   tree                  code_label;
1760 };
1761
1762 typedef struct case_node case_node;
1763 typedef struct case_node *case_node_ptr;
1764
1765 struct nesting
1766 {
1767   struct nesting *all;
1768   struct nesting *next;
1769   int depth;
1770   rtx exit_label;
1771   union
1772     {
1773       struct
1774         {
1775           rtx else_label;
1776           rtx after_label;
1777         } cond;
1778       struct
1779         {
1780           rtx start_label;
1781           rtx end_label;
1782
1783           rtx continue_label;
1784         } loop;
1785       struct
1786         {
1787           rtx stack_level;
1788
1789           rtx first_insn;
1790           struct nesting *innermost_stack_block;
1791
1792           tree cleanups;
1793
1794           tree outer_cleanups;
1795
1796           struct label_chain *label_chain;
1797         } block;
1798
1799       struct
1800         {
1801
1802           rtx start;
1803
1804           struct case_node *case_list;
1805           tree default_label;
1806           tree index_expr;
1807           tree nominal_type;
1808           short num_ranges;
1809         } case_stmt;
1810     } data;
1811 };
1812
1813 struct nesting *block_stack;
1814
1815 struct nesting *stack_block_stack;
1816
1817 struct nesting *cond_stack;
1818
1819 struct nesting *loop_stack;
1820
1821 struct nesting *case_stack;
1822
1823 struct nesting *nesting_stack;
1824
1825 int nesting_depth;
1826
1827 static rtx
1828 label_rtx (label)
1829      tree label;
1830 {
1831   if (((label)->common.code)  != LABEL_DECL)
1832     abort ();
1833
1834   if (((label)->decl.rtl) )
1835     return ((label)->decl.rtl) ;
1836
1837   return ((label)->decl.rtl)  = gen_label_rtx ();
1838 }
1839
1840 void
1841 emit_jump (label)
1842      rtx label;
1843 {
1844   do_pending_stack_adjust ();
1845   emit_jump_insn (gen_jump (label));
1846   emit_barrier ();
1847 }
1848
1849 struct goto_fixup
1850 {
1851   struct goto_fixup *next;
1852
1853   rtx before_jump;
1854
1855   tree target;
1856   rtx target_rtl;
1857
1858   rtx stack_level;
1859
1860   tree cleanup_list_list;
1861 };
1862
1863 static struct goto_fixup *goto_fixup_chain;
1864
1865 struct label_chain
1866 {
1867   struct label_chain *next;
1868   tree label;
1869 };
1870
1871 void
1872 expand_label (body)
1873      tree body;
1874 {
1875   struct label_chain *p;
1876
1877   do_pending_stack_adjust ();
1878   emit_label (label_rtx (body));
1879
1880   if (stack_block_stack != 0)
1881     {
1882       p = (struct label_chain *) oballoc (sizeof (struct label_chain));
1883       p->next = stack_block_stack->data.block.label_chain;
1884       stack_block_stack->data.block.label_chain = p;
1885       p->label = body;
1886     }
1887 }
1888
1889 void
1890 expand_goto (body)
1891      tree body;
1892 {
1893   expand_goto_internal (body, label_rtx (body), 0);
1894 }
1895
1896 static void
1897 expand_goto_internal (body, label, last_insn)
1898      tree body;
1899      rtx label;
1900      rtx last_insn;
1901 {
1902   struct nesting *block;
1903   rtx stack_level = 0;
1904
1905   if (  ((label)->code)  != CODE_LABEL)
1906     abort ();
1907
1908   if (((label)->fld[1].rtx)  != 0)
1909     {
1910
1911       for (block = block_stack; block; block = block->next)
1912         {
1913           if (((block->data.block.first_insn)->fld[0].rtint)  < ((label)->fld[0].rtint) )
1914             break;
1915           if (block->data.block.stack_level != 0)
1916             stack_level = block->data.block.stack_level;
1917           if (block->data.block.cleanups != 0)
1918             expand_cleanups (block->data.block.cleanups, 0);
1919         }
1920
1921       if (stack_level)
1922         emit_move_insn (stack_pointer_rtx, stack_level);
1923
1924       if (body != 0 && ((body)->common.packed_attr) )
1925         error ("jump to `%s' invalidly jumps into binding contour",
1926                ((((body)->decl.name) )->identifier.pointer) );
1927     }
1928
1929   else if (! expand_fixup (body, label, last_insn))
1930     {
1931
1932       if (body != 0)
1933         ((body)->common.addressable_attr)  = 1;
1934     }
1935
1936   emit_jump (label);
1937 }
1938
1939 static int
1940 expand_fixup (tree_label, rtl_label, last_insn)
1941      tree tree_label;
1942      rtx rtl_label;
1943      rtx last_insn;
1944 {
1945   struct nesting *block, *end_block;
1946
1947   if (cond_stack
1948       && (rtl_label == cond_stack->data.cond.else_label
1949           || rtl_label == cond_stack->data.cond.after_label))
1950     end_block = cond_stack;
1951
1952   else if (loop_stack
1953       && (rtl_label == loop_stack->data.loop.start_label
1954           || rtl_label == loop_stack->data.loop.end_label
1955           || rtl_label == loop_stack->data.loop.continue_label))
1956     end_block = loop_stack;
1957   else
1958     end_block = 0;
1959
1960   if (end_block)
1961     {
1962       struct nesting *next_block = end_block->all;
1963       block = block_stack;
1964
1965       while (next_block && next_block != block)
1966         next_block = next_block->all;
1967
1968       if (next_block)
1969         return 0;
1970
1971       next_block = block_stack->next;
1972       for (block = block_stack; block != end_block; block = block->all)
1973         if (block == next_block)
1974           next_block = next_block->next;
1975       end_block = next_block;
1976     }
1977
1978   for (block = block_stack; block != end_block; block = block->next)
1979     if (block->data.block.stack_level != 0
1980         || block->data.block.cleanups != 0)
1981       break;
1982
1983   if (block != end_block)
1984     {
1985       struct goto_fixup *fixup
1986         = (struct goto_fixup *) oballoc (sizeof (struct goto_fixup));
1987
1988       do_pending_stack_adjust ();
1989       fixup->before_jump = last_insn ? last_insn : get_last_insn ();
1990       fixup->target = tree_label;
1991       fixup->target_rtl = rtl_label;
1992       fixup->stack_level = 0;
1993       fixup->cleanup_list_list
1994         = (block->data.block.outer_cleanups || block->data.block.cleanups
1995            ? tree_cons (0, block->data.block.cleanups,
1996                         block->data.block.outer_cleanups)
1997            : 0);
1998       fixup->next = goto_fixup_chain;
1999       goto_fixup_chain = fixup;
2000     }
2001
2002   return block != 0;
2003 }
2004
2005 static void
2006 fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
2007      struct nesting *thisblock;
2008      rtx stack_level;
2009      tree cleanup_list;
2010      rtx first_insn;
2011      int dont_jump_in;
2012 {
2013   register struct goto_fixup *f, *prev;
2014
2015   for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
2016     {
2017       if (f->before_jump == 0)
2018         {
2019           if (prev != 0)
2020             prev->next = f->next;
2021         }
2022
2023       else if (((f->target_rtl)->fld[1].rtx)  != 0)
2024         {
2025
2026           if (f->target != 0
2027               && (dont_jump_in || stack_level || cleanup_list)
2028               && ((first_insn)->fld[0].rtint)  > ((f->before_jump)->fld[0].rtint) 
2029               && ! ((f->target)->common.addressable_attr) )
2030             {
2031               error_with_decl (f->target,
2032                                "label `%s' used before containing binding contour");
2033               ((f->target)->common.addressable_attr)  = 1;
2034             }
2035
2036           if (f->cleanup_list_list)
2037             {
2038               tree lists;
2039               for (lists = f->cleanup_list_list; lists; lists = ((lists)->common.chain) )
2040
2041                 if (((lists)->common.addressable_attr) 
2042                     && ((lists)->list.value)  != 0)
2043                   fixup_cleanups (((lists)->list.value) , &f->before_jump);
2044             }
2045
2046           if (f->stack_level)
2047             emit_insn_after (gen_move_insn (stack_pointer_rtx, f->stack_level),
2048                              f->before_jump);
2049           f->before_jump = 0;
2050         }
2051
2052       else if (thisblock != 0)
2053         {
2054           tree lists = f->cleanup_list_list;
2055           for (; lists; lists = ((lists)->common.chain) )
2056
2057             if (((lists)->common.chain)  == thisblock->data.block.outer_cleanups)
2058               ((lists)->common.addressable_attr)  = 1;
2059
2060           if (stack_level)
2061             f->stack_level = stack_level;
2062         }
2063     }
2064 }
2065
2066 void
2067 expand_asm (body)
2068      tree body;
2069 {
2070   emit_insn (gen_rtx (ASM_INPUT, VOIDmode,
2071                       ((body)->string.pointer) ));
2072   last_expr_type = 0;
2073 }
2074
2075 void
2076 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
2077      tree string, outputs, inputs, clobbers;
2078      int vol;
2079      char *filename;
2080      int line;
2081 {
2082   rtvec argvec, constraints;
2083   rtx body;
2084   int ninputs = list_length (inputs);
2085   int noutputs = list_length (outputs);
2086   int nclobbers = list_length (clobbers);
2087   tree tail;
2088   register int i;
2089   rtx *output_rtx = (rtx *) __builtin_alloca  (noutputs * sizeof (rtx));
2090   rtx insn;
2091
2092   last_expr_type = 0;
2093
2094   for (i = 0, tail = outputs; tail; tail = ((tail)->common.chain) , i++)
2095     {
2096       tree val = ((tail)->list.value) ;
2097       int j;
2098       int found_equal;
2099
2100       if (((val)->common.type)  == error_mark_node)
2101         return;
2102
2103       found_equal = 0;
2104       for (j = 0; j < ((((tail)->list.purpose) )->string.length) ; j++)
2105         {
2106           if (((((tail)->list.purpose) )->string.pointer) [j] == '+')
2107             {
2108               error ("input operand constraint contains `+'");
2109               return;
2110             }
2111           if (((((tail)->list.purpose) )->string.pointer) [j] == '=')
2112             found_equal = 1;
2113         }
2114       if (! found_equal)
2115         {
2116           error ("output operand constraint lacks `='");
2117           return;
2118         }
2119
2120       if (((val)->common.code)  != VAR_DECL
2121           && ((val)->common.code)  != PARM_DECL
2122           && ((val)->common.code)  != INDIRECT_REF)
2123         {
2124           rtx reg = gen_reg_rtx (((((val)->common.type) )->type.mode) );
2125           tree t = build_nt (SAVE_EXPR, val, reg);
2126
2127           save_expr_regs = gen_rtx (EXPR_LIST, VOIDmode, reg, save_expr_regs);
2128           ((tail)->list.value)  = t;
2129           ((t)->common.type)  = ((val)->common.type) ;
2130         }
2131       output_rtx[i] = expand_expr (((tail)->list.value) , 0, VOIDmode, 0);
2132     }
2133
2134   if (ninputs + noutputs > 5 )
2135     {
2136       error ("more than %d operands in `asm'", 5 );
2137       return;
2138     }
2139
2140   argvec = rtvec_alloc (ninputs);
2141   constraints = rtvec_alloc (ninputs);
2142
2143   body = gen_rtx (ASM_OPERANDS, VOIDmode,
2144                   ((string)->string.pointer) , "", 0, argvec, constraints,
2145                   filename, line);
2146   ((body)->volatil)  = vol;
2147
2148   i = 0;
2149   for (tail = inputs; tail; tail = ((tail)->common.chain) )
2150     {
2151       int j;
2152
2153       if (((((tail)->list.value) )->common.type)  == error_mark_node)
2154         return;
2155       if (((tail)->list.purpose)  == (tree) 0  )
2156         {
2157           error ("hard register `%s' listed as input operand to `asm'",
2158                  ((((tail)->list.value) )->string.pointer)  );
2159           return;
2160         }
2161
2162       for (j = 0; j < ((((tail)->list.purpose) )->string.length) ; j++)
2163         if (((((tail)->list.purpose) )->string.pointer) [j] == '='
2164             || ((((tail)->list.purpose) )->string.pointer) [j] == '+')
2165           {
2166             error ("input operand constraint contains `%c'",
2167                    ((((tail)->list.purpose) )->string.pointer) [j]);
2168             return;
2169           }
2170
2171       ((body)->fld[ 3].rtvec->elem[ i].rtx)        
2172         = expand_expr (((tail)->list.value) , 0, VOIDmode, 0);
2173       ((body)->fld[ 4].rtvec->elem[ i].rtx)        
2174         = gen_rtx (ASM_INPUT, ((((((tail)->list.value) )->common.type) )->type.mode) ,
2175                    ((((tail)->list.purpose) )->string.pointer) );
2176       i++;
2177     }
2178
2179   for (i = 0; i < ninputs; i++)
2180     ((body)->fld[ 3].rtvec->elem[ i].rtx)  = protect_from_queue (((body)->fld[ 3].rtvec->elem[ i].rtx) , 0);
2181
2182   for (i = 0; i < noutputs; i++)
2183     output_rtx[i] = protect_from_queue (output_rtx[i], 1);
2184
2185   if (noutputs == 1 && nclobbers == 0)
2186     {
2187       ((body)->fld[ 1].rtstr)  = ((((outputs)->list.purpose) )->string.pointer) ;
2188       insn = emit_insn (gen_rtx (SET, VOIDmode, output_rtx[0], body));
2189     }
2190   else if (noutputs == 0 && nclobbers == 0)
2191     {
2192       insn = emit_insn (body);
2193     }
2194   else
2195     {
2196       rtx obody = body;
2197       int num = noutputs;
2198       if (num == 0) num = 1;
2199       body = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (num + nclobbers));
2200
2201       for (i = 0, tail = outputs; tail; tail = ((tail)->common.chain) , i++)
2202         {
2203           ((body)->fld[ 0].rtvec->elem[ i].rtx) 
2204             = gen_rtx (SET, VOIDmode,
2205                        output_rtx[i],
2206                        gen_rtx (ASM_OPERANDS, VOIDmode,
2207                                 ((string)->string.pointer) ,
2208                                 ((((tail)->list.purpose) )->string.pointer) ,
2209                                 i, argvec, constraints,
2210                                 filename, line));
2211           ((((((body)->fld[ 0].rtvec->elem[ i].rtx) )->fld[1].rtx) )->volatil)  = vol;
2212         }
2213
2214       if (i == 0)
2215         ((body)->fld[ 0].rtvec->elem[ i++].rtx)  = obody;
2216
2217       for (tail = clobbers; tail; tail = ((tail)->common.chain) , i++)
2218         {
2219           int j;
2220           char *regname = ((((tail)->list.value) )->string.pointer) ;
2221           extern char *reg_names[];
2222           for (j = 0; j < 56 ; j++)
2223             if (!strcmp (regname, reg_names[j]))
2224               break;
2225           if (j == 56 )
2226             {
2227               error ("unknown register name `%s' in `asm'", regname);
2228               return;
2229             }
2230
2231           ((body)->fld[ 0].rtvec->elem[ i].rtx) 
2232             = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, QImode, j));
2233         }
2234
2235       insn = emit_insn (body);
2236     }
2237
2238   last_expr_type = 0;
2239 }
2240
2241 int expr_stmts_for_value;
2242
2243 void
2244 expand_expr_stmt (exp)
2245      tree exp;
2246 {
2247
2248   if (extra_warnings && expr_stmts_for_value == 0 && !((exp)->common.volatile_attr) 
2249       && exp != error_mark_node)
2250     warning_with_file_and_line (emit_filename, emit_lineno,
2251                                 "statement with no effect");
2252   last_expr_type = ((exp)->common.type) ;
2253   if (! flag_syntax_only)
2254     last_expr_value = expand_expr (exp, expr_stmts_for_value ? 0 : const0_rtx,
2255                                    VOIDmode, 0);
2256   emit_queue ();
2257 }
2258
2259 void
2260 clear_last_expr ()
2261 {
2262   last_expr_type = 0;
2263 }
2264
2265 tree
2266 expand_start_stmt_expr ()
2267 {
2268   rtx save = start_sequence ();
2269
2270   int momentary = suspend_momentary ();
2271   tree t = make_node (RTL_EXPR);
2272   resume_momentary (momentary);
2273   (*(struct rtx_def **) &(t)->exp.operands[1])  = save;
2274   expr_stmts_for_value++;
2275   return t;
2276 }
2277
2278 tree
2279 expand_end_stmt_expr (t)
2280      tree t;
2281 {
2282   rtx saved = (*(struct rtx_def **) &(t)->exp.operands[1]) ;
2283
2284   do_pending_stack_adjust ();
2285
2286   if (last_expr_type == 0)
2287     {
2288       last_expr_type = void_type_node;
2289       last_expr_value = const0_rtx;
2290     }
2291   ((t)->common.type)  = last_expr_type;
2292   (*(struct rtx_def **) &(t)->exp.operands[1])  = last_expr_value;
2293   (*(struct rtx_def **) &(t)->exp.operands[0])  = get_insns ();
2294
2295   rtl_expr_chain = tree_cons ((tree) 0  , t, rtl_expr_chain);
2296
2297   end_sequence (saved);
2298
2299   ((t)->common.volatile_attr)  = 1;
2300   ((t)->common.this_vol_attr)  = volatile_refs_p (last_expr_value);
2301
2302   last_expr_type = 0;
2303   expr_stmts_for_value--;
2304
2305   return t;
2306 }
2307
2308 void
2309 expand_start_cond (cond, exitflag)
2310      tree cond;
2311      int exitflag;
2312 {
2313   struct nesting *thiscond
2314     = (struct nesting *) xmalloc (sizeof (struct nesting));
2315
2316   thiscond->next = cond_stack;
2317   thiscond->all = nesting_stack;
2318   thiscond->depth = ++nesting_depth;
2319   thiscond->data.cond.after_label = 0;
2320   thiscond->data.cond.else_label = gen_label_rtx ();
2321   thiscond->exit_label = exitflag ? thiscond->data.cond.else_label : 0;
2322   cond_stack = thiscond;
2323   nesting_stack = thiscond;
2324
2325   do_jump (cond, thiscond->data.cond.else_label, 0 );
2326 }
2327
2328 void
2329 expand_end_cond ()
2330 {
2331   struct nesting *thiscond = cond_stack;
2332
2333   do_pending_stack_adjust ();
2334   emit_label (thiscond->data.cond.else_label);
2335
2336   do { int initial_depth = nesting_stack->depth;        do { struct nesting *this = cond_stack; cond_stack = this->next;        nesting_stack = this->all;      nesting_depth = this->depth;    free (this); }  while (nesting_depth > initial_depth); } while (0) ;
2337   last_expr_type = 0;
2338 }
2339
2340 void
2341 expand_start_else ()
2342 {
2343   cond_stack->data.cond.after_label = gen_label_rtx ();
2344   if (cond_stack->exit_label != 0)
2345     cond_stack->exit_label = cond_stack->data.cond.after_label;
2346   emit_jump (cond_stack->data.cond.after_label);
2347   if (cond_stack->data.cond.else_label)
2348     emit_label (cond_stack->data.cond.else_label);
2349 }
2350
2351 void
2352 expand_end_else ()
2353 {
2354   struct nesting *thiscond = cond_stack;
2355
2356   do_pending_stack_adjust ();
2357
2358   if (thiscond->data.cond.after_label)
2359     emit_label (thiscond->data.cond.after_label);
2360
2361   do { int initial_depth = nesting_stack->depth;        do { struct nesting *this = cond_stack; cond_stack = this->next;        nesting_stack = this->all;      nesting_depth = this->depth;    free (this); }  while (nesting_depth > initial_depth); } while (0) ;
2362   last_expr_type = 0;
2363 }
2364
2365 void
2366 expand_start_loop (exit_flag)
2367      int exit_flag;
2368 {
2369   register struct nesting *thisloop
2370     = (struct nesting *) xmalloc (sizeof (struct nesting));
2371
2372   thisloop->next = loop_stack;
2373   thisloop->all = nesting_stack;
2374   thisloop->depth = ++nesting_depth;
2375   thisloop->data.loop.start_label = gen_label_rtx ();
2376   thisloop->data.loop.end_label = gen_label_rtx ();
2377   thisloop->data.loop.continue_label = thisloop->data.loop.start_label;
2378   thisloop->exit_label = exit_flag ? thisloop->data.loop.end_label : 0;
2379   loop_stack = thisloop;
2380   nesting_stack = thisloop;
2381
2382   do_pending_stack_adjust ();
2383   emit_queue ();
2384   emit_note (0, -4 );
2385   emit_label (thisloop->data.loop.start_label);
2386 }
2387
2388 void
2389 expand_start_loop_continue_elsewhere (exit_flag)
2390      int exit_flag;
2391 {
2392   expand_start_loop (exit_flag);
2393   loop_stack->data.loop.continue_label = gen_label_rtx ();
2394 }
2395
2396 void
2397 expand_loop_continue_here ()
2398 {
2399   do_pending_stack_adjust ();
2400   emit_note (0, -8 );
2401   emit_label (loop_stack->data.loop.continue_label);
2402 }
2403
2404 void
2405 expand_end_loop ()
2406 {
2407   register rtx insn = get_last_insn ();
2408   register rtx start_label = loop_stack->data.loop.start_label;
2409
2410   do_pending_stack_adjust ();
2411
2412   if (optimize
2413       &&
2414       ! (       ((insn)->code)  == JUMP_INSN
2415          &&     ((((insn)->fld[3].rtx) )->code)  == SET
2416          && ((((insn)->fld[3].rtx) )->fld[0].rtx)  == pc_rtx
2417          &&     ((((((insn)->fld[3].rtx) )->fld[1].rtx) )->code)  == IF_THEN_ELSE))
2418     {
2419
2420       for (insn = loop_stack->data.loop.start_label; insn; insn= ((insn)->fld[2].rtx) )
2421         if (    ((insn)->code)  == JUMP_INSN &&         ((((insn)->fld[3].rtx) )->code)  == SET
2422             && ((((insn)->fld[3].rtx) )->fld[0].rtx)  == pc_rtx
2423             &&  ((((((insn)->fld[3].rtx) )->fld[1].rtx) )->code)  == IF_THEN_ELSE
2424             &&
2425             ((  ((((((((insn)->fld[3].rtx) )->fld[1].rtx) )->fld[ 1].rtx) )->code)  == LABEL_REF
2426               && (((((((((insn)->fld[3].rtx) )->fld[1].rtx) )->fld[ 1].rtx) )->fld[ 0].rtx) 
2427                   == loop_stack->data.loop.end_label))
2428              ||
2429              (  ((((((((insn)->fld[3].rtx) )->fld[1].rtx) )->fld[ 2].rtx) )->code)  == LABEL_REF
2430               && (((((((((insn)->fld[3].rtx) )->fld[1].rtx) )->fld[ 2].rtx) )->fld[ 0].rtx) 
2431                   == loop_stack->data.loop.end_label))))
2432           break;
2433       if (insn != 0)
2434         {
2435
2436           register rtx newstart_label = gen_label_rtx ();
2437
2438           emit_label_after (newstart_label, ((start_label)->fld[1].rtx) );
2439           reorder_insns (start_label, insn, get_last_insn ());
2440           emit_jump_insn_after (gen_jump (start_label), ((newstart_label)->fld[1].rtx) );
2441           emit_barrier_after (((newstart_label)->fld[1].rtx) );
2442           start_label = newstart_label;
2443         }
2444     }
2445
2446   emit_jump (start_label);
2447   emit_note (0, -5 );
2448   emit_label (loop_stack->data.loop.end_label);
2449
2450   do { int initial_depth = nesting_stack->depth;        do { struct nesting *this = loop_stack; loop_stack = this->next;        nesting_stack = this->all;      nesting_depth = this->depth;    free (this); }  while (nesting_depth > initial_depth); } while (0) ;
2451
2452   last_expr_type = 0;
2453 }
2454
2455 int
2456 expand_continue_loop ()
2457 {
2458   last_expr_type = 0;
2459   if (loop_stack == 0)
2460     return 0;
2461   expand_goto_internal (0, loop_stack->data.loop.continue_label, 0);
2462   return 1;
2463 }
2464
2465 int
2466 expand_exit_loop ()
2467 {
2468   last_expr_type = 0;
2469   if (loop_stack == 0)
2470     return 0;
2471   expand_goto_internal (0, loop_stack->data.loop.end_label, 0);
2472   return 1;
2473 }
2474
2475 int
2476 expand_exit_loop_if_false (cond)
2477      tree cond;
2478 {
2479   last_expr_type = 0;
2480   if (loop_stack == 0)
2481     return 0;
2482   do_jump (cond, loop_stack->data.loop.end_label, 0 );
2483   return 1;
2484 }
2485
2486 int
2487 expand_exit_something ()
2488 {
2489   struct nesting *n;
2490   last_expr_type = 0;
2491   for (n = nesting_stack; n; n = n->all)
2492     if (n->exit_label != 0)
2493       {
2494         expand_goto_internal (0, n->exit_label, 0);
2495         return 1;
2496       }
2497
2498   return 0;
2499 }
2500
2501 void
2502 expand_null_return ()
2503 {
2504   expand_null_return_1 (0);
2505 }
2506
2507 static void
2508 expand_null_return_1 (last_insn)
2509      rtx last_insn;
2510 {
2511   clear_pending_stack_adjust ();
2512   do_pending_stack_adjust ();
2513   last_expr_type = 0;
2514
2515   if (current_function_returns_pcc_struct)
2516     {
2517       expand_goto_internal (0, return_label, last_insn);
2518       return;
2519     }
2520
2521   if ((0) )
2522     {
2523       emit_jump_insn (gen_return ());
2524       emit_barrier ();
2525       return;
2526     }
2527
2528   expand_goto_internal (0, return_label, last_insn);
2529 }
2530
2531 void
2532 expand_return (retval)
2533      tree retval;
2534 {
2535   register rtx val = 0;
2536   register rtx op0;
2537   tree retval_rhs;
2538   int cleanups;
2539   struct nesting *block;
2540
2541   cleanups = 0;
2542   for (block = block_stack; block; block = block->next)
2543     if (block->data.block.cleanups != 0)
2544       {
2545         cleanups = 1;
2546         break;
2547       }
2548
2549   if (((retval)->common.code)  == RESULT_DECL)
2550     retval_rhs = retval;
2551   else if ((((retval)->common.code)  == MODIFY_EXPR || ((retval)->common.code)  == INIT_EXPR)
2552            && ((((retval)->exp.operands[ 0]) )->common.code)  == RESULT_DECL)
2553     retval_rhs = ((retval)->exp.operands[ 1]) ;
2554   else if (((retval)->common.type)  == void_type_node)
2555     retval_rhs = retval;
2556   else
2557     retval_rhs = (tree) 0  ;
2558
2559   if (optimize && retval_rhs != 0
2560       && frame_offset == 0 
2561       && ((retval_rhs)->common.code)  == CALL_EXPR
2562       && ((((retval_rhs)->exp.operands[ 0]) )->common.code)  == ADDR_EXPR
2563       && ((((retval_rhs)->exp.operands[ 0]) )->exp.operands[ 0])  == this_function
2564
2565       && tail_recursion_args (((retval_rhs)->exp.operands[ 1]) ,
2566                               ((this_function)->decl.arguments)  ))
2567     {
2568       if (tail_recursion_label == 0)
2569         {
2570           tail_recursion_label = gen_label_rtx ();
2571           emit_label_after (tail_recursion_label,
2572                             tail_recursion_reentry);
2573         }
2574       expand_goto_internal (0, tail_recursion_label, get_last_insn ());
2575       emit_barrier ();
2576       return;
2577     }
2578
2579   if ((0)  && ! cleanups
2580       && ! current_function_returns_pcc_struct)
2581     {
2582
2583       if (retval_rhs)
2584         switch (((retval_rhs)->common.code) )
2585           {
2586           case EQ_EXPR:
2587           case NE_EXPR:
2588           case GT_EXPR:
2589           case GE_EXPR:
2590           case LT_EXPR:
2591           case LE_EXPR:
2592           case TRUTH_ANDIF_EXPR:
2593           case TRUTH_ORIF_EXPR:
2594           case TRUTH_AND_EXPR:
2595           case TRUTH_OR_EXPR:
2596           case TRUTH_NOT_EXPR:
2597             op0 = gen_label_rtx ();
2598             val = ((((this_function)->decl.result) )->decl.rtl) ;
2599             jumpifnot (retval_rhs, op0);
2600             emit_move_insn (val, const1_rtx);
2601             emit_insn (gen_rtx (USE, VOIDmode, val));
2602             expand_null_return ();
2603             emit_label (op0);
2604             emit_move_insn (val, const0_rtx);
2605             emit_insn (gen_rtx (USE, VOIDmode, val));
2606             expand_null_return ();
2607             return;
2608           }
2609     }
2610
2611   if (cleanups
2612       && retval_rhs != 0
2613       && ((retval_rhs)->common.type)  != void_type_node
2614       &&        ((((((this_function)->decl.result) )->decl.rtl) )->code)  == REG)
2615     {
2616       rtx last_insn;
2617       val = expand_expr (retval_rhs, 0, VOIDmode, 0);
2618       emit_queue ();
2619       last_insn = get_last_insn ();
2620       emit_move_insn (((((this_function)->decl.result) )->decl.rtl) , val);
2621       val = ((((this_function)->decl.result) )->decl.rtl) ;
2622
2623       if (      ((val)->code)  == REG)
2624         emit_insn (gen_rtx (USE, VOIDmode, val));
2625       expand_null_return_1 (last_insn);
2626     }
2627   else
2628     {
2629
2630       val = expand_expr (retval, 0, VOIDmode, 0);
2631       emit_queue ();
2632
2633       val = ((((this_function)->decl.result) )->decl.rtl) ;
2634       if (      ((val)->code)  == REG)
2635         emit_insn (gen_rtx (USE, VOIDmode, val));
2636       expand_null_return ();
2637     }
2638 }
2639
2640 int
2641 drop_through_at_end_p ()
2642 {
2643   rtx insn = get_last_insn ();
2644   while (insn &&        ((insn)->code)  == NOTE)
2645     insn = ((insn)->fld[1].rtx) ;
2646   return insn &&        ((insn)->code)  != BARRIER;
2647 }
2648
2649 static int
2650 tail_recursion_args (actuals, formals)
2651      tree actuals, formals;
2652 {
2653   register tree a = actuals, f = formals;
2654   register int i;
2655   register rtx *argvec;
2656
2657   for (a = actuals, f = formals, i = 0; a && f; a = ((a)->common.chain) , f = ((f)->common.chain) , i++)
2658     {
2659       if (((((a)->list.value) )->common.type)  != ((f)->common.type) )
2660         return 0;
2661       if (      ((((f)->decl.rtl) )->code)  != REG || ((f)->decl.mode)  == BLKmode)
2662         return 0;
2663     }
2664   if (a != 0 || f != 0)
2665     return 0;
2666
2667   argvec = (rtx *) __builtin_alloca  (i * sizeof (rtx));
2668
2669   for (a = actuals, i = 0; a; a = ((a)->common.chain) , i++)
2670     argvec[i] = expand_expr (((a)->list.value) , 0, VOIDmode, 0);
2671
2672   for (a = actuals, i = 0; a; a = ((a)->common.chain) , i++)
2673     {
2674       int copy = 0;
2675       register int j;
2676       for (f = formals, j = 0; j < i; f = ((f)->common.chain) , j++)
2677         if (reg_mentioned_p (((f)->decl.rtl) , argvec[i]))
2678           { copy = 1; break; }
2679       if (copy)
2680         argvec[i] = copy_to_reg (argvec[i]);
2681     }
2682
2683   for (f = formals, a = actuals, i = 0; f;
2684        f = ((f)->common.chain) , a = ((a)->common.chain) , i++)
2685     {
2686       if (((f)->decl.mode)  ==  ((argvec[i])->mode) )
2687         emit_move_insn (((f)->decl.rtl) , argvec[i]);
2688       else
2689         convert_move (((f)->decl.rtl) , argvec[i],
2690                       ((((((a)->list.value) )->common.type) )->common.unsigned_attr) );
2691     }
2692
2693   return 1;
2694 }
2695
2696 void
2697 expand_start_bindings (exit_flag)
2698      int exit_flag;
2699 {
2700   struct nesting *thisblock
2701     = (struct nesting *) xmalloc (sizeof (struct nesting));
2702
2703   rtx note = emit_note (0, -2 );
2704
2705   thisblock->next = block_stack;
2706   thisblock->all = nesting_stack;
2707   thisblock->depth = ++nesting_depth;
2708   thisblock->data.block.stack_level = 0;
2709   thisblock->data.block.cleanups = 0;
2710
2711   thisblock->data.block.outer_cleanups
2712     = (block_stack
2713        ? tree_cons ((tree) 0  , block_stack->data.block.cleanups,
2714                     block_stack->data.block.outer_cleanups)
2715        : 0);
2716   thisblock->data.block.label_chain = 0;
2717   thisblock->data.block.innermost_stack_block = stack_block_stack;
2718   thisblock->data.block.first_insn = note;
2719   thisblock->exit_label = exit_flag ? gen_label_rtx () : 0;
2720   block_stack = thisblock;
2721   nesting_stack = thisblock;
2722 }
2723
2724 void
2725 use_variable (rtl)
2726      rtx rtl;
2727 {
2728   if (  ((rtl)->code)  == REG)
2729     emit_insn (gen_rtx (USE, VOIDmode, rtl));
2730   else if (     ((rtl)->code)  == MEM
2731            &&   ((((rtl)->fld[ 0].rtx) )->code)  == REG
2732            && ((rtl)->fld[ 0].rtx)  != frame_pointer_rtx
2733            && ((rtl)->fld[ 0].rtx)  != arg_pointer_rtx)
2734     emit_insn (gen_rtx (USE, VOIDmode, ((rtl)->fld[ 0].rtx) ));
2735 }
2736
2737 static void
2738 use_variable_after (rtl, insn)
2739      rtx rtl, insn;
2740 {
2741   if (  ((rtl)->code)  == REG)
2742     emit_insn_after (gen_rtx (USE, VOIDmode, rtl), insn);
2743   else if (     ((rtl)->code)  == MEM
2744            &&   ((((rtl)->fld[ 0].rtx) )->code)  == REG
2745            && ((rtl)->fld[ 0].rtx)  != frame_pointer_rtx
2746            && ((rtl)->fld[ 0].rtx)  != arg_pointer_rtx)
2747     emit_insn_after (gen_rtx (USE, VOIDmode, ((rtl)->fld[ 0].rtx) ), insn);
2748 }
2749
2750 void
2751 expand_end_bindings (vars, mark_ends, dont_jump_in)
2752      tree vars;
2753      int mark_ends;
2754      int dont_jump_in;
2755 {
2756   register struct nesting *thisblock = block_stack;
2757   register tree decl;
2758
2759   if (warn_unused)
2760     for (decl = vars; decl; decl = ((decl)->common.chain) )
2761       if (! ((decl)->common.used_attr)  && ((decl)->common.code)  == VAR_DECL)
2762         warning_with_decl (decl, "unused variable `%s'");
2763
2764   if (mark_ends)
2765     emit_note (0, -3 );
2766   else
2767     ((thisblock->data.block.first_insn)->fld[4].rtint)  = -1 ;
2768
2769   if (thisblock->exit_label)
2770     {
2771       do_pending_stack_adjust ();
2772       emit_label (thisblock->exit_label);
2773     }
2774
2775   if (dont_jump_in
2776       || thisblock->data.block.stack_level != 0
2777       || thisblock->data.block.cleanups != 0)
2778     {
2779       struct label_chain *chain;
2780
2781       for (chain = thisblock->data.block.label_chain; chain; chain = chain->next)
2782         {
2783           ((chain->label)->common.packed_attr)  = 1;
2784
2785           if (((chain->label)->common.addressable_attr) )
2786             error_with_decl (chain->label,
2787                              "label `%s' used before containing binding contour");
2788         }
2789     }
2790
2791   if (thisblock->data.block.stack_level != 0
2792       || thisblock->data.block.cleanups != 0)
2793     {
2794
2795       expand_cleanups (thisblock->data.block.cleanups, 0);
2796
2797       if (thisblock->data.block.stack_level != 0)
2798         {
2799           do_pending_stack_adjust ();
2800           emit_move_insn (stack_pointer_rtx,
2801                           thisblock->data.block.stack_level);
2802         }
2803
2804       fixup_gotos (thisblock,
2805                    thisblock->data.block.stack_level,
2806                    thisblock->data.block.cleanups,
2807                    thisblock->data.block.first_insn,
2808                    dont_jump_in);
2809     }
2810
2811   if (obey_regdecls)
2812     for (decl = vars; decl; decl = ((decl)->common.chain) )
2813       {
2814         rtx rtl = ((decl)->decl.rtl) ;
2815         if (((decl)->common.code)  == VAR_DECL && rtl != 0)
2816           use_variable (rtl);
2817       }
2818
2819   stack_block_stack = thisblock->data.block.innermost_stack_block;
2820   do { int initial_depth = nesting_stack->depth;        do { struct nesting *this = block_stack;        block_stack = this->next;       nesting_stack = this->all;      nesting_depth = this->depth;    free (this); }  while (nesting_depth > initial_depth); } while (0) ;
2821 }
2822
2823 void
2824 expand_decl (decl, cleanup)
2825      register tree decl;
2826      tree cleanup;
2827 {
2828   struct nesting *thisblock = block_stack;
2829   tree type;
2830
2831   if (cleanup != 0)
2832     {
2833       thisblock->data.block.cleanups
2834         = temp_tree_cons (decl, cleanup, thisblock->data.block.cleanups);
2835       stack_block_stack = thisblock;
2836     }
2837
2838   if (decl == (tree) 0  )
2839     {
2840       if (cleanup == 0)
2841         abort ();
2842       return;
2843     }
2844
2845   type = ((decl)->common.type) ;
2846
2847   if (((decl)->common.code)  != VAR_DECL)
2848     return;
2849   if (((decl)->common.static_attr)  || ((decl)->common.external_attr) )
2850     return;
2851
2852   if (type == error_mark_node)
2853     ((decl)->decl.rtl)  = gen_rtx (MEM, BLKmode, const0_rtx);
2854   else if (((decl)->decl.size)  == 0)
2855     {
2856       if (((decl)->decl.initial)  == 0)
2857         ((decl)->decl.rtl)  = assign_stack_local (((decl)->decl.mode) , 0);
2858       else
2859
2860         ((decl)->decl.rtl)  = gen_rtx (MEM, BLKmode, gen_reg_rtx (SImode ));
2861     }
2862   else if (((decl)->decl.mode)  != BLKmode
2863
2864            && !(flag_float_store
2865                 && ((type)->common.code)  == REAL_TYPE)
2866            && ! ((decl)->common.volatile_attr) 
2867            && ! ((decl)->common.addressable_attr) 
2868            && (((decl)->common.regdecl_attr)  || ! obey_regdecls))
2869     {
2870       ((decl)->decl.rtl)  = gen_reg_rtx (((decl)->decl.mode) );
2871       if (((type)->common.code)  == POINTER_TYPE)
2872         mark_reg_pointer (((decl)->decl.rtl) );
2873       ((((decl)->decl.rtl) )->volatil)  = 1;
2874     }
2875   else if (((((decl)->decl.size) )->common.literal_attr) )
2876     {
2877       rtx oldaddr = 0;
2878       rtx addr;
2879
2880       if (((decl)->decl.rtl)  != 0)
2881         {
2882           if (  ((((decl)->decl.rtl) )->code)  != MEM
2883               ||        ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  != REG)
2884             abort ();
2885           oldaddr = ((((decl)->decl.rtl) )->fld[ 0].rtx) ;
2886         }
2887
2888       ((decl)->decl.rtl) 
2889         = assign_stack_local (((decl)->decl.mode) ,
2890                               (((((decl)->decl.size) )->int_cst.int_cst_low) 
2891                                * ((decl)->decl.size_unit) 
2892                                + 8  - 1)
2893                               / 8 );
2894       if (oldaddr)
2895         {
2896           addr = force_operand (((((decl)->decl.rtl) )->fld[ 0].rtx) , oldaddr);
2897           emit_move_insn (oldaddr, addr);
2898         }
2899
2900       ((((decl)->decl.rtl) )->in_struct) 
2901         = (((((decl)->common.type) )->common.code)  == ARRAY_TYPE
2902            || ((((decl)->common.type) )->common.code)  == RECORD_TYPE
2903            || ((((decl)->common.type) )->common.code)  == UNION_TYPE);
2904
2905     }
2906   else
2907     {
2908       rtx address, size;
2909
2910       frame_pointer_needed = 1;
2911
2912       if (thisblock->data.block.stack_level == 0)
2913         {
2914           do_pending_stack_adjust ();
2915           thisblock->data.block.stack_level
2916             = copy_to_reg (stack_pointer_rtx);
2917           stack_block_stack = thisblock;
2918         }
2919
2920       size = expand_expr (convert_units (((decl)->decl.size) ,
2921                                          ((decl)->decl.size_unit) ,
2922                                          8 ),
2923                           0, VOIDmode, 0);
2924
2925       if (((decl)->decl.size_unit)  % 16 )
2926         {
2927
2928           size = round_push (size);
2929         }
2930
2931       anti_adjust_stack (size);
2932
2933       address = copy_to_reg (stack_pointer_rtx);
2934
2935       ((decl)->decl.rtl)  = gen_rtx (MEM, ((decl)->decl.mode) , address);
2936     }
2937
2938   if (((decl)->common.volatile_attr) )
2939     ((((decl)->decl.rtl) )->volatil)  = 1;
2940   if (((decl)->common.readonly_attr) )
2941     ((((decl)->decl.rtl) )->unchanging)  = 1;
2942
2943   if (obey_regdecls)
2944     use_variable (((decl)->decl.rtl) );
2945 }
2946
2947 void
2948 expand_decl_init (decl)
2949      tree decl;
2950 {
2951   if (((decl)->common.static_attr) )
2952     return;
2953
2954   if (((decl)->decl.initial)  == error_mark_node)
2955     {
2956       enum tree_code code = ((((decl)->common.type) )->common.code) ;
2957       if (code == INTEGER_TYPE || code == REAL_TYPE || code == ENUMERAL_TYPE
2958           || code == POINTER_TYPE)
2959         expand_assignment (decl, convert (((decl)->common.type) , integer_zero_node),
2960                            0, 0);
2961       emit_queue ();
2962     }
2963   else if (((decl)->decl.initial)  && ((((decl)->decl.initial) )->common.code)  != TREE_LIST)
2964     {
2965       emit_line_note (((decl)->decl.filename) , ((decl)->decl.linenum) );
2966       expand_assignment (decl, ((decl)->decl.initial) , 0, 0);
2967       emit_queue ();
2968     }
2969 }
2970
2971 void
2972 expand_anon_union_decl (decl, cleanup, decl_elts)
2973      tree decl, cleanup, decl_elts;
2974 {
2975   struct nesting *thisblock = block_stack;
2976   rtx x;
2977
2978   expand_decl (decl, cleanup);
2979   x = ((decl)->decl.rtl) ;
2980
2981   while (decl_elts)
2982     {
2983       tree decl_elt = ((decl_elts)->list.value) ;
2984       tree cleanup_elt = ((decl_elts)->list.purpose) ;
2985
2986       ((decl_elt)->decl.rtl) 
2987         = (     ((x)->mode)  != BLKmode
2988
2989            ? gen_rtx (SUBREG, ((((decl_elt)->common.type) )->type.mode) , x, 0)
2990            : x);
2991
2992       if (cleanup != 0)
2993         thisblock->data.block.cleanups
2994           = temp_tree_cons (decl_elt, cleanup_elt,
2995                             thisblock->data.block.cleanups);
2996
2997       decl_elts = ((decl_elts)->common.chain) ;
2998     }
2999 }
3000
3001 static void
3002 expand_cleanups (list, dont_do)
3003      tree list;
3004      tree dont_do;
3005 {
3006   tree tail;
3007   for (tail = list; tail; tail = ((tail)->common.chain) )
3008     if (dont_do == 0 || ((tail)->list.purpose)  != dont_do)
3009       {
3010         if (((((tail)->list.value) )->common.code)  == TREE_LIST)
3011           expand_cleanups (((tail)->list.value) , dont_do);
3012         else
3013           expand_expr (((tail)->list.value) , const0_rtx, VOIDmode, 0);
3014       }
3015 }
3016
3017 static void
3018 fixup_cleanups (list, before_jump)
3019      tree list;
3020      rtx *before_jump;
3021 {
3022   rtx beyond_jump = get_last_insn ();
3023   rtx new_before_jump;
3024
3025   expand_cleanups (list, 0);
3026   new_before_jump = get_last_insn ();
3027
3028   reorder_insns (((beyond_jump)->fld[2].rtx) , new_before_jump, *before_jump);
3029   *before_jump = new_before_jump;
3030 }
3031
3032 void
3033 move_cleanups_up ()
3034 {
3035   struct nesting *block = block_stack;
3036   struct nesting *outer = block->next;
3037
3038   outer->data.block.cleanups
3039     = chainon (block->data.block.cleanups,
3040                outer->data.block.cleanups);
3041   block->data.block.cleanups = 0;
3042 }
3043
3044 void
3045 expand_start_case (exit_flag, expr, type)
3046      int exit_flag;
3047      tree expr;
3048      tree type;
3049 {
3050   register struct nesting *thiscase
3051     = (struct nesting *) xmalloc (sizeof (struct nesting));
3052
3053   thiscase->next = case_stack;
3054   thiscase->all = nesting_stack;
3055   thiscase->depth = ++nesting_depth;
3056   thiscase->exit_label = exit_flag ? gen_label_rtx () : 0;
3057   thiscase->data.case_stmt.case_list = 0;
3058   thiscase->data.case_stmt.index_expr = expr;
3059   thiscase->data.case_stmt.nominal_type = type;
3060   thiscase->data.case_stmt.default_label = 0;
3061   thiscase->data.case_stmt.num_ranges = 0;
3062   case_stack = thiscase;
3063   nesting_stack = thiscase;
3064
3065   do_pending_stack_adjust ();
3066
3067   if (  ((get_last_insn ())->code)  != NOTE)
3068     emit_note (0, -1 );
3069
3070   thiscase->data.case_stmt.start = get_last_insn ();
3071 }
3072
3073 void
3074 expand_start_case_dummy ()
3075 {
3076   register struct nesting *thiscase
3077     = (struct nesting *) xmalloc (sizeof (struct nesting));
3078
3079   thiscase->next = case_stack;
3080   thiscase->all = nesting_stack;
3081   thiscase->depth = ++nesting_depth;
3082   thiscase->exit_label = 0;
3083   thiscase->data.case_stmt.case_list = 0;
3084   thiscase->data.case_stmt.start = 0;
3085   thiscase->data.case_stmt.nominal_type = 0;
3086   thiscase->data.case_stmt.default_label = 0;
3087   thiscase->data.case_stmt.num_ranges = 0;
3088   case_stack = thiscase;
3089   nesting_stack = thiscase;
3090 }
3091
3092 void
3093 expand_end_case_dummy ()
3094 {
3095   do { int initial_depth = nesting_stack->depth;        do { struct nesting *this = case_stack; case_stack = this->next;        nesting_stack = this->all;      nesting_depth = this->depth;    free (this); }  while (nesting_depth > initial_depth); } while (0) ;
3096 }
3097
3098 int
3099 pushcase (value, label)
3100      register tree value;
3101      register tree label;
3102 {
3103   register struct case_node **l;
3104   register struct case_node *n;
3105   tree index_type;
3106   tree nominal_type;
3107
3108   if (! (case_stack && case_stack->data.case_stmt.start))
3109     return 1;
3110
3111   index_type = ((case_stack->data.case_stmt.index_expr)->common.type) ;
3112   nominal_type = case_stack->data.case_stmt.nominal_type;
3113
3114   if (index_type == error_mark_node)
3115     return 0;
3116
3117   if (value != 0)
3118     value = convert (nominal_type, value);
3119
3120   if (value != 0 && ! int_fits_type_p (value, index_type))
3121     return 3;
3122
3123   if (value == 0)
3124     {
3125       if (case_stack->data.case_stmt.default_label != 0)
3126         return 2;
3127       case_stack->data.case_stmt.default_label = label;
3128     }
3129   else
3130     {
3131
3132       for (l = &case_stack->data.case_stmt.case_list;
3133            *l != 0 && tree_int_cst_lt ((*l)->high, value);
3134            l = &(*l)->right)
3135         ;
3136       if (*l)
3137         {
3138
3139           if (! tree_int_cst_lt (value, (*l)->low))
3140             return 2;
3141         }
3142
3143       n = (struct case_node *) oballoc (sizeof (struct case_node));
3144       n->left = 0;
3145       n->right = *l;
3146       n->high = n->low = copy_node (value);
3147       n->code_label = label;
3148       n->test_label = 0;
3149       *l = n;
3150     }
3151
3152   expand_label (label);
3153   return 0;
3154 }
3155
3156 int
3157 pushcase_range (value1, value2, label)
3158      register tree value1, value2;
3159      register tree label;
3160 {
3161   register struct case_node **l;
3162   register struct case_node *n;
3163   tree index_type;
3164   tree nominal_type;
3165
3166   if (! (case_stack && case_stack->data.case_stmt.start))
3167     return 1;
3168
3169   index_type = ((case_stack->data.case_stmt.index_expr)->common.type) ;
3170   nominal_type = case_stack->data.case_stmt.nominal_type;
3171
3172   if (index_type == error_mark_node)
3173     return 0;
3174
3175   if (value1 != 0)
3176     value1 = convert (nominal_type, value1);
3177   if (value2 != 0)
3178     value2 = convert (nominal_type, value2);
3179
3180   if (value1 != 0 && ! int_fits_type_p (value1, index_type))
3181     return 3;
3182
3183   if (value2 != 0 && ! int_fits_type_p (value2, index_type))
3184     return 3;
3185
3186   if (tree_int_cst_lt (value2, value1))
3187     return 4;
3188
3189   if (tree_int_cst_equal (value1, value2))
3190     return pushcase (value1, label);
3191
3192   for (l = &case_stack->data.case_stmt.case_list;
3193        *l != 0 && tree_int_cst_lt ((*l)->high, value1);
3194        l = &(*l)->right)
3195     ;
3196   if (*l)
3197     {
3198
3199       if (! tree_int_cst_lt (value2, (*l)->low))
3200         return 2;
3201     }
3202
3203   n = (struct case_node *) oballoc (sizeof (struct case_node));
3204   n->left = 0;
3205   n->right = *l;
3206   n->low = copy_node (value1);
3207   n->high = copy_node (value2);
3208   n->code_label = label;
3209   n->test_label = 0;
3210   *l = n;
3211
3212   expand_label (label);
3213
3214   case_stack->data.case_stmt.num_ranges++;
3215
3216   return 0;
3217 }
3218
3219 void
3220 check_for_full_enumeration_handling ()
3221 {
3222   tree index_expr = case_stack->data.case_stmt.index_expr;
3223
3224   if (((index_expr)->common.code)  == INTEGER_CST)
3225     return;
3226   else
3227     {
3228       register struct case_node *n;
3229       register tree chain;
3230       tree enum_node = ((index_expr)->exp.operands[ 0]) ;
3231
3232       for (chain = ((((enum_node)->common.type) )->type.values) ;
3233            chain; 
3234            chain = ((chain)->common.chain) )
3235         {
3236
3237           for (n = case_stack->data.case_stmt.case_list; 
3238                n && tree_int_cst_lt (n->high, ((chain)->list.value) );
3239                n = n->right)
3240             ;
3241
3242           if (!(n && tree_int_cst_equal (n->low, ((chain)->list.value) )))
3243             warning ("enumerated value `%s' not handled in switch",
3244                      ((((chain)->list.purpose) )->identifier.pointer) );
3245         }
3246
3247       for (n = case_stack->data.case_stmt.case_list; n; n = n->right)
3248         {
3249           for (chain = (( ((enum_node)->common.type) )->type.values) ;
3250                chain && !tree_int_cst_equal (n->low, ((chain)->list.value) ); 
3251                chain = ((chain)->common.chain) )
3252             ;
3253
3254           if (!chain)
3255             warning ("case value `%d' not in enumerated type `%s'",
3256                      ((n->low)->int_cst.int_cst_low) , 
3257                      ((((((((enum_node)->common.type) )->type.name) )->decl.name) )->identifier.pointer) );
3258         }
3259     }
3260 }
3261
3262 void
3263 expand_end_case (orig_index)
3264      tree orig_index;
3265 {
3266   tree minval, maxval, range;
3267   rtx default_label = 0;
3268   register struct case_node *n;
3269   int count;
3270   rtx index;
3271   rtx table_label = gen_label_rtx ();
3272   int ncases;
3273   rtx *labelvec;
3274   register int i;
3275   rtx before_case;
3276   register struct nesting *thiscase = case_stack;
3277   tree index_expr = thiscase->data.case_stmt.index_expr;
3278
3279   do_pending_stack_adjust ();
3280
3281   if (((index_expr)->common.type)  != error_mark_node)
3282     {
3283
3284       if (!thiscase->data.case_stmt.default_label 
3285           && ((((orig_index)->common.type) )->common.code)  == ENUMERAL_TYPE
3286           && warn_switch)
3287         check_for_full_enumeration_handling ();
3288
3289       if (thiscase->data.case_stmt.default_label == 0)
3290         {
3291           thiscase->data.case_stmt.default_label
3292             = build_decl (LABEL_DECL, (tree) 0  , (tree) 0  );
3293           expand_label (thiscase->data.case_stmt.default_label);
3294         }
3295       default_label = label_rtx (thiscase->data.case_stmt.default_label);
3296
3297       before_case = get_last_insn ();
3298
3299       group_case_nodes (thiscase->data.case_stmt.case_list);
3300
3301       count = 0;
3302       for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
3303         {
3304           if (((n->low)->common.code)  != INTEGER_CST)
3305             abort ();
3306           if (((n->high)->common.code)  != INTEGER_CST)
3307             abort ();
3308
3309           n->low = convert (((index_expr)->common.type) , n->low);
3310           n->high = convert (((index_expr)->common.type) , n->high);
3311
3312           if (count++ == 0)
3313             {
3314               minval = n->low;
3315               maxval = n->high;
3316             }
3317           else
3318             {
3319               if ((((n->low)->int_cst.int_cst_high)  < (( minval)->int_cst.int_cst_high)        || (((n->low)->int_cst.int_cst_high)  == (( minval)->int_cst.int_cst_high)      && ((unsigned) ((n->low)->int_cst.int_cst_low)  < (unsigned) (( minval)->int_cst.int_cst_low) ))) )
3320                 minval = n->low;
3321               if ((((maxval)->int_cst.int_cst_high)  < (( n->high)->int_cst.int_cst_high)       || (((maxval)->int_cst.int_cst_high)  == (( n->high)->int_cst.int_cst_high)     && ((unsigned) ((maxval)->int_cst.int_cst_low)  < (unsigned) (( n->high)->int_cst.int_cst_low) ))) )
3322                 maxval = n->high;
3323             }
3324           if (! tree_int_cst_equal (n->low, n->high))
3325             count++;
3326         }
3327
3328       if (count != 0)
3329         range = combine (MINUS_EXPR, maxval, minval);
3330
3331       if (count == 0 || ((((index_expr)->common.type) )->common.code)  == ERROR_MARK)
3332         {
3333           expand_expr (index_expr, const0_rtx, VOIDmode, 0);
3334           emit_queue ();
3335           emit_jump (default_label);
3336         }
3337
3338       else if (((range)->int_cst.int_cst_high)  != 0
3339
3340                || count < 4
3341
3342                || (unsigned) (((range)->int_cst.int_cst_low) ) > 10 * count
3343                || ((index_expr)->common.code)  == INTEGER_CST)
3344         {
3345           index = expand_expr (index_expr, 0, VOIDmode, 0);
3346           emit_queue ();
3347           do_pending_stack_adjust ();
3348
3349           index = protect_from_queue (index, 0);
3350           if (  ((index)->code)  == MEM)
3351             index = copy_to_reg (index);
3352           if (  ((index)->code)  == CONST_INT
3353               || ((index_expr)->common.code)  == INTEGER_CST)
3354             {
3355
3356               if (((index_expr)->common.code)  != INTEGER_CST)
3357                 {
3358                   index_expr = build_int_2 (((index)->fld[0].rtint) , 0);
3359                   index_expr = convert (((index_expr)->common.type) , index_expr);
3360                 }
3361
3362               for (n = thiscase->data.case_stmt.case_list;
3363                    n;
3364                    n = n->right)
3365                 {
3366                   if (! tree_int_cst_lt (index_expr, n->low)
3367                       && ! tree_int_cst_lt (n->high, index_expr))
3368                     break;
3369                 }
3370               if (n)
3371                 emit_jump (label_rtx (n->code_label));
3372               else
3373                 emit_jump (default_label);
3374             }
3375           else
3376             {
3377
3378               balance_case_nodes (&thiscase->data.case_stmt.case_list, 0);
3379               emit_case_nodes (index, thiscase->data.case_stmt.case_list,
3380                                default_label,
3381                                ((((index_expr)->common.type) )->common.unsigned_attr) );
3382               emit_jump_if_reachable (default_label);
3383             }
3384         }
3385       else
3386         {
3387
3388           if (((((index_expr)->common.type) )->type.mode)  == DImode)
3389             {
3390               index_expr = build (MINUS_EXPR, ((index_expr)->common.type) ,
3391                                   index_expr, minval);
3392               minval = integer_zero_node;
3393             }
3394           if (((((index_expr)->common.type) )->type.mode)  != SImode)
3395             index_expr = convert (type_for_size ( (8  * mode_size[(int)(SImode)]) , 0),
3396                                   index_expr);
3397           index = expand_expr (index_expr, 0, VOIDmode, 0);
3398           emit_queue ();
3399           index = protect_from_queue (index, 0);
3400           do_pending_stack_adjust ();
3401
3402           emit_jump_insn (gen_casesi (index, expand_expr (minval, 0, VOIDmode, 0),
3403                                       expand_expr (range, 0, VOIDmode, 0),
3404                                       table_label, default_label));
3405
3406           ncases = ((range)->int_cst.int_cst_low)  + 1;
3407           labelvec = (rtx *) __builtin_alloca  (ncases * sizeof (rtx));
3408           memset (labelvec,0, ncases * sizeof (rtx)) ;
3409
3410           for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
3411             {
3412               register int i
3413                 = ((n->low)->int_cst.int_cst_low)  - ((minval)->int_cst.int_cst_low) ;
3414
3415               while (i + ((minval)->int_cst.int_cst_low) 
3416                      <= ((n->high)->int_cst.int_cst_low) )
3417                 labelvec[i++]
3418                   = gen_rtx (LABEL_REF, SImode , label_rtx (n->code_label));
3419             }
3420
3421           for (i = 0; i < ncases; i++)
3422             if (labelvec[i] == 0)
3423               labelvec[i] = gen_rtx (LABEL_REF, SImode , default_label);
3424
3425           emit_label (table_label);
3426
3427           emit_jump_insn (gen_rtx (ADDR_DIFF_VEC, HImode ,
3428                                    gen_rtx (LABEL_REF, SImode , table_label),
3429                                    gen_rtvec_v (ncases, labelvec)));
3430
3431           emit_barrier ();
3432
3433         }
3434
3435       reorder_insns (((before_case)->fld[2].rtx) , get_last_insn (),
3436                      thiscase->data.case_stmt.start);
3437     }
3438   if (thiscase->exit_label)
3439     emit_label (thiscase->exit_label);
3440
3441   do { int initial_depth = nesting_stack->depth;        do { struct nesting *this = case_stack; case_stack = this->next;        nesting_stack = this->all;      nesting_depth = this->depth;    free (this); }  while (nesting_depth > initial_depth); } while (0) ;
3442 }
3443
3444 static void
3445 do_jump_if_equal (op1, op2, label, unsignedp)
3446      rtx op1, op2, label;
3447      int unsignedp;
3448 {
3449   if (  ((op1)->code)  == CONST_INT
3450       &&        ((op2)->code)  == CONST_INT)
3451     {
3452       if (((op1)->fld[0].rtint)  == ((op2)->fld[0].rtint) )
3453         emit_jump (label);
3454     }
3455   else
3456     {
3457       emit_cmp_insn (op1, op2, 0, unsignedp, 0);
3458       emit_jump_insn (gen_beq (label));
3459     }
3460 }
3461
3462 static void
3463 group_case_nodes (head)
3464      case_node_ptr head;
3465 {
3466   case_node_ptr node = head;
3467
3468   while (node)
3469     {
3470       rtx lb = next_real_insn (label_rtx (node->code_label));
3471       case_node_ptr np = node;
3472
3473       while (((np = np->right) != 0)
3474              && next_real_insn (label_rtx (np->code_label)) == lb
3475              && tree_int_cst_equal (np->low,
3476                                     combine (PLUS_EXPR, node->high,
3477                                              build_int_2 (1, 0))))
3478         {
3479           node->high = np->high;
3480         }
3481
3482       node->right = np;
3483       node = np;
3484     }
3485 }
3486
3487 static void
3488 balance_case_nodes (head, parent)
3489      case_node_ptr *head;
3490      case_node_ptr parent;
3491 {
3492   register case_node_ptr np;
3493
3494   np = *head;
3495   if (np)
3496     {
3497       int i = 0;
3498       int ranges = 0;
3499       register case_node_ptr *npp;
3500       case_node_ptr left;
3501
3502       while (np)
3503         {
3504           if (!tree_int_cst_equal (np->low, np->high))
3505             ranges++;
3506           i++;
3507           np = np->right;
3508         }
3509       if (i > 2)
3510         {
3511           npp = head;
3512           left = *npp;
3513           if (i == 3)
3514             npp = &(*npp)->right;
3515           else
3516             {
3517
3518               i = (i + ranges + 1) / 2;
3519               while (1)
3520                 {
3521                   if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
3522                     i--;
3523                   i--;
3524                   if (i <= 0)
3525                     break;
3526                   npp = &(*npp)->right;
3527                 }
3528             }
3529           *head = np = *npp;
3530           *npp = 0;
3531           np->parent = parent;
3532           np->left = left;
3533
3534           balance_case_nodes (&np->left, np);
3535           balance_case_nodes (&np->right, np);
3536         }
3537       else
3538         {
3539
3540           np = *head;
3541           np->parent = parent;
3542           for (; np->right; np = np->right)
3543             np->right->parent = np;
3544         }
3545     }
3546 }
3547
3548 static int
3549 node_has_low_bound (node)
3550      case_node_ptr node;
3551 {
3552   tree low_minus_one;
3553   case_node_ptr pnode;
3554
3555   if (node->left)
3556     {
3557       low_minus_one = combine (MINUS_EXPR, node->low, build_int_2 (1, 0));
3558       if (tree_int_cst_lt (low_minus_one, node->low))
3559         for (pnode = node->parent; pnode; pnode = pnode->parent)
3560           {
3561             if (tree_int_cst_equal (low_minus_one, pnode->high))
3562               return 1;
3563
3564             if (node->left)
3565               break;
3566           }
3567     }
3568   return 0;
3569 }
3570
3571 static int
3572 node_has_high_bound (node)
3573      case_node_ptr node;
3574 {
3575   tree high_plus_one;
3576   case_node_ptr pnode;
3577
3578   if (node->right == 0)
3579     {
3580       high_plus_one = combine (PLUS_EXPR, node->high, build_int_2 (1, 0));
3581       if (tree_int_cst_lt (node->high, high_plus_one))
3582         for (pnode = node->parent; pnode; pnode = pnode->parent)
3583           {
3584             if (tree_int_cst_equal (high_plus_one, pnode->low))
3585               return 1;
3586
3587             if (node->right)
3588               break;
3589           }
3590     }
3591   return 0;
3592 }
3593
3594 static int
3595 node_is_bounded (node)
3596      case_node_ptr node;
3597 {
3598   if (node->left || node->right)
3599     return 0;
3600   return node_has_low_bound (node) && node_has_high_bound (node);
3601 }
3602
3603 static void
3604 emit_jump_if_reachable (label)
3605      rtx label;
3606 {
3607   rtx last_insn;
3608
3609   if (  ((get_last_insn ())->code)  != BARRIER)
3610     emit_jump (label);
3611 }
3612
3613 static void
3614 emit_case_nodes (index, node, default_label, unsignedp)
3615      rtx index;
3616      case_node_ptr node;
3617      rtx default_label;
3618      int unsignedp;
3619 {
3620   typedef rtx rtx_function ();
3621   rtx_function *gen_bgt_pat = unsignedp ? gen_bgtu : gen_bgt;
3622   rtx_function *gen_bge_pat = unsignedp ? gen_bgeu : gen_bge;
3623   rtx_function *gen_blt_pat = unsignedp ? gen_bltu : gen_blt;
3624   rtx_function *gen_ble_pat = unsignedp ? gen_bleu : gen_ble;
3625
3626   if (node->test_label)
3627     {
3628
3629       emit_jump_if_reachable (default_label);
3630       expand_label (node->test_label);
3631     }
3632   if (tree_int_cst_equal (node->low, node->high))
3633     {
3634       do_jump_if_equal (index, expand_expr (node->low, 0, VOIDmode, 0),
3635                         label_rtx (node->code_label), unsignedp);
3636       if (node->right)
3637         {
3638           if (node->left)
3639             {
3640               emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0), 0, 0, 0);
3641
3642               if (node_is_bounded (node->right))
3643                 {
3644                   emit_jump_insn (gen_bgt_pat (label_rtx (node->right->code_label)));
3645                   if (node_is_bounded (node->left))
3646                     emit_jump (label_rtx (node->left->code_label));
3647                   else
3648                     emit_case_nodes (index, node->left,
3649                                      default_label, unsignedp);
3650                 }
3651               else
3652                 {
3653                   if (node_is_bounded (node->left))
3654                     emit_jump_insn (gen_blt_pat (label_rtx (node->left->code_label)));
3655                   else
3656                     {
3657                  &