fixing stuff
[dyninst.git] / codeCoverage / sparc-sun-solaris2.8 / tests / cc1 / 1toplev.i
1
2 extern int target_flags;
3
4 enum reg_class { NO_REGS, LO_FPA_REGS, FPA_REGS, FP_REGS,
5   FP_OR_FPA_REGS, DATA_REGS, DATA_OR_FPA_REGS, DATA_OR_FP_REGS,
6   DATA_OR_FP_OR_FPA_REGS, ADDR_REGS, GENERAL_REGS,
7   GENERAL_OR_FPA_REGS, GENERAL_OR_FP_REGS, ALL_REGS,
8   LIM_REG_CLASSES };
9
10 extern enum reg_class regno_reg_class[];
11
12 extern  struct  _iobuf {
13         int     _cnt;
14         unsigned char *_ptr;
15         unsigned char *_base;
16         int     _bufsiz;
17         short   _flag;
18         char    _file;           
19 } _iob[];
20
21 extern struct _iobuf    *fopen();
22 extern struct _iobuf    *fdopen();
23 extern struct _iobuf    *freopen();
24 extern struct _iobuf    *popen();
25 extern struct _iobuf    *tmpfile();
26 extern long     ftell();
27 extern char     *fgets();
28 extern char     *gets();
29
30 extern char     *ctermid();
31 extern char     *cuserid();
32 extern char     *tempnam();
33 extern char     *tmpnam();
34
35 typedef int     faultcode_t;     
36
37 void    (*signal())();
38
39 void  (*sigset())();
40 int   sighold();
41 int   sigrelse();
42 int   sigignore();
43
44 struct  sigvec {
45         void    (*sv_handler)();         
46         int     sv_mask;                 
47         int     sv_flags;                
48 };
49
50 struct  sigstack {
51         char    *ss_sp;                  
52         int     ss_onstack;              
53 };
54
55 struct  sigcontext {
56         int     sc_onstack;              
57         int     sc_mask;                 
58
59         int     sc_sp;                   
60         int     sc_pc;                   
61         int     sc_ps;                   
62
63 };
64
65 extern int sigsetjmp(), setjmp(), _setjmp();
66 extern void siglongjmp(), longjmp(), _longjmp();
67
68 typedef int jmp_buf[58 ];
69
70 typedef int sigjmp_buf[58 +1];
71
72 typedef unsigned char   u_char;
73 typedef unsigned short  u_short;
74 typedef unsigned int    u_int;
75 typedef unsigned long   u_long;
76 typedef unsigned short  ushort;          
77 typedef unsigned int    uint;            
78
79 typedef struct  _physadr { short r[1]; } *physadr;
80 typedef struct  label_t {
81         int     val[13];
82 } label_t;
83
84 typedef struct  _quad { long val[2]; } quad;
85 typedef long    daddr_t;
86 typedef char *  caddr_t;
87 typedef u_long  ino_t;
88 typedef long    swblk_t;
89 typedef int     size_t;
90 typedef long    time_t;
91 typedef short   dev_t;
92 typedef long    off_t;
93 typedef u_short uid_t;
94 typedef u_short gid_t;
95 typedef long    key_t;
96
97 typedef long    fd_mask;
98
99 typedef struct fd_set {
100         fd_mask fds_bits[(((256 )+(( (sizeof(fd_mask) * 8               )       )-1))/( (sizeof(fd_mask) * 8            )       )) ];
101 } fd_set;
102
103 typedef char *  addr_t;
104
105 struct  stat
106 {
107         dev_t   st_dev;
108         ino_t   st_ino;
109         unsigned short st_mode;
110         short   st_nlink;
111         short   st_uid;
112         short   st_gid;
113         dev_t   st_rdev;
114         off_t   st_size;
115         time_t  st_atime;
116         int     st_spare1;
117         time_t  st_mtime;
118         int     st_spare2;
119         time_t  st_ctime;
120         int     st_spare3;
121         long    st_blksize;
122         long    st_blocks;
123         long    st_spare4[2];
124 };
125
126 struct tms {
127         time_t  tms_utime;               
128         time_t  tms_stime;               
129         time_t  tms_cutime;              
130         time_t  tms_cstime;              
131 };
132
133 struct tm {
134         int     tm_sec;
135         int     tm_min;
136         int     tm_hour;
137         int     tm_mday;
138         int     tm_mon;
139         int     tm_year;
140         int     tm_wday;
141         int     tm_yday;
142         int     tm_isdst;
143         char    *tm_zone;
144         long    tm_gmtoff;
145 };
146
147 extern  struct tm *gmtime(), *localtime();
148 extern  char *asctime(), *ctime();
149 extern  void tzset(), tzsetwall();
150
151 enum tree_code {
152
153   ERROR_MARK, 
154
155   IDENTIFIER_NODE, 
156
157   OP_IDENTIFIER, 
158
159   TREE_LIST, 
160
161   VOID_TYPE,     
162
163   INTEGER_TYPE, 
164
165   REAL_TYPE, 
166
167   COMPLEX_TYPE, 
168
169   ENUMERAL_TYPE, 
170
171   BOOLEAN_TYPE, 
172
173   CHAR_TYPE, 
174
175   POINTER_TYPE, 
176
177   OFFSET_TYPE, 
178
179   REFERENCE_TYPE, 
180
181   METHOD_TYPE, 
182
183   FILE_TYPE, 
184
185   ARRAY_TYPE, 
186
187   SET_TYPE, 
188
189   STRING_TYPE, 
190
191   RECORD_TYPE, 
192
193   UNION_TYPE,    
194
195   FUNCTION_TYPE, 
196
197   LANG_TYPE, 
198
199   LABEL_STMT, 
200
201   GOTO_STMT, 
202
203   RETURN_STMT, 
204
205   EXPR_STMT, 
206
207   WITH_STMT, 
208
209   LET_STMT, 
210
211   IF_STMT, 
212
213   EXIT_STMT, 
214
215   CASE_STMT, 
216
217   LOOP_STMT, 
218
219   COMPOUND_STMT, 
220
221   ASM_STMT, 
222
223   INTEGER_CST, 
224
225   REAL_CST, 
226
227   COMPLEX_CST, 
228
229   STRING_CST, 
230
231   FUNCTION_DECL, 
232   LABEL_DECL, 
233   CONST_DECL, 
234   TYPE_DECL, 
235   VAR_DECL, 
236   PARM_DECL, 
237   RESULT_DECL, 
238   FIELD_DECL, 
239   FRIEND_DECL, 
240
241   COMPONENT_REF, 
242
243   INDIRECT_REF, 
244
245   OFFSET_REF, 
246
247   BUFFER_REF, 
248
249   ARRAY_REF, 
250
251   CONSTRUCTOR, 
252
253   COMPOUND_EXPR, 
254
255   MODIFY_EXPR, 
256
257   INIT_EXPR, 
258
259   NEW_EXPR, 
260
261   DELETE_EXPR, 
262
263   COND_EXPR, 
264
265   CALL_EXPR, 
266
267   METHOD_CALL_EXPR, 
268
269   WITH_CLEANUP_EXPR, 
270
271   PLUS_EXPR, 
272   MINUS_EXPR, 
273   MULT_EXPR, 
274
275   TRUNC_DIV_EXPR, 
276
277   CEIL_DIV_EXPR, 
278
279   FLOOR_DIV_EXPR, 
280
281   ROUND_DIV_EXPR, 
282
283   TRUNC_MOD_EXPR, 
284   CEIL_MOD_EXPR, 
285   FLOOR_MOD_EXPR, 
286   ROUND_MOD_EXPR, 
287
288   RDIV_EXPR, 
289
290   FIX_TRUNC_EXPR, 
291   FIX_CEIL_EXPR, 
292   FIX_FLOOR_EXPR, 
293   FIX_ROUND_EXPR, 
294
295   FLOAT_EXPR, 
296
297   EXPON_EXPR, 
298
299   NEGATE_EXPR, 
300
301   MIN_EXPR, 
302   MAX_EXPR, 
303   ABS_EXPR, 
304   FFS_EXPR, 
305
306   LSHIFT_EXPR, 
307   RSHIFT_EXPR, 
308   LROTATE_EXPR, 
309   RROTATE_EXPR, 
310
311   BIT_IOR_EXPR, 
312   BIT_XOR_EXPR, 
313   BIT_AND_EXPR, 
314   BIT_ANDTC_EXPR, 
315   BIT_NOT_EXPR, 
316
317   TRUTH_ANDIF_EXPR, 
318   TRUTH_ORIF_EXPR, 
319   TRUTH_AND_EXPR, 
320   TRUTH_OR_EXPR, 
321   TRUTH_NOT_EXPR, 
322
323   LT_EXPR, 
324   LE_EXPR, 
325   GT_EXPR, 
326   GE_EXPR, 
327   EQ_EXPR, 
328   NE_EXPR, 
329
330   IN_EXPR, 
331   SET_LE_EXPR, 
332   CARD_EXPR, 
333   RANGE_EXPR, 
334
335   CONVERT_EXPR, 
336
337   NOP_EXPR, 
338
339   SAVE_EXPR, 
340
341   RTL_EXPR, 
342
343   ADDR_EXPR, 
344
345   REFERENCE_EXPR, 
346
347   WRAPPER_EXPR, 
348   ANTI_WRAPPER_EXPR, 
349
350   ENTRY_VALUE_EXPR, 
351
352   COMPLEX_EXPR, 
353
354   CONJ_EXPR, 
355
356   REALPART_EXPR, 
357   IMAGPART_EXPR, 
358
359   PREDECREMENT_EXPR, 
360   PREINCREMENT_EXPR, 
361   POSTDECREMENT_EXPR, 
362   POSTINCREMENT_EXPR, 
363
364   LAST_AND_UNUSED_TREE_CODE      
365
366 };
367
368 extern char *tree_code_type[];
369
370 extern int tree_code_length[];
371
372 enum machine_mode {
373
374  VOIDmode, 
375
376  QImode,                 
377  HImode, 
378
379  PSImode, 
380  SImode, 
381  PDImode, 
382  DImode, 
383  TImode, 
384  QFmode, 
385  HFmode,                 
386  SFmode, 
387  DFmode, 
388  XFmode,         
389  TFmode, 
390  CQImode, 
391  CHImode,        
392  CSImode, 
393  CDImode, 
394  CTImode, 
395  CQFmode, 
396  CHFmode,        
397  CSFmode, 
398  CDFmode, 
399  CXFmode, 
400  CTFmode, 
401
402  BImode,         
403
404  BLKmode, 
405
406  EPmode, 
407
408 };
409
410 enum built_in_function
411 {
412   NOT_BUILT_IN,
413   BUILT_IN_ALLOCA,
414   BUILT_IN_ABS,
415   BUILT_IN_FABS,
416   BUILT_IN_LABS,
417   BUILT_IN_FFS,
418   BUILT_IN_DIV,
419   BUILT_IN_LDIV,
420   BUILT_IN_FFLOOR,
421   BUILT_IN_FCEIL,
422   BUILT_IN_FMOD,
423   BUILT_IN_FREM,
424   BUILT_IN_MEMCPY,
425   BUILT_IN_MEMCMP,
426   BUILT_IN_MEMSET,
427   BUILT_IN_FSQRT,
428   BUILT_IN_GETEXP,
429   BUILT_IN_GETMAN,
430   BUILT_IN_SAVEREGS,
431
432   BUILT_IN_NEW,
433   BUILT_IN_VEC_NEW,
434   BUILT_IN_DELETE,
435   BUILT_IN_VEC_DELETE,
436 };
437
438 typedef union tree_node *tree;
439
440 struct tree_common
441 {
442   int uid;
443   union tree_node *chain;
444   union tree_node *type;
445   enum tree_code code : 8;
446
447   unsigned external_attr : 1;
448   unsigned public_attr : 1;
449   unsigned static_attr : 1;
450   unsigned volatile_attr : 1;
451   unsigned packed_attr : 1;
452   unsigned readonly_attr : 1;
453   unsigned literal_attr : 1;
454   unsigned nonlocal_attr : 1;
455   unsigned permanent_attr : 1;
456   unsigned addressable_attr : 1;
457   unsigned regdecl_attr : 1;
458   unsigned this_vol_attr : 1;
459   unsigned unsigned_attr : 1;
460   unsigned asm_written_attr: 1;
461   unsigned inline_attr : 1;
462   unsigned used_attr : 1;
463   unsigned lang_flag_1 : 1;
464   unsigned lang_flag_2 : 1;
465   unsigned lang_flag_3 : 1;
466   unsigned lang_flag_4 : 1;
467 };
468
469 struct tree_int_cst
470 {
471   char common[sizeof (struct tree_common)];
472   long int_cst_low;
473   long int_cst_high;
474 };
475
476 extern double ldexp ();
477
478 extern double atof ();
479
480 union real_extract 
481 {
482   double  d;
483   int i[sizeof (double ) / sizeof (int)];
484 };
485
486 struct tree_real_cst
487 {
488   char common[sizeof (struct tree_common)];
489   struct rtx_def *rtl;   
490
491   double  real_cst;
492 };
493
494 struct tree_string
495 {
496   char common[sizeof (struct tree_common)];
497   struct rtx_def *rtl;   
498
499   int length;
500   char *pointer;
501 };
502
503 struct tree_complex
504 {
505   char common[sizeof (struct tree_common)];
506   struct rtx_def *rtl;   
507
508   union tree_node *real;
509   union tree_node *imag;
510 };
511
512 struct tree_identifier
513 {
514   char common[sizeof (struct tree_common)];
515   int length;
516   char *pointer;
517   union tree_node *global_value;
518   union tree_node *local_value;
519   union tree_node *label_value;
520   union tree_node *implicit_decl;
521   union tree_node *error_locus;
522 };
523
524 struct tree_list
525 {
526   char common[sizeof (struct tree_common)];
527   union tree_node *purpose;
528   union tree_node *value;
529 };
530
531 struct tree_exp
532 {
533   char common[sizeof (struct tree_common)];
534   int complexity;
535   union tree_node *operands[1];
536 };
537
538 struct tree_type
539 {
540   char common[sizeof (struct tree_common)];
541   union tree_node *values;
542   union tree_node *sep;
543   union tree_node *size;
544
545   enum machine_mode mode : 8;
546   unsigned char size_unit;
547   unsigned char align;
548   unsigned char sep_unit;
549
550   union tree_node *pointer_to;
551   union tree_node *reference_to;
552   int parse_info;
553   int symtab_address;
554   union tree_node *name;
555   union tree_node *max;
556   union tree_node *next_variant;
557   union tree_node *main_variant;
558   union tree_node *basetypes;
559   union tree_node *noncopied_parts;
560   struct lang_type *lang_specific;
561 };
562
563 struct tree_decl
564 {
565   char common[sizeof (struct tree_common)];
566   char *filename;
567   int linenum;
568   union tree_node *size;
569   enum machine_mode mode;
570   unsigned char size_unit;
571   unsigned char align;
572   unsigned char voffset_unit;
573   union tree_node *name;
574   union tree_node *context;
575   int offset;
576   union tree_node *voffset;
577   union tree_node *arguments;
578   union tree_node *result;
579   union tree_node *initial;
580   struct rtx_def *rtl;   
581
582   int frame_size;                
583   struct rtx_def *saved_insns;   
584
585   int block_symtab_address;
586   struct lang_decl *lang_specific;
587 };
588
589 struct tree_stmt
590 {
591   char common[sizeof (struct tree_common)];
592   char *filename;
593   int linenum;
594   union tree_node *body;
595 };
596
597 struct tree_if_stmt
598 {
599   char common[sizeof (struct tree_common)];
600   char *filename;
601   int linenum;
602   union tree_node *cond, *thenpart, *elsepart;
603 };
604
605 struct tree_bind_stmt
606 {
607   char common[sizeof (struct tree_common)];
608   char *filename;
609   int linenum;
610   union tree_node *body, *vars, *supercontext, *bind_size, *type_tags;
611 };
612
613 struct tree_case_stmt
614 {
615   char common[sizeof (struct tree_common)];
616   char *filename;
617   int linenum;
618   union tree_node *index, *case_list;
619 };
620
621 union tree_node
622 {
623   struct tree_common common;
624   struct tree_int_cst int_cst;
625   struct tree_real_cst real_cst;
626   struct tree_string string;
627   struct tree_complex complex;
628   struct tree_identifier identifier;
629   struct tree_decl decl;
630   struct tree_type type;
631   struct tree_list list;
632   struct tree_exp exp;
633   struct tree_stmt stmt;
634   struct tree_if_stmt if_stmt;
635   struct tree_bind_stmt bind_stmt;
636   struct tree_case_stmt case_stmt;
637 };
638 extern char *oballoc ();
639 extern char *permalloc ();
640
641 extern tree make_node ();
642
643 extern tree copy_node ();
644
645 extern tree get_identifier ();
646
647 extern tree build_int_2 ();
648 extern tree build_real ();
649 extern tree build_real_from_string ();
650 extern tree build_real_from_int_cst ();
651 extern tree build_complex ();
652 extern tree build_string ();
653 extern tree build ();
654 extern tree build_nt ();
655 extern tree build_tree_list ();
656 extern tree build_op_identifier ();
657 extern tree build_decl ();
658 extern tree build_let ();
659
660 extern tree make_signed_type ();
661 extern tree make_unsigned_type ();
662 extern void fixup_unsigned_type ();
663 extern tree build_pointer_type ();
664 extern tree build_reference_type ();
665 extern tree build_index_type ();
666 extern tree build_array_type ();
667 extern tree build_function_type ();
668 extern tree build_method_type ();
669 extern tree build_offset_type ();
670 extern tree array_type_nelts ();
671
672 extern tree build_binary_op ();
673 extern tree build_indirect_ref ();
674 extern tree build_unary_op ();
675
676 extern tree build_type_variant ();
677
678 extern void layout_type ();
679
680 extern tree type_hash_canon ();
681
682 extern void layout_decl ();
683
684 extern tree fold ();
685
686 extern tree combine ();
687
688 extern tree convert ();
689 extern tree convert_units ();
690 extern tree size_in_bytes ();
691 extern tree genop ();
692 extern tree build_int ();
693 extern tree get_pending_sizes ();
694
695 extern tree sizetype;
696
697 extern tree chainon ();
698
699 extern tree tree_cons (), perm_tree_cons (), temp_tree_cons ();
700 extern tree saveable_tree_cons ();
701
702 extern tree tree_last ();
703
704 extern tree nreverse ();
705
706 extern int list_length ();
707
708 extern int integer_zerop ();
709
710 extern int integer_onep ();
711
712 extern int integer_all_onesp ();
713
714 extern int type_unsigned_p ();
715
716 extern int staticp ();
717
718 extern int lvalue_or_else ();
719
720 extern tree save_expr ();
721
722 extern tree stabilize_reference ();
723
724 extern tree get_unwidened ();
725
726 extern tree get_narrower ();
727
728 extern tree type_for_size ();
729
730 extern tree unsigned_type ();
731
732 extern tree signed_type ();
733
734 extern tree get_floating_type ();
735
736 extern char *function_cannot_inline_p ();
737
738 extern tree integer_zero_node;
739
740 extern tree integer_one_node;
741
742 extern tree size_zero_node;
743
744 extern tree size_one_node;
745
746 extern tree null_pointer_node;
747
748 extern tree error_mark_node;
749
750 extern tree void_type_node;
751
752 extern tree integer_type_node;
753
754 extern tree unsigned_type_node;
755
756 extern tree char_type_node;
757
758 extern char *input_filename;
759
760 extern int pedantic;
761
762 extern int immediate_size_expand;
763
764 extern tree current_function_decl;
765
766 extern int current_function_calls_setjmp;
767
768 extern int all_types_permanent;
769
770 extern tree expand_start_stmt_expr ();
771 extern tree expand_end_stmt_expr ();
772 extern void expand_expr_stmt(), clear_last_expr();
773 extern void expand_label(), expand_goto(), expand_asm();
774 extern void expand_start_cond(), expand_end_cond();
775 extern void expand_start_else(), expand_end_else();
776 extern void expand_start_loop(), expand_start_loop_continue_elsewhere();
777 extern void expand_loop_continue_here();
778 extern void expand_end_loop();
779 extern int expand_continue_loop();
780 extern int expand_exit_loop(), expand_exit_loop_if_false();
781 extern int expand_exit_something();
782
783 extern void expand_start_delayed_expr ();
784 extern tree expand_end_delayed_expr ();
785 extern void expand_emit_delayed_expr ();
786
787 extern void expand_null_return(), expand_return();
788 extern void expand_start_bindings(), expand_end_bindings();
789 extern void expand_start_case(), expand_end_case();
790 extern int pushcase(), pushcase_range ();
791 extern void expand_start_function(), expand_end_function();
792
793 extern int pedantic;
794
795 extern tree build_component_ref(), build_conditional_expr(), build_compound_expr();
796 extern tree build_unary_op(), build_binary_op(), build_function_call();
797 extern tree build_binary_op_nodefault ();
798 extern tree build_indirect_ref(), build_array_ref(), build_c_cast();
799 extern tree build_modify_expr();
800 extern tree c_sizeof (), c_alignof ();
801 extern void store_init_value ();
802 extern tree digest_init ();
803 extern tree c_expand_start_case ();
804 extern tree default_conversion ();
805
806 extern tree commontype ();
807
808 extern tree build_label ();
809
810 extern int start_function ();
811 extern void finish_function ();
812 extern void store_parm_decls ();
813 extern tree get_parm_info ();
814
815 extern void pushlevel(), poplevel();
816
817 extern tree groktypename(), lookup_name();
818
819 extern tree lookup_label(), define_label();
820
821 extern tree implicitly_declare(), getdecls(), gettags ();
822
823 extern tree start_decl();
824 extern void finish_decl();
825
826 extern tree start_struct(), finish_struct(), xref_tag();
827 extern tree grokfield();
828
829 extern tree start_enum(), finish_enum();
830 extern tree build_enumerator();
831
832 extern tree make_index_type ();
833
834 extern tree double_type_node, long_double_type_node, float_type_node;
835 extern tree char_type_node, unsigned_char_type_node, signed_char_type_node;
836
837 extern tree short_integer_type_node, short_unsigned_type_node;
838 extern tree long_integer_type_node, long_unsigned_type_node;
839 extern tree unsigned_type_node;
840 extern tree string_type_node, char_array_type_node, int_array_type_node;
841
842 extern int current_function_returns_value;
843 extern int current_function_returns_null;
844
845 extern int lineno;
846
847 extern tree ridpointers[];
848
849 extern tree current_function_decl;
850
851 extern int dollars_in_ident;
852
853 extern int flag_signed_char;
854
855 extern int flag_cond_mismatch;
856
857 extern int flag_no_asm;
858
859 extern int warn_implicit;
860
861 extern int warn_return_type;
862
863 extern int warn_write_strings;
864
865 extern int warn_pointer_arith;
866
867 extern int warn_strict_prototypes;
868
869 extern int warn_cast_qual;
870
871 extern int flag_traditional;
872
873 enum rtx_code  {
874
875   UNKNOWN , 
876
877   NIL , 
878
879   EXPR_LIST , 
880
881   INSN_LIST , 
882
883   MATCH_OPERAND , 
884
885   MATCH_DUP , 
886
887   MATCH_OPERATOR , 
888
889   DEFINE_INSN , 
890
891   DEFINE_PEEPHOLE , 
892
893   DEFINE_COMBINE , 
894
895   DEFINE_EXPAND , 
896
897   SEQUENCE , 
898
899   ADDRESS , 
900
901   INSN , 
902
903   JUMP_INSN , 
904
905   CALL_INSN , 
906
907   BARRIER , 
908
909   CODE_LABEL , 
910
911   NOTE , 
912
913   INLINE_HEADER , 
914
915   PARALLEL , 
916
917   ASM_INPUT , 
918
919   ASM_OPERANDS , 
920
921   ADDR_VEC , 
922
923   ADDR_DIFF_VEC , 
924
925   SET , 
926
927   USE , 
928
929   CLOBBER , 
930
931   CALL , 
932
933   RETURN , 
934
935   CONST_INT , 
936
937   CONST_DOUBLE , 
938
939   CONST , 
940
941   PC , 
942
943   REG , 
944
945   SUBREG , 
946
947   STRICT_LOW_PART , 
948
949   MEM , 
950
951   LABEL_REF , 
952
953   SYMBOL_REF , 
954
955   CC0 , 
956
957   QUEUED , 
958
959   IF_THEN_ELSE , 
960
961   COMPARE , 
962
963   PLUS , 
964
965   MINUS , 
966
967   NEG , 
968
969   MULT , 
970
971   DIV , 
972   MOD , 
973
974   UMULT , 
975   UDIV , 
976   UMOD , 
977
978   AND , 
979
980   IOR , 
981
982   XOR , 
983
984   NOT , 
985
986   LSHIFT , 
987   ASHIFT , 
988   ROTATE , 
989
990   ASHIFTRT , 
991   LSHIFTRT , 
992   ROTATERT , 
993
994   PRE_DEC , 
995   PRE_INC , 
996   POST_DEC , 
997   POST_INC , 
998
999   NE , 
1000   EQ , 
1001   GE , 
1002   GT , 
1003   LE , 
1004   LT , 
1005   GEU , 
1006   GTU , 
1007   LEU , 
1008   LTU , 
1009
1010   SIGN_EXTEND , 
1011
1012   ZERO_EXTEND , 
1013
1014   TRUNCATE , 
1015
1016   FLOAT_EXTEND , 
1017   FLOAT_TRUNCATE , 
1018
1019   FLOAT , 
1020
1021   FIX , 
1022
1023   UNSIGNED_FLOAT , 
1024
1025   UNSIGNED_FIX , 
1026
1027   ABS , 
1028
1029   SQRT , 
1030
1031   FFS , 
1032
1033   SIGN_EXTRACT , 
1034
1035   ZERO_EXTRACT , 
1036
1037   LAST_AND_UNUSED_RTX_CODE};     
1038
1039 extern int rtx_length[];
1040
1041 extern char *rtx_name[];
1042
1043 extern char *rtx_format[];
1044
1045 extern char *mode_name[];
1046
1047 enum mode_class { MODE_RANDOM, MODE_INT, MODE_FLOAT,
1048                   MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MODE_FUNCTION };
1049
1050 extern enum mode_class mode_class[];
1051
1052 extern int mode_size[];
1053
1054 extern int mode_unit_size[];
1055
1056 typedef union rtunion_def
1057 {
1058   int rtint;
1059   char *rtstr;
1060   struct rtx_def *rtx;
1061   struct rtvec_def *rtvec;
1062   enum machine_mode rttype;
1063 } rtunion;
1064
1065 typedef struct rtx_def
1066 {
1067
1068   enum rtx_code code : 16;
1069
1070   enum machine_mode mode : 8;
1071
1072   unsigned int jump : 1;
1073   unsigned int call : 1;
1074
1075   unsigned int unchanging : 1;
1076
1077   unsigned int volatil : 1;
1078
1079   unsigned int in_struct : 1;
1080
1081   unsigned int used : 1;
1082
1083   unsigned integrated : 1;
1084
1085   rtunion fld[1];
1086 } *rtx;
1087
1088 typedef struct rtvec_def{
1089   unsigned num_elem;             
1090   rtunion elem[1];
1091 } *rtvec;
1092
1093 enum reg_note { REG_DEAD = 1, REG_INC = 2, REG_EQUIV = 3, REG_WAS_0 = 4,
1094                 REG_EQUAL = 5, REG_RETVAL = 6, REG_LIBCALL = 7,
1095                 REG_NONNEG = 8 };
1096
1097 extern char *reg_note_name[];
1098
1099 extern char *note_insn_name[];
1100
1101 extern rtx rtx_alloc ();
1102 extern rtvec rtvec_alloc ();
1103 extern rtx find_reg_note ();
1104 extern rtx gen_rtx ();
1105 extern rtx copy_rtx ();
1106 extern rtvec gen_rtvec ();
1107 extern rtvec gen_rtvec_v ();
1108 extern rtx gen_reg_rtx ();
1109 extern rtx gen_label_rtx ();
1110 extern rtx gen_inline_header_rtx ();
1111 extern rtx gen_lowpart ();
1112 extern rtx gen_highpart ();
1113 extern int subreg_lowpart_p ();
1114 extern rtx make_safe_from ();
1115 extern rtx memory_address ();
1116 extern rtx get_insns ();
1117 extern rtx get_last_insn ();
1118 extern rtx start_sequence ();
1119 extern rtx gen_sequence ();
1120 extern rtx expand_expr ();
1121 extern rtx output_constant_def ();
1122 extern rtx immed_real_const ();
1123 extern rtx immed_real_const_1 ();
1124 extern rtx immed_double_const ();
1125 extern rtx force_const_double_mem ();
1126 extern rtx force_const_mem ();
1127 extern rtx get_parm_real_loc ();
1128 extern rtx assign_stack_local ();
1129 extern rtx protect_from_queue ();
1130 extern void emit_queue ();
1131 extern rtx emit_move_insn ();
1132 extern rtx emit_insn ();
1133 extern rtx emit_jump_insn ();
1134 extern rtx emit_call_insn ();
1135 extern rtx emit_call_insn_before ();
1136 extern rtx emit_insn_before ();
1137 extern rtx emit_insn_after ();
1138 extern rtx emit_label ();
1139 extern rtx emit_barrier ();
1140 extern rtx emit_note ();
1141 extern rtx emit_line_note ();
1142 extern rtx emit_line_note_force ();
1143 extern rtx prev_real_insn ();
1144 extern rtx next_real_insn ();
1145 extern rtx next_nondeleted_insn ();
1146 extern rtx plus_constant ();
1147 extern rtx find_equiv_reg ();
1148 extern rtx delete_insn ();
1149 extern rtx adj_offsetable_operand ();
1150
1151 extern int max_parallel;
1152
1153 extern int asm_noperands ();
1154 extern char *decode_asm_operands ();
1155
1156 extern enum reg_class reg_preferred_class ();
1157
1158 extern rtx get_first_nonparm_insn ();
1159
1160 extern rtx pc_rtx;
1161 extern rtx cc0_rtx;
1162 extern rtx const0_rtx;
1163 extern rtx const1_rtx;
1164 extern rtx fconst0_rtx;
1165 extern rtx dconst0_rtx;
1166
1167 extern rtx stack_pointer_rtx;
1168 extern rtx frame_pointer_rtx;
1169 extern rtx arg_pointer_rtx;
1170 extern rtx struct_value_rtx;
1171 extern rtx struct_value_incoming_rtx;
1172 extern rtx static_chain_rtx;
1173 extern rtx static_chain_incoming_rtx;
1174
1175 extern char *main_input_filename;
1176
1177 enum debugger { NO_DEBUG = 0, GDB_DEBUG = 1, DBX_DEBUG = 2, SDB_DEBUG = 3,
1178                 EXTENDED_DBX_DEBUG = 4 };
1179
1180 extern enum debugger write_symbols;
1181
1182 extern int use_gdb_dbx_extensions;
1183
1184 extern int optimize;
1185
1186 extern int obey_regdecls;
1187
1188 extern int quiet_flag;
1189
1190 extern int inhibit_warnings;
1191
1192 extern int extra_warnings;
1193
1194 extern int warn_unused;
1195
1196 extern int warn_shadow;
1197
1198 extern int warn_switch;
1199
1200 extern int warn_id_clash;
1201 extern int id_clash_len;
1202
1203 extern int profile_flag;
1204
1205 extern int profile_block_flag;
1206
1207 extern int pedantic;
1208
1209 extern int flag_caller_saves;
1210
1211 extern int flag_pcc_struct_return;
1212
1213 extern int flag_force_mem;
1214
1215 extern int flag_force_addr;
1216
1217 extern int flag_defer_pop;
1218
1219 extern int flag_float_store;
1220
1221 extern int flag_combine_regs;
1222
1223 extern int flag_strength_reduce;
1224
1225 extern int flag_writable_strings;
1226
1227 extern int flag_no_function_cse;
1228
1229 extern int flag_omit_frame_pointer;
1230
1231 extern int frame_pointer_needed;
1232
1233 extern int flag_no_peephole;
1234
1235 extern int flag_volatile;
1236
1237 extern int flag_inline_functions;
1238
1239 extern int flag_keep_inline_functions;
1240
1241 extern int flag_syntax_only;
1242
1243 extern int flag_shared_data;
1244
1245 extern int yydebug;
1246
1247 extern struct _iobuf  *finput;
1248
1249 extern int reload_completed;
1250 extern int rtx_equal_function_value_matters;
1251
1252 extern void init_lex ();
1253 extern void init_decl_processing ();
1254 extern void init_tree ();
1255 extern void init_rtl ();
1256 extern void init_optabs ();
1257 extern void init_reg_sets ();
1258 extern void dump_flow_info ();
1259 extern void dump_local_alloc ();
1260
1261 void rest_of_decl_compilation ();
1262 void error ();
1263 void error_with_file_and_line ();
1264 void set_target_switch ();
1265
1266 int target_flags;
1267
1268 char *input_filename;
1269
1270 char *main_input_filename;
1271
1272 extern int lineno;
1273
1274 extern tree current_function_decl;
1275
1276 char *dump_base_name;
1277
1278 int rtl_dump = 0;
1279 int rtl_dump_and_exit = 0;
1280 int jump_opt_dump = 0;
1281 int cse_dump = 0;
1282 int loop_dump = 0;
1283 int flow_dump = 0;
1284 int combine_dump = 0;
1285 int local_reg_dump = 0;
1286 int global_reg_dump = 0;
1287 int jump2_opt_dump = 0;
1288
1289 enum debugger write_symbols = NO_DEBUG;
1290
1291 int use_gdb_dbx_extensions;
1292
1293 int optimize = 0;
1294
1295 int flag_caller_saves = 0;
1296
1297 int flag_pcc_struct_return = 0;
1298
1299 int flag_force_mem = 0;
1300
1301 int flag_force_addr = 0;
1302
1303 int flag_defer_pop = 1;
1304
1305 int flag_float_store = 0;
1306
1307 int flag_combine_regs = 0;
1308
1309 int flag_strength_reduce = 0;
1310
1311 int flag_writable_strings = 0;
1312
1313 int flag_no_function_cse = 0;
1314
1315 int flag_omit_frame_pointer = 0;
1316
1317 int flag_no_peephole = 0;
1318
1319 int flag_volatile;
1320
1321 int obey_regdecls = 0;
1322
1323 int quiet_flag = 0;
1324
1325 int inhibit_warnings = 0;
1326
1327 int extra_warnings = 0;
1328
1329 int warn_unused;
1330
1331 int warn_shadow;
1332
1333 int warn_switch;
1334
1335 int warn_id_clash;
1336 int id_clash_len;
1337
1338 int errorcount = 0;
1339 int warningcount = 0;
1340 int sorrycount = 0;
1341
1342 int profile_flag = 0;
1343
1344 int profile_block_flag;
1345
1346 int pedantic = 0;
1347
1348 int flag_inline_functions;
1349
1350 int flag_keep_inline_functions;
1351
1352 int flag_syntax_only;
1353
1354 int flag_shared_data;
1355
1356 char *asm_file_name;
1357
1358 char *sym_file_name;
1359
1360 struct { char *string; int *variable; int on_value;} f_options[] =
1361 {
1362   {"float-store", &flag_float_store, 1},
1363   {"volatile", &flag_volatile, 1},
1364   {"defer-pop", &flag_defer_pop, 1},
1365   {"omit-frame-pointer", &flag_omit_frame_pointer, 1},
1366   {"strength-reduce", &flag_strength_reduce, 1},
1367   {"writable-strings", &flag_writable_strings, 1},
1368   {"peephole", &flag_no_peephole, 0},
1369   {"force-mem", &flag_force_mem, 1},
1370   {"force-addr", &flag_force_addr, 1},
1371   {"combine-regs", &flag_combine_regs, 1},
1372   {"function-cse", &flag_no_function_cse, 0},
1373   {"inline-functions", &flag_inline_functions, 1},
1374   {"keep-inline-functions", &flag_keep_inline_functions, 1},
1375   {"syntax-only", &flag_syntax_only, 1},
1376   {"shared-data", &flag_shared_data, 1},
1377   {"caller-saves", &flag_caller_saves, 1},
1378   {"pcc-struct-return", &flag_pcc_struct_return, 1}
1379 };
1380
1381 struct _iobuf  *asm_out_file;
1382 struct _iobuf  *rtl_dump_file;
1383 struct _iobuf  *jump_opt_dump_file;
1384 struct _iobuf  *cse_dump_file;
1385 struct _iobuf  *loop_dump_file;
1386 struct _iobuf  *flow_dump_file;
1387 struct _iobuf  *combine_dump_file;
1388 struct _iobuf  *local_reg_dump_file;
1389 struct _iobuf  *global_reg_dump_file;
1390 struct _iobuf  *jump2_opt_dump_file;
1391
1392 int parse_time;
1393 int varconst_time;
1394 int integration_time;
1395 int jump_time;
1396 int cse_time;
1397 int loop_time;
1398 int flow_time;
1399 int combine_time;
1400 int local_alloc_time;
1401 int global_alloc_time;
1402 int final_time;
1403 int symout_time;
1404 int dump_time;
1405
1406 int
1407 gettime ()
1408 {
1409
1410   struct tms tms;
1411
1412   if (quiet_flag)
1413     return 0;
1414
1415   times (&tms);
1416   return (tms.tms_utime + tms.tms_stime) * (1000000 / 60                );
1417
1418 }
1419
1420 void
1421 print_time (str, total)
1422      char *str;
1423      int total;
1424 {
1425   fprintf ((&_iob[2]) ,
1426            "time in %s: %d.%06d\n",
1427            str, total / 1000000, total % 1000000);
1428 }
1429
1430 int
1431 count_error (warningp)
1432      int warningp;
1433 {
1434   if (warningp && inhibit_warnings)
1435     return 0;
1436
1437   if (warningp)
1438     warningcount++;
1439   else
1440     errorcount++;
1441
1442   return 1;
1443 }
1444
1445 void
1446 pfatal_with_name (name)
1447      char *name;
1448 {
1449   fprintf ((&_iob[2]) , "cc1: ");
1450   perror (name);
1451   exit (35);
1452 }
1453
1454 void
1455 fatal_io_error (name)
1456      char *name;
1457 {
1458   fprintf ((&_iob[2]) , "cc1:%s: I/O error\n", name);
1459   exit (35);
1460 }
1461
1462 void
1463 fatal (s, v)
1464      char *s;
1465 {
1466   error (s, v);
1467   exit (34);
1468 }
1469 static int need_error_newline;
1470
1471 static tree last_error_function = 0 ;
1472
1473 void
1474 announce_function (decl)
1475      tree decl;
1476 {
1477   if (! quiet_flag)
1478     {
1479       fprintf ((&_iob[2]) , " %s", ((((decl)->decl.name) )->identifier.pointer) );
1480       fflush ((&_iob[2]) );
1481       need_error_newline = 1;
1482       last_error_function = current_function_decl;
1483     }
1484 }
1485
1486 static void
1487 report_error_function (file)
1488      char *file;
1489 {
1490   if (need_error_newline)
1491     {
1492       fprintf ((&_iob[2]) , "\n");
1493       need_error_newline = 0;
1494     }
1495
1496   if (last_error_function != current_function_decl)
1497     {
1498       if (file)
1499         fprintf ((&_iob[2]) , "%s: ", file);
1500
1501       if (current_function_decl == 0 )
1502         fprintf ((&_iob[2]) , "At top level:\n");
1503       else
1504         fprintf ((&_iob[2]) , "In function %s:\n",
1505                  ((((current_function_decl)->decl.name) )->identifier.pointer) );
1506
1507       last_error_function = current_function_decl;
1508     }
1509 }
1510
1511 void
1512 error (s, v, v2)
1513      char *s;
1514      int v;                      
1515      int v2;                     
1516 {
1517   error_with_file_and_line (input_filename, lineno, s, v, v2);
1518 }
1519
1520 void
1521 error_with_file_and_line (file, line, s, v, v2)
1522      char *file;
1523      int line;
1524      char *s;
1525      int v;
1526      int v2;
1527 {
1528   count_error (0);
1529
1530   report_error_function (file);
1531
1532   if (file)
1533     fprintf ((&_iob[2]) , "%s:%d: ", file, line);
1534   else
1535     fprintf ((&_iob[2]) , "cc1: ");
1536   fprintf ((&_iob[2]) , s, v, v2);
1537   fprintf ((&_iob[2]) , "\n");
1538 }
1539
1540 void
1541 error_with_decl (decl, s, v)
1542      tree decl;
1543      char *s;
1544      int v;
1545 {
1546   count_error (0);
1547
1548   report_error_function (((decl)->decl.filename) );
1549
1550   fprintf ((&_iob[2]) , "%s:%d: ",
1551            ((decl)->decl.filename) , ((decl)->decl.linenum) );
1552
1553   if (((decl)->decl.name) )
1554     fprintf ((&_iob[2]) , s, ((((decl)->decl.name) )->identifier.pointer) , v);
1555   else
1556     fprintf ((&_iob[2]) , s, "((anonymous))", v);
1557   fprintf ((&_iob[2]) , "\n");
1558 }
1559
1560 void
1561 error_for_asm (insn, s, v, v2)
1562      rtx insn;
1563      char *s;
1564      int v;                      
1565      int v2;                     
1566 {
1567   rtx temp;
1568   char *filename;
1569   int line;
1570   rtx body = ((insn)->fld[3].rtx) ;
1571   rtx asmop;
1572
1573   if (  ((body)->code)  == SET &&       ((((body)->fld[1].rtx) )->code)  == ASM_OPERANDS)
1574     asmop = ((body)->fld[1].rtx) ;
1575   else if (     ((body)->code)  == ASM_OPERANDS)
1576     asmop = body;
1577   else if (     ((body)->code)  == PARALLEL
1578            &&   ((((body)->fld[ 0].rtvec->elem[ 0].rtx) )->code)  == SET)
1579     asmop = ((((body)->fld[ 0].rtvec->elem[ 0].rtx) )->fld[1].rtx) ;
1580   else if (     ((body)->code)  == PARALLEL
1581            &&   ((((body)->fld[ 0].rtvec->elem[ 0].rtx) )->code)  == ASM_OPERANDS)
1582     asmop = ((body)->fld[ 0].rtvec->elem[ 0].rtx) ;
1583
1584   filename = (((asmop))->fld[ 5].rtstr)  ;
1585   line = (((asmop))->fld[ 6].rtint)  ;
1586   error_with_file_and_line (filename, line, s, v, v2);
1587 }
1588
1589 void
1590 warning_with_file_and_line (file, line, s, v, v2)
1591      char *file;
1592      int line;
1593      char *s;
1594      int v;
1595      int v2;
1596 {
1597   if (count_error (1) == 0)
1598     return;
1599
1600   report_error_function (file);
1601
1602   if (file)
1603     fprintf ((&_iob[2]) , "%s:%d: ", file, line);
1604   else
1605     fprintf ((&_iob[2]) , "cc1: ");
1606
1607   fprintf ((&_iob[2]) , "warning: ");
1608   fprintf ((&_iob[2]) , s, v, v2);
1609   fprintf ((&_iob[2]) , "\n");
1610 }
1611
1612 void
1613 warning (s, v, v2)
1614      char *s;
1615      int v;                      
1616      int v2;
1617 {
1618   warning_with_file_and_line (input_filename, lineno, s, v, v2);
1619 }
1620
1621 void
1622 warning_with_decl (decl, s, v)
1623      tree decl;
1624      char *s;
1625      int v;
1626 {
1627   if (count_error (1) == 0)
1628     return;
1629
1630   report_error_function (((decl)->decl.filename) );
1631
1632   fprintf ((&_iob[2]) , "%s:%d: ",
1633            ((decl)->decl.filename) , ((decl)->decl.linenum) );
1634
1635   fprintf ((&_iob[2]) , "warning: ");
1636   if (((decl)->decl.name) )
1637     fprintf ((&_iob[2]) , s, ((((decl)->decl.name) )->identifier.pointer) , v);
1638   else
1639     fprintf ((&_iob[2]) , s, "((anonymous))", v);
1640   fprintf ((&_iob[2]) , "\n");
1641 }
1642
1643 void
1644 sorry (s, v, v2)
1645      char *s;
1646      int v, v2;
1647 {
1648   sorrycount++;
1649   if (input_filename)
1650     fprintf ((&_iob[2]) , "%s:%d: ", input_filename, lineno);
1651   else
1652     fprintf ((&_iob[2]) , "cc1: ");
1653
1654   fprintf ((&_iob[2]) , "sorry, not implemented: ");
1655   fprintf ((&_iob[2]) , s, v, v2);
1656   fprintf ((&_iob[2]) , "\n");
1657 }
1658
1659 void
1660 really_sorry (s, v, v2)
1661      char *s;
1662      int v, v2;
1663 {
1664   if (input_filename)
1665     fprintf ((&_iob[2]) , "%s:%d: ", input_filename, lineno);
1666   else
1667     fprintf ((&_iob[2]) , "c++: ");
1668
1669   fprintf ((&_iob[2]) , "sorry, not implemented: ");
1670   fprintf ((&_iob[2]) , s, v, v2);
1671   fatal (" (fatal)\n");
1672 }
1673
1674 void
1675 botch (s)
1676 {
1677   abort ();
1678 }
1679
1680 int
1681 xmalloc (size)
1682      unsigned size;
1683 {
1684   register int value = (int) malloc (size);
1685   if (value == 0)
1686     fatal ("Virtual memory exhausted.");
1687   return value;
1688 }
1689
1690 int
1691 xrealloc (ptr, size)
1692      char *ptr;
1693      int size;
1694 {
1695   int result = realloc (ptr, size);
1696   if (!result)
1697     fatal ("Virtual memory exhausted.");
1698   return result;
1699 }
1700
1701 int
1702 exact_log2 (x)
1703      register unsigned int x;
1704 {
1705   register int log = 0;
1706   for (log = 0; log < 32 ; log++)
1707     if (x == (1 << log))
1708       return log;
1709   return -1;
1710 }
1711
1712 int
1713 floor_log2 (x)
1714      register unsigned int x;
1715 {
1716   register int log = 0;
1717   for (log = 0; log < 32 ; log++)
1718     if ((x & ((-1) << log)) == 0)
1719       return log - 1;
1720   return 32  - 1;
1721 }
1722
1723 int float_handled;
1724 jmp_buf float_handler;
1725
1726 void
1727 set_float_handler (handler)
1728      jmp_buf handler;
1729 {
1730   float_handled = (handler != 0);
1731   if (handler)
1732     memcpy ( float_handler,handler, sizeof (float_handler)) ;
1733 }
1734
1735 static void
1736 float_signal ()
1737 {
1738   if (float_handled == 0)
1739     abort ();
1740   warning ("floating overflow in constant folding");
1741   float_handled = 0;
1742   longjmp (float_handler, 1);
1743 }
1744
1745 static void
1746 pipe_closed ()
1747 {
1748   fatal ("output pipe has been closed");
1749 }
1750
1751 static void
1752 compile_file (name)
1753      char *name;
1754 {
1755   tree globals;
1756   int start_time;
1757   int dump_base_name_length;
1758
1759   int name_specified = name != 0;
1760
1761   if (dump_base_name == 0)
1762     dump_base_name = name ? name : "gccdump";
1763   dump_base_name_length = strlen (dump_base_name);
1764
1765   parse_time = 0;
1766   varconst_time = 0;
1767   integration_time = 0;
1768   jump_time = 0;
1769   cse_time = 0;
1770   loop_time = 0;
1771   flow_time = 0;
1772   combine_time = 0;
1773   local_alloc_time = 0;
1774   global_alloc_time = 0;
1775   final_time = 0;
1776   symout_time = 0;
1777   dump_time = 0;
1778
1779   if (name == 0 || !strcmp (name, "-"))
1780     {
1781       finput = (&_iob[0]) ;
1782       name = "stdin";
1783     }
1784   else
1785     finput = fopen (name, "r");
1786   if (finput == 0)
1787     pfatal_with_name (name);
1788
1789   init_tree ();
1790   init_lex ();
1791   init_rtl ();
1792   init_emit_once ();
1793   init_decl_processing ();
1794   init_optabs ();
1795
1796   if (rtl_dump)
1797     {
1798       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1799       strcpy (dumpname, dump_base_name);
1800       strcat (dumpname, ".rtl");
1801       rtl_dump_file = fopen (dumpname, "w");
1802       if (rtl_dump_file == 0)
1803         pfatal_with_name (dumpname);
1804     }
1805
1806   if (jump_opt_dump)
1807     {
1808       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1809       strcpy (dumpname, dump_base_name);
1810       strcat (dumpname, ".jump");
1811       jump_opt_dump_file = fopen (dumpname, "w");
1812       if (jump_opt_dump_file == 0)
1813         pfatal_with_name (dumpname);
1814     }
1815
1816   if (cse_dump)
1817     {
1818       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1819       strcpy (dumpname, dump_base_name);
1820       strcat (dumpname, ".cse");
1821       cse_dump_file = fopen (dumpname, "w");
1822       if (cse_dump_file == 0)
1823         pfatal_with_name (dumpname);
1824     }
1825
1826   if (loop_dump)
1827     {
1828       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1829       strcpy (dumpname, dump_base_name);
1830       strcat (dumpname, ".loop");
1831       loop_dump_file = fopen (dumpname, "w");
1832       if (loop_dump_file == 0)
1833         pfatal_with_name (dumpname);
1834     }
1835
1836   if (flow_dump)
1837     {
1838       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1839       strcpy (dumpname, dump_base_name);
1840       strcat (dumpname, ".flow");
1841       flow_dump_file = fopen (dumpname, "w");
1842       if (flow_dump_file == 0)
1843         pfatal_with_name (dumpname);
1844     }
1845
1846   if (combine_dump)
1847     {
1848       register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
1849       strcpy (dumpname, dump_base_name);
1850       strcat (dumpname, ".combine");
1851       combine_dump_file = fopen (dumpname, "w");
1852       if (combine_dump_file == 0)
1853         pfatal_with_name (dumpname);
1854     }
1855
1856   if (local_reg_dump)
1857     {
1858       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1859       strcpy (dumpname, dump_base_name);
1860       strcat (dumpname, ".lreg");
1861       local_reg_dump_file = fopen (dumpname, "w");
1862       if (local_reg_dump_file == 0)
1863         pfatal_with_name (dumpname);
1864     }
1865
1866   if (global_reg_dump)
1867     {
1868       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1869       strcpy (dumpname, dump_base_name);
1870       strcat (dumpname, ".greg");
1871       global_reg_dump_file = fopen (dumpname, "w");
1872       if (global_reg_dump_file == 0)
1873         pfatal_with_name (dumpname);
1874     }
1875
1876   if (jump2_opt_dump)
1877     {
1878       register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
1879       strcpy (dumpname, dump_base_name);
1880       strcat (dumpname, ".jump2");
1881       jump2_opt_dump_file = fopen (dumpname, "w");
1882       if (jump2_opt_dump_file == 0)
1883         pfatal_with_name (dumpname);
1884     }
1885
1886   if (! name_specified && asm_file_name == 0)
1887     asm_out_file = (&_iob[1]) ;
1888   else
1889     {
1890       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1891       int len = strlen (dump_base_name);
1892       strcpy (dumpname, dump_base_name);
1893       if (len > 2 && ! strcmp (".c", dumpname + len - 2))
1894         dumpname[len - 2] = 0;
1895       else if (len > 2 && ! strcmp (".i", dumpname + len - 2))
1896         dumpname[len - 2] = 0;
1897       else if (len > 3 && ! strcmp (".co", dumpname + len - 3))
1898         dumpname[len - 3] = 0;
1899       strcat (dumpname, ".s");
1900       if (asm_file_name == 0)
1901         {
1902           asm_file_name = (char *) malloc (strlen (dumpname) + 1);
1903           strcpy (asm_file_name, dumpname);
1904         }
1905       if (!strcmp (asm_file_name, "-"))
1906         asm_out_file = (&_iob[1]) ;
1907       else
1908         asm_out_file = fopen (asm_file_name, "w");
1909       if (asm_out_file == 0)
1910         pfatal_with_name (asm_file_name);
1911     }
1912
1913   input_filename = name;
1914
1915   ungetc (check_newline (), finput);
1916
1917   if (main_input_filename == 0)
1918     main_input_filename = name;
1919
1920   fprintf (asm_out_file, "#NO_APP\n"); ;
1921
1922   fprintf (asm_out_file, "gcc_compiled.:\n");
1923
1924   if (write_symbols == GDB_DEBUG)
1925     {
1926       register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
1927       int len = strlen (dump_base_name);
1928       strcpy (dumpname, dump_base_name);
1929       if (len > 2 && ! strcmp (".c", dumpname + len - 2))
1930         dumpname[len - 2] = 0;
1931       else if (len > 2 && ! strcmp (".i", dumpname + len - 2))
1932         dumpname[len - 2] = 0;
1933       else if (len > 3 && ! strcmp (".co", dumpname + len - 3))
1934         dumpname[len - 3] = 0;
1935       strcat (dumpname, ".sym");
1936       if (sym_file_name == 0)
1937         sym_file_name = dumpname;
1938       symout_init (sym_file_name, asm_out_file, main_input_filename);
1939     }
1940
1941   if (write_symbols == DBX_DEBUG)
1942     dbxout_init (asm_out_file, main_input_filename);
1943
1944   init_final (main_input_filename);
1945
1946   start_time = gettime ();
1947
1948   yyparse ();
1949
1950   parse_time += gettime () - start_time;
1951
1952   parse_time -= varconst_time;
1953
1954   globals = getdecls ();
1955
1956   {
1957     tree decl;
1958     for (decl = globals; decl; decl = ((decl)->common.chain) )
1959       {
1960         if (((decl)->common.code)  == VAR_DECL && ((decl)->common.static_attr) 
1961             && ! ((decl)->common.asm_written_attr) )
1962           rest_of_decl_compilation (decl, 0, 1, 1);
1963         if (((decl)->common.code)  == FUNCTION_DECL
1964             && ! ((decl)->common.asm_written_attr) 
1965             && ((decl)->decl.initial)  != 0
1966             && ((decl)->common.addressable_attr) )
1967           output_inline_function (decl);
1968
1969         if (warn_unused
1970             && ((decl)->common.code)  == FUNCTION_DECL
1971             && ((decl)->decl.initial)  == 0
1972             && ((decl)->common.external_attr) 
1973             && ! ((decl)->common.public_attr) )
1974           warning_with_decl (decl, "`%s' declared but never defined");
1975
1976         if (warn_unused
1977             && (((decl)->common.code)  == FUNCTION_DECL
1978                 || ((decl)->common.code)  == VAR_DECL)
1979             && ! ((decl)->common.external_attr) 
1980             && ! ((decl)->common.public_attr) 
1981             && ! ((decl)->common.used_attr) 
1982             && ! ((decl)->common.inline_attr) )
1983           warning_with_decl (decl, "`%s' defined but not used");
1984       }
1985   }
1986
1987   if (write_symbols == DBX_DEBUG)
1988     do { int otime = gettime (); 
1989              {
1990                dbxout_tags (gettags ());
1991                dbxout_types (get_permanent_types ());
1992              }; symout_time += gettime () - otime; } while (0) ;
1993
1994   if (write_symbols == GDB_DEBUG)
1995     do { int otime = gettime (); 
1996              {
1997                struct stat statbuf;
1998                fstat (((finput)->_file) , &statbuf);
1999                symout_types (get_permanent_types ());
2000                symout_top_blocks (globals, gettags ());
2001                symout_finish (name, statbuf.st_ctime);
2002              }; symout_time += gettime () - otime; } while (0) ;
2003
2004   end_final (main_input_filename);
2005
2006   if (rtl_dump)
2007     fclose (rtl_dump_file);
2008
2009   if (jump_opt_dump)
2010     fclose (jump_opt_dump_file);
2011
2012   if (cse_dump)
2013     fclose (cse_dump_file);
2014
2015   if (loop_dump)
2016     fclose (loop_dump_file);
2017
2018   if (flow_dump)
2019     fclose (flow_dump_file);
2020
2021   if (combine_dump)
2022     {
2023       dump_combine_total_stats (combine_dump_file);
2024       fclose (combine_dump_file);
2025     }
2026
2027   if (local_reg_dump)
2028     fclose (local_reg_dump_file);
2029
2030   if (global_reg_dump)
2031     fclose (global_reg_dump_file);
2032
2033   if (jump2_opt_dump)
2034     fclose (jump2_opt_dump_file);
2035
2036   fclose (finput);
2037   if ((((asm_out_file)->_flag&040 )!=0)  != 0)
2038     fatal_io_error (asm_file_name);
2039   fclose (asm_out_file);
2040
2041   if (! quiet_flag)
2042     {
2043       fprintf ((&_iob[2]) ,"\n");
2044       print_time ("parse", parse_time);
2045       print_time ("integration", integration_time);
2046       print_time ("jump", jump_time);
2047       print_time ("cse", cse_time);
2048       print_time ("loop", loop_time);
2049       print_time ("flow", flow_time);
2050       print_time ("combine", combine_time);
2051       print_time ("local-alloc", local_alloc_time);
2052       print_time ("global-alloc", global_alloc_time);
2053       print_time ("final", final_time);
2054       print_time ("varconst", varconst_time);
2055       print_time ("symout", symout_time);
2056       print_time ("dump", dump_time);
2057     }
2058 }
2059
2060 void
2061 rest_of_decl_compilation (decl, asmspec, top_level, at_end)
2062      tree decl;
2063      tree asmspec;
2064      int top_level;
2065      int at_end;
2066 {
2067
2068   if (((decl)->common.static_attr)  || ((decl)->common.external_attr) )
2069     do { int otime = gettime (); 
2070              {
2071                make_decl_rtl (decl, asmspec, top_level);
2072                if (! (! at_end && top_level
2073                       && (((decl)->decl.initial)  == 0
2074                           || ((decl)->decl.initial)  == error_mark_node)))
2075                  assemble_variable (decl, top_level, write_symbols, at_end);
2076              }; varconst_time += gettime () - otime; } while (0) ;
2077
2078   else if (write_symbols == DBX_DEBUG && ((decl)->common.code)  == TYPE_DECL)
2079     do { int otime = gettime ();  dbxout_symbol (decl, 0); varconst_time += gettime () - otime; } while (0) ;
2080
2081   if (top_level)
2082     {
2083       if (write_symbols == GDB_DEBUG)
2084         {
2085           do { int otime = gettime (); 
2086                    {
2087                      symout_types (get_temporary_types ());
2088                    }; symout_time += gettime () - otime; } while (0) ;
2089
2090         }
2091       else
2092         get_temporary_types ();
2093     }
2094 }
2095
2096 void
2097 rest_of_compilation (decl)
2098      tree decl;
2099 {
2100   register rtx insns;
2101   int start_time = gettime ();
2102   int tem;
2103
2104   if (((decl)->decl.saved_insns)  == 0)
2105     {
2106
2107       if (flag_inline_functions || ((decl)->common.inline_attr) )
2108         {
2109           do { int otime = gettime (); 
2110                    {
2111                      int specd = ((decl)->common.inline_attr) ;
2112                      char *lose = function_cannot_inline_p (decl);
2113                      if (lose != 0 && specd)
2114                        warning_with_decl (decl, lose);
2115                      if (lose == 0)
2116                        save_for_inline (decl);
2117                      else
2118                        ((decl)->common.inline_attr)  = 0;
2119                    }; integration_time += gettime () - otime; } while (0) ;
2120         }
2121
2122       insns = get_insns ();
2123
2124       if (rtl_dump)
2125         do { int otime = gettime (); 
2126                  {
2127                    fprintf (rtl_dump_file, "\n;; Function %s\n\n",
2128                             ((((decl)->decl.name) )->identifier.pointer) );
2129                    if (((decl)->decl.saved_insns) )
2130                      fprintf (rtl_dump_file, ";; (integrable)\n\n");
2131                    print_rtl (rtl_dump_file, insns);
2132                    fflush (rtl_dump_file);
2133                  }; dump_time += gettime () - otime; } while (0) ;
2134
2135       if (((decl)->common.public_attr)  == 0
2136           && ((decl)->common.inline_attr) 
2137           && ! flag_keep_inline_functions)
2138         goto exit_rest_of_compilation;
2139     }
2140
2141   if (rtl_dump_and_exit)
2142     goto exit_rest_of_compilation;
2143
2144   ((decl)->common.asm_written_attr)  = 1;
2145
2146   insns = get_insns ();
2147
2148   unshare_all_rtl (insns);
2149
2150   if (optimize || extra_warnings || warn_return_type
2151       || ((decl)->common.this_vol_attr) )
2152     do { int otime = gettime ();  jump_optimize (insns, 0, 0); jump_time += gettime () - otime; } while (0) ;
2153
2154   if (jump_opt_dump)
2155     do { int otime = gettime (); 
2156              {
2157                fprintf (jump_opt_dump_file, "\n;; Function %s\n\n",
2158                         ((((decl)->decl.name) )->identifier.pointer) );
2159                print_rtl (jump_opt_dump_file, insns);
2160                fflush (jump_opt_dump_file);
2161              }; dump_time += gettime () - otime; } while (0) ;
2162
2163   if (optimize)
2164     {
2165       do { int otime = gettime ();  reg_scan (insns, max_reg_num (), 0); cse_time += gettime () - otime; } while (0) ;
2166
2167       do { int otime = gettime ();  tem = cse_main (insns, max_reg_num ()); cse_time += gettime () - otime; } while (0) ;
2168
2169       if (tem)
2170         do { int otime = gettime ();  jump_optimize (insns, 0, 0); jump_time += gettime () - otime; } while (0) ;
2171     }
2172
2173   if (cse_dump)
2174     do { int otime = gettime (); 
2175              {
2176                fprintf (cse_dump_file, "\n;; Function %s\n\n",
2177                         ((((decl)->decl.name) )->identifier.pointer) );
2178                print_rtl (cse_dump_file, insns);
2179                fflush (cse_dump_file);
2180              }; dump_time += gettime () - otime; } while (0) ;
2181
2182   if (loop_dump)
2183     do { int otime = gettime (); 
2184              {
2185                fprintf (loop_dump_file, "\n;; Function %s\n\n",
2186                         ((((decl)->decl.name) )->identifier.pointer) );
2187              }; dump_time += gettime () - otime; } while (0) ;
2188
2189   if (optimize)
2190     {
2191       do { int otime = gettime (); 
2192                {
2193                  reg_scan (insns, max_reg_num (), 1);
2194                  loop_optimize (insns, loop_dump ? loop_dump_file : 0);
2195                }; loop_time += gettime () - otime; } while (0) ;
2196     }
2197
2198   if (loop_dump)
2199     do { int otime = gettime (); 
2200              {
2201                print_rtl (loop_dump_file, insns);
2202                fflush (loop_dump_file);
2203              }; dump_time += gettime () - otime; } while (0) ;
2204
2205   if (optimize)          
2206     obey_regdecls = 0;   
2207
2208   regclass_init ();
2209
2210   if (flow_dump)
2211     do { int otime = gettime (); 
2212              {
2213                fprintf (flow_dump_file, "\n;; Function %s\n\n",
2214                         ((((decl)->decl.name) )->identifier.pointer) );
2215              }; dump_time += gettime () - otime; } while (0) ;
2216
2217   if (obey_regdecls)
2218     {
2219       do { int otime = gettime (); 
2220                {
2221                  regclass (insns, max_reg_num ());
2222                  stupid_life_analysis (insns, max_reg_num (),
2223                                        flow_dump_file);
2224                }; flow_time += gettime () - otime; } while (0) ;
2225     }
2226   else
2227     {
2228
2229       do { int otime = gettime ();  flow_analysis (insns, max_reg_num (),
2230                                          flow_dump_file); flow_time += gettime () - otime; } while (0) ;
2231       if (extra_warnings)
2232         uninitialized_vars_warning (((decl)->decl.initial) );
2233     }
2234
2235   if (flow_dump)
2236     do { int otime = gettime (); 
2237              {
2238                print_rtl (flow_dump_file, insns);
2239                fflush (flow_dump_file);
2240              }; dump_time += gettime () - otime; } while (0) ;
2241
2242   if (optimize)
2243     do { int otime = gettime ();  combine_instructions (insns, max_reg_num ()); combine_time += gettime () - otime; } while (0) ;
2244
2245   if (combine_dump)
2246     do { int otime = gettime (); 
2247              {
2248                fprintf (combine_dump_file, "\n;; Function %s\n\n",
2249                         ((((decl)->decl.name) )->identifier.pointer) );
2250                dump_combine_stats (combine_dump_file);
2251                print_rtl (combine_dump_file, insns);
2252                fflush (combine_dump_file);
2253              }; dump_time += gettime () - otime; } while (0) ;
2254
2255   if (!obey_regdecls)
2256     do { int otime = gettime (); 
2257              {
2258                regclass (insns, max_reg_num ());
2259                local_alloc ();
2260              }; local_alloc_time += gettime () - otime; } while (0) ;
2261
2262   if (local_reg_dump)
2263     do { int otime = gettime (); 
2264              {
2265                fprintf (local_reg_dump_file, "\n;; Function %s\n\n",
2266                         ((((decl)->decl.name) )->identifier.pointer) );
2267                dump_flow_info (local_reg_dump_file);
2268                dump_local_alloc (local_reg_dump_file);
2269                print_rtl (local_reg_dump_file, insns);
2270                fflush (local_reg_dump_file);
2271              }; dump_time += gettime () - otime; } while (0) ;
2272
2273   if (global_reg_dump)
2274     do { int otime = gettime (); 
2275              fprintf (global_reg_dump_file, "\n;; Function %s\n\n",
2276                       ((((decl)->decl.name) )->identifier.pointer) ); dump_time += gettime () - otime; } while (0) ;
2277
2278   do { int otime = gettime (); 
2279            {
2280              if (!obey_regdecls)
2281                global_alloc (global_reg_dump ? global_reg_dump_file : 0);
2282              else
2283                reload (insns, 0,
2284                        global_reg_dump ? global_reg_dump_file : 0);
2285            }; global_alloc_time += gettime () - otime; } while (0) ;
2286
2287   if (global_reg_dump)
2288     do { int otime = gettime (); 
2289              {
2290                dump_global_regs (global_reg_dump_file);
2291                print_rtl (global_reg_dump_file, insns);
2292                fflush (global_reg_dump_file);
2293              }; dump_time += gettime () - otime; } while (0) ;
2294
2295   rtx_equal_function_value_matters = 1;
2296   reload_completed = 1;
2297
2298   if (optimize)
2299     {
2300       do { int otime = gettime ();  jump_optimize (insns, 1, 1); jump_time += gettime () - otime; } while (0) ;
2301     }
2302
2303   if (jump2_opt_dump)
2304     do { int otime = gettime (); 
2305              {
2306                fprintf (jump2_opt_dump_file, "\n;; Function %s\n\n",
2307                         ((((decl)->decl.name) )->identifier.pointer) );
2308                print_rtl (jump2_opt_dump_file, insns);
2309                fflush (jump2_opt_dump_file);
2310              }; dump_time += gettime () - otime; } while (0) ;
2311
2312   do { int otime = gettime (); 
2313            {
2314              assemble_function (decl);
2315              final_start_function (insns, asm_out_file,
2316                                    write_symbols, optimize);
2317              final (insns, asm_out_file,
2318                     write_symbols, optimize, 0);
2319              final_end_function (insns, asm_out_file,
2320                                  write_symbols, optimize);
2321              fflush (asm_out_file);
2322            }; final_time += gettime () - otime; } while (0) ;
2323
2324   if (write_symbols == GDB_DEBUG)
2325     {
2326       do { int otime = gettime (); 
2327                {
2328                  symout_types (get_permanent_types ());
2329                  symout_types (get_temporary_types ());
2330
2331                  ((decl)->decl.block_symtab_address) 
2332                    = symout_function (((decl)->decl.initial) ,
2333                                       ((decl)->decl.arguments)  , 0);
2334                  symout_function_end ();
2335                }; symout_time += gettime () - otime; } while (0) ;
2336     }
2337   else
2338     get_temporary_types ();
2339
2340   if (write_symbols == DBX_DEBUG)
2341     do { int otime = gettime ();  dbxout_function (decl); symout_time += gettime () - otime; } while (0) ;
2342
2343  exit_rest_of_compilation:
2344
2345   rtx_equal_function_value_matters = 0;
2346   reload_completed = 0;
2347
2348   clear_const_double_mem ();
2349
2350   parse_time -= gettime () - start_time;
2351 }
2352
2353 int
2354 main (argc, argv, envp)
2355      int argc;
2356      char **argv;
2357      char **envp;
2358 {
2359   register int i;
2360   char *filename = 0;
2361   int print_mem_flag = 0;
2362
2363   signal (8     , float_signal);
2364
2365   signal (13    , pipe_closed);
2366
2367   flag_signed_char = 1 ;
2368
2369   obey_regdecls = 1;
2370
2371   init_reg_sets ();
2372
2373   target_flags = 0;
2374   set_target_switch ("");
2375
2376   for (i = 1; i < argc; i++)
2377     if (argv[i][0] == '-' && argv[i][1] != 0)
2378       {
2379         register char *str = argv[i] + 1;
2380         if (str[0] == 'Y')
2381           str++;
2382
2383         if (str[0] == 'm')
2384           set_target_switch (&str[1]);
2385         else if (!strcmp (str, "dumpbase"))
2386           {
2387             dump_base_name = argv[++i];
2388           }
2389         else if (str[0] == 'd')
2390           {
2391             register char *p = &str[1];
2392             while (*p)
2393               switch (*p++)
2394                 {
2395                 case 'c':
2396                   combine_dump = 1;
2397                   break;
2398                 case 'f':
2399                   flow_dump = 1;
2400                   break;
2401                 case 'g':
2402                   global_reg_dump = 1;
2403                   break;
2404                 case 'j':
2405                   jump_opt_dump = 1;
2406                   break;
2407                 case 'J':
2408                   jump2_opt_dump = 1;
2409                   break;
2410                 case 'l':
2411                   local_reg_dump = 1;
2412                   break;
2413                 case 'L':
2414                   loop_dump = 1;
2415                   break;
2416                 case 'm':
2417                   print_mem_flag = 1;
2418                   break;
2419                 case 'r':
2420                   rtl_dump = 1;
2421                   break;
2422                 case 's':
2423                   cse_dump = 1;
2424                   break;
2425                 case 'y':
2426                   yydebug = 1;
2427                   break;
2428                 }
2429           }
2430         else if (str[0] == 'f')
2431           {
2432             int j;
2433             register char *p = &str[1];
2434             int found = 0;
2435
2436             for (j = 0;
2437                  !found && j < sizeof (f_options) / sizeof (f_options[0]);
2438                  j++)
2439               {
2440                 if (!strcmp (p, f_options[j].string))
2441                   {
2442                     *f_options[j].variable = f_options[j].on_value;
2443
2444                     found = 1;
2445                   }
2446                 if (p[0] == 'n' && p[1] == 'o' && p[2] == '-'
2447                     && ! strcmp (p+3, f_options[j].string))
2448                   {
2449                     *f_options[j].variable = ! f_options[j].on_value;
2450                     found = 1;
2451                   }
2452               }
2453
2454             if (found)
2455               ;
2456             else if (!strncmp (p, "fixed-", 6))
2457               fix_register (&p[6], 1, 1);
2458             else if (!strncmp (p, "call-used-", 10))
2459               fix_register (&p[10], 0, 1);
2460             else if (!strncmp (p, "call-saved-", 11))
2461               fix_register (&p[11], 0, 0);
2462             else if (! lang_decode_option (argv[i]))
2463               error ("Invalid option `%s'", argv[i]);         
2464           }
2465         else if (!strcmp (str, "noreg"))
2466           ;
2467         else if (!strcmp (str, "opt"))
2468           optimize = 1, obey_regdecls = 0;
2469         else if (!strcmp (str, "O"))
2470           optimize = 1, obey_regdecls = 0;
2471         else if (!strcmp (str, "pedantic"))
2472           pedantic = 1;
2473         else if (lang_decode_option (argv[i]))
2474           ;
2475         else if (!strcmp (str, "quiet"))
2476           quiet_flag = 1;
2477         else if (!strcmp (str, "version"))
2478           {
2479             extern char *version_string, *language_string;
2480             fprintf ((&_iob[2]) , "%s version %s", language_string, version_string);
2481
2482             fprintf ((&_iob[2]) , " (68k, MIT syntax)"); ;
2483
2484             fprintf ((&_iob[2]) , " compiled by GNU C version %s.\n", "1.35");
2485
2486           }
2487         else if (!strcmp (str, "w"))
2488           inhibit_warnings = 1;
2489         else if (!strcmp (str, "W"))
2490           extra_warnings = 1;
2491         else if (!strcmp (str, "Wunused"))
2492           warn_unused = 1;
2493         else if (!strcmp (str, "Wshadow"))
2494           warn_shadow = 1;
2495         else if (!strcmp (str, "Wswitch"))
2496           warn_switch = 1;
2497         else if (!strncmp (str, "Wid-clash-", 10))
2498           {
2499             char *endp = str + 10;
2500
2501             while (*endp)
2502               {
2503                 if (*endp >= '0' && *endp <= '9')
2504                   endp++;
2505                 else
2506                   error ("Invalid option `%s'", argv[i]);
2507               }
2508             warn_id_clash = 1;
2509             id_clash_len = atoi (str + 10);
2510           }
2511         else if (!strcmp (str, "p"))
2512           profile_flag = 1;
2513         else if (!strcmp (str, "a"))
2514           {
2515
2516             profile_block_flag = 1;
2517
2518           }
2519         else if (!strcmp (str, "gg"))
2520           write_symbols = GDB_DEBUG;
2521
2522         else if (!strcmp (str, "g"))
2523           write_symbols = DBX_DEBUG;
2524         else if (!strcmp (str, "G"))
2525           write_symbols = DBX_DEBUG;
2526
2527         else if (!strcmp (str, "symout"))
2528           {
2529             if (write_symbols == NO_DEBUG)
2530               write_symbols = GDB_DEBUG;
2531             sym_file_name = argv[++i];
2532           }
2533         else if (!strcmp (str, "o"))
2534           {
2535             asm_file_name = argv[++i];
2536           }
2537         else
2538           error ("Invalid option `%s'", argv[i]);
2539       }
2540     else
2541       filename = argv[i];
2542
2543   {     if ((target_flags & 0100) ) target_flags &= ~2; } ;
2544
2545   init_reg_sets_1 ();
2546
2547   compile_file (filename);
2548
2549   if (errorcount)
2550     exit (33 );
2551   if (sorrycount)
2552     exit (33 );
2553   exit (0 );
2554   return 34;
2555 }
2556
2557 struct {char *name; int value;} target_switches []
2558   = { { "68020", 5},    { "c68020", 5}, { "68881", 2},  { "bitfield", 4},       { "68000", -5}, { "c68000", -5},        { "soft-float", -0102}, { "nobitfield", -4},    { "rtd", 8},    { "nortd", -8}, { "short", 040},        { "noshort", -040},     { "fpa", 0100}, { "nofpa", -0100},      { "", 7 }} ;
2559
2560 void
2561 set_target_switch (name)
2562      char *name;
2563 {
2564   register int j;
2565   for (j = 0; j < sizeof target_switches / sizeof target_switches[0]; j++)
2566     if (!strcmp (target_switches[j].name, name))
2567       {
2568         if (target_switches[j].value < 0)
2569           target_flags &= ~-target_switches[j].value;
2570         else
2571           target_flags |= target_switches[j].value;
2572         return;
2573       }
2574   error ("Invalid option `%s'", name);
2575 }
2576