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