fixing stuff
[dyninst.git] / codeCoverage / sparc-sun-solaris2.9 / tests / cc1 / 1dbxout.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 enum tree_code {
13
14   ERROR_MARK, 
15
16   IDENTIFIER_NODE, 
17
18   OP_IDENTIFIER, 
19
20   TREE_LIST, 
21
22   VOID_TYPE,     
23
24   INTEGER_TYPE, 
25
26   REAL_TYPE, 
27
28   COMPLEX_TYPE, 
29
30   ENUMERAL_TYPE, 
31
32   BOOLEAN_TYPE, 
33
34   CHAR_TYPE, 
35
36   POINTER_TYPE, 
37
38   OFFSET_TYPE, 
39
40   REFERENCE_TYPE, 
41
42   METHOD_TYPE, 
43
44   FILE_TYPE, 
45
46   ARRAY_TYPE, 
47
48   SET_TYPE, 
49
50   STRING_TYPE, 
51
52   RECORD_TYPE, 
53
54   UNION_TYPE,    
55
56   FUNCTION_TYPE, 
57
58   LANG_TYPE, 
59
60   LABEL_STMT, 
61
62   GOTO_STMT, 
63
64   RETURN_STMT, 
65
66   EXPR_STMT, 
67
68   WITH_STMT, 
69
70   LET_STMT, 
71
72   IF_STMT, 
73
74   EXIT_STMT, 
75
76   CASE_STMT, 
77
78   LOOP_STMT, 
79
80   COMPOUND_STMT, 
81
82   ASM_STMT, 
83
84   INTEGER_CST, 
85
86   REAL_CST, 
87
88   COMPLEX_CST, 
89
90   STRING_CST, 
91
92   FUNCTION_DECL, 
93   LABEL_DECL, 
94   CONST_DECL, 
95   TYPE_DECL, 
96   VAR_DECL, 
97   PARM_DECL, 
98   RESULT_DECL, 
99   FIELD_DECL, 
100   FRIEND_DECL, 
101
102   COMPONENT_REF, 
103
104   INDIRECT_REF, 
105
106   OFFSET_REF, 
107
108   BUFFER_REF, 
109
110   ARRAY_REF, 
111
112   CONSTRUCTOR, 
113
114   COMPOUND_EXPR, 
115
116   MODIFY_EXPR, 
117
118   INIT_EXPR, 
119
120   NEW_EXPR, 
121
122   DELETE_EXPR, 
123
124   COND_EXPR, 
125
126   CALL_EXPR, 
127
128   METHOD_CALL_EXPR, 
129
130   WITH_CLEANUP_EXPR, 
131
132   PLUS_EXPR, 
133   MINUS_EXPR, 
134   MULT_EXPR, 
135
136   TRUNC_DIV_EXPR, 
137
138   CEIL_DIV_EXPR, 
139
140   FLOOR_DIV_EXPR, 
141
142   ROUND_DIV_EXPR, 
143
144   TRUNC_MOD_EXPR, 
145   CEIL_MOD_EXPR, 
146   FLOOR_MOD_EXPR, 
147   ROUND_MOD_EXPR, 
148
149   RDIV_EXPR, 
150
151   FIX_TRUNC_EXPR, 
152   FIX_CEIL_EXPR, 
153   FIX_FLOOR_EXPR, 
154   FIX_ROUND_EXPR, 
155
156   FLOAT_EXPR, 
157
158   EXPON_EXPR, 
159
160   NEGATE_EXPR, 
161
162   MIN_EXPR, 
163   MAX_EXPR, 
164   ABS_EXPR, 
165   FFS_EXPR, 
166
167   LSHIFT_EXPR, 
168   RSHIFT_EXPR, 
169   LROTATE_EXPR, 
170   RROTATE_EXPR, 
171
172   BIT_IOR_EXPR, 
173   BIT_XOR_EXPR, 
174   BIT_AND_EXPR, 
175   BIT_ANDTC_EXPR, 
176   BIT_NOT_EXPR, 
177
178   TRUTH_ANDIF_EXPR, 
179   TRUTH_ORIF_EXPR, 
180   TRUTH_AND_EXPR, 
181   TRUTH_OR_EXPR, 
182   TRUTH_NOT_EXPR, 
183
184   LT_EXPR, 
185   LE_EXPR, 
186   GT_EXPR, 
187   GE_EXPR, 
188   EQ_EXPR, 
189   NE_EXPR, 
190
191   IN_EXPR, 
192   SET_LE_EXPR, 
193   CARD_EXPR, 
194   RANGE_EXPR, 
195
196   CONVERT_EXPR, 
197
198   NOP_EXPR, 
199
200   SAVE_EXPR, 
201
202   RTL_EXPR, 
203
204   ADDR_EXPR, 
205
206   REFERENCE_EXPR, 
207
208   WRAPPER_EXPR, 
209   ANTI_WRAPPER_EXPR, 
210
211   ENTRY_VALUE_EXPR, 
212
213   COMPLEX_EXPR, 
214
215   CONJ_EXPR, 
216
217   REALPART_EXPR, 
218   IMAGPART_EXPR, 
219
220   PREDECREMENT_EXPR, 
221   PREINCREMENT_EXPR, 
222   POSTDECREMENT_EXPR, 
223   POSTINCREMENT_EXPR, 
224
225   LAST_AND_UNUSED_TREE_CODE      
226
227 };
228
229 extern char *tree_code_type[];
230
231 extern int tree_code_length[];
232
233 enum machine_mode {
234
235  VOIDmode, 
236
237  QImode,                 
238  HImode, 
239
240  PSImode, 
241  SImode, 
242  PDImode, 
243  DImode, 
244  TImode, 
245  QFmode, 
246  HFmode,                 
247  SFmode, 
248  DFmode, 
249  XFmode,         
250  TFmode, 
251  CQImode, 
252  CHImode,        
253  CSImode, 
254  CDImode, 
255  CTImode, 
256  CQFmode, 
257  CHFmode,        
258  CSFmode, 
259  CDFmode, 
260  CXFmode, 
261  CTFmode, 
262
263  BImode,         
264
265  BLKmode, 
266
267  EPmode, 
268
269 };
270
271 enum built_in_function
272 {
273   NOT_BUILT_IN,
274   BUILT_IN_ALLOCA,
275   BUILT_IN_ABS,
276   BUILT_IN_FABS,
277   BUILT_IN_LABS,
278   BUILT_IN_FFS,
279   BUILT_IN_DIV,
280   BUILT_IN_LDIV,
281   BUILT_IN_FFLOOR,
282   BUILT_IN_FCEIL,
283   BUILT_IN_FMOD,
284   BUILT_IN_FREM,
285   BUILT_IN_MEMCPY,
286   BUILT_IN_MEMCMP,
287   BUILT_IN_MEMSET,
288   BUILT_IN_FSQRT,
289   BUILT_IN_GETEXP,
290   BUILT_IN_GETMAN,
291   BUILT_IN_SAVEREGS,
292
293   BUILT_IN_NEW,
294   BUILT_IN_VEC_NEW,
295   BUILT_IN_DELETE,
296   BUILT_IN_VEC_DELETE,
297 };
298
299 typedef union tree_node *tree;
300
301 struct tree_common
302 {
303   int uid;
304   union tree_node *chain;
305   union tree_node *type;
306   enum tree_code code : 8;
307
308   unsigned external_attr : 1;
309   unsigned public_attr : 1;
310   unsigned static_attr : 1;
311   unsigned volatile_attr : 1;
312   unsigned packed_attr : 1;
313   unsigned readonly_attr : 1;
314   unsigned literal_attr : 1;
315   unsigned nonlocal_attr : 1;
316   unsigned permanent_attr : 1;
317   unsigned addressable_attr : 1;
318   unsigned regdecl_attr : 1;
319   unsigned this_vol_attr : 1;
320   unsigned unsigned_attr : 1;
321   unsigned asm_written_attr: 1;
322   unsigned inline_attr : 1;
323   unsigned used_attr : 1;
324   unsigned lang_flag_1 : 1;
325   unsigned lang_flag_2 : 1;
326   unsigned lang_flag_3 : 1;
327   unsigned lang_flag_4 : 1;
328 };
329
330 struct tree_int_cst
331 {
332   char common[sizeof (struct tree_common)];
333   long int_cst_low;
334   long int_cst_high;
335 };
336
337 extern double ldexp ();
338
339 extern double atof ();
340
341 union real_extract 
342 {
343   double  d;
344   int i[sizeof (double ) / sizeof (int)];
345 };
346
347 struct tree_real_cst
348 {
349   char common[sizeof (struct tree_common)];
350   struct rtx_def *rtl;   
351
352   double  real_cst;
353 };
354
355 struct tree_string
356 {
357   char common[sizeof (struct tree_common)];
358   struct rtx_def *rtl;   
359
360   int length;
361   char *pointer;
362 };
363
364 struct tree_complex
365 {
366   char common[sizeof (struct tree_common)];
367   struct rtx_def *rtl;   
368
369   union tree_node *real;
370   union tree_node *imag;
371 };
372
373 struct tree_identifier
374 {
375   char common[sizeof (struct tree_common)];
376   int length;
377   char *pointer;
378   union tree_node *global_value;
379   union tree_node *local_value;
380   union tree_node *label_value;
381   union tree_node *implicit_decl;
382   union tree_node *error_locus;
383 };
384
385 struct tree_list
386 {
387   char common[sizeof (struct tree_common)];
388   union tree_node *purpose;
389   union tree_node *value;
390 };
391
392 struct tree_exp
393 {
394   char common[sizeof (struct tree_common)];
395   int complexity;
396   union tree_node *operands[1];
397 };
398
399 struct tree_type
400 {
401   char common[sizeof (struct tree_common)];
402   union tree_node *values;
403   union tree_node *sep;
404   union tree_node *size;
405
406   enum machine_mode mode : 8;
407   unsigned char size_unit;
408   unsigned char align;
409   unsigned char sep_unit;
410
411   union tree_node *pointer_to;
412   union tree_node *reference_to;
413   int parse_info;
414   int symtab_address;
415   union tree_node *name;
416   union tree_node *max;
417   union tree_node *next_variant;
418   union tree_node *main_variant;
419   union tree_node *basetypes;
420   union tree_node *noncopied_parts;
421   struct lang_type *lang_specific;
422 };
423
424 struct tree_decl
425 {
426   char common[sizeof (struct tree_common)];
427   char *filename;
428   int linenum;
429   union tree_node *size;
430   enum machine_mode mode;
431   unsigned char size_unit;
432   unsigned char align;
433   unsigned char voffset_unit;
434   union tree_node *name;
435   union tree_node *context;
436   int offset;
437   union tree_node *voffset;
438   union tree_node *arguments;
439   union tree_node *result;
440   union tree_node *initial;
441   struct rtx_def *rtl;   
442
443   int frame_size;                
444   struct rtx_def *saved_insns;   
445
446   int block_symtab_address;
447   struct lang_decl *lang_specific;
448 };
449
450 struct tree_stmt
451 {
452   char common[sizeof (struct tree_common)];
453   char *filename;
454   int linenum;
455   union tree_node *body;
456 };
457
458 struct tree_if_stmt
459 {
460   char common[sizeof (struct tree_common)];
461   char *filename;
462   int linenum;
463   union tree_node *cond, *thenpart, *elsepart;
464 };
465
466 struct tree_bind_stmt
467 {
468   char common[sizeof (struct tree_common)];
469   char *filename;
470   int linenum;
471   union tree_node *body, *vars, *supercontext, *bind_size, *type_tags;
472 };
473
474 struct tree_case_stmt
475 {
476   char common[sizeof (struct tree_common)];
477   char *filename;
478   int linenum;
479   union tree_node *index, *case_list;
480 };
481
482 union tree_node
483 {
484   struct tree_common common;
485   struct tree_int_cst int_cst;
486   struct tree_real_cst real_cst;
487   struct tree_string string;
488   struct tree_complex complex;
489   struct tree_identifier identifier;
490   struct tree_decl decl;
491   struct tree_type type;
492   struct tree_list list;
493   struct tree_exp exp;
494   struct tree_stmt stmt;
495   struct tree_if_stmt if_stmt;
496   struct tree_bind_stmt bind_stmt;
497   struct tree_case_stmt case_stmt;
498 };
499 extern char *oballoc ();
500 extern char *permalloc ();
501
502 extern tree make_node ();
503
504 extern tree copy_node ();
505
506 extern tree get_identifier ();
507
508 extern tree build_int_2 ();
509 extern tree build_real ();
510 extern tree build_real_from_string ();
511 extern tree build_real_from_int_cst ();
512 extern tree build_complex ();
513 extern tree build_string ();
514 extern tree build ();
515 extern tree build_nt ();
516 extern tree build_tree_list ();
517 extern tree build_op_identifier ();
518 extern tree build_decl ();
519 extern tree build_let ();
520
521 extern tree make_signed_type ();
522 extern tree make_unsigned_type ();
523 extern void fixup_unsigned_type ();
524 extern tree build_pointer_type ();
525 extern tree build_reference_type ();
526 extern tree build_index_type ();
527 extern tree build_array_type ();
528 extern tree build_function_type ();
529 extern tree build_method_type ();
530 extern tree build_offset_type ();
531 extern tree array_type_nelts ();
532
533 extern tree build_binary_op ();
534 extern tree build_indirect_ref ();
535 extern tree build_unary_op ();
536
537 extern tree build_type_variant ();
538
539 extern void layout_type ();
540
541 extern tree type_hash_canon ();
542
543 extern void layout_decl ();
544
545 extern tree fold ();
546
547 extern tree combine ();
548
549 extern tree convert ();
550 extern tree convert_units ();
551 extern tree size_in_bytes ();
552 extern tree genop ();
553 extern tree build_int ();
554 extern tree get_pending_sizes ();
555
556 extern tree sizetype;
557
558 extern tree chainon ();
559
560 extern tree tree_cons (), perm_tree_cons (), temp_tree_cons ();
561 extern tree saveable_tree_cons ();
562
563 extern tree tree_last ();
564
565 extern tree nreverse ();
566
567 extern int list_length ();
568
569 extern int integer_zerop ();
570
571 extern int integer_onep ();
572
573 extern int integer_all_onesp ();
574
575 extern int type_unsigned_p ();
576
577 extern int staticp ();
578
579 extern int lvalue_or_else ();
580
581 extern tree save_expr ();
582
583 extern tree stabilize_reference ();
584
585 extern tree get_unwidened ();
586
587 extern tree get_narrower ();
588
589 extern tree type_for_size ();
590
591 extern tree unsigned_type ();
592
593 extern tree signed_type ();
594
595 extern tree get_floating_type ();
596
597 extern char *function_cannot_inline_p ();
598
599 extern tree integer_zero_node;
600
601 extern tree integer_one_node;
602
603 extern tree size_zero_node;
604
605 extern tree size_one_node;
606
607 extern tree null_pointer_node;
608
609 extern tree error_mark_node;
610
611 extern tree void_type_node;
612
613 extern tree integer_type_node;
614
615 extern tree unsigned_type_node;
616
617 extern tree char_type_node;
618
619 extern char *input_filename;
620
621 extern int pedantic;
622
623 extern int immediate_size_expand;
624
625 extern tree current_function_decl;
626
627 extern int current_function_calls_setjmp;
628
629 extern int all_types_permanent;
630
631 extern tree expand_start_stmt_expr ();
632 extern tree expand_end_stmt_expr ();
633 extern void expand_expr_stmt(), clear_last_expr();
634 extern void expand_label(), expand_goto(), expand_asm();
635 extern void expand_start_cond(), expand_end_cond();
636 extern void expand_start_else(), expand_end_else();
637 extern void expand_start_loop(), expand_start_loop_continue_elsewhere();
638 extern void expand_loop_continue_here();
639 extern void expand_end_loop();
640 extern int expand_continue_loop();
641 extern int expand_exit_loop(), expand_exit_loop_if_false();
642 extern int expand_exit_something();
643
644 extern void expand_start_delayed_expr ();
645 extern tree expand_end_delayed_expr ();
646 extern void expand_emit_delayed_expr ();
647
648 extern void expand_null_return(), expand_return();
649 extern void expand_start_bindings(), expand_end_bindings();
650 extern void expand_start_case(), expand_end_case();
651 extern int pushcase(), pushcase_range ();
652 extern void expand_start_function(), expand_end_function();
653
654 enum rtx_code  {
655
656   UNKNOWN , 
657
658   NIL , 
659
660   EXPR_LIST , 
661
662   INSN_LIST , 
663
664   MATCH_OPERAND , 
665
666   MATCH_DUP , 
667
668   MATCH_OPERATOR , 
669
670   DEFINE_INSN , 
671
672   DEFINE_PEEPHOLE , 
673
674   DEFINE_COMBINE , 
675
676   DEFINE_EXPAND , 
677
678   SEQUENCE , 
679
680   ADDRESS , 
681
682   INSN , 
683
684   JUMP_INSN , 
685
686   CALL_INSN , 
687
688   BARRIER , 
689
690   CODE_LABEL , 
691
692   NOTE , 
693
694   INLINE_HEADER , 
695
696   PARALLEL , 
697
698   ASM_INPUT , 
699
700   ASM_OPERANDS , 
701
702   ADDR_VEC , 
703
704   ADDR_DIFF_VEC , 
705
706   SET , 
707
708   USE , 
709
710   CLOBBER , 
711
712   CALL , 
713
714   RETURN , 
715
716   CONST_INT , 
717
718   CONST_DOUBLE , 
719
720   CONST , 
721
722   PC , 
723
724   REG , 
725
726   SUBREG , 
727
728   STRICT_LOW_PART , 
729
730   MEM , 
731
732   LABEL_REF , 
733
734   SYMBOL_REF , 
735
736   CC0 , 
737
738   QUEUED , 
739
740   IF_THEN_ELSE , 
741
742   COMPARE , 
743
744   PLUS , 
745
746   MINUS , 
747
748   NEG , 
749
750   MULT , 
751
752   DIV , 
753   MOD , 
754
755   UMULT , 
756   UDIV , 
757   UMOD , 
758
759   AND , 
760
761   IOR , 
762
763   XOR , 
764
765   NOT , 
766
767   LSHIFT , 
768   ASHIFT , 
769   ROTATE , 
770
771   ASHIFTRT , 
772   LSHIFTRT , 
773   ROTATERT , 
774
775   PRE_DEC , 
776   PRE_INC , 
777   POST_DEC , 
778   POST_INC , 
779
780   NE , 
781   EQ , 
782   GE , 
783   GT , 
784   LE , 
785   LT , 
786   GEU , 
787   GTU , 
788   LEU , 
789   LTU , 
790
791   SIGN_EXTEND , 
792
793   ZERO_EXTEND , 
794
795   TRUNCATE , 
796
797   FLOAT_EXTEND , 
798   FLOAT_TRUNCATE , 
799
800   FLOAT , 
801
802   FIX , 
803
804   UNSIGNED_FLOAT , 
805
806   UNSIGNED_FIX , 
807
808   ABS , 
809
810   SQRT , 
811
812   FFS , 
813
814   SIGN_EXTRACT , 
815
816   ZERO_EXTRACT , 
817
818   LAST_AND_UNUSED_RTX_CODE};     
819
820 extern int rtx_length[];
821
822 extern char *rtx_name[];
823
824 extern char *rtx_format[];
825
826 extern char *mode_name[];
827
828 enum mode_class { MODE_RANDOM, MODE_INT, MODE_FLOAT,
829                   MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MODE_FUNCTION };
830
831 extern enum mode_class mode_class[];
832
833 extern int mode_size[];
834
835 extern int mode_unit_size[];
836
837 typedef union rtunion_def
838 {
839   int rtint;
840   char *rtstr;
841   struct rtx_def *rtx;
842   struct rtvec_def *rtvec;
843   enum machine_mode rttype;
844 } rtunion;
845
846 typedef struct rtx_def
847 {
848
849   enum rtx_code code : 16;
850
851   enum machine_mode mode : 8;
852
853   unsigned int jump : 1;
854   unsigned int call : 1;
855
856   unsigned int unchanging : 1;
857
858   unsigned int volatil : 1;
859
860   unsigned int in_struct : 1;
861
862   unsigned int used : 1;
863
864   unsigned integrated : 1;
865
866   rtunion fld[1];
867 } *rtx;
868
869 typedef struct rtvec_def{
870   unsigned num_elem;             
871   rtunion elem[1];
872 } *rtvec;
873
874 enum reg_note { REG_DEAD = 1, REG_INC = 2, REG_EQUIV = 3, REG_WAS_0 = 4,
875                 REG_EQUAL = 5, REG_RETVAL = 6, REG_LIBCALL = 7,
876                 REG_NONNEG = 8 };
877
878 extern char *reg_note_name[];
879
880 extern char *note_insn_name[];
881
882 extern rtx rtx_alloc ();
883 extern rtvec rtvec_alloc ();
884 extern rtx find_reg_note ();
885 extern rtx gen_rtx ();
886 extern rtx copy_rtx ();
887 extern rtvec gen_rtvec ();
888 extern rtvec gen_rtvec_v ();
889 extern rtx gen_reg_rtx ();
890 extern rtx gen_label_rtx ();
891 extern rtx gen_inline_header_rtx ();
892 extern rtx gen_lowpart ();
893 extern rtx gen_highpart ();
894 extern int subreg_lowpart_p ();
895 extern rtx make_safe_from ();
896 extern rtx memory_address ();
897 extern rtx get_insns ();
898 extern rtx get_last_insn ();
899 extern rtx start_sequence ();
900 extern rtx gen_sequence ();
901 extern rtx expand_expr ();
902 extern rtx output_constant_def ();
903 extern rtx immed_real_const ();
904 extern rtx immed_real_const_1 ();
905 extern rtx immed_double_const ();
906 extern rtx force_const_double_mem ();
907 extern rtx force_const_mem ();
908 extern rtx get_parm_real_loc ();
909 extern rtx assign_stack_local ();
910 extern rtx protect_from_queue ();
911 extern void emit_queue ();
912 extern rtx emit_move_insn ();
913 extern rtx emit_insn ();
914 extern rtx emit_jump_insn ();
915 extern rtx emit_call_insn ();
916 extern rtx emit_call_insn_before ();
917 extern rtx emit_insn_before ();
918 extern rtx emit_insn_after ();
919 extern rtx emit_label ();
920 extern rtx emit_barrier ();
921 extern rtx emit_note ();
922 extern rtx emit_line_note ();
923 extern rtx emit_line_note_force ();
924 extern rtx prev_real_insn ();
925 extern rtx next_real_insn ();
926 extern rtx next_nondeleted_insn ();
927 extern rtx plus_constant ();
928 extern rtx find_equiv_reg ();
929 extern rtx delete_insn ();
930 extern rtx adj_offsetable_operand ();
931
932 extern int max_parallel;
933
934 extern int asm_noperands ();
935 extern char *decode_asm_operands ();
936
937 extern enum reg_class reg_preferred_class ();
938
939 extern rtx get_first_nonparm_insn ();
940
941 extern rtx pc_rtx;
942 extern rtx cc0_rtx;
943 extern rtx const0_rtx;
944 extern rtx const1_rtx;
945 extern rtx fconst0_rtx;
946 extern rtx dconst0_rtx;
947
948 extern rtx stack_pointer_rtx;
949 extern rtx frame_pointer_rtx;
950 extern rtx arg_pointer_rtx;
951 extern rtx struct_value_rtx;
952 extern rtx struct_value_incoming_rtx;
953 extern rtx static_chain_rtx;
954 extern rtx static_chain_incoming_rtx;
955
956 extern char *main_input_filename;
957
958 enum debugger { NO_DEBUG = 0, GDB_DEBUG = 1, DBX_DEBUG = 2, SDB_DEBUG = 3,
959                 EXTENDED_DBX_DEBUG = 4 };
960
961 extern enum debugger write_symbols;
962
963 extern int use_gdb_dbx_extensions;
964
965 extern int optimize;
966
967 extern int obey_regdecls;
968
969 extern int quiet_flag;
970
971 extern int inhibit_warnings;
972
973 extern int extra_warnings;
974
975 extern int warn_unused;
976
977 extern int warn_shadow;
978
979 extern int warn_switch;
980
981 extern int warn_id_clash;
982 extern int id_clash_len;
983
984 extern int profile_flag;
985
986 extern int profile_block_flag;
987
988 extern int pedantic;
989
990 extern int flag_caller_saves;
991
992 extern int flag_pcc_struct_return;
993
994 extern int flag_force_mem;
995
996 extern int flag_force_addr;
997
998 extern int flag_defer_pop;
999
1000 extern int flag_float_store;
1001
1002 extern int flag_combine_regs;
1003
1004 extern int flag_strength_reduce;
1005
1006 extern int flag_writable_strings;
1007
1008 extern int flag_no_function_cse;
1009
1010 extern int flag_omit_frame_pointer;
1011
1012 extern int frame_pointer_needed;
1013
1014 extern int flag_no_peephole;
1015
1016 extern int flag_volatile;
1017
1018 extern int flag_inline_functions;
1019
1020 extern int flag_keep_inline_functions;
1021
1022 extern int flag_syntax_only;
1023
1024 extern int flag_shared_data;
1025
1026 extern  struct  _iobuf {
1027         int     _cnt;
1028         unsigned char *_ptr;
1029         unsigned char *_base;
1030         int     _bufsiz;
1031         short   _flag;
1032         char    _file;           
1033 } _iob[];
1034
1035 extern struct _iobuf    *fopen();
1036 extern struct _iobuf    *fdopen();
1037 extern struct _iobuf    *freopen();
1038 extern struct _iobuf    *popen();
1039 extern struct _iobuf    *tmpfile();
1040 extern long     ftell();
1041 extern char     *fgets();
1042 extern char     *gets();
1043
1044 extern char     *ctermid();
1045 extern char     *cuserid();
1046 extern char     *tempnam();
1047 extern char     *tmpnam();
1048
1049 static struct _iobuf  *asmfile;
1050
1051 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
1052
1053 enum typestatus *typevec;
1054
1055 static int typevec_len;
1056
1057 static int next_type_number;
1058
1059 static int next_block_number;
1060
1061 static int current_sym_code;
1062 static int current_sym_value;
1063 static rtx current_sym_addr;
1064
1065 static int current_sym_nchars;
1066
1067 void dbxout_types ();
1068 void dbxout_tags ();
1069 void dbxout_args ();
1070 void dbxout_symbol ();
1071 static void dbxout_type_name ();
1072 static void dbxout_type ();
1073 static void dbxout_finish_symbol ();
1074 static void dbxout_continue ();
1075
1076 void
1077 dbxout_init (asm_file, input_file_name)
1078      struct _iobuf  *asm_file;
1079      char *input_file_name;
1080 {
1081   asmfile = asm_file;
1082
1083   typevec_len = 100;
1084   typevec = (enum typestatus *) xmalloc (typevec_len * sizeof typevec[0]);
1085   memset (typevec,0, typevec_len * sizeof typevec[0]) ;
1086
1087   fprintf (asmfile,
1088            "\t.stabs \"%s\",%d,0,0,Ltext\nLtext:\n",
1089            input_file_name, 0x64                );
1090
1091   next_type_number = 1;
1092   next_block_number = 2;
1093
1094   dbxout_symbol (((integer_type_node)->type.name) , 0);
1095   dbxout_symbol (((char_type_node)->type.name) , 0);
1096
1097   dbxout_types (get_permanent_types ());
1098 }
1099
1100 static void
1101 dbxout_continue ()
1102 {
1103
1104   fprintf (asmfile, "\\\\");
1105
1106   dbxout_finish_symbol ();
1107   fprintf (asmfile, ".stabs \"");
1108   current_sym_nchars = 0;
1109 }
1110
1111 static void
1112 dbxout_type (type, full)
1113      tree type;
1114      int full;
1115 {
1116   register tree tem;
1117
1118   if (type == error_mark_node)
1119     type = integer_type_node;
1120   else if (((type)->type.size)  == 0)
1121     type = ((type)->type.main_variant) ;
1122
1123   if (((type)->type.symtab_address)  == 0)
1124     {
1125       ((type)->type.symtab_address)  = next_type_number++;
1126
1127       if (next_type_number == typevec_len)
1128         {
1129           typevec = (enum typestatus *) xrealloc (typevec, typevec_len * 2 * sizeof typevec[0]);
1130           memset (typevec + typevec_len,0, typevec_len * sizeof typevec[0]) ;
1131           typevec_len *= 2;
1132         }
1133     }
1134
1135   fprintf (asmfile, "%d", ((type)->type.symtab_address) );
1136   (current_sym_nchars += (3)) ;
1137
1138   switch (typevec[((type)->type.symtab_address) ])
1139     {
1140     case TYPE_UNSEEN:
1141       break;
1142     case TYPE_XREF:
1143       if (! full)
1144         return;
1145       break;
1146     case TYPE_DEFINED:
1147       return;
1148     }
1149
1150   fprintf (asmfile, "=");
1151   (current_sym_nchars += (1)) ;
1152
1153   typevec[((type)->type.symtab_address) ] = TYPE_DEFINED;
1154
1155   switch (((type)->common.code) )
1156     {
1157     case VOID_TYPE:
1158
1159       fprintf (asmfile, "%d", ((type)->type.symtab_address) );
1160       (current_sym_nchars += (3)) ;
1161       break;
1162
1163     case INTEGER_TYPE:
1164       if (type == char_type_node && ! ((type)->common.unsigned_attr) )
1165
1166         fprintf (asmfile, "r2;0;127;");
1167       else
1168         fprintf (asmfile, "r1;%d;%d;",
1169                  ((((type)->type.sep) )->int_cst.int_cst_low) ,
1170                  ((((type)->type.max) )->int_cst.int_cst_low) );
1171       (current_sym_nchars += (25)) ;
1172       break;
1173
1174     case REAL_TYPE:
1175       fprintf (asmfile, "r1;%d;0;",
1176                ((size_in_bytes (type))->int_cst.int_cst_low) );
1177       (current_sym_nchars += (16)) ;
1178       break;
1179
1180     case ARRAY_TYPE:
1181
1182       fprintf (asmfile, "ar1;0;%d;",
1183                (((type)->type.values) 
1184                 ? ((((((type)->type.values) )->type.max) )->int_cst.int_cst_low) 
1185                 : -1));
1186       (current_sym_nchars += (17)) ;
1187       dbxout_type (((type)->common.type) , 0);
1188       break;
1189
1190     case RECORD_TYPE:
1191     case UNION_TYPE:
1192       if ((((type)->type.name)  != 0 && !full)
1193           || ((type)->type.size)  == 0)
1194         {
1195
1196           fprintf (asmfile, (((type)->common.code)  == RECORD_TYPE) ? "xs" : "xu");
1197           (current_sym_nchars += (3)) ;
1198
1199           dbxout_type_name (type);
1200           fprintf (asmfile, ":");
1201           typevec[((type)->type.symtab_address) ] = TYPE_XREF;
1202           break;
1203         }
1204       tem = size_in_bytes (type);
1205       fprintf (asmfile, (((type)->common.code)  == RECORD_TYPE) ? "s%d" : "u%d",
1206                ((tem)->int_cst.int_cst_low) );
1207
1208       if (((type)->type.basetypes)  && use_gdb_dbx_extensions)
1209         {
1210           (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)('!')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('!')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('!'),  asmfile))) ;
1211           (--(
1212                 asmfile)->_cnt >= 0 ?   (int)(*(
1213                 asmfile)->_ptr++ = (unsigned char)((((((type)->type.basetypes) )->common.public_attr)  ? '2' : '0'))) : (((
1214                 asmfile)->_flag & 0200 ) && -(
1215                 asmfile)->_cnt < (
1216                 asmfile)->_bufsiz ?     ((*(
1217                 asmfile)->_ptr = (unsigned char)((((((type)->type.basetypes) )->common.public_attr)  ? '2' : '0'))) != '\n' ?   (int)(*(
1218                 asmfile)->_ptr++) :     _flsbuf(*(unsigned char *)(
1219                 asmfile)->_ptr, 
1220                 asmfile)) :     _flsbuf((unsigned char)((((((type)->type.basetypes) )->common.public_attr)  ? '2' : '0')), 
1221                 asmfile))) ;
1222           dbxout_type (((((type)->type.basetypes) )->list.value) , 0);
1223           (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)(',')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(',')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(','),  asmfile))) ;
1224           (current_sym_nchars += (3)) ;
1225         }
1226       (current_sym_nchars += (11)) ;
1227
1228       for (tem = ((type)->type.values) ; tem; tem = ((tem)->common.chain) )
1229
1230         if (((tem)->decl.name)  != 0)
1231           {
1232
1233             if (tem != ((type)->type.values) )
1234               do {if (current_sym_nchars > 80 ) dbxout_continue ();} while (0) ;
1235             fprintf (asmfile, "%s:", ((((tem)->decl.name) )->identifier.pointer) );
1236             (current_sym_nchars += (2 + ((((tem)->decl.name) )->identifier.length) )) ;
1237             if (use_gdb_dbx_extensions)
1238               {
1239                 (--( asmfile)->_cnt >= 0 ?      (int)(*( asmfile)->_ptr++ = (unsigned char)('/')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('/')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('/'),  asmfile))) ;
1240
1241                 (current_sym_nchars += (2)) ;
1242                 if (((tem)->common.code)  == FUNCTION_DECL)
1243                   {
1244                     (--( asmfile)->_cnt >= 0 ?  (int)(*( asmfile)->_ptr++ = (unsigned char)(':')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(':')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(':'),  asmfile))) ;
1245                     (current_sym_nchars += (1)) ;
1246                     dbxout_type (((tem)->common.type) , 0);  
1247                     dbxout_args (((((tem)->common.type) )->type.values) );
1248
1249                     (current_sym_nchars += (3 + strlen (((((((tem)->decl.rtl) )->fld[ 0].rtx) )->fld[ 0].rtstr) ))) ;
1250                   }
1251                 else
1252                   dbxout_type (((tem)->common.type) , 0);
1253               }
1254             else
1255               dbxout_type (((tem)->common.type) , 0);
1256
1257             if (((tem)->common.code)  == VAR_DECL)
1258               {
1259                 if (use_gdb_dbx_extensions)
1260                   {
1261                     fprintf (asmfile, ":%s", 
1262                              ((((((tem)->decl.rtl) )->fld[ 0].rtx) )->fld[ 0].rtstr) );
1263                     (current_sym_nchars += (2 + strlen (((((((tem)->decl.rtl) )->fld[ 0].rtx) )->fld[ 0].rtstr) ))) ;
1264                   }
1265                 else
1266                   {
1267                     fprintf (asmfile, ",0,0;");
1268                     (current_sym_nchars += (5)) ;
1269                   }
1270               }
1271             else
1272               {
1273                 fprintf (asmfile, ",%d,%d;", ((tem)->decl.offset) ,
1274                          (((((tem)->decl.size) )->int_cst.int_cst_low) 
1275                           * ((tem)->decl.size_unit) ));
1276                 (current_sym_nchars += (23)) ;
1277               }
1278           }
1279
1280       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)(';')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(';')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(';'),  asmfile))) ;
1281       (current_sym_nchars += (1)) ;
1282       break;
1283
1284     case ENUMERAL_TYPE:
1285       if ((((type)->type.name)  != 0 && !full)
1286           || ((type)->type.size)  == 0)
1287         {
1288           fprintf (asmfile, "xe");
1289           (current_sym_nchars += (3)) ;
1290           dbxout_type_name (type);
1291           typevec[((type)->type.symtab_address) ] = TYPE_XREF;
1292           fprintf (asmfile, ":");
1293           return;
1294         }
1295       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)('e')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('e')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('e'),  asmfile))) ;
1296       (current_sym_nchars += (1)) ;
1297       for (tem = ((type)->type.values) ; tem; tem = ((tem)->common.chain) )
1298         {
1299           fprintf (asmfile, "%s:%d,", ((((tem)->list.purpose) )->identifier.pointer) ,
1300                    ((((tem)->list.value) )->int_cst.int_cst_low) );
1301           (current_sym_nchars += (11 + ((((tem)->list.purpose) )->identifier.length) )) ;
1302           if (((tem)->common.chain)  != 0)
1303             do {if (current_sym_nchars > 80 ) dbxout_continue ();} while (0) ;
1304         }
1305       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)(';')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(';')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(';'),  asmfile))) ;
1306       (current_sym_nchars += (1)) ;
1307       break;
1308
1309     case POINTER_TYPE:
1310       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)('*')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('*')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('*'),  asmfile))) ;
1311       (current_sym_nchars += (1)) ;
1312       dbxout_type (((type)->common.type) , 0);
1313       break;
1314
1315     case METHOD_TYPE:
1316       if (use_gdb_dbx_extensions)
1317         {
1318           (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)('@')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('@')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('@'),  asmfile))) ;
1319           (current_sym_nchars += (1)) ;
1320           dbxout_type (((type)->type.max) , 0);
1321           (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)(',')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(',')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(','),  asmfile))) ;
1322           (current_sym_nchars += (1)) ;
1323           dbxout_type (((type)->common.type) , 0);
1324         }
1325       else
1326         {
1327           dbxout_type (((type)->common.type) , 0);
1328         }
1329       break;
1330
1331     case OFFSET_TYPE:
1332       if (use_gdb_dbx_extensions)
1333         {
1334           (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)('@')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('@')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('@'),  asmfile))) ;
1335           (current_sym_nchars += (1)) ;
1336           dbxout_type (((type)->type.max) , 0);
1337           (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)(',')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(',')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(','),  asmfile))) ;
1338           (current_sym_nchars += (1)) ;
1339           dbxout_type (((type)->common.type) , 0);
1340         }
1341       else
1342         {
1343           dbxout_type (((type)->common.type) , 0);
1344         }
1345       break;
1346
1347     case REFERENCE_TYPE:
1348       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)(use_gdb_dbx_extensions ? '&' : '*')) :      ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(use_gdb_dbx_extensions ? '&' : '*')) != '\n' ?    (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(use_gdb_dbx_extensions ? '&' : '*'),  asmfile))) ;
1349       (current_sym_nchars += (1)) ;
1350       dbxout_type (((type)->common.type) , 0);
1351       break;
1352
1353     case FUNCTION_TYPE:
1354       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)('f')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('f')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('f'),  asmfile))) ;
1355       (current_sym_nchars += (1)) ;
1356       dbxout_type (((type)->common.type) , 0);
1357       break;
1358
1359     default:
1360       abort ();
1361     }
1362 }
1363
1364 static void
1365 dbxout_type_name (type)
1366      register tree type;
1367 {
1368   tree t;
1369   if (((type)->type.name)  == 0)
1370     abort ();
1371   if (((((type)->type.name) )->common.code)  == IDENTIFIER_NODE)
1372     {
1373       t = ((type)->type.name) ;
1374     }
1375   else if (((((type)->type.name) )->common.code)  == TYPE_DECL)
1376     {
1377       t = ((((type)->type.name) )->decl.name) ;
1378     }
1379   else
1380     abort ();
1381
1382   fprintf (asmfile, "%s", ((t)->identifier.pointer) );
1383   (current_sym_nchars += (((t)->identifier.length) )) ;
1384 }
1385
1386 void
1387 dbxout_symbol (decl, local)
1388      tree decl;
1389      int local;
1390 {
1391   int letter = 0;
1392   tree type = ((decl)->common.type) ;
1393
1394   if (local == 0)
1395     {
1396       dbxout_tags (gettags ());
1397       dbxout_types (get_permanent_types ());
1398     }
1399
1400   current_sym_code = 0;
1401   current_sym_value = 0;
1402   current_sym_addr = 0;
1403
1404   current_sym_nchars = 2 + ((((decl)->decl.name) )->identifier.length) ;
1405
1406   switch (((decl)->common.code) )
1407     {
1408     case CONST_DECL:
1409       break;
1410
1411     case FUNCTION_DECL:
1412       if (((decl)->decl.rtl)  == 0)
1413         return;
1414       if (((decl)->common.external_attr) )
1415         break;
1416       if (      ((((decl)->decl.rtl) )->code)  != MEM
1417           ||    ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  != SYMBOL_REF)
1418         break;
1419        ;
1420       fprintf (asmfile, ".stabs \"%s:%c",
1421                ((((decl)->decl.name) )->identifier.pointer) ,
1422                ((decl)->common.public_attr)  ? 'F' : 'f');
1423
1424       current_sym_code = 0x24           ;
1425       current_sym_addr = ((((decl)->decl.rtl) )->fld[ 0].rtx) ;
1426
1427       if (((((decl)->common.type) )->common.type) )
1428         dbxout_type (((((decl)->common.type) )->common.type) , 0);
1429       else
1430         dbxout_type (void_type_node, 0);
1431       dbxout_finish_symbol ();
1432       break;
1433
1434     case TYPE_DECL:
1435
1436       if (((decl)->common.asm_written_attr) )
1437         return;
1438
1439        ;
1440       fprintf (asmfile, ".stabs \"%s:t",
1441                ((((decl)->decl.name) )->identifier.pointer) );
1442
1443       current_sym_code = 0x80           ;
1444
1445       dbxout_type (((decl)->common.type) , 1);
1446       dbxout_finish_symbol ();
1447
1448       ((decl)->common.asm_written_attr)  = 1;
1449       break;
1450     case PARM_DECL:
1451
1452       abort ();
1453
1454     case VAR_DECL:
1455       if (((decl)->decl.rtl)  == 0)
1456         return;
1457
1458       if (((decl)->common.external_attr) )
1459         break;
1460
1461       if (      ((((decl)->decl.rtl) )->code)  == REG
1462           && (((((decl)->decl.rtl) )->fld[0].rtint)  < 0
1463               || ((((decl)->decl.rtl) )->fld[0].rtint)  >= 56 ))
1464         break;
1465
1466       if (      ((((decl)->decl.rtl) )->code)  == MEM
1467           &&    ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  == SYMBOL_REF)
1468         {
1469           if (((decl)->common.public_attr) )
1470             {
1471               letter = 'G';
1472               current_sym_code = 0x20           ;
1473             }
1474           else
1475             {
1476               current_sym_addr = ((((decl)->decl.rtl) )->fld[ 0].rtx) ;
1477
1478               letter = ((decl)->common.permanent_attr)  ? 'S' : 'V';
1479
1480               if (!((decl)->decl.initial) )
1481                 current_sym_code = 0x28         ;
1482
1483               else
1484                 current_sym_code = 0x26         ;
1485             }
1486         }
1487       else if ( ((((decl)->decl.rtl) )->code)  == REG)
1488         {
1489           letter = 'r';
1490           current_sym_code = 0x40               ;
1491           current_sym_value = ((((((decl)->decl.rtl) )->fld[0].rtint) ) < 16 ? (((((decl)->decl.rtl) )->fld[0].rtint) ) : (((((decl)->decl.rtl) )->fld[0].rtint) ) + 2) ;
1492         }
1493       else if ( ((((decl)->decl.rtl) )->code)  == MEM
1494                && (     ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  == MEM
1495                    || ( ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  == REG
1496                        && ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[0].rtint)  != 14 )))
1497
1498         {
1499           if (  ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  == REG)
1500             {
1501               letter = 'r';
1502               current_sym_code = 0x40           ;
1503               current_sym_value = ((((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[0].rtint) ) < 16 ? (((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[0].rtint) ) : (((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[0].rtint) ) + 2) ;
1504             }
1505           else
1506             {
1507               current_sym_code = 0x80           ;
1508
1509               current_sym_value = ((((((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint) ;
1510             }
1511
1512           type = build_pointer_type (((decl)->common.type) );
1513         }
1514       else if ( ((((decl)->decl.rtl) )->code)  == MEM
1515                &&       ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  == REG)
1516         {
1517           current_sym_code = 0x80               ;
1518           current_sym_value = 0;
1519         }
1520       else if ( ((((decl)->decl.rtl) )->code)  == MEM
1521                &&       ((((((decl)->decl.rtl) )->fld[ 0].rtx) )->code)  == PLUS
1522                &&       ((((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == CONST_INT)
1523         {
1524           current_sym_code = 0x80               ;
1525
1526           current_sym_value = ((((((((decl)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint) ;
1527         }
1528       else
1529
1530         break;
1531
1532        ;
1533       fprintf (asmfile, ".stabs \"%s:",
1534                ((((decl)->decl.name) )->identifier.pointer) );
1535       if (letter) (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)(letter)) :  ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(letter)) != '\n' ?        (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(letter),  asmfile))) ;
1536       dbxout_type (type, 0);
1537       dbxout_finish_symbol ();
1538       break;
1539     }
1540 }
1541
1542 static void
1543 dbxout_finish_symbol ()
1544 {
1545   fprintf (asmfile, "\",%d,0,0,", current_sym_code);
1546   if (current_sym_addr)
1547     output_addr_const (asmfile, current_sym_addr);
1548   else
1549     fprintf (asmfile, "%d", current_sym_value);
1550   (--( asmfile)->_cnt >= 0 ?    (int)(*( asmfile)->_ptr++ = (unsigned char)('\n')) :    ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)('\n')) != '\n' ?  (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)('\n'),  asmfile))) ;
1551 }
1552
1553 static void
1554 dbxout_syms (syms)
1555      tree syms;
1556 {
1557   while (syms)
1558     {
1559       dbxout_symbol (syms, 1);
1560       syms = ((syms)->common.chain) ;
1561     }
1562 }
1563
1564 static void
1565 dbxout_parms (parms)
1566      tree parms;
1567 {
1568   for (; parms; parms = ((parms)->common.chain) )
1569     {
1570       if (((parms)->decl.offset)  >= 0)
1571         {
1572           current_sym_code = 0xa0               ;
1573           current_sym_value = ((parms)->decl.offset)  / 8 ;
1574           current_sym_addr = 0;
1575           current_sym_nchars = 2 + strlen (((((parms)->decl.name) )->identifier.pointer) );
1576
1577            ;
1578           fprintf (asmfile, ".stabs \"%s:p",
1579                    ((((parms)->decl.name) )->identifier.pointer) );
1580
1581           if (  ((((parms)->decl.rtl) )->code)  == REG
1582               && ((((parms)->decl.rtl) )->fld[0].rtint)  >= 0
1583               && ((((parms)->decl.rtl) )->fld[0].rtint)  < 56 )
1584             dbxout_type (((parms)->decl.arguments)   , 0);
1585           else
1586             {
1587
1588               if (((parms)->common.type)  != ((parms)->decl.arguments)   )
1589                 current_sym_value += (  (mode_size[(int)(((((parms)->decl.arguments)   )->type.mode) )]) 
1590                                       -         (mode_size[(int)(       ((((parms)->decl.rtl) )->mode) )]) );
1591
1592               if (      ((((parms)->decl.rtl) )->code)  == MEM
1593                   &&    ((((((parms)->decl.rtl) )->fld[ 0].rtx) )->code)  == PLUS
1594                   &&    ((((((((parms)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == CONST_INT
1595                   && ((((((((parms)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint)  == current_sym_value)
1596                 dbxout_type (((parms)->common.type) , 0);
1597               else
1598                 {
1599                   current_sym_value = ((parms)->decl.offset)  / 8 ;
1600                   dbxout_type (((parms)->decl.arguments)   , 0);
1601                 }
1602             }
1603           dbxout_finish_symbol ();
1604         }
1605
1606       else if ( ((((parms)->decl.rtl) )->code)  == REG
1607                && ((((parms)->decl.rtl) )->fld[0].rtint)  >= 0
1608                && ((((parms)->decl.rtl) )->fld[0].rtint)  < 56 )
1609         {
1610           current_sym_code = 0x40               ;
1611           current_sym_value = ((((((parms)->decl.rtl) )->fld[0].rtint) ) < 16 ? (((((parms)->decl.rtl) )->fld[0].rtint) ) : (((((parms)->decl.rtl) )->fld[0].rtint) ) + 2) ;
1612           current_sym_addr = 0;
1613           current_sym_nchars = 2 + strlen (((((parms)->decl.name) )->identifier.pointer) );
1614
1615            ;
1616           fprintf (asmfile, ".stabs \"%s:P",
1617                    ((((parms)->decl.name) )->identifier.pointer) );
1618
1619           dbxout_type (((parms)->decl.arguments)   , 0);
1620           dbxout_finish_symbol ();
1621         }
1622       else if ( ((((parms)->decl.rtl) )->code)  == MEM
1623                && ((((parms)->decl.rtl) )->fld[ 0].rtx)  != const0_rtx)
1624         {
1625           current_sym_code = 0x80               ;
1626
1627           current_sym_value = ((((((((parms)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint) ;
1628           current_sym_addr = 0;
1629           current_sym_nchars = 2 + strlen (((((parms)->decl.name) )->identifier.pointer) );
1630
1631            ;
1632           fprintf (asmfile, ".stabs \"%s:p",
1633                    ((((parms)->decl.name) )->identifier.pointer) );
1634
1635           if (((parms)->common.type)  != ((parms)->decl.arguments)   )
1636             current_sym_value += (      (mode_size[(int)(((((parms)->decl.arguments)   )->type.mode) )]) 
1637                                   -     (mode_size[(int)(       ((((parms)->decl.rtl) )->mode) )]) );
1638
1639           dbxout_type (((parms)->common.type) , 0);
1640           dbxout_finish_symbol ();
1641         }
1642     }
1643 }
1644
1645 static void
1646 dbxout_reg_parms (parms)
1647      tree parms;
1648 {
1649   while (parms)
1650     {
1651       if (      ((((parms)->decl.rtl) )->code)  == REG
1652           && ((((parms)->decl.rtl) )->fld[0].rtint)  >= 0
1653           && ((((parms)->decl.rtl) )->fld[0].rtint)  < 56 
1654           && ((parms)->decl.offset)  >= 0)
1655         {
1656           current_sym_code = 0x40               ;
1657           current_sym_value = ((((((parms)->decl.rtl) )->fld[0].rtint) ) < 16 ? (((((parms)->decl.rtl) )->fld[0].rtint) ) : (((((parms)->decl.rtl) )->fld[0].rtint) ) + 2) ;
1658           current_sym_addr = 0;
1659           current_sym_nchars = 2 + ((((parms)->decl.name) )->identifier.length) ;
1660            ;
1661           fprintf (asmfile, ".stabs \"%s:r",
1662                    ((((parms)->decl.name) )->identifier.pointer) );
1663           dbxout_type (((parms)->common.type) , 0);
1664           dbxout_finish_symbol ();
1665         }
1666       else if ( ((((parms)->decl.rtl) )->code)  == MEM
1667                &&       ((((((parms)->decl.rtl) )->fld[ 0].rtx) )->code)  == PLUS
1668                &&       ((((((((parms)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->code)  == CONST_INT)
1669         {
1670           int offset = ((parms)->decl.offset)  / 8 ;
1671
1672           if (offset != -1 && ((parms)->common.type)  != ((parms)->decl.arguments)   )
1673             offset += ( (mode_size[(int)(((((parms)->decl.arguments)   )->type.mode) )]) 
1674                        -        (mode_size[(int)(       ((((parms)->decl.rtl) )->mode) )]) );
1675
1676           if (((((((((parms)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint)  != offset)
1677             {
1678               current_sym_code = 0x80           ;
1679               current_sym_value = ((((((((parms)->decl.rtl) )->fld[ 0].rtx) )->fld[ 1].rtx) )->fld[0].rtint) ;
1680               current_sym_addr = 0;
1681               current_sym_nchars = 2 + ((((parms)->decl.name) )->identifier.length) ;
1682                ;
1683               fprintf (asmfile, ".stabs \"%s:",
1684                        ((((parms)->decl.name) )->identifier.pointer) );
1685               dbxout_type (((parms)->common.type) , 0);
1686               dbxout_finish_symbol ();
1687             }
1688         }
1689       parms = ((parms)->common.chain) ;
1690     }
1691 }
1692
1693 void
1694 dbxout_args (args)
1695      tree args;
1696 {
1697   while (args)
1698     {
1699       (--( asmfile)->_cnt >= 0 ?        (int)(*( asmfile)->_ptr++ = (unsigned char)(',')) :     ((( asmfile)->_flag & 0200 ) && -( asmfile)->_cnt < ( asmfile)->_bufsiz ?       ((*( asmfile)->_ptr = (unsigned char)(',')) != '\n' ?   (int)(*( asmfile)->_ptr++) :    _flsbuf(*(unsigned char *)( asmfile)->_ptr,  asmfile)) :        _flsbuf((unsigned char)(','),  asmfile))) ;
1700       dbxout_type (((args)->list.value) , 0);
1701       (current_sym_nchars += (1)) ;
1702       args = ((args)->common.chain) ;
1703     }
1704 }
1705
1706 void
1707 dbxout_types (types)
1708      register tree types;
1709 {
1710   while (types)
1711     {
1712       if (((types)->type.name) 
1713           && ((((types)->type.name) )->common.code)  == TYPE_DECL
1714           && ! ((((types)->type.name) )->common.asm_written_attr) )
1715         dbxout_symbol (((types)->type.name) , 1);
1716       types = ((types)->common.chain) ;
1717     }
1718 }
1719
1720 void
1721 dbxout_tags (tags)
1722      tree tags;
1723 {
1724   register tree link;
1725   for (link = tags; link; link = ((link)->common.chain) )
1726     {
1727       register tree type = ((((link)->list.value) )->type.main_variant) ;
1728       if (((link)->list.purpose)  != 0
1729           && ! ((link)->common.asm_written_attr) 
1730           && ((type)->type.size)  != 0)
1731         {
1732           ((link)->common.asm_written_attr)  = 1;
1733           current_sym_code = 0x80               ;
1734           current_sym_value = 0;
1735           current_sym_addr = 0;
1736           current_sym_nchars = 2 + ((((link)->list.purpose) )->identifier.length) ;
1737
1738            ;
1739           fprintf (asmfile, ".stabs \"%s:T",
1740                    ((((link)->list.purpose) )->identifier.pointer) );
1741           dbxout_type (type, 1);
1742           dbxout_finish_symbol ();
1743         }
1744     }
1745 }
1746
1747 static void
1748 dbxout_block (stmt, depth, args)
1749      register tree stmt;
1750      int depth;
1751      tree args;
1752 {
1753   int blocknum;
1754
1755   while (stmt)
1756     {
1757       switch (((stmt)->common.code) )
1758         {
1759         case COMPOUND_STMT:
1760         case LOOP_STMT:
1761           dbxout_block (((stmt)->stmt.body) , depth, 0);
1762           break;
1763
1764         case IF_STMT:
1765           dbxout_block (((stmt)->if_stmt.thenpart) , depth, 0);
1766           dbxout_block (((stmt)->if_stmt.elsepart) , depth, 0);
1767           break;
1768
1769         case LET_STMT:
1770           dbxout_tags (((stmt)->bind_stmt.type_tags) );
1771           dbxout_syms (((stmt)->bind_stmt.vars) );
1772           if (args)
1773             dbxout_reg_parms (args);
1774
1775           if (depth > 0)
1776             {
1777               char buf[20];
1778               blocknum = next_block_number++;
1779               sprintf (buf, "*%s%d",  "LBB",  blocknum) ;
1780               fprintf (asmfile, ".stabn %d,0,0,", 0xc0          );
1781               assemble_name (asmfile, buf);
1782               fprintf (asmfile, "\n");
1783             }
1784
1785           dbxout_block (((stmt)->stmt.body) , depth + 1, 0);
1786
1787           if (depth > 0)
1788             {
1789               char buf[20];
1790               sprintf (buf, "*%s%d",  "LBE",  blocknum) ;
1791               fprintf (asmfile, ".stabn %d,0,0,", 0xe0          );
1792               assemble_name (asmfile, buf);
1793               fprintf (asmfile, "\n");
1794             }
1795         }
1796       stmt = ((stmt)->common.chain) ;
1797     }
1798 }
1799
1800 void
1801 dbxout_function (decl)
1802      tree decl;
1803 {
1804   dbxout_symbol (decl, 0);
1805   dbxout_parms (((decl)->decl.arguments)  );
1806   dbxout_block (((decl)->decl.initial) , 0, ((decl)->decl.arguments)  );
1807
1808   dbxout_types (get_temporary_types ());
1809 }
1810
1811