fixing stuff
[dyninst.git] / codeCoverage / sparc-sun-solaris2.9 / tests / cc1 / 1expr.i
1 extern int target_flags;
2 extern int hard_regno_nregs[];
3 extern int hard_regno_mode_ok[64 ];
4 extern int leaf_function;
5 enum reg_class { NO_REGS, GENERAL_REGS, FP_REGS, ALL_REGS, LIM_REG_CLASSES };
6 extern char leaf_reg_remap[];
7 extern char leaf_reg_backmap[];
8 extern struct rtx_def *sparc_compare_op0, *sparc_compare_op1;
9 extern struct rtx_def *gen_compare_reg ();
10 extern int actual_fsize;
11 extern int apparent_fsize;
12 extern int current_function_calls_alloca;
13 extern int current_function_outgoing_args_size;
14 extern union tree_node *current_function_decl;
15 extern struct rtx_def *legitimize_pic_address ();
16 extern char *singlemove_string ();
17 extern char *output_move_double ();
18 extern char *output_move_quad ();
19 extern char *output_fp_move_double ();
20 extern char *output_fp_move_quad ();
21 extern char *output_block_move ();
22 extern char *output_scc_insn ();
23 extern char *output_cbranch ();
24 extern char *output_return ();
25 extern int flag_pic;
26 enum machine_mode {
27  VOIDmode, 
28  QImode,                 
29  HImode, 
30  PSImode, 
31  SImode, 
32  PDImode, 
33  DImode, 
34  TImode, 
35  SFmode, 
36  DFmode, 
37  XFmode,     
38  TFmode, 
39  SCmode, 
40  DCmode, 
41  XCmode, 
42  TCmode, 
43  BLKmode, 
44  CCmode, 
45   CC_NOOVmode, CCFPmode, CCFPEmode ,
46 MAX_MACHINE_MODE };
47 extern char *mode_name[];
48 enum mode_class { MODE_RANDOM, MODE_INT, MODE_FLOAT, MODE_PARTIAL_INT, MODE_CC,
49                   MODE_COMPLEX_INT, MODE_COMPLEX_FLOAT, MAX_MODE_CLASS};
50 extern enum mode_class mode_class[];
51 extern int mode_size[];
52 extern int mode_unit_size[];
53 extern enum machine_mode mode_wider_mode[];
54 extern enum machine_mode mode_for_size ();
55 extern enum machine_mode get_best_mode ();
56 extern enum machine_mode class_narrowest_mode[];
57 extern enum machine_mode byte_mode;
58 extern enum machine_mode word_mode;
59 enum rtx_code  {
60   UNKNOWN , 
61   NIL , 
62   EXPR_LIST , 
63   INSN_LIST , 
64   MATCH_OPERAND , 
65   MATCH_SCRATCH , 
66   MATCH_DUP , 
67   MATCH_OPERATOR , 
68   MATCH_PARALLEL , 
69   MATCH_OP_DUP , 
70   MATCH_PAR_DUP , 
71   DEFINE_INSN , 
72   DEFINE_PEEPHOLE , 
73   DEFINE_SPLIT , 
74   DEFINE_COMBINE , 
75   DEFINE_EXPAND , 
76   DEFINE_DELAY , 
77   DEFINE_FUNCTION_UNIT , 
78   DEFINE_ASM_ATTRIBUTES , 
79   SEQUENCE , 
80   ADDRESS , 
81   DEFINE_ATTR , 
82   ATTR , 
83   SET_ATTR , 
84   SET_ATTR_ALTERNATIVE , 
85   EQ_ATTR , 
86   INSN , 
87   JUMP_INSN , 
88   CALL_INSN , 
89   BARRIER , 
90   CODE_LABEL , 
91   NOTE , 
92   INLINE_HEADER , 
93   PARALLEL , 
94   ASM_INPUT , 
95   ASM_OPERANDS , 
96   UNSPEC , 
97   UNSPEC_VOLATILE , 
98   ADDR_VEC , 
99   ADDR_DIFF_VEC , 
100   SET , 
101   USE , 
102   CLOBBER , 
103   CALL , 
104   RETURN , 
105   TRAP_IF , 
106   CONST_INT , 
107   CONST_DOUBLE , 
108   CONST_STRING , 
109   CONST , 
110   PC , 
111   REG , 
112   SCRATCH , 
113   SUBREG , 
114   STRICT_LOW_PART , 
115   MEM , 
116   LABEL_REF , 
117   SYMBOL_REF , 
118   CC0 , 
119   QUEUED , 
120   IF_THEN_ELSE , 
121   COND , 
122   COMPARE , 
123   PLUS , 
124   MINUS , 
125   NEG , 
126   MULT , 
127   DIV , 
128   MOD , 
129   UDIV , 
130   UMOD , 
131   AND , 
132   IOR , 
133   XOR , 
134   NOT , 
135   LSHIFT , 
136   ASHIFT , 
137   ROTATE , 
138   ASHIFTRT , 
139   LSHIFTRT , 
140   ROTATERT , 
141   SMIN , 
142   SMAX , 
143   UMIN , 
144   UMAX , 
145   PRE_DEC , 
146   PRE_INC , 
147   POST_DEC , 
148   POST_INC , 
149   NE , 
150   EQ , 
151   GE , 
152   GT , 
153   LE , 
154   LT , 
155   GEU , 
156   GTU , 
157   LEU , 
158   LTU , 
159   SIGN_EXTEND , 
160   ZERO_EXTEND , 
161   TRUNCATE , 
162   FLOAT_EXTEND , 
163   FLOAT_TRUNCATE , 
164   FLOAT , 
165   FIX , 
166   UNSIGNED_FLOAT , 
167   UNSIGNED_FIX , 
168   ABS , 
169   SQRT , 
170   FFS , 
171   SIGN_EXTRACT , 
172   ZERO_EXTRACT , 
173   HIGH , 
174   LO_SUM , 
175   LAST_AND_UNUSED_RTX_CODE};     
176 extern int rtx_length[];
177 extern char *rtx_name[];
178 extern char *rtx_format[];
179 extern char rtx_class[];
180 typedef union rtunion_def
181 {
182   int  rtwint;
183   int rtint;
184   char *rtstr;
185   struct rtx_def *rtx;
186   struct rtvec_def *rtvec;
187   enum machine_mode rttype;
188 } rtunion;
189 typedef struct rtx_def
190 {
191   enum rtx_code code : 16;
192   enum machine_mode mode : 8;
193   unsigned int jump : 1;
194   unsigned int call : 1;
195   unsigned int unchanging : 1;
196   unsigned int volatil : 1;
197   unsigned int in_struct : 1;
198   unsigned int used : 1;
199   unsigned integrated : 1;
200   rtunion fld[1];
201 } *rtx;
202 typedef struct rtvec_def{
203   unsigned num_elem;             
204   rtunion elem[1];
205 } *rtvec;
206 enum reg_note { REG_DEAD = 1, REG_INC = 2, REG_EQUIV = 3, REG_WAS_0 = 4,
207                 REG_EQUAL = 5, REG_RETVAL = 6, REG_LIBCALL = 7,
208                 REG_NONNEG = 8, REG_NO_CONFLICT = 9, REG_UNUSED = 10,
209                 REG_CC_SETTER = 11, REG_CC_USER = 12, REG_LABEL = 13,
210                 REG_DEP_ANTI = 14, REG_DEP_OUTPUT = 15 };
211 extern char *reg_note_name[];
212 extern char *note_insn_name[];
213 extern rtx plus_constant_wide            (rtx, int ) ;
214 extern rtx plus_constant_for_output_wide (rtx, int ) ;
215 extern rtx gen_rtx ();
216 extern rtvec gen_rtvec ();
217 extern rtx read_rtx ();
218 extern char *xrealloc ();
219 extern char *xmalloc                    (unsigned) ;
220 extern char *oballoc                    (int) ;
221 extern char *permalloc                  (int) ;
222 extern void free                        (void *) ;
223 extern rtx rtx_alloc                    (enum rtx_code ) ;
224 extern rtvec rtvec_alloc                (int) ;
225 extern rtx find_reg_note                (rtx, enum reg_note, rtx) ;
226 extern rtx find_regno_note              (rtx, enum reg_note, int) ;
227 extern int  get_integer_term    (rtx) ;
228 extern rtx get_related_value            (rtx) ;
229 extern rtx single_set                   (rtx) ;
230 extern rtx find_last_value              (rtx, rtx *, rtx) ;
231 extern rtx copy_rtx                     (rtx) ;
232 extern rtx copy_rtx_if_shared           (rtx) ;
233 extern rtx copy_most_rtx                (rtx, rtx) ;
234 extern rtx replace_rtx                  (rtx, rtx, rtx) ;
235 extern rtvec gen_rtvec_v                (int, rtx *) ;
236 extern rtx gen_reg_rtx                  (enum machine_mode) ;
237 extern rtx gen_label_rtx                (void) ;
238 extern rtx gen_inline_header_rtx        (rtx, rtx, int, int, int, int, int, int, rtx, int, int, rtvec, rtx) ;
239 extern rtx gen_lowpart_common           (enum machine_mode, rtx) ;
240 extern rtx gen_lowpart                  (enum machine_mode, rtx) ;
241 extern rtx gen_lowpart_if_possible      (enum machine_mode, rtx) ;
242 extern rtx gen_highpart                 (enum machine_mode, rtx) ;
243 extern rtx gen_realpart                 (enum machine_mode, rtx) ;
244 extern rtx gen_imagpart                 (enum machine_mode, rtx) ;
245 extern rtx operand_subword              (rtx, int, int, enum machine_mode) ;
246 extern rtx operand_subword_force        (rtx, int, enum machine_mode) ;
247 extern int subreg_lowpart_p             (rtx) ;
248 extern rtx make_safe_from               (rtx, rtx) ;
249 extern rtx memory_address               (enum machine_mode, rtx) ;
250 extern rtx get_insns                    (void) ;
251 extern rtx get_last_insn                (void) ;
252 extern rtx get_last_insn_anywhere       (void) ;
253 extern void start_sequence              (void) ;
254 extern void push_to_sequence            (rtx) ;
255 extern void end_sequence                (void) ;
256 extern rtx gen_sequence                 (void) ;
257 extern rtx immed_double_const           (int , int , enum machine_mode) ;
258 extern rtx force_const_mem              (enum machine_mode, rtx) ;
259 extern rtx force_reg                    (enum machine_mode, rtx) ;
260 extern rtx get_pool_constant            (rtx) ;
261 extern enum machine_mode get_pool_mode  (rtx) ;
262 extern int get_pool_offset              (rtx) ;
263 extern rtx simplify_subtraction         (rtx) ;
264 extern rtx assign_stack_local           (enum machine_mode, int, int) ;
265 extern rtx assign_stack_temp            (enum machine_mode, int, int) ;
266 extern rtx protect_from_queue           (rtx, int) ;
267 extern void emit_queue                  (void) ;
268 extern rtx emit_move_insn               (rtx, rtx) ;
269 extern rtx emit_insn_before             (rtx, rtx) ;
270 extern rtx emit_jump_insn_before        (rtx, rtx) ;
271 extern rtx emit_call_insn_before        (rtx, rtx) ;
272 extern rtx emit_barrier_before          (rtx) ;
273 extern rtx emit_note_before             (int, rtx) ;
274 extern rtx emit_insn_after              (rtx, rtx) ;
275 extern rtx emit_jump_insn_after         (rtx, rtx) ;
276 extern rtx emit_barrier_after           (rtx) ;
277 extern rtx emit_label_after             (rtx, rtx) ;
278 extern rtx emit_note_after              (int, rtx) ;
279 extern rtx emit_line_note_after         (char *, int, rtx) ;
280 extern rtx emit_insn                    (rtx) ;
281 extern rtx emit_insns                   (rtx) ;
282 extern rtx emit_insns_before            (rtx, rtx) ;
283 extern rtx emit_jump_insn               (rtx) ;
284 extern rtx emit_call_insn               (rtx) ;
285 extern rtx emit_label                   (rtx) ;
286 extern rtx emit_barrier                 (void) ;
287 extern rtx emit_line_note               (char *, int) ;
288 extern rtx emit_note                    (char *, int) ;
289 extern rtx emit_line_note_force         (char *, int) ;
290 extern rtx make_insn_raw                (rtx) ;
291 extern rtx previous_insn                (rtx) ;
292 extern rtx next_insn                    (rtx) ;
293 extern rtx prev_nonnote_insn            (rtx) ;
294 extern rtx next_nonnote_insn            (rtx) ;
295 extern rtx prev_real_insn               (rtx) ;
296 extern rtx next_real_insn               (rtx) ;
297 extern rtx prev_active_insn             (rtx) ;
298 extern rtx next_active_insn             (rtx) ;
299 extern rtx prev_label                   (rtx) ;
300 extern rtx next_label                   (rtx) ;
301 extern rtx next_cc0_user                (rtx) ;
302 extern rtx prev_cc0_setter              (rtx) ;
303 extern rtx reg_set_last                 (rtx, rtx) ;
304 extern rtx next_nondeleted_insn         (rtx) ;
305 extern enum rtx_code reverse_condition  (enum rtx_code) ;
306 extern enum rtx_code swap_condition     (enum rtx_code) ;
307 extern enum rtx_code unsigned_condition (enum rtx_code) ;
308 extern enum rtx_code signed_condition   (enum rtx_code) ;
309 extern rtx find_equiv_reg               (rtx, rtx, enum reg_class, int, short *, int, enum machine_mode) ;
310 extern rtx squeeze_notes                (rtx, rtx) ;
311 extern rtx delete_insn                  (rtx) ;
312 extern void delete_jump                 (rtx) ;
313 extern rtx get_label_before             (rtx) ;
314 extern rtx get_label_after              (rtx) ;
315 extern rtx follow_jumps                 (rtx) ;
316 extern rtx adj_offsettable_operand      (rtx, int) ;
317 extern rtx try_split                    (rtx, rtx, int) ;
318 extern rtx split_insns                  (rtx, rtx) ;
319 extern rtx simplify_unary_operation     (enum rtx_code, enum machine_mode, rtx, enum machine_mode) ;
320 extern rtx simplify_binary_operation    (enum rtx_code, enum machine_mode, rtx, rtx) ;
321 extern rtx simplify_ternary_operation   (enum rtx_code, enum machine_mode, enum machine_mode, rtx, rtx, rtx) ;
322 extern rtx simplify_relational_operation (enum rtx_code, enum machine_mode, rtx, rtx) ;
323 extern rtx nonlocal_label_rtx_list      (void) ;
324 extern rtx gen_move_insn                (rtx, rtx) ;
325 extern rtx gen_jump                     (rtx) ;
326 extern rtx gen_beq                      (rtx) ;
327 extern rtx gen_bge                      (rtx) ;
328 extern rtx gen_ble                      (rtx) ;
329 extern rtx eliminate_constant_term      (rtx, rtx *) ;
330 extern rtx expand_complex_abs           (enum machine_mode, rtx, rtx, int) ;
331 extern int max_parallel;
332 extern int asm_noperands                (rtx) ;
333 extern char *decode_asm_operands        (rtx, rtx *, rtx **, char **, enum machine_mode *) ;
334 extern enum reg_class reg_preferred_class (int) ;
335 extern enum reg_class reg_alternate_class (int) ;
336 extern rtx get_first_nonparm_insn       (void) ;
337 extern rtx pc_rtx;
338 extern rtx cc0_rtx;
339 extern rtx const0_rtx;
340 extern rtx const1_rtx;
341 extern rtx const2_rtx;
342 extern rtx constm1_rtx;
343 extern rtx const_true_rtx;
344 extern rtx const_tiny_rtx[3][(int) MAX_MACHINE_MODE];
345 extern rtx stack_pointer_rtx;
346 extern rtx frame_pointer_rtx;
347 extern rtx arg_pointer_rtx;
348 extern rtx pic_offset_table_rtx;
349 extern rtx struct_value_rtx;
350 extern rtx struct_value_incoming_rtx;
351 extern rtx static_chain_rtx;
352 extern rtx static_chain_incoming_rtx;
353 extern rtx virtual_incoming_args_rtx;
354 extern rtx virtual_stack_vars_rtx;
355 extern rtx virtual_stack_dynamic_rtx;
356 extern rtx virtual_outgoing_args_rtx;
357 extern rtx find_next_ref                (rtx, rtx) ;
358 extern rtx *find_single_use             (rtx, rtx, rtx *) ;
359 extern rtx expand_expr ();
360 extern rtx immed_real_const_1();
361 extern rtx output_constant_def ();
362 extern rtx immed_real_const ();
363 extern rtx immed_real_const_1 ();
364 extern int reload_completed;
365 extern int reload_in_progress;
366 extern int cse_not_expected;
367 extern rtx *regno_reg_rtx;
368 enum tree_code {
369   ERROR_MARK, 
370   IDENTIFIER_NODE, 
371   OP_IDENTIFIER, 
372   TREE_LIST, 
373   TREE_VEC, 
374   BLOCK, 
375   VOID_TYPE,     
376   INTEGER_TYPE, 
377   REAL_TYPE, 
378   COMPLEX_TYPE, 
379   ENUMERAL_TYPE, 
380   BOOLEAN_TYPE, 
381   CHAR_TYPE, 
382   POINTER_TYPE, 
383   OFFSET_TYPE, 
384   REFERENCE_TYPE, 
385   METHOD_TYPE, 
386   FILE_TYPE, 
387   ARRAY_TYPE, 
388   SET_TYPE, 
389   STRING_TYPE, 
390   RECORD_TYPE, 
391   UNION_TYPE,    
392   FUNCTION_TYPE, 
393   LANG_TYPE, 
394   INTEGER_CST, 
395   REAL_CST, 
396   COMPLEX_CST, 
397   STRING_CST, 
398   FUNCTION_DECL, 
399   LABEL_DECL, 
400   CONST_DECL, 
401   TYPE_DECL, 
402   VAR_DECL, 
403   PARM_DECL, 
404   RESULT_DECL, 
405   FIELD_DECL, 
406   COMPONENT_REF, 
407   BIT_FIELD_REF, 
408   INDIRECT_REF, 
409   OFFSET_REF, 
410   BUFFER_REF, 
411   ARRAY_REF, 
412   CONSTRUCTOR, 
413   COMPOUND_EXPR, 
414   MODIFY_EXPR, 
415   INIT_EXPR, 
416   TARGET_EXPR, 
417   COND_EXPR, 
418   BIND_EXPR, 
419   CALL_EXPR, 
420   METHOD_CALL_EXPR, 
421   WITH_CLEANUP_EXPR, 
422   PLUS_EXPR, 
423   MINUS_EXPR, 
424   MULT_EXPR, 
425   TRUNC_DIV_EXPR, 
426   CEIL_DIV_EXPR, 
427   FLOOR_DIV_EXPR, 
428   ROUND_DIV_EXPR, 
429   TRUNC_MOD_EXPR, 
430   CEIL_MOD_EXPR, 
431   FLOOR_MOD_EXPR, 
432   ROUND_MOD_EXPR, 
433   RDIV_EXPR, 
434   EXACT_DIV_EXPR, 
435   FIX_TRUNC_EXPR, 
436   FIX_CEIL_EXPR, 
437   FIX_FLOOR_EXPR, 
438   FIX_ROUND_EXPR, 
439   FLOAT_EXPR, 
440   EXPON_EXPR, 
441   NEGATE_EXPR, 
442   MIN_EXPR, 
443   MAX_EXPR, 
444   ABS_EXPR, 
445   FFS_EXPR, 
446   LSHIFT_EXPR, 
447   RSHIFT_EXPR, 
448   LROTATE_EXPR, 
449   RROTATE_EXPR, 
450   BIT_IOR_EXPR, 
451   BIT_XOR_EXPR, 
452   BIT_AND_EXPR, 
453   BIT_ANDTC_EXPR, 
454   BIT_NOT_EXPR, 
455   TRUTH_ANDIF_EXPR, 
456   TRUTH_ORIF_EXPR, 
457   TRUTH_AND_EXPR, 
458   TRUTH_OR_EXPR, 
459   TRUTH_NOT_EXPR, 
460   LT_EXPR, 
461   LE_EXPR, 
462   GT_EXPR, 
463   GE_EXPR, 
464   EQ_EXPR, 
465   NE_EXPR, 
466   IN_EXPR, 
467   SET_LE_EXPR, 
468   CARD_EXPR, 
469   RANGE_EXPR, 
470   CONVERT_EXPR, 
471   NOP_EXPR, 
472   NON_LVALUE_EXPR, 
473   SAVE_EXPR, 
474   RTL_EXPR, 
475   ADDR_EXPR, 
476   REFERENCE_EXPR, 
477   ENTRY_VALUE_EXPR, 
478   COMPLEX_EXPR, 
479   CONJ_EXPR, 
480   REALPART_EXPR, 
481   IMAGPART_EXPR, 
482   PREDECREMENT_EXPR, 
483   PREINCREMENT_EXPR, 
484   POSTDECREMENT_EXPR, 
485   POSTINCREMENT_EXPR, 
486   LABEL_EXPR, 
487   GOTO_EXPR, 
488   RETURN_EXPR, 
489   EXIT_EXPR, 
490   LOOP_EXPR, 
491   LAST_AND_UNUSED_TREE_CODE      
492 };
493 extern char **tree_code_type;
494 extern int *tree_code_length;
495 extern char **tree_code_name;
496 enum built_in_function
497 {
498   NOT_BUILT_IN,
499   BUILT_IN_ALLOCA,
500   BUILT_IN_ABS,
501   BUILT_IN_FABS,
502   BUILT_IN_LABS,
503   BUILT_IN_FFS,
504   BUILT_IN_DIV,
505   BUILT_IN_LDIV,
506   BUILT_IN_FFLOOR,
507   BUILT_IN_FCEIL,
508   BUILT_IN_FMOD,
509   BUILT_IN_FREM,
510   BUILT_IN_MEMCPY,
511   BUILT_IN_MEMCMP,
512   BUILT_IN_MEMSET,
513   BUILT_IN_STRCPY,
514   BUILT_IN_STRCMP,
515   BUILT_IN_STRLEN,
516   BUILT_IN_FSQRT,
517   BUILT_IN_SIN,
518   BUILT_IN_COS,
519   BUILT_IN_GETEXP,
520   BUILT_IN_GETMAN,
521   BUILT_IN_SAVEREGS,
522   BUILT_IN_CLASSIFY_TYPE,
523   BUILT_IN_NEXT_ARG,
524   BUILT_IN_ARGS_INFO,
525   BUILT_IN_CONSTANT_P,
526   BUILT_IN_FRAME_ADDRESS,
527   BUILT_IN_RETURN_ADDRESS,
528   BUILT_IN_CALLER_RETURN_ADDRESS,
529   BUILT_IN_NEW,
530   BUILT_IN_VEC_NEW,
531   BUILT_IN_DELETE,
532   BUILT_IN_VEC_DELETE
533 };
534 typedef union tree_node *tree;
535 struct tree_common
536 {
537   union tree_node *chain;
538   union tree_node *type;
539   enum tree_code code : 8;
540   unsigned side_effects_flag : 1;
541   unsigned constant_flag : 1;
542   unsigned permanent_flag : 1;
543   unsigned addressable_flag : 1;
544   unsigned volatile_flag : 1;
545   unsigned readonly_flag : 1;
546   unsigned unsigned_flag : 1;
547   unsigned asm_written_flag: 1;
548   unsigned used_flag : 1;
549   unsigned raises_flag : 1;
550   unsigned static_flag : 1;
551   unsigned public_flag : 1;
552   unsigned private_flag : 1;
553   unsigned protected_flag : 1;
554   unsigned lang_flag_0 : 1;
555   unsigned lang_flag_1 : 1;
556   unsigned lang_flag_2 : 1;
557   unsigned lang_flag_3 : 1;
558   unsigned lang_flag_4 : 1;
559   unsigned lang_flag_5 : 1;
560   unsigned lang_flag_6 : 1;
561 };
562 struct tree_int_cst
563 {
564   char common[sizeof (struct tree_common)];
565   int  int_cst_low;
566   int  int_cst_high;
567 };
568 extern double ldexp ();
569 extern double (atof) ();
570 extern double  real_value_truncate ();
571 extern double  dconst0;
572 extern double  dconst1;
573 extern double  dconst2;
574 extern double  dconstm1;
575 union real_extract 
576 {
577   double  d;
578   int  i[sizeof (double ) / sizeof (int )];
579 };
580 double  real_value_from_int_cst ();
581 struct tree_real_cst
582 {
583   char common[sizeof (struct tree_common)];
584   struct rtx_def *rtl;   
585   double  real_cst;
586 };
587 struct tree_string
588 {
589   char common[sizeof (struct tree_common)];
590   struct rtx_def *rtl;   
591   int length;
592   char *pointer;
593 };
594 struct tree_complex
595 {
596   char common[sizeof (struct tree_common)];
597   struct rtx_def *rtl;   
598   union tree_node *real;
599   union tree_node *imag;
600 };
601 struct tree_identifier
602 {
603   char common[sizeof (struct tree_common)];
604   int length;
605   char *pointer;
606 };
607 struct tree_list
608 {
609   char common[sizeof (struct tree_common)];
610   union tree_node *purpose;
611   union tree_node *value;
612 };
613 struct tree_vec
614 {
615   char common[sizeof (struct tree_common)];
616   int length;
617   union tree_node *a[1];
618 };
619 struct tree_exp
620 {
621   char common[sizeof (struct tree_common)];
622   int complexity;
623   union tree_node *operands[1];
624 };
625 struct tree_block
626 {
627   char common[sizeof (struct tree_common)];
628   unsigned handler_block_flag : 1;
629   unsigned abstract_flag : 1;
630   union tree_node *vars;
631   union tree_node *type_tags;
632   union tree_node *subblocks;
633   union tree_node *supercontext;
634   union tree_node *abstract_origin;
635   struct rtx_def *end_note;
636 };
637 struct tree_type
638 {
639   char common[sizeof (struct tree_common)];
640   union tree_node *values;
641   union tree_node *size;
642   unsigned uid;
643   enum machine_mode mode : 8;
644   unsigned char precision;
645   unsigned no_force_blk_flag : 1;
646   unsigned lang_flag_0 : 1;
647   unsigned lang_flag_1 : 1;
648   unsigned lang_flag_2 : 1;
649   unsigned lang_flag_3 : 1;
650   unsigned lang_flag_4 : 1;
651   unsigned lang_flag_5 : 1;
652   unsigned lang_flag_6 : 1;
653   unsigned int align;
654   union tree_node *pointer_to;
655   union tree_node *reference_to;
656   int parse_info;
657   int symtab_address;
658   union tree_node *name;
659   union tree_node *minval;
660   union tree_node *maxval;
661   union tree_node *next_variant;
662   union tree_node *main_variant;
663   union tree_node *binfo;
664   union tree_node *noncopied_parts;
665   union tree_node *context;
666   struct lang_type *lang_specific;
667 };
668 struct tree_decl
669 {
670   char common[sizeof (struct tree_common)];
671   char *filename;
672   int linenum;
673   union tree_node *size;
674   unsigned int uid;
675   enum machine_mode mode : 8;
676   unsigned external_flag : 1;
677   unsigned nonlocal_flag : 1;
678   unsigned regdecl_flag : 1;
679   unsigned inline_flag : 1;
680   unsigned bit_field_flag : 1;
681   unsigned virtual_flag : 1;
682   unsigned ignored_flag : 1;
683   unsigned abstract_flag : 1;
684   unsigned in_system_header_flag : 1;
685   unsigned lang_flag_0 : 1;
686   unsigned lang_flag_1 : 1;
687   unsigned lang_flag_2 : 1;
688   unsigned lang_flag_3 : 1;
689   unsigned lang_flag_4 : 1;
690   unsigned lang_flag_5 : 1;
691   unsigned lang_flag_6 : 1;
692   unsigned lang_flag_7 : 1;
693   union tree_node *name;
694   union tree_node *context;
695   union tree_node *arguments;
696   union tree_node *result;
697   union tree_node *initial;
698   union tree_node *abstract_origin;
699   char *print_name;
700   union tree_node *assembler_name;
701   struct rtx_def *rtl;   
702   int frame_size;
703   union {
704     struct rtx_def *r;
705     int i;
706   } saved_insns;
707   union tree_node *vindex;
708   struct lang_decl *lang_specific;
709 };
710 union tree_node
711 {
712   struct tree_common common;
713   struct tree_int_cst int_cst;
714   struct tree_real_cst real_cst;
715   struct tree_string string;
716   struct tree_complex complex;
717   struct tree_identifier identifier;
718   struct tree_decl decl;
719   struct tree_type type;
720   struct tree_list list;
721   struct tree_vec vec;
722   struct tree_exp exp;
723   struct tree_block block;
724  };
725 extern char *xrealloc ();
726 extern char *oballoc                    (int) ;
727 extern char *permalloc                  (int) ;
728 extern char *savealloc                  (int) ;
729 extern char *xmalloc                    (unsigned) ;
730 extern void free                        (void *) ;
731 extern tree make_node                   (enum tree_code) ;
732 extern tree copy_node                   (tree) ;
733 extern tree copy_list                   (tree) ;
734 extern tree make_tree_vec               (int) ;
735 extern tree get_identifier              (char *) ;
736 extern tree build ();
737 extern tree build_nt ();
738 extern tree build_parse_node ();
739 extern tree build_int_2_wide            (int , int ) ;
740 extern tree build_real                  (tree, double ) ;
741 extern tree build_real_from_int_cst     (tree, tree) ;
742 extern tree build_complex               (tree, tree) ;
743 extern tree build_string                (int, char *) ;
744 extern tree build1                      (enum tree_code, tree, tree) ;
745 extern tree build_tree_list             (tree, tree) ;
746 extern tree build_decl_list             (tree, tree) ;
747 extern tree build_decl                  (enum tree_code, tree, tree) ;
748 extern tree build_block                 (tree, tree, tree, tree, tree) ;
749 extern tree make_signed_type            (int) ;
750 extern tree make_unsigned_type          (int) ;
751 extern tree signed_or_unsigned_type     (int, tree) ;
752 extern void fixup_unsigned_type         (tree) ;
753 extern tree build_pointer_type          (tree) ;
754 extern tree build_reference_type        (tree) ;
755 extern tree build_index_type            (tree) ;
756 extern tree build_index_2_type          (tree, tree) ;
757 extern tree build_array_type            (tree, tree) ;
758 extern tree build_function_type         (tree, tree) ;
759 extern tree build_method_type           (tree, tree) ;
760 extern tree build_offset_type           (tree, tree) ;
761 extern tree build_complex_type          (tree) ;
762 extern tree array_type_nelts            (tree) ;
763 extern tree build_binary_op ();
764 extern tree build_indirect_ref ();
765 extern tree build_unary_op              (enum tree_code, tree, int) ;
766 extern tree make_tree ();
767 extern tree build_type_variant          (tree, int, int) ;
768 extern tree build_type_copy             (tree) ;
769 extern void layout_type                 (tree) ;
770 extern tree type_hash_canon             (int, tree) ;
771 extern void layout_decl                 (tree, unsigned) ;
772 extern tree fold                        (tree) ;
773 extern tree non_lvalue                  (tree) ;
774 extern tree convert                     (tree, tree) ;
775 extern tree size_in_bytes               (tree) ;
776 extern int int_size_in_bytes            (tree) ;
777 extern tree size_binop                  (enum tree_code, tree, tree) ;
778 extern tree size_int                    (unsigned) ;
779 extern tree round_up                    (tree, int) ;
780 extern tree get_pending_sizes           (void) ;
781 extern tree sizetype;
782 extern tree chainon                     (tree, tree) ;
783 extern tree tree_cons                   (tree, tree, tree) ;
784 extern tree perm_tree_cons              (tree, tree, tree) ;
785 extern tree temp_tree_cons              (tree, tree, tree) ;
786 extern tree saveable_tree_cons          (tree, tree, tree) ;
787 extern tree decl_tree_cons              (tree, tree, tree) ;
788 extern tree tree_last                   (tree) ;
789 extern tree nreverse                    (tree) ;
790 extern int list_length                  (tree) ;
791 extern int integer_zerop                (tree) ;
792 extern int integer_onep                 (tree) ;
793 extern int integer_all_onesp            (tree) ;
794 extern int integer_pow2p                (tree) ;
795 extern int staticp                      (tree) ;
796 extern int lvalue_or_else               (tree, char *) ;
797 extern tree save_expr                   (tree) ;
798 extern tree variable_size               (tree) ;
799 extern tree stabilize_reference         (tree) ;
800 extern tree get_unwidened               (tree, tree) ;
801 extern tree get_narrower                (tree, int *) ;
802 extern tree type_for_mode               (enum machine_mode, int) ;
803 extern tree type_for_size               (unsigned, int) ;
804 extern tree unsigned_type               (tree) ;
805 extern tree signed_type                 (tree) ;
806 extern tree maybe_build_cleanup         (tree) ;
807 extern tree get_inner_reference         (tree, int *, int *, tree *, enum machine_mode *, int *, int *) ;
808 extern tree decl_function_context       (tree) ;
809 extern tree decl_type_context           (tree) ;
810 extern char *function_cannot_inline_p   (tree) ;
811 extern tree integer_zero_node;
812 extern tree integer_one_node;
813 extern tree size_zero_node;
814 extern tree size_one_node;
815 extern tree null_pointer_node;
816 extern tree error_mark_node;
817 extern tree void_type_node;
818 extern tree integer_type_node;
819 extern tree unsigned_type_node;
820 extern tree char_type_node;
821 extern char *input_filename;
822 extern int lineno;
823 extern int pedantic;
824 extern int immediate_size_expand;
825 extern tree current_function_decl;
826 extern int current_function_calls_setjmp;
827 extern int current_function_calls_longjmp;
828 extern int all_types_permanent;
829 extern char *(*decl_printable_name) ();
830 extern char *perm_calloc                        (int, long) ;
831 extern tree expand_start_stmt_expr              (void) ;
832 extern tree expand_end_stmt_expr                (tree) ;
833 extern void expand_expr_stmt                    (tree) ;
834 extern void clear_last_expr                     (void) ;
835 extern void expand_label                        (tree) ;
836 extern void expand_goto                         (tree) ;
837 extern void expand_asm                          (tree) ;
838 extern void expand_start_cond                   (tree, int) ;
839 extern void expand_end_cond                     (void) ;
840 extern void expand_start_else                   (void) ;
841 extern void expand_start_elseif                 (tree) ;
842 extern struct nesting *expand_start_loop        (int) ;
843 extern struct nesting *expand_start_loop_continue_elsewhere     (int) ;
844 extern void expand_loop_continue_here           (void) ;
845 extern void expand_end_loop                     (void) ;
846 extern int expand_continue_loop                 (struct nesting *) ;
847 extern int expand_exit_loop                     (struct nesting *) ;
848 extern int expand_exit_loop_if_false            (struct nesting *, tree) ;
849 extern int expand_exit_something                (void) ;
850 extern void expand_null_return                  (void) ;
851 extern void expand_return                       (tree) ;
852 extern void expand_start_bindings               (int) ;
853 extern void expand_end_bindings                 (tree, int, int) ;
854 extern tree last_cleanup_this_contour           (void) ;
855 extern void expand_start_case                   (int, tree, tree, char *) ;
856 extern void expand_end_case                     (tree) ;
857 extern int pushcase                             (tree, tree, tree *) ;
858 extern int pushcase_range                       (tree, tree, tree, tree *) ;
859 extern tree invert_truthvalue                   (tree) ;
860 extern void init_lex                            (void) ;
861 extern void init_decl_processing                (void) ;
862 extern void lang_init                           (void) ;
863 extern void lang_finish                         (void) ;
864 extern int yyparse                              (void) ;
865 extern int lang_decode_option                   (char *) ;
866 extern void pushlevel                           (int) ;
867 extern tree poplevel                            (int, int, int) ;
868 extern void set_block                           (tree) ;
869 extern tree pushdecl                            (tree) ;
870 extern tree getdecls                            (void) ;
871 extern tree gettags                             (void) ;
872 extern char *main_input_filename;
873 enum debug_info_type
874 {
875   NO_DEBUG,          
876   DBX_DEBUG,         
877   SDB_DEBUG,         
878   DWARF_DEBUG,       
879   XCOFF_DEBUG        
880 };
881 extern enum debug_info_type write_symbols;
882 enum debug_info_level
883 {
884   DINFO_LEVEL_NONE,      
885   DINFO_LEVEL_TERSE,     
886   DINFO_LEVEL_NORMAL,    
887   DINFO_LEVEL_VERBOSE    
888 };
889 extern enum debug_info_level debug_info_level;
890 extern int use_gnu_debug_info_extensions;
891 extern int optimize;
892 extern int obey_regdecls;
893 extern int quiet_flag;
894 extern int inhibit_warnings;
895 extern int extra_warnings;
896 extern int warn_unused;
897 extern int warn_uninitialized;
898 extern int warn_shadow;
899 extern int warn_switch;
900 extern int warn_return_type;
901 extern int warn_cast_align;
902 extern int warn_id_clash;
903 extern int id_clash_len;
904 extern int warn_aggregate_return;
905 extern int profile_flag;
906 extern int profile_block_flag;
907 extern int pedantic;
908 extern int in_system_header;
909 extern int flag_print_asm_name;
910 extern int flag_signed_char;
911 extern int flag_short_enums;
912 extern int flag_caller_saves;
913 extern int flag_pcc_struct_return;
914 extern int flag_force_mem;
915 extern int flag_force_addr;
916 extern int flag_defer_pop;
917 extern int flag_float_store;
918 extern int flag_strength_reduce;
919 extern int flag_unroll_loops;
920 extern int flag_unroll_all_loops;
921 extern int flag_cse_follow_jumps;
922 extern int flag_cse_skip_blocks;
923 extern int flag_expensive_optimizations;
924 extern int flag_writable_strings;
925 extern int flag_no_function_cse;
926 extern int flag_omit_frame_pointer;
927 extern int flag_no_peephole;
928 extern int flag_volatile;
929 extern int flag_fast_math;
930 extern int flag_inline_functions;
931 extern int flag_keep_inline_functions;
932 extern int flag_no_inline;
933 extern int flag_syntax_only;
934 extern int flag_gen_aux_info;
935 extern int flag_shared_data;
936 extern int flag_schedule_insns;
937 extern int flag_schedule_insns_after_reload;
938 extern int flag_delayed_branch;
939 extern int flag_pretend_float;
940 extern int flag_pedantic_errors;
941 extern int flag_pic;
942 extern int flag_no_common;
943 extern int flag_inhibit_size_directive;
944 extern int flag_verbose_asm;
945 extern int flag_gnu_linker;
946 extern int frame_pointer_needed;
947 extern int can_reach_end;
948 extern int current_function_has_nonlocal_label;
949 struct var_refs_queue
950   {
951     rtx modified;
952     enum machine_mode promoted_mode;
953     int unsignedp;
954     struct var_refs_queue *next;
955   };
956 struct sequence_stack
957 {
958   rtx first, last;
959   struct sequence_stack *next;
960 };
961 extern struct sequence_stack *sequence_stack;
962 struct function
963 {
964   struct function *next;
965   char *name;
966   tree decl;
967   int pops_args;
968   int returns_struct;
969   int returns_pcc_struct;
970   int needs_context;
971   int calls_setjmp;
972   int calls_longjmp;
973   int calls_alloca;
974   int has_nonlocal_label;
975   rtx nonlocal_goto_handler_slot;
976   rtx nonlocal_goto_stack_level;
977   tree nonlocal_labels;
978   int args_size;
979   int pretend_args_size;
980   rtx arg_offset_rtx;
981   int max_parm_reg;
982   rtx *parm_reg_stack_loc;
983   int outgoing_args_size;
984   rtx return_rtx;
985   rtx cleanup_label;
986   rtx return_label;
987   rtx save_expr_regs;
988   rtx stack_slot_list;
989   rtx parm_birth_insn;
990   int frame_offset;
991   rtx tail_recursion_label;
992   rtx tail_recursion_reentry;
993   rtx internal_arg_pointer;
994   rtx arg_pointer_save_area;
995   tree rtl_expr_chain;
996   rtx last_parm_insn;
997   tree context_display;
998   tree trampoline_list;
999   int function_call_count;
1000   struct temp_slot *temp_slots;
1001   int temp_slot_level;
1002   struct var_refs_queue *fixup_var_refs_queue;
1003   struct nesting *block_stack;
1004   struct nesting *stack_block_stack;
1005   struct nesting *cond_stack;
1006   struct nesting *loop_stack;
1007   struct nesting *case_stack;
1008   struct nesting *nesting_stack;
1009   int nesting_depth;
1010   int block_start_count;
1011   tree last_expr_type;
1012   rtx last_expr_value;
1013   int expr_stmts_for_value;
1014   char *emit_filename;
1015   int emit_lineno;
1016   struct goto_fixup *goto_fixup_chain;
1017   int pending_stack_adjust;
1018   int inhibit_defer_pop;
1019   tree cleanups_this_call;
1020   rtx saveregs_value;
1021   rtx forced_labels;
1022   int reg_rtx_no;
1023   int first_label_num;
1024   rtx first_insn;
1025   rtx last_insn;
1026   struct sequence_stack *sequence_stack;
1027   int cur_insn_uid;
1028   int last_linenum;
1029   char *last_filename;
1030   char *regno_pointer_flag;
1031   int regno_pointer_flag_length;
1032   rtx *regno_reg_rtx;
1033   tree permanent_type_chain;
1034   tree temporary_type_chain;
1035   tree permanent_type_end;
1036   tree temporary_type_end;
1037   tree pending_sizes;
1038   int immediate_size_expand;
1039   int all_types_permanent;
1040   struct momentary_level *momentary_stack;
1041   char *maybepermanent_firstobj;
1042   char *temporary_firstobj;
1043   char *momentary_firstobj;
1044   struct obstack *current_obstack;
1045   struct obstack *function_obstack;
1046   struct obstack *function_maybepermanent_obstack;
1047   struct obstack *expression_obstack;
1048   struct obstack *saveable_obstack;
1049   struct obstack *rtl_obstack;
1050   int uses_const_pool;
1051   int uses_pic_offset_table;
1052   rtx epilogue_delay_list;
1053   struct constant_descriptor **const_rtx_hash_table;
1054   struct pool_sym **const_rtx_sym_hash_table;
1055   struct pool_constant *first_pool, *last_pool;
1056   int pool_offset;
1057 };
1058 extern tree inline_function_decl;
1059 extern rtx return_label;
1060 extern rtx stack_slot_list;
1061 struct function *find_function_data ();
1062 extern struct function *outer_function_chain;
1063 tree *identify_blocks ();
1064 extern rtx gen_cmpsi            (rtx, rtx) ;
1065 extern rtx gen_cmpsf            (rtx, rtx) ;
1066 extern rtx gen_cmpdf            (rtx, rtx) ;
1067 extern rtx gen_cmptf            (rtx, rtx) ;
1068 extern rtx gen_seq_special      (rtx, rtx, rtx) ;
1069 extern rtx gen_sne_special      (rtx, rtx, rtx) ;
1070 extern rtx gen_seq              (rtx) ;
1071 extern rtx gen_sne              (rtx) ;
1072 extern rtx gen_sgt              (rtx) ;
1073 extern rtx gen_slt              (rtx) ;
1074 extern rtx gen_sge              (rtx) ;
1075 extern rtx gen_sle              (rtx) ;
1076 extern rtx gen_sgtu             (rtx) ;
1077 extern rtx gen_sltu             (rtx) ;
1078 extern rtx gen_sgeu             (rtx) ;
1079 extern rtx gen_sleu             (rtx) ;
1080 extern rtx gen_beq              (rtx) ;
1081 extern rtx gen_bne              (rtx) ;
1082 extern rtx gen_bgt              (rtx) ;
1083 extern rtx gen_bgtu             (rtx) ;
1084 extern rtx gen_blt              (rtx) ;
1085 extern rtx gen_bltu             (rtx) ;
1086 extern rtx gen_bge              (rtx) ;
1087 extern rtx gen_bgeu             (rtx) ;
1088 extern rtx gen_ble              (rtx) ;
1089 extern rtx gen_bleu             (rtx) ;
1090 extern rtx gen_movsi            (rtx, rtx) ;
1091 extern rtx gen_reload_insi      (rtx, rtx, rtx) ;
1092 extern rtx gen_movhi            (rtx, rtx) ;
1093 extern rtx gen_movqi            (rtx, rtx) ;
1094 extern rtx gen_movstrsi         (rtx, rtx, rtx, rtx) ;
1095 extern rtx gen_movtf            (rtx, rtx) ;
1096 extern rtx gen_movdf            (rtx, rtx) ;
1097 extern rtx gen_movdi            (rtx, rtx) ;
1098 extern rtx gen_movsf            (rtx, rtx) ;
1099 extern rtx gen_zero_extendhisi2 (rtx, rtx) ;
1100 extern rtx gen_zero_extendqihi2 (rtx, rtx) ;
1101 extern rtx gen_zero_extendqisi2 (rtx, rtx) ;
1102 extern rtx gen_extendhisi2      (rtx, rtx) ;
1103 extern rtx gen_extendqihi2      (rtx, rtx) ;
1104 extern rtx gen_extendqisi2      (rtx, rtx) ;
1105 extern rtx gen_extendsfdf2      (rtx, rtx) ;
1106 extern rtx gen_extendsftf2      (rtx, rtx) ;
1107 extern rtx gen_extenddftf2      (rtx, rtx) ;
1108 extern rtx gen_truncdfsf2       (rtx, rtx) ;
1109 extern rtx gen_trunctfsf2       (rtx, rtx) ;
1110 extern rtx gen_trunctfdf2       (rtx, rtx) ;
1111 extern rtx gen_floatsisf2       (rtx, rtx) ;
1112 extern rtx gen_floatsidf2       (rtx, rtx) ;
1113 extern rtx gen_floatsitf2       (rtx, rtx) ;
1114 extern rtx gen_fix_truncsfsi2   (rtx, rtx) ;
1115 extern rtx gen_fix_truncdfsi2   (rtx, rtx) ;
1116 extern rtx gen_fix_trunctfsi2   (rtx, rtx) ;
1117 extern rtx gen_adddi3           (rtx, rtx, rtx) ;
1118 extern rtx gen_addsi3           (rtx, rtx, rtx) ;
1119 extern rtx gen_subdi3           (rtx, rtx, rtx) ;
1120 extern rtx gen_subsi3           (rtx, rtx, rtx) ;
1121 extern rtx gen_mulsi3           (rtx, rtx, rtx) ;
1122 extern rtx gen_mulsidi3         (rtx, rtx, rtx) ;
1123 extern rtx gen_umulsidi3        (rtx, rtx, rtx) ;
1124 extern rtx gen_divsi3           (rtx, rtx, rtx) ;
1125 extern rtx gen_udivsi3          (rtx, rtx, rtx) ;
1126 extern rtx gen_anddi3           (rtx, rtx, rtx) ;
1127 extern rtx gen_andsi3           (rtx, rtx, rtx) ;
1128 extern rtx gen_iordi3           (rtx, rtx, rtx) ;
1129 extern rtx gen_iorsi3           (rtx, rtx, rtx) ;
1130 extern rtx gen_xordi3           (rtx, rtx, rtx) ;
1131 extern rtx gen_xorsi3           (rtx, rtx, rtx) ;
1132 extern rtx gen_negdi2           (rtx, rtx) ;
1133 extern rtx gen_negsi2           (rtx, rtx) ;
1134 extern rtx gen_one_cmpldi2      (rtx, rtx) ;
1135 extern rtx gen_one_cmplsi2      (rtx, rtx) ;
1136 extern rtx gen_addtf3           (rtx, rtx, rtx) ;
1137 extern rtx gen_adddf3           (rtx, rtx, rtx) ;
1138 extern rtx gen_addsf3           (rtx, rtx, rtx) ;
1139 extern rtx gen_subtf3           (rtx, rtx, rtx) ;
1140 extern rtx gen_subdf3           (rtx, rtx, rtx) ;
1141 extern rtx gen_subsf3           (rtx, rtx, rtx) ;
1142 extern rtx gen_multf3           (rtx, rtx, rtx) ;
1143 extern rtx gen_muldf3           (rtx, rtx, rtx) ;
1144 extern rtx gen_mulsf3           (rtx, rtx, rtx) ;
1145 extern rtx gen_divtf3           (rtx, rtx, rtx) ;
1146 extern rtx gen_divdf3           (rtx, rtx, rtx) ;
1147 extern rtx gen_divsf3           (rtx, rtx, rtx) ;
1148 extern rtx gen_negtf2           (rtx, rtx) ;
1149 extern rtx gen_negdf2           (rtx, rtx) ;
1150 extern rtx gen_negsf2           (rtx, rtx) ;
1151 extern rtx gen_abstf2           (rtx, rtx) ;
1152 extern rtx gen_absdf2           (rtx, rtx) ;
1153 extern rtx gen_abssf2           (rtx, rtx) ;
1154 extern rtx gen_sqrttf2          (rtx, rtx) ;
1155 extern rtx gen_sqrtdf2          (rtx, rtx) ;
1156 extern rtx gen_sqrtsf2          (rtx, rtx) ;
1157 extern rtx gen_ashldi3          (rtx, rtx, rtx) ;
1158 extern rtx gen_ashlsi3          (rtx, rtx, rtx) ;
1159 extern rtx gen_ashrsi3          (rtx, rtx, rtx) ;
1160 extern rtx gen_lshrsi3          (rtx, rtx, rtx) ;
1161 extern rtx gen_jump             (rtx) ;
1162 extern rtx gen_tablejump        (rtx, rtx) ;
1163 extern rtx gen_pic_tablejump    (rtx, rtx) ;
1164 extern rtx gen_return           (void) ;
1165 extern rtx gen_nop              (void) ;
1166 extern rtx gen_indirect_jump    (rtx) ;
1167 extern rtx gen_nonlocal_goto    (rtx, rtx, rtx, rtx) ;
1168 extern rtx gen_call ();
1169 extern rtx gen_call_value ();
1170 enum insn_code {
1171   CODE_FOR_cmpsi = 0,
1172   CODE_FOR_cmpsf = 1,
1173   CODE_FOR_cmpdf = 2,
1174   CODE_FOR_cmptf = 3,
1175   CODE_FOR_seq_special = 4,
1176   CODE_FOR_sne_special = 5,
1177   CODE_FOR_seq = 6,
1178   CODE_FOR_sne = 7,
1179   CODE_FOR_sgt = 8,
1180   CODE_FOR_slt = 9,
1181   CODE_FOR_sge = 10,
1182   CODE_FOR_sle = 11,
1183   CODE_FOR_sgtu = 12,
1184   CODE_FOR_sltu = 13,
1185   CODE_FOR_sgeu = 14,
1186   CODE_FOR_sleu = 15,
1187   CODE_FOR_beq = 45,
1188   CODE_FOR_bne = 46,
1189   CODE_FOR_bgt = 47,
1190   CODE_FOR_bgtu = 48,
1191   CODE_FOR_blt = 49,
1192   CODE_FOR_bltu = 50,
1193   CODE_FOR_bge = 51,
1194   CODE_FOR_bgeu = 52,
1195   CODE_FOR_ble = 53,
1196   CODE_FOR_bleu = 54,
1197   CODE_FOR_movsi = 57,
1198   CODE_FOR_reload_insi = 58,
1199   CODE_FOR_movhi = 69,
1200   CODE_FOR_movqi = 73,
1201   CODE_FOR_movstrsi = 77,
1202   CODE_FOR_movtf = 80,
1203   CODE_FOR_movdf = 84,
1204   CODE_FOR_movdi = 87,
1205   CODE_FOR_movsf = 90,
1206   CODE_FOR_zero_extendhisi2 = 93,
1207   CODE_FOR_zero_extendqihi2 = 95,
1208   CODE_FOR_zero_extendqisi2 = 97,
1209   CODE_FOR_extendhisi2 = 101,
1210   CODE_FOR_extendqihi2 = 103,
1211   CODE_FOR_extendqisi2 = 105,
1212   CODE_FOR_extendsfdf2 = 108,
1213   CODE_FOR_extendsftf2 = 109,
1214   CODE_FOR_extenddftf2 = 110,
1215   CODE_FOR_truncdfsf2 = 111,
1216   CODE_FOR_trunctfsf2 = 112,
1217   CODE_FOR_trunctfdf2 = 113,
1218   CODE_FOR_floatsisf2 = 114,
1219   CODE_FOR_floatsidf2 = 115,
1220   CODE_FOR_floatsitf2 = 116,
1221   CODE_FOR_fix_truncsfsi2 = 117,
1222   CODE_FOR_fix_truncdfsi2 = 118,
1223   CODE_FOR_fix_trunctfsi2 = 119,
1224   CODE_FOR_adddi3 = 120,
1225   CODE_FOR_addsi3 = 121,
1226   CODE_FOR_subdi3 = 124,
1227   CODE_FOR_subsi3 = 125,
1228   CODE_FOR_mulsi3 = 128,
1229   CODE_FOR_mulsidi3 = 130,
1230   CODE_FOR_umulsidi3 = 131,
1231   CODE_FOR_divsi3 = 132,
1232   CODE_FOR_udivsi3 = 134,
1233   CODE_FOR_anddi3 = 136,
1234   CODE_FOR_andsi3 = 138,
1235   CODE_FOR_iordi3 = 142,
1236   CODE_FOR_iorsi3 = 144,
1237   CODE_FOR_xordi3 = 148,
1238   CODE_FOR_xorsi3 = 150,
1239   CODE_FOR_negdi2 = 161,
1240   CODE_FOR_negsi2 = 162,
1241   CODE_FOR_one_cmpldi2 = 165,
1242   CODE_FOR_one_cmplsi2 = 167,
1243   CODE_FOR_addtf3 = 170,
1244   CODE_FOR_adddf3 = 171,
1245   CODE_FOR_addsf3 = 172,
1246   CODE_FOR_subtf3 = 173,
1247   CODE_FOR_subdf3 = 174,
1248   CODE_FOR_subsf3 = 175,
1249   CODE_FOR_multf3 = 176,
1250   CODE_FOR_muldf3 = 177,
1251   CODE_FOR_mulsf3 = 178,
1252   CODE_FOR_divtf3 = 179,
1253   CODE_FOR_divdf3 = 180,
1254   CODE_FOR_divsf3 = 181,
1255   CODE_FOR_negtf2 = 182,
1256   CODE_FOR_negdf2 = 183,
1257   CODE_FOR_negsf2 = 184,
1258   CODE_FOR_abstf2 = 185,
1259   CODE_FOR_absdf2 = 186,
1260   CODE_FOR_abssf2 = 187,
1261   CODE_FOR_sqrttf2 = 188,
1262   CODE_FOR_sqrtdf2 = 189,
1263   CODE_FOR_sqrtsf2 = 190,
1264   CODE_FOR_ashldi3 = 191,
1265   CODE_FOR_ashlsi3 = 193,
1266   CODE_FOR_ashrsi3 = 194,
1267   CODE_FOR_lshrsi3 = 195,
1268   CODE_FOR_jump = 196,
1269   CODE_FOR_tablejump = 197,
1270   CODE_FOR_pic_tablejump = 198,
1271   CODE_FOR_call = 201,
1272   CODE_FOR_call_value = 204,
1273   CODE_FOR_return = 206,
1274   CODE_FOR_nop = 207,
1275   CODE_FOR_indirect_jump = 208,
1276   CODE_FOR_nonlocal_goto = 209,
1277   CODE_FOR_nothing };
1278 enum expand_modifier {EXPAND_NORMAL, EXPAND_SUM,
1279                       EXPAND_CONST_ADDRESS, EXPAND_INITIALIZER};
1280 extern rtx forced_labels;
1281 extern rtx save_expr_regs;
1282 extern int current_function_calls_alloca;
1283 extern int current_function_outgoing_args_size;
1284 extern rtx current_function_arg_offset_rtx;
1285 extern int current_function_uses_const_pool;
1286 extern int current_function_uses_pic_offset_table;
1287 extern rtx current_function_internal_arg_pointer;
1288 extern int inhibit_defer_pop;
1289 extern int function_call_count;
1290 extern rtx nonlocal_goto_handler_slot;
1291 extern rtx nonlocal_goto_stack_level;
1292 extern tree nonlocal_labels;
1293 extern int pending_stack_adjust;
1294 extern tree cleanups_this_call;
1295 struct args_size
1296 {
1297   int constant;
1298   tree var;
1299 };
1300 enum direction {none, upward, downward};   
1301 typedef struct optab
1302 {
1303   enum rtx_code code;
1304   struct {
1305     enum insn_code insn_code;
1306     rtx libfunc;
1307   } handlers [(int) MAX_MACHINE_MODE ];
1308 } * optab;
1309 extern rtx (*const insn_gen_function[]) ();
1310 extern optab add_optab;
1311 extern optab sub_optab;
1312 extern optab smul_optab;         
1313 extern optab smul_widen_optab;   
1314 extern optab umul_widen_optab;
1315 extern optab sdiv_optab;         
1316 extern optab sdivmod_optab;      
1317 extern optab udiv_optab;
1318 extern optab udivmod_optab;
1319 extern optab smod_optab;         
1320 extern optab umod_optab;
1321 extern optab flodiv_optab;       
1322 extern optab ftrunc_optab;       
1323 extern optab and_optab;          
1324 extern optab ior_optab;          
1325 extern optab xor_optab;          
1326 extern optab ashl_optab;         
1327 extern optab ashr_optab;         
1328 extern optab lshl_optab;         
1329 extern optab lshr_optab;         
1330 extern optab rotl_optab;         
1331 extern optab rotr_optab;         
1332 extern optab smin_optab;         
1333 extern optab smax_optab;         
1334 extern optab umin_optab;         
1335 extern optab umax_optab;         
1336 extern optab mov_optab;          
1337 extern optab movstrict_optab;    
1338 extern optab cmp_optab;          
1339 extern optab tst_optab;          
1340 extern optab neg_optab;          
1341 extern optab abs_optab;          
1342 extern optab one_cmpl_optab;     
1343 extern optab ffs_optab;          
1344 extern optab sqrt_optab;         
1345 extern optab sin_optab;          
1346 extern optab cos_optab;          
1347 extern optab strlen_optab;       
1348 enum optab_methods
1349 {
1350   OPTAB_DIRECT,
1351   OPTAB_LIB,
1352   OPTAB_WIDEN,
1353   OPTAB_LIB_WIDEN,
1354   OPTAB_MUST_WIDEN
1355 };
1356 extern rtx extendsfdf2_libfunc;
1357 extern rtx extendsfxf2_libfunc;
1358 extern rtx extendsftf2_libfunc;
1359 extern rtx extenddfxf2_libfunc;
1360 extern rtx extenddftf2_libfunc;
1361 extern rtx truncdfsf2_libfunc;
1362 extern rtx truncxfsf2_libfunc;
1363 extern rtx trunctfsf2_libfunc;
1364 extern rtx truncxfdf2_libfunc;
1365 extern rtx trunctfdf2_libfunc;
1366 extern rtx memcpy_libfunc;
1367 extern rtx bcopy_libfunc;
1368 extern rtx memcmp_libfunc;
1369 extern rtx bcmp_libfunc;
1370 extern rtx memset_libfunc;
1371 extern rtx bzero_libfunc;
1372 extern rtx eqsf2_libfunc;
1373 extern rtx nesf2_libfunc;
1374 extern rtx gtsf2_libfunc;
1375 extern rtx gesf2_libfunc;
1376 extern rtx ltsf2_libfunc;
1377 extern rtx lesf2_libfunc;
1378 extern rtx eqdf2_libfunc;
1379 extern rtx nedf2_libfunc;
1380 extern rtx gtdf2_libfunc;
1381 extern rtx gedf2_libfunc;
1382 extern rtx ltdf2_libfunc;
1383 extern rtx ledf2_libfunc;
1384 extern rtx eqxf2_libfunc;
1385 extern rtx nexf2_libfunc;
1386 extern rtx gtxf2_libfunc;
1387 extern rtx gexf2_libfunc;
1388 extern rtx ltxf2_libfunc;
1389 extern rtx lexf2_libfunc;
1390 extern rtx eqtf2_libfunc;
1391 extern rtx netf2_libfunc;
1392 extern rtx gttf2_libfunc;
1393 extern rtx getf2_libfunc;
1394 extern rtx lttf2_libfunc;
1395 extern rtx letf2_libfunc;
1396 extern rtx floatsisf_libfunc;
1397 extern rtx floatdisf_libfunc;
1398 extern rtx floattisf_libfunc;
1399 extern rtx floatsidf_libfunc;
1400 extern rtx floatdidf_libfunc;
1401 extern rtx floattidf_libfunc;
1402 extern rtx floatsixf_libfunc;
1403 extern rtx floatdixf_libfunc;
1404 extern rtx floattixf_libfunc;
1405 extern rtx floatsitf_libfunc;
1406 extern rtx floatditf_libfunc;
1407 extern rtx floattitf_libfunc;
1408 extern rtx fixsfsi_libfunc;
1409 extern rtx fixsfdi_libfunc;
1410 extern rtx fixsfti_libfunc;
1411 extern rtx fixdfsi_libfunc;
1412 extern rtx fixdfdi_libfunc;
1413 extern rtx fixdfti_libfunc;
1414 extern rtx fixxfsi_libfunc;
1415 extern rtx fixxfdi_libfunc;
1416 extern rtx fixxfti_libfunc;
1417 extern rtx fixtfsi_libfunc;
1418 extern rtx fixtfdi_libfunc;
1419 extern rtx fixtfti_libfunc;
1420 extern rtx fixunssfsi_libfunc;
1421 extern rtx fixunssfdi_libfunc;
1422 extern rtx fixunssfti_libfunc;
1423 extern rtx fixunsdfsi_libfunc;
1424 extern rtx fixunsdfdi_libfunc;
1425 extern rtx fixunsdfti_libfunc;
1426 extern rtx fixunsxfsi_libfunc;
1427 extern rtx fixunsxfdi_libfunc;
1428 extern rtx fixunsxfti_libfunc;
1429 extern rtx fixunstfsi_libfunc;
1430 extern rtx fixunstfdi_libfunc;
1431 extern rtx fixunstfti_libfunc;
1432 typedef rtx (*rtxfun) ();
1433 extern rtxfun bcc_gen_fctn[((int)LAST_AND_UNUSED_RTX_CODE) ];
1434 extern enum insn_code setcc_gen_code[((int)LAST_AND_UNUSED_RTX_CODE) ];
1435 extern rtx expand_binop ();
1436 extern rtx sign_expand_binop ();
1437 extern rtx expand_unop ();
1438 extern rtx expand_complex_abs ();
1439 extern rtx negate_rtx ();
1440 extern rtx expand_and ();
1441 extern rtx emit_store_flag ();
1442 extern rtx label_rtx ();
1443 extern rtx get_condition ();
1444 extern enum insn_code can_extend_p ();
1445 extern void init_fixtab ();
1446 extern void init_floattab ();
1447 extern void expand_fix ();
1448 extern void expand_float ();
1449 extern rtx gen_add2_insn ();
1450 extern rtx gen_sub2_insn ();
1451 extern rtx gen_move_insn ();
1452 extern void emit_clr_insn ();
1453 extern void emit_0_to_1_insn ();
1454 extern void emit_cmp_insn ();
1455 extern rtx compare_from_rtx ();
1456 extern void convert_move ();
1457 extern rtx convert_to_mode ();
1458 extern void emit_library_call ();
1459 extern rtx force_operand ();
1460 extern rtx expr_size ();
1461 extern rtx lookup_static_chain ();
1462 extern rtx eliminate_constant_term ();
1463 extern rtx memory_address ();
1464 extern rtx memory_address_noforce ();
1465 extern rtx change_address ();
1466 extern rtx validize_mem ();
1467 extern rtx fix_lexical_addr ();
1468 extern rtx trampoline_address ();
1469 extern rtx assemble_trampoline_template ();
1470 extern int rtx_equal_p ();
1471 extern rtx stabilize ();
1472 extern rtx copy_all_regs ();
1473 extern rtx copy_to_reg ();
1474 extern rtx copy_addr_to_reg ();
1475 extern rtx copy_to_mode_reg ();
1476 extern rtx copy_to_suggested_reg ();
1477 extern rtx force_reg ();
1478 extern rtx force_not_mem ();
1479 extern void adjust_stack ();
1480 extern void anti_adjust_stack ();
1481 enum save_level {SAVE_BLOCK, SAVE_FUNCTION, SAVE_NONLOCAL};
1482 extern void emit_stack_save ();
1483 extern void emit_stack_restore ();
1484 extern rtx allocate_dynamic_stack_space ();
1485 extern rtx function_value ();
1486 extern rtx hard_function_value ();
1487 extern rtx hard_libcall_value ();
1488 extern void copy_function_value ();
1489 extern rtx round_push ();
1490 extern rtx push_block ();
1491 extern rtx store_expr ();
1492 extern rtx prepare_call_address ();
1493 extern rtx expand_call ();
1494 extern void emit_call_1 ();
1495 extern void emit_block_move ();
1496 extern void emit_push_insn ();
1497 extern void use_regs ();
1498 extern void move_block_to_reg ();
1499 extern rtx store_bit_field ();
1500 extern rtx extract_bit_field ();
1501 extern rtx expand_shift ();
1502 extern rtx expand_mult ();
1503 extern rtx expand_divmod ();
1504 extern rtx expand_mult_add ();
1505 extern rtx expand_stmt_expr ();
1506 extern rtx emit_no_conflict_block ();
1507 extern void emit_libcall_block ();
1508 extern void jumpifnot ();
1509 extern void jumpif ();
1510 extern void do_jump ();
1511 extern rtx assemble_static_space ();
1512 extern void locate_and_pad_parm ();
1513 extern rtx expand_inline_function ();
1514 extern rtx (*lang_expand_expr) ();
1515 extern int recog_memoized ();
1516 extern int validate_change ();
1517 extern int apply_change_group ();
1518 extern int num_validated_changes ();
1519 extern void cancel_changes ();
1520 extern int volatile_ok;
1521 extern void insn_extract ();
1522 extern rtx recog_operand[];
1523 extern rtx *recog_operand_loc[];
1524 extern rtx *recog_dup_loc[];
1525 extern char recog_dup_num[];
1526 extern char *const insn_template[];
1527 extern char *(*const insn_outfun[]) ();
1528 extern const int insn_n_operands[];
1529 extern const int insn_n_dups[];
1530 extern const int insn_n_alternatives[];
1531 extern char *const insn_operand_constraint[][10 ];
1532 extern const enum machine_mode insn_operand_mode[][10 ];
1533 extern const char insn_operand_strict_low[][10 ];
1534 extern int (*const insn_operand_predicate[][10 ]) ();
1535 extern char * insn_name[];
1536 extern void output_asm_insn ();
1537 extern void asm_fprintf ();
1538 extern void output_addr_const ();
1539 extern void assemble_name ();
1540 extern rtx alter_subreg ();
1541 extern int which_alternative;
1542 extern rtx final_sequence;
1543 extern int current_function_pops_args;
1544 extern int current_function_returns_struct;
1545 extern int current_function_returns_pcc_struct;
1546 extern int current_function_needs_context;
1547 extern int current_function_calls_setjmp;
1548 extern int current_function_calls_longjmp;
1549 extern int current_function_calls_alloca;
1550 extern int current_function_has_nonlocal_label;
1551 extern int current_function_contains_functions;
1552 extern int current_function_returns_pointer;
1553 extern int current_function_args_size;
1554 extern int current_function_pretend_args_size;
1555 extern int current_function_outgoing_args_size;
1556 extern int current_function_varargs;
1557 extern int  current_function_args_info;
1558 extern char *current_function_name;
1559 extern rtx current_function_return_rtx;
1560 extern rtx current_function_epilogue_delay_list;
1561 extern int flag_pic;
1562 extern int current_function_uses_pic_offset_table;
1563 extern int current_function_uses_const_pool;
1564 enum type_class
1565 {
1566   no_type_class = -1,
1567   void_type_class, integer_type_class, char_type_class,
1568   enumeral_type_class, boolean_type_class,
1569   pointer_type_class, reference_type_class, offset_type_class,
1570   real_type_class, complex_type_class,
1571   function_type_class, method_type_class,
1572   record_type_class, union_type_class,
1573   array_type_class, string_type_class, set_type_class, file_type_class,
1574   lang_type_class
1575 };
1576 int cse_not_expected;
1577 int do_preexpand_calls = 1;
1578 int pending_stack_adjust;
1579 int inhibit_defer_pop;
1580 tree cleanups_this_call;
1581 static rtx saveregs_value;
1582 rtx store_expr ();
1583 static void store_constructor ();
1584 static rtx store_field ();
1585 static rtx expand_builtin ();
1586 static rtx compare ();
1587 static rtx do_store_flag ();
1588 static void preexpand_calls ();
1589 static rtx expand_increment ();
1590 static void init_queue ();
1591 void do_pending_stack_adjust ();
1592 static void do_jump_for_compare ();
1593 static void do_jump_by_parts_equality ();
1594 static void do_jump_by_parts_equality_rtx ();
1595 static void do_jump_by_parts_greater ();
1596 static char direct_load[(int) MAX_MACHINE_MODE ];
1597 static char direct_store[(int) MAX_MACHINE_MODE ];
1598 static enum insn_code movstr_optab[(int) MAX_MACHINE_MODE ];
1599 void
1600 init_expr_once ()
1601 {
1602   rtx insn, pat;
1603   enum machine_mode mode;
1604   rtx mem = gen_rtx (MEM, VOIDmode, stack_pointer_rtx);
1605   rtx mem1 = gen_rtx (MEM, VOIDmode, frame_pointer_rtx);
1606   start_sequence ();
1607   insn = emit_insn (gen_rtx (SET, 0, 0));
1608   pat = ((insn)->fld[3].rtx) ;
1609   for (mode = VOIDmode; (int) mode < (int) MAX_MACHINE_MODE ;
1610        mode = (enum machine_mode) ((int) mode + 1))
1611     {
1612       int regno;
1613       rtx reg;
1614       int num_clobbers;
1615       direct_load[(int) mode] = direct_store[(int) mode] = 0;
1616       ((mem)->mode = ( mode)) ;
1617       ((mem1)->mode = ( mode)) ;
1618       if (mode != VOIDmode && mode != BLKmode)
1619         for (regno = 0; regno < 64 
1620              && (direct_load[(int) mode] == 0 || direct_store[(int) mode] == 0);
1621              regno++)
1622           {
1623             if (! ((hard_regno_mode_ok[regno] & (1<<(int)( mode))) != 0) )
1624               continue;
1625             reg = gen_rtx (REG, mode, regno);
1626             ((pat)->fld[1].rtx)  = mem;
1627             ((pat)->fld[0].rtx)  = reg;
1628             if (recog (pat, insn, &num_clobbers) >= 0)
1629               direct_load[(int) mode] = 1;
1630             ((pat)->fld[1].rtx)  = mem1;
1631             ((pat)->fld[0].rtx)  = reg;
1632             if (recog (pat, insn, &num_clobbers) >= 0)
1633               direct_load[(int) mode] = 1;
1634             ((pat)->fld[1].rtx)  = reg;
1635             ((pat)->fld[0].rtx)  = mem;
1636             if (recog (pat, insn, &num_clobbers) >= 0)
1637               direct_store[(int) mode] = 1;
1638             ((pat)->fld[1].rtx)  = reg;
1639             ((pat)->fld[0].rtx)  = mem1;
1640             if (recog (pat, insn, &num_clobbers) >= 0)
1641               direct_store[(int) mode] = 1;
1642           }
1643       movstr_optab[(int) mode] = CODE_FOR_nothing;
1644     }
1645   end_sequence ();
1646   if (1 )
1647     movstr_optab[(int) SImode] = CODE_FOR_movstrsi;
1648 }
1649 void
1650 init_expr ()
1651 {
1652   init_queue ();
1653   pending_stack_adjust = 0;
1654   inhibit_defer_pop = 0;
1655   cleanups_this_call = 0;
1656   saveregs_value = 0;
1657   forced_labels = 0;
1658 }
1659 void
1660 save_expr_status (p)
1661      struct function *p;
1662 {
1663   emit_queue ();
1664   p->pending_stack_adjust = pending_stack_adjust;
1665   p->inhibit_defer_pop = inhibit_defer_pop;
1666   p->cleanups_this_call = cleanups_this_call;
1667   p->saveregs_value = saveregs_value;
1668   p->forced_labels = forced_labels;
1669   pending_stack_adjust = 0;
1670   inhibit_defer_pop = 0;
1671   cleanups_this_call = 0;
1672   saveregs_value = 0;
1673   forced_labels = 0;
1674 }
1675 void
1676 restore_expr_status (p)
1677      struct function *p;
1678 {
1679   pending_stack_adjust = p->pending_stack_adjust;
1680   inhibit_defer_pop = p->inhibit_defer_pop;
1681   cleanups_this_call = p->cleanups_this_call;
1682   saveregs_value = p->saveregs_value;
1683   forced_labels = p->forced_labels;
1684 }
1685 static rtx pending_chain;
1686 static rtx
1687 enqueue_insn (var, body)
1688      rtx var, body;
1689 {
1690   pending_chain = gen_rtx (QUEUED,      ((var)->mode) ,
1691                            var, (rtx) 0 , (rtx) 0 , body, pending_chain);
1692   return pending_chain;
1693 }
1694 rtx
1695 protect_from_queue (x, modify)
1696      register rtx x;
1697      int modify;
1698 {
1699   register enum rtx_code  code =        ((x)->code) ;
1700   if (code != QUEUED)
1701     {
1702       if (code == MEM &&        ((x)->mode)  != BLKmode
1703           &&    ((((x)->fld[ 0].rtx) )->code)  == QUEUED && !modify)
1704         {
1705           register rtx y = ((x)->fld[ 0].rtx) ;
1706           ((x)->fld[ 0].rtx)  = ((y)->fld[ 0].rtx)  ;
1707           if (((y)->fld[ 1].rtx)  )
1708             {
1709               register rtx temp = gen_reg_rtx ( ((x)->mode) );
1710               emit_insn_before (gen_move_insn (temp, x),
1711                                 ((y)->fld[ 1].rtx)  );
1712               return temp;
1713             }
1714           return x;
1715         }
1716       if (code == MEM)
1717         ((x)->fld[ 0].rtx)  = protect_from_queue (((x)->fld[ 0].rtx) , 0);
1718       else if (code == PLUS || code == MULT)
1719         {
1720           ((x)->fld[ 0].rtx)  = protect_from_queue (((x)->fld[ 0].rtx) , 0);
1721           ((x)->fld[ 1].rtx)  = protect_from_queue (((x)->fld[ 1].rtx) , 0);
1722         }
1723       return x;
1724     }
1725   if (((x)->fld[ 1].rtx)   == 0)
1726     return ((x)->fld[ 0].rtx)  ;
1727   if (((x)->fld[ 2].rtx)   != 0)
1728     return ((x)->fld[ 2].rtx)  ;
1729   ((x)->fld[ 2].rtx)   = gen_reg_rtx (  ((((x)->fld[ 0].rtx)  )->mode) );
1730   emit_insn_before (gen_move_insn (((x)->fld[ 2].rtx)  , ((x)->fld[ 0].rtx)  ),
1731                     ((x)->fld[ 1].rtx)  );
1732   return ((x)->fld[ 2].rtx)  ;
1733 }
1734 static int
1735 queued_subexp_p (x)
1736      rtx x;
1737 {
1738   register enum rtx_code code =         ((x)->code) ;
1739   switch (code)
1740     {
1741     case QUEUED:
1742       return 1;
1743     case MEM:
1744       return queued_subexp_p (((x)->fld[ 0].rtx) );
1745     case MULT:
1746     case PLUS:
1747     case MINUS:
1748       return queued_subexp_p (((x)->fld[ 0].rtx) )
1749         || queued_subexp_p (((x)->fld[ 1].rtx) );
1750     }
1751   return 0;
1752 }
1753 void
1754 emit_queue ()
1755 {
1756   register rtx p;
1757   while (p = pending_chain)
1758     {
1759       ((p)->fld[ 1].rtx)   = emit_insn (((p)->fld[ 3].rtx)  );
1760       pending_chain = ((p)->fld[ 4].rtx)  ;
1761     }
1762 }
1763 static void
1764 init_queue ()
1765 {
1766   if (pending_chain)
1767     abort ();
1768 }
1769 void
1770 convert_move (to, from, unsignedp)
1771      register rtx to, from;
1772      int unsignedp;
1773 {
1774   enum machine_mode to_mode =   ((to)->mode) ;
1775   enum machine_mode from_mode =         ((from)->mode) ;
1776   int to_real =         (mode_class[(int)(to_mode)])  == MODE_FLOAT;
1777   int from_real =       (mode_class[(int)(from_mode)])  == MODE_FLOAT;
1778   enum insn_code code;
1779   rtx libcall;
1780   enum rtx_code equiv_code = (unsignedp ? ZERO_EXTEND : SIGN_EXTEND);
1781   to = protect_from_queue (to, 1);
1782   from = protect_from_queue (from, 0);
1783   if (to_real != from_real)
1784     abort ();
1785   if (  ((from)->code)  == SUBREG && ((from)->in_struct) 
1786       && (      (mode_size[(int)(       ((((from)->fld[0].rtx) )->mode) )]) 
1787           >=    (mode_size[(int)(to_mode)]) )
1788       && ((from)->unchanging)  == unsignedp)
1789     from = gen_lowpart (to_mode, from), from_mode = to_mode;
1790   if (  ((to)->code)  == SUBREG && ((to)->in_struct) )
1791     abort ();
1792   if (to_mode == from_mode
1793       || (from_mode == VOIDmode && (    ((from)->code)  == LABEL_REF ||         ((from)->code)  == SYMBOL_REF   ||      ((from)->code)  == CONST_INT ||         ((from)->code)  == CONST_DOUBLE ||      ((from)->code)  == CONST ||     ((from)->code)  == HIGH) ))
1794     {
1795       emit_move_insn (to, from);
1796       return;
1797     }
1798   if (to_real)
1799     {
1800       if (1  && from_mode == SFmode && to_mode == DFmode)
1801         {
1802           emit_unop_insn (CODE_FOR_extendsfdf2, to, from, UNKNOWN);
1803           return;
1804         }
1805       if (1  && from_mode == SFmode && to_mode == TFmode)
1806         {
1807           emit_unop_insn (CODE_FOR_extendsftf2, to, from, UNKNOWN);
1808           return;
1809         }
1810       if (1  && from_mode == DFmode && to_mode == TFmode)
1811         {
1812           emit_unop_insn (CODE_FOR_extenddftf2, to, from, UNKNOWN);
1813           return;
1814         }
1815       if (1  && from_mode == DFmode && to_mode == SFmode)
1816         {
1817           emit_unop_insn (CODE_FOR_truncdfsf2, to, from, UNKNOWN);
1818           return;
1819         }
1820       if (1  && from_mode == TFmode && to_mode == SFmode)
1821         {
1822           emit_unop_insn (CODE_FOR_trunctfsf2, to, from, UNKNOWN);
1823           return;
1824         }
1825       if (1  && from_mode == TFmode && to_mode == DFmode)
1826         {
1827           emit_unop_insn (CODE_FOR_trunctfdf2, to, from, UNKNOWN);
1828           return;
1829         }
1830       libcall = (rtx) 0;
1831       switch (from_mode)
1832         {
1833         case SFmode:
1834           switch (to_mode)
1835             {
1836             case DFmode:
1837               libcall = extendsfdf2_libfunc;
1838               break;
1839             case XFmode:
1840               libcall = extendsfxf2_libfunc;
1841               break;
1842             case TFmode:
1843               libcall = extendsftf2_libfunc;
1844               break;
1845             }
1846           break;
1847         case DFmode:
1848           switch (to_mode)
1849             {
1850             case SFmode:
1851               libcall = truncdfsf2_libfunc;
1852               break;
1853             case XFmode:
1854               libcall = extenddfxf2_libfunc;
1855               break;
1856             case TFmode:
1857               libcall = extenddftf2_libfunc;
1858               break;
1859             }
1860           break;
1861         case XFmode:
1862           switch (to_mode)
1863             {
1864             case SFmode:
1865               libcall = truncxfsf2_libfunc;
1866               break;
1867             case DFmode:
1868               libcall = truncxfdf2_libfunc;
1869               break;
1870             }
1871           break;
1872         case TFmode:
1873           switch (to_mode)
1874             {
1875             case SFmode:
1876               libcall = trunctfsf2_libfunc;
1877               break;
1878             case DFmode:
1879               libcall = trunctfdf2_libfunc;
1880               break;
1881             }
1882           break;
1883         }
1884       if (libcall == (rtx) 0)
1885         abort ();
1886       emit_library_call (libcall, 1, to_mode, 1, from, from_mode);
1887       emit_move_insn (to, hard_libcall_value (to_mode));
1888       return;
1889     }
1890   if ( (8  * mode_size[(int)(from_mode)])  <  (8  * mode_size[(int)(to_mode)]) 
1891       &&  (8  * mode_size[(int)(to_mode)])  > 32 )
1892     {
1893       rtx insns;
1894       rtx lowpart;
1895       rtx fill_value;
1896       rtx lowfrom;
1897       int i;
1898       enum machine_mode lowpart_mode;
1899       int nwords = (((  (mode_size[(int)(to_mode)]) ) + ( 4 ) - 1) / ( 4 )) ;
1900       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
1901           != CODE_FOR_nothing)
1902         {
1903           if (optimize > 0 &&   ((from)->code)  == SUBREG)
1904             from = force_reg (from_mode, from);
1905           emit_unop_insn (code, to, from, equiv_code);
1906           return;
1907         }
1908       else if ( (8  * mode_size[(int)(from_mode)])  < 32 
1909                && ((code = can_extend_p (to_mode, word_mode, unsignedp))
1910                    != CODE_FOR_nothing))
1911         {
1912           convert_move (gen_lowpart (word_mode, to), from, unsignedp);
1913           emit_unop_insn (code, to,
1914                           gen_lowpart (word_mode, to), equiv_code);
1915           return;
1916         }
1917       start_sequence ();
1918       if ( (8  * mode_size[(int)(from_mode)])  < 32 )
1919         lowpart_mode = word_mode;
1920       else
1921         lowpart_mode = from_mode;
1922       lowfrom = convert_to_mode (lowpart_mode, from, unsignedp);
1923       lowpart = gen_lowpart (lowpart_mode, to);
1924       emit_move_insn (lowpart, lowfrom);
1925       if (unsignedp)
1926         fill_value = const0_rtx;
1927       else
1928         {
1929           if (1 
1930               && insn_operand_mode[(int) CODE_FOR_slt][0] == word_mode
1931               && 1  == -1)
1932             {
1933               emit_cmp_insn (lowfrom, const0_rtx, NE, (rtx) 0 ,
1934                              lowpart_mode, 0, 0);
1935               fill_value = gen_reg_rtx (word_mode);
1936               emit_insn (gen_slt (fill_value));
1937             }
1938           else
1939             {
1940               fill_value
1941                 = expand_shift (RSHIFT_EXPR, lowpart_mode, lowfrom,
1942                                 size_int ( (8  * mode_size[(int)(lowpart_mode)])  - 1),
1943                                 (rtx) 0 , 0);
1944               fill_value = convert_to_mode (word_mode, fill_value, 1);
1945             }
1946         }
1947       for (i =  (mode_size[(int)(lowpart_mode)])  / 4 ; i < nwords; i++)
1948         {
1949           int index = (1  ? nwords - i - 1 : i);
1950           rtx subword = operand_subword (to, index, 1, to_mode);
1951           if (subword == 0)
1952             abort ();
1953           if (fill_value != subword)
1954             emit_move_insn (subword, fill_value);
1955         }
1956       insns = get_insns ();
1957       end_sequence ();
1958       emit_no_conflict_block (insns, to, from, (rtx) 0 ,
1959                               gen_rtx (equiv_code, to_mode, from));
1960       return;
1961     }
1962   if ( (8  * mode_size[(int)(from_mode)])  > 32 )
1963     {
1964       convert_move (to, gen_lowpart (word_mode, from), 0);
1965       return;
1966     }
1967   if (to_mode == PSImode)
1968     {
1969       if (from_mode != SImode)
1970         from = convert_to_mode (SImode, from, unsignedp);
1971       abort ();
1972     }
1973   if (from_mode == PSImode)
1974     {
1975       if (to_mode != SImode)
1976         {
1977           from = convert_to_mode (SImode, from, unsignedp);
1978           from_mode = SImode;
1979         }
1980       else
1981         {
1982           abort ();
1983         }
1984     }
1985   if ( (8  * mode_size[(int)(to_mode)])  <  (8  * mode_size[(int)(from_mode)]) 
1986       && 1 
1987       && ((     ((from)->code)  == MEM
1988            && ! ((from)->volatil) 
1989            && direct_load[(int) to_mode]
1990            && ! mode_dependent_address_p (((from)->fld[ 0].rtx) ))
1991           ||    ((from)->code)  == REG
1992           ||    ((from)->code)  == SUBREG))
1993     {
1994       emit_move_insn (to, gen_lowpart (to_mode, from));
1995       return;
1996     }
1997   if ( (8  * mode_size[(int)(to_mode)])  >  (8  * mode_size[(int)(from_mode)]) )
1998     {
1999       if ((code = can_extend_p (to_mode, from_mode, unsignedp))
2000           != CODE_FOR_nothing)
2001         {
2002           if (optimize > 0 &&   ((from)->code)  == SUBREG)
2003             from = force_reg (from_mode, from);
2004           emit_unop_insn (code, to, from, equiv_code);
2005           return;
2006         }
2007       else
2008         {
2009           enum machine_mode intermediate;
2010           for (intermediate = from_mode; intermediate != VOIDmode;
2011                intermediate = (mode_wider_mode[(int)(intermediate)]) )
2012             if ((can_extend_p (to_mode, intermediate, unsignedp)
2013                  != CODE_FOR_nothing)
2014                 && (can_extend_p (intermediate, from_mode, unsignedp)
2015                     != CODE_FOR_nothing))
2016               {
2017                 convert_move (to, convert_to_mode (intermediate, from,
2018                                                    unsignedp), unsignedp);
2019                 return;
2020               }
2021           abort ();
2022         }
2023     }
2024   if (from_mode == DImode && to_mode == SImode)
2025     {
2026       convert_move (to, force_reg (from_mode, from), unsignedp);
2027       return;
2028     }
2029   if (from_mode == DImode && to_mode == HImode)
2030     {
2031       convert_move (to, force_reg (from_mode, from), unsignedp);
2032       return;
2033     }
2034   if (from_mode == DImode && to_mode == QImode)
2035     {
2036       convert_move (to, force_reg (from_mode, from), unsignedp);
2037       return;
2038     }
2039   if (from_mode == SImode && to_mode == HImode)
2040     {
2041       convert_move (to, force_reg (from_mode, from), unsignedp);
2042       return;
2043     }
2044   if (from_mode == SImode && to_mode == QImode)
2045     {
2046       convert_move (to, force_reg (from_mode, from), unsignedp);
2047       return;
2048     }
2049   if (from_mode == HImode && to_mode == QImode)
2050     {
2051       convert_move (to, force_reg (from_mode, from), unsignedp);
2052       return;
2053     }
2054   if ( (8  * mode_size[(int)(to_mode)])  <  (8  * mode_size[(int)(from_mode)]) )
2055     {
2056       rtx temp = force_reg (to_mode, gen_lowpart (to_mode, from));
2057       emit_move_insn (to, temp);
2058       return;
2059     }
2060   abort ();
2061 }
2062 rtx
2063 convert_to_mode (mode, x, unsignedp)
2064      enum machine_mode mode;
2065      rtx x;
2066      int unsignedp;
2067 {
2068   register rtx temp;
2069   if (  ((x)->code)  == SUBREG && ((x)->in_struct) 
2070       &&        (mode_size[(int)(       ((((x)->fld[0].rtx) )->mode) )])  >=    (mode_size[(int)(mode)]) 
2071       && ((x)->unchanging)  == unsignedp)
2072     x = gen_lowpart (mode, x);
2073   if (mode ==   ((x)->mode) )
2074     return x;
2075   if (unsignedp &&      (mode_class[(int)(mode)])  == MODE_INT
2076       &&  (8  * mode_size[(int)(mode)])  == 2 * 32  
2077       &&        ((x)->code)  == CONST_INT && ((x)->fld[0].rtwint)  < 0)
2078     return immed_double_const (((x)->fld[0].rtwint) , (int ) 0, mode);
2079   if (  ((x)->code)  == CONST_INT
2080       || (      (mode_class[(int)(mode)])  == MODE_INT
2081           &&    (mode_class[(int)(      ((x)->mode) )])  == MODE_INT
2082           && (  ((x)->code)  == CONST_DOUBLE
2083               || (      (mode_size[(int)(mode)])  <=    (mode_size[(int)(       ((x)->mode) )]) 
2084                   && (( ((x)->code)  == MEM && ! ((x)->volatil) )
2085                       && direct_load[(int) mode]
2086                       ||        ((x)->code)  == REG)))))
2087     return gen_lowpart (mode, x);
2088   temp = gen_reg_rtx (mode);
2089   convert_move (temp, x, unsignedp);
2090   return temp;
2091 }
2092 struct move_by_pieces
2093 {
2094   rtx to;
2095   rtx to_addr;
2096   int autinc_to;
2097   int explicit_inc_to;
2098   rtx from;
2099   rtx from_addr;
2100   int autinc_from;
2101   int explicit_inc_from;
2102   int len;
2103   int offset;
2104   int reverse;
2105 };
2106 static void move_by_pieces_1 ();
2107 static int move_by_pieces_ninsns ();
2108 static void
2109 move_by_pieces (to, from, len, align)
2110      rtx to, from;
2111      int len, align;
2112 {
2113   struct move_by_pieces data;
2114   rtx to_addr = ((to)->fld[ 0].rtx) , from_addr = ((from)->fld[ 0].rtx) ;
2115   int max_size = 8  + 1;
2116   data.offset = 0;
2117   data.to_addr = to_addr;
2118   data.from_addr = from_addr;
2119   data.to = to;
2120   data.from = from;
2121   data.autinc_to
2122     = ( ((to_addr)->code)  == PRE_INC ||        ((to_addr)->code)  == PRE_DEC
2123        ||       ((to_addr)->code)  == POST_INC ||       ((to_addr)->code)  == POST_DEC);
2124   data.autinc_from
2125     = ( ((from_addr)->code)  == PRE_INC ||      ((from_addr)->code)  == PRE_DEC
2126        ||       ((from_addr)->code)  == POST_INC
2127        ||       ((from_addr)->code)  == POST_DEC);
2128   data.explicit_inc_from = 0;
2129   data.explicit_inc_to = 0;
2130   data.reverse
2131     = ( ((to_addr)->code)  == PRE_DEC ||        ((to_addr)->code)  == POST_DEC);
2132   if (data.reverse) data.offset = len;
2133   data.len = len;
2134   if (!(data.autinc_from && data.autinc_to)
2135       && move_by_pieces_ninsns (len, align) > 2)
2136     {
2137       if (!data.autinc_from && (        ((from_addr)->code)  == LABEL_REF ||    ((from_addr)->code)  == SYMBOL_REF      ||      ((from_addr)->code)  == CONST_INT ||    ((from_addr)->code)  == CONST_DOUBLE    ||      ((from_addr)->code)  == CONST ||        ((from_addr)->code)  == HIGH) )
2138         data.from_addr = copy_addr_to_reg (from_addr);
2139       if (!data.autinc_to && (  ((to_addr)->code)  == LABEL_REF ||      ((to_addr)->code)  == SYMBOL_REF        ||      ((to_addr)->code)  == CONST_INT ||      ((to_addr)->code)  == CONST_DOUBLE      ||      ((to_addr)->code)  == CONST ||  ((to_addr)->code)  == HIGH) )
2140         data.to_addr = copy_addr_to_reg (to_addr);
2141     }
2142   if (! (1  || 0 )
2143       || align > 8  || align >= 64  / 8 )
2144     align = 8 ;
2145   while (max_size > 1)
2146     {
2147       enum machine_mode mode = VOIDmode, tmode;
2148       enum insn_code icode;
2149       for (tmode = class_narrowest_mode[(int)(MODE_INT)] ;
2150            tmode != VOIDmode; tmode = (mode_wider_mode[(int)(tmode)]) )
2151         if (    (mode_size[(int)(tmode)])  < max_size)
2152           mode = tmode;
2153       if (mode == VOIDmode)
2154         break;
2155       icode = mov_optab->handlers[(int) mode].insn_code;
2156       if (icode != CODE_FOR_nothing
2157           && align >= ((64  / 8 ) < (
2158                                 (mode_size[(int)(mode)]) ) ? (64  / 8 ) : (                             (mode_size[(int)(mode)]) )) )
2159         move_by_pieces_1 ((*insn_gen_function[(int) (icode)]) , mode, &data);
2160       max_size =        (mode_size[(int)(mode)]) ;
2161     }
2162   if (data.len != 0)
2163     abort ();
2164 }
2165 static int
2166 move_by_pieces_ninsns (l, align)
2167      unsigned int l;
2168      int align;
2169 {
2170   register int n_insns = 0;
2171   int max_size = 8  + 1;
2172   if (! (1  || 0 )
2173       || align > 8  || align >= 64  / 8 )
2174     align = 8 ;
2175   while (max_size > 1)
2176     {
2177       enum machine_mode mode = VOIDmode, tmode;
2178       enum insn_code icode;
2179       for (tmode = class_narrowest_mode[(int)(MODE_INT)] ;
2180            tmode != VOIDmode; tmode = (mode_wider_mode[(int)(tmode)]) )
2181         if (    (mode_size[(int)(tmode)])  < max_size)
2182           mode = tmode;
2183       if (mode == VOIDmode)
2184         break;
2185       icode = mov_optab->handlers[(int) mode].insn_code;
2186       if (icode != CODE_FOR_nothing
2187           && align >= ((64  / 8 ) < (
2188                                 (mode_size[(int)(mode)]) ) ? (64  / 8 ) : (                             (mode_size[(int)(mode)]) )) )
2189         n_insns += l /  (mode_size[(int)(mode)]) , l %=         (mode_size[(int)(mode)]) ;
2190       max_size =        (mode_size[(int)(mode)]) ;
2191     }
2192   return n_insns;
2193 }
2194 static void
2195 move_by_pieces_1 (genfun, mode, data)
2196      rtx (*genfun) ();
2197      enum machine_mode mode;
2198      struct move_by_pieces *data;
2199 {
2200   register int size =   (mode_size[(int)(mode)]) ;
2201   register rtx to1, from1;
2202   while (data->len >= size)
2203     {
2204       if (data->reverse) data->offset -= size;
2205       to1 = (data->autinc_to
2206              ? gen_rtx (MEM, mode, data->to_addr)
2207              : change_address (data->to, mode,
2208                                plus_constant_wide (data->to_addr, (int ) ( data->offset)) ));
2209       from1 =
2210         (data->autinc_from
2211          ? gen_rtx (MEM, mode, data->from_addr)
2212          : change_address (data->from, mode,
2213                            plus_constant_wide (data->from_addr, (int ) ( data->offset)) ));
2214       emit_insn ((*genfun) (to1, from1));
2215       if (! data->reverse) data->offset += size;
2216       data->len -= size;
2217     }
2218 }
2219 void
2220 emit_block_move (x, y, size, align)
2221      rtx x, y;
2222      rtx size;
2223      int align;
2224 {
2225   if (  ((x)->mode)  != BLKmode)
2226     abort ();
2227   if (  ((y)->mode)  != BLKmode)
2228     abort ();
2229   x = protect_from_queue (x, 1);
2230   y = protect_from_queue (y, 0);
2231   size = protect_from_queue (size, 0);
2232   if (  ((x)->code)  != MEM)
2233     abort ();
2234   if (  ((y)->code)  != MEM)
2235     abort ();
2236   if (size == 0)
2237     abort ();
2238   if (  ((size)->code)  == CONST_INT
2239       && (move_by_pieces_ninsns (((size)->fld[0].rtwint) , align) < 2 ))
2240     move_by_pieces (x, y, ((size)->fld[0].rtwint) , align);
2241   else
2242     {
2243       rtx opalign = gen_rtx (CONST_INT, VOIDmode, (align)) ;
2244       enum machine_mode mode;
2245       for (mode = class_narrowest_mode[(int)(MODE_INT)] ; mode != VOIDmode;
2246            mode = (mode_wider_mode[(int)(mode)]) )
2247         {
2248           enum insn_code code = movstr_optab[(int) mode];
2249           if (code != CODE_FOR_nothing
2250               && (unsigned) ((size)->fld[0].rtwint)  <= (( (8  * mode_size[(int)(mode)])  >= 32  ) ?(int ) ~0 : (((int ) 1 <<  (8  * mode_size[(int)(mode)]) ) - 1)) 
2251               && (insn_operand_predicate[(int) code][0] == 0
2252                   || (*insn_operand_predicate[(int) code][0]) (x, BLKmode))
2253               && (insn_operand_predicate[(int) code][1] == 0
2254                   || (*insn_operand_predicate[(int) code][1]) (y, BLKmode))
2255               && (insn_operand_predicate[(int) code][3] == 0
2256                   || (*insn_operand_predicate[(int) code][3]) (opalign,
2257                                                                VOIDmode)))
2258             {
2259               rtx op2;
2260               rtx last = get_last_insn ();
2261               rtx pat;
2262               op2 = convert_to_mode (mode, size, 1);
2263               if (insn_operand_predicate[(int) code][2] != 0
2264                   && ! (*insn_operand_predicate[(int) code][2]) (op2, mode))
2265                 op2 = copy_to_mode_reg (mode, op2);
2266               pat = (*insn_gen_function[(int) ((int) code)])  (x, y, op2, opalign);
2267               if (pat)
2268                 {
2269                   emit_insn (pat);
2270                   return;
2271                 }
2272               else
2273                 delete_insns_since (last);
2274             }
2275         }
2276       emit_library_call (memcpy_libfunc, 0,
2277                          VOIDmode, 3, ((x)->fld[ 0].rtx) , SImode ,
2278                          ((y)->fld[ 0].rtx) , SImode ,
2279                          convert_to_mode (SImode , size, 1), SImode );
2280     }
2281 }
2282 void
2283 move_block_to_reg (regno, x, nregs, mode)
2284      int regno;
2285      rtx x;
2286      int nregs;
2287      enum machine_mode mode;
2288 {
2289   int i;
2290   rtx pat, last;
2291   if (( ((x)->code)  == LABEL_REF ||    ((x)->code)  == SYMBOL_REF      ||      ((x)->code)  == CONST_INT ||    ((x)->code)  == CONST_DOUBLE    ||      ((x)->code)  == CONST ||        ((x)->code)  == HIGH)  && ! (   ((x)->code)  != CONST_DOUBLE ||         ((x)->mode)  == VOIDmode) )
2292     x = validize_mem (force_const_mem (mode, x));
2293   for (i = 0; i < nregs; i++)
2294     emit_move_insn (gen_rtx (REG, word_mode, regno + i),
2295                     operand_subword_force (x, i, mode));
2296 }
2297 void
2298 move_block_from_reg (regno, x, nregs)
2299      int regno;
2300      rtx x;
2301      int nregs;
2302 {
2303   int i;
2304   rtx pat, last;
2305   for (i = 0; i < nregs; i++)
2306     {
2307       rtx tem = operand_subword (x, i, 1, BLKmode);
2308       if (tem == 0)
2309         abort ();
2310       emit_move_insn (tem, gen_rtx (REG, word_mode, regno + i));
2311     }
2312 }
2313 void
2314 use_regs (regno, nregs)
2315      int regno;
2316      int nregs;
2317 {
2318   int i;
2319   for (i = 0; i < nregs; i++)
2320     emit_insn (gen_rtx (USE, VOIDmode, gen_rtx (REG, word_mode, regno + i)));
2321 }
2322 static rtx
2323 group_insns (prev)
2324      rtx prev;
2325 {
2326   rtx insn_first;
2327   rtx insn_last;
2328   if (prev)
2329     insn_first = ((prev)->fld[2].rtx) ;
2330   else
2331     insn_first = get_insns ();
2332   insn_last = get_last_insn ();
2333   ((insn_last)->fld[6].rtx)  = gen_rtx (INSN_LIST, REG_RETVAL, insn_first,
2334                                    ((insn_last)->fld[6].rtx) );
2335   ((insn_first)->fld[6].rtx)  = gen_rtx (INSN_LIST, REG_LIBCALL, insn_last,
2336                                     ((insn_first)->fld[6].rtx) );
2337 }
2338 void
2339 clear_storage (object, size)
2340      rtx object;
2341      int size;
2342 {
2343   if (  ((object)->mode)  == BLKmode)
2344     {
2345       emit_library_call (memset_libfunc, 0,
2346                          VOIDmode, 3,
2347                          ((object)->fld[ 0].rtx) , SImode , const0_rtx, SImode ,
2348                          gen_rtx (CONST_INT, VOIDmode, (size)) , SImode );
2349     }
2350   else
2351     emit_move_insn (object, const0_rtx);
2352 }
2353 rtx
2354 emit_move_insn (x, y)
2355      rtx x, y;
2356 {
2357   enum machine_mode mode =      ((x)->mode) ;
2358   enum machine_mode submode;
2359   enum mode_class class =       (mode_class[(int)(mode)]) ;
2360   int i;
2361   x = protect_from_queue (x, 1);
2362   y = protect_from_queue (y, 0);
2363   if (mode == BLKmode || (      ((y)->mode)  != mode &&         ((y)->mode)  != VOIDmode))
2364     abort ();
2365   if (( ((y)->code)  == LABEL_REF ||    ((y)->code)  == SYMBOL_REF      ||      ((y)->code)  == CONST_INT ||    ((y)->code)  == CONST_DOUBLE    ||      ((y)->code)  == CONST ||        ((y)->code)  == HIGH)  && ! (   ((y)->code)  != CONST_DOUBLE ||         ((y)->mode)  == VOIDmode) )
2366     y = force_const_mem (mode, y);
2367   if (  ((x)->code)  == MEM
2368       && ((! memory_address_p ( ((x)->mode) , ((x)->fld[ 0].rtx) )
2369            && ! push_operand (x,        ((x)->mode) ))
2370           || (flag_force_addr
2371               && ((     ((((x)->fld[ 0].rtx) )->code)  == LABEL_REF ||  ((((x)->fld[ 0].rtx) )->code)  == SYMBOL_REF    ||      ((((x)->fld[ 0].rtx) )->code)  == CONST_INT ||  ((((x)->fld[ 0].rtx) )->code)  == CONST_DOUBLE  ||      ((((x)->fld[ 0].rtx) )->code)  == CONST ||      ((((x)->fld[ 0].rtx) )->code)  == HIGH) ) )))
2372     x = change_address (x, VOIDmode, ((x)->fld[ 0].rtx) );
2373   if (  ((y)->code)  == MEM
2374       && (! memory_address_p (  ((y)->mode) , ((y)->fld[ 0].rtx) )
2375           || (flag_force_addr
2376               && ((     ((((y)->fld[ 0].rtx) )->code)  == LABEL_REF ||  ((((y)->fld[ 0].rtx) )->code)  == SYMBOL_REF    ||      ((((y)->fld[ 0].rtx) )->code)  == CONST_INT ||  ((((y)->fld[ 0].rtx) )->code)  == CONST_DOUBLE  ||      ((((y)->fld[ 0].rtx) )->code)  == CONST ||      ((((y)->fld[ 0].rtx) )->code)  == HIGH) ) )))
2377     y = change_address (y, VOIDmode, ((y)->fld[ 0].rtx) );
2378   if (mode == BLKmode)
2379     abort ();
2380   if (class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2381     submode = mode_for_size ((mode_unit_size[(int)(mode)])  * 8 ,
2382                              (class == MODE_COMPLEX_INT
2383                               ? MODE_INT : MODE_FLOAT),
2384                              0);
2385   if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
2386     return
2387       emit_insn ((*insn_gen_function[(int) (mov_optab->handlers[(int) mode].insn_code)])  (x, y));
2388   else if ((class == MODE_COMPLEX_FLOAT || class == MODE_COMPLEX_INT)
2389            && submode != BLKmode
2390            && (mov_optab->handlers[(int) submode].insn_code
2391                != CODE_FOR_nothing))
2392     {
2393       int stack = push_operand (x,      ((x)->mode) );
2394       rtx prev = get_last_insn ();
2395       if (      ((x)->code)  == REG)
2396         emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
2397       emit_insn ((*insn_gen_function[(int) (mov_optab->handlers[(int) submode].insn_code)]) 
2398                  ((stack ? change_address (x, submode, (rtx) 0)
2399                    : gen_highpart (submode, x)),
2400                   gen_highpart (submode, y)));
2401       emit_insn ((*insn_gen_function[(int) (mov_optab->handlers[(int) submode].insn_code)]) 
2402                  ((stack ? change_address (x, submode, (rtx) 0)
2403                    : gen_lowpart (submode, x)),
2404                   gen_lowpart (submode, y)));
2405       group_insns (prev);
2406       return get_last_insn ();
2407     }
2408   else if (     (mode_size[(int)(mode)])  > 4 )
2409     {
2410       rtx last_insn = 0;
2411       rtx prev_insn = get_last_insn ();
2412       for (i = 0;
2413            i < (        (mode_size[(int)(mode)])   + (4  - 1)) / 4 ;
2414            i++)
2415         {
2416           rtx xpart = operand_subword (x, i, 1, mode);
2417           rtx ypart = operand_subword (y, i, 1, mode);
2418           if (ypart == 0 && (   ((y)->code)  == LABEL_REF ||    ((y)->code)  == SYMBOL_REF      ||      ((y)->code)  == CONST_INT ||    ((y)->code)  == CONST_DOUBLE    ||      ((y)->code)  == CONST ||        ((y)->code)  == HIGH) )
2419             {
2420               y = force_const_mem (mode, y);
2421               ypart = operand_subword (y, i, 1, mode);
2422             }
2423           else if (ypart == 0)
2424             ypart = operand_subword_force (y, i, mode);
2425           if (xpart == 0 || ypart == 0)
2426             abort ();
2427           last_insn = emit_move_insn (xpart, ypart);
2428         }
2429       group_insns (prev_insn);
2430       return last_insn;
2431     }
2432   else
2433     abort ();
2434 }
2435 rtx
2436 push_block (size, extra, below)
2437      rtx size;
2438      int extra, below;
2439 {
2440   register rtx temp;
2441   if (( ((size)->code)  == LABEL_REF ||         ((size)->code)  == SYMBOL_REF   ||      ((size)->code)  == CONST_INT ||         ((size)->code)  == CONST_DOUBLE ||      ((size)->code)  == CONST ||     ((size)->code)  == HIGH) )
2442     anti_adjust_stack (plus_constant_wide (size, (int ) ( extra)) );
2443   else if (     ((size)->code)  == REG && extra == 0)
2444     anti_adjust_stack (size);
2445   else
2446     {
2447       rtx temp = copy_to_mode_reg (SImode , size);
2448       if (extra != 0)
2449         temp = expand_binop (SImode , add_optab, temp, gen_rtx (CONST_INT, VOIDmode, (extra)) ,
2450                              temp, 0, OPTAB_LIB_WIDEN);
2451       anti_adjust_stack (temp);
2452     }
2453   temp = virtual_outgoing_args_rtx;
2454   if (extra != 0 && below)
2455     temp = plus_constant_wide (temp, (int ) ( extra)) ;
2456   return memory_address (class_narrowest_mode[(int)(MODE_INT)] , temp);
2457 }
2458 rtx
2459 gen_push_operand ()
2460 {
2461   return gen_rtx (PRE_DEC , SImode , stack_pointer_rtx);
2462 }
2463 void
2464 emit_push_insn (x, mode, type, size, align, partial, reg, extra,
2465                 args_addr, args_so_far)
2466      register rtx x;
2467      enum machine_mode mode;
2468      tree type;
2469      rtx size;
2470      int align;
2471      int partial;
2472      rtx reg;
2473      int extra;
2474      rtx args_addr;
2475      rtx args_so_far;
2476 {
2477   rtx xinner;
2478   enum direction stack_direction
2479     = downward;
2480   enum direction where_pad = (((mode) == BLKmode        ? (( type) && ((enum tree_code) ((( type)->type.size) )->common.code)  == INTEGER_CST   && int_size_in_bytes ( type) < 32  / 8 )        :  (8  * mode_size[(int)(mode)])  < 32 )        ? downward : upward) ;
2481   if (PRE_DEC  == POST_INC || PRE_DEC  == POST_DEC)
2482     if (where_pad != none)
2483       where_pad = (where_pad == downward ? upward : downward);
2484   xinner = x = protect_from_queue (x, 0);
2485   if (mode == BLKmode)
2486     {
2487       register rtx temp;
2488       int used = partial * 4 ;
2489       int offset = used % (32  / 8 );
2490       int skip;
2491       if (size == 0)
2492         abort ();
2493       used -= offset;
2494       if (partial != 0)
2495         xinner = change_address (xinner, BLKmode,
2496                                  plus_constant_wide (((xinner)->fld[ 0].rtx) , (int ) ( used)) );
2497       skip = used;
2498         {
2499           if (partial != 0)
2500             {
2501               if (      ((size)->code)  == CONST_INT)
2502                 size = gen_rtx (CONST_INT, VOIDmode, (((size)->fld[0].rtwint)  - used)) ;
2503               else
2504                 size = expand_binop (   ((size)->mode) , sub_optab, size,
2505                                      gen_rtx (CONST_INT, VOIDmode, (used)) , (rtx) 0 , 0,
2506                                      OPTAB_LIB_WIDEN);
2507             }
2508           if (! args_addr)
2509             {
2510               temp = push_block (size, extra, where_pad == downward);
2511               extra = 0;
2512             }
2513           else if (     ((args_so_far)->code)  == CONST_INT)
2514             temp = memory_address (BLKmode,
2515                                    plus_constant_wide (args_addr, (int ) (
2516                                                   skip + ((args_so_far)->fld[0].rtwint) )) );
2517           else
2518             temp = memory_address (BLKmode,
2519                                    plus_constant_wide (gen_rtx (PLUS, SImode ,
2520                                                            args_addr, args_so_far), (int ) (
2521                                                   skip)) );
2522           if (  ((size)->code)  == CONST_INT
2523               && (move_by_pieces_ninsns ((unsigned) ((size)->fld[0].rtwint) , align)
2524                   < 2 ))
2525             {
2526               move_by_pieces (gen_rtx (MEM, BLKmode, temp), xinner,
2527                               ((size)->fld[0].rtwint) , align);
2528               goto ret;
2529             }
2530           if (1 )
2531             {
2532               emit_insn (gen_movstrsi (gen_rtx (MEM, BLKmode, temp),
2533                                        xinner, size, gen_rtx (CONST_INT, VOIDmode, (align)) ));
2534               goto ret;
2535             }
2536           (inhibit_defer_pop += 1) ;
2537           emit_library_call (memcpy_libfunc, 0,
2538                              VOIDmode, 3, temp, SImode , ((xinner)->fld[ 0].rtx) , SImode ,
2539                              size, SImode );
2540           (inhibit_defer_pop -= 1) ;
2541         }
2542     }
2543   else if (partial > 0)
2544     {
2545       int size =        (mode_size[(int)(mode)])  / 4 ;
2546       int i;
2547       int not_stack;
2548       int offset = partial % (32  / 32 );
2549       int args_offset = ((args_so_far)->fld[0].rtwint) ;
2550       int skip;
2551       if (extra && args_addr == 0
2552           && where_pad != none && where_pad != stack_direction)
2553         anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, (extra)) );
2554       if (args_addr == 0)
2555         offset = 0;
2556       not_stack = partial - offset;
2557       skip = not_stack;
2558       if ((     ((x)->code)  == LABEL_REF ||    ((x)->code)  == SYMBOL_REF      ||      ((x)->code)  == CONST_INT ||    ((x)->code)  == CONST_DOUBLE    ||      ((x)->code)  == CONST ||        ((x)->code)  == HIGH)  && ! (   ((x)->code)  != CONST_DOUBLE ||         ((x)->mode)  == VOIDmode) )
2559         x = validize_mem (force_const_mem (mode, x));
2560       if ((     ((x)->code)  == REG && ((x)->fld[0].rtint)  < 64 
2561            &&   (mode_class[(int)(      ((x)->mode) )])  != MODE_INT))
2562         x = copy_to_reg (x);
2563       for (i = not_stack; i < size; i++)
2564         if (i >= not_stack + offset)
2565           emit_push_insn (operand_subword_force (x, i, mode),
2566                           word_mode, (tree) 0  , (rtx) 0 , align, 0, (rtx) 0 ,
2567                           0, args_addr,
2568                           gen_rtx (CONST_INT, VOIDmode, (args_offset + ((i - not_stack + skip)
2569                                                   * 4 ))) );
2570     }
2571   else
2572     {
2573       rtx addr;
2574       if (extra && args_addr == 0
2575           && where_pad != none && where_pad != stack_direction)
2576         anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, (extra)) );
2577         if (    ((args_so_far)->code)  == CONST_INT)
2578           addr
2579             = memory_address (mode,
2580                               plus_constant_wide (args_addr, (int ) ( ((args_so_far)->fld[0].rtwint) )) );
2581       else
2582         addr = memory_address (mode, gen_rtx (PLUS, SImode , args_addr,
2583                                               args_so_far));
2584       emit_move_insn (gen_rtx (MEM, mode, addr), x);
2585     }
2586  ret:
2587   if (partial > 0)
2588     move_block_to_reg (((reg)->fld[0].rtint) , x, partial, mode);
2589   if (extra && args_addr == 0 && where_pad == stack_direction)
2590     anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, (extra)) );
2591 }
2592 typedef char *va_list;
2593 void
2594 emit_library_call (va_alist)
2595      int va_alist;
2596 {
2597   va_list p;
2598   struct args_size args_size;
2599   register int argnum;
2600   enum machine_mode outmode;
2601   int nargs;
2602   rtx fun;
2603   rtx orgfun;
2604   int inc;
2605   int count;
2606   rtx argblock = 0;
2607   int  args_so_far;
2608   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
2609                struct args_size offset; struct args_size size; };
2610   struct arg *argvec;
2611   int old_inhibit_defer_pop = inhibit_defer_pop;
2612   int no_queue = 0;
2613   rtx use_insns;
2614   p = (char *) &va_alist;
2615   orgfun = fun = (( rtx *)(p += sizeof( rtx)))[-1] ;
2616   no_queue = (( int *)(p += sizeof( int)))[-1] ;
2617   outmode = (( enum machine_mode *)(p += sizeof( enum machine_mode)))[-1] ;
2618   nargs = (( int *)(p += sizeof( int)))[-1] ;
2619   argvec = (struct arg *) alloca (nargs * sizeof (struct arg));
2620   ((args_so_far) = 0) ;
2621   args_size.constant = 0;
2622   args_size.var = 0;
2623   for (count = 0; count < nargs; count++)
2624     {
2625       rtx val = (( rtx *)(p += sizeof( rtx)))[-1] ;
2626       enum machine_mode mode = (( enum machine_mode *)(p += sizeof( enum machine_mode)))[-1] ;
2627       if (mode == BLKmode
2628           || (  ((val)->mode)  != mode &&       ((val)->mode)  != VOIDmode))
2629         abort ();
2630       if (      ((val)->code)  != REG &&        ((val)->code)  != MEM
2631           && ! ((       ((val)->code)  == LABEL_REF ||  ((val)->code)  == SYMBOL_REF    ||      ((val)->code)  == CONST_INT ||  ((val)->code)  == CONST_DOUBLE  ||      ((val)->code)  == CONST ||      ((val)->code)  == HIGH)  && (   ((val)->code)  != CONST_DOUBLE ||       ((val)->mode)  == VOIDmode) ))
2632         val = force_operand (val, (rtx) 0 );
2633       argvec[count].value = val;
2634       argvec[count].mode = mode;
2635       if ((( (tree) 0   && (((enum tree_code) ( (tree) 0  )->common.code)  == RECORD_TYPE       || ((enum tree_code) ( (tree) 0  )->common.code)  == UNION_TYPE))       || ( mode == TFmode)) )
2636         abort ();
2637       argvec[count].reg = (((target_flags & 32)  && (mode_unit_size[(int)(( ( mode)))])  > 4    ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far)))  < 6   && (( (tree) 0  )==0 || ! (((tree)( (tree) 0  ))->common.addressable_flag) )    && (( (tree) 0  )==0 || ( mode) != BLKmode      || (((( (tree) 0  ))->type.align)  % 32  == 0)) ? gen_rtx (REG, ( mode),        ((8)  + ((target_flags & 32)  && (mode_unit_size[(int)(( ( mode)))])  > 4       ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far))) ))     : 0) ;
2638       if (argvec[count].reg &&  ((argvec[count].reg)->code)  == EXPR_LIST)
2639         abort ();
2640       argvec[count].partial
2641         = ((((target_flags & 32)  && (mode_unit_size[(int)(( ( mode)))])  > 4   ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far)))  < 6   && (( (tree) 0  )==0 || ! (((tree)( (tree) 0  ))->common.addressable_flag) )    && (( (tree) 0  )==0 || ( mode) != BLKmode      || (((( (tree) 0  ))->type.align)  % 32  == 0)) && (((target_flags & 32)  && (mode_unit_size[(int)(( ( mode)))])  > 4   ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far)))        + (( mode) == BLKmode   ? ((int_size_in_bytes ( (tree) 0  ) + 4  - 1) / 4 )     : ((    (mode_size[(int)( mode)])  + 4  - 1) / 4 ) )) - 6  > 0) ? (6  - ((target_flags & 32)  && (mode_unit_size[(int)(( ( mode)))])  > 4       ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far))) )      : 0) ;
2642       locate_and_pad_parm (mode, (tree) 0  ,
2643                            argvec[count].reg && argvec[count].partial == 0,
2644                            (tree) 0  , &args_size, &argvec[count].offset,
2645                            &argvec[count].size);
2646       if (argvec[count].size.var)
2647         abort ();
2648       if (argvec[count].reg == 0 || argvec[count].partial != 0
2649           || 1
2650           )
2651         args_size.constant += argvec[count].size.constant;
2652       if (argvec[count].reg == 0 || argvec[count].partial != 0)
2653         abort ();
2654       ((args_so_far) = (((target_flags & 32)  && (mode_unit_size[(int)(( ( mode)))])  > 4       ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far)))        + (( mode) != BLKmode   ? ((    (mode_size[(int)( mode)])  + 4  - 1) / 4 )      : ((int_size_in_bytes ( (tree)0) + 4  - 1) / 4 ) ))) ;
2655     }
2656    ;
2657   assemble_external_libcall (fun);
2658   args_size.constant = (((args_size.constant + ((64  / 8 )  - 1))
2659                          / (64  / 8 ) ) * (64  / 8 ) );
2660   args_size.constant = ((args_size.constant) > (
2661                             (6  * 4 ) ) ? (args_size.constant) : (                          (6  * 4 ) )) ;
2662   if (args_size.constant > current_function_outgoing_args_size)
2663     current_function_outgoing_args_size = args_size.constant;
2664   args_size.constant = 0;
2665   argblock = push_block (gen_rtx (CONST_INT, VOIDmode, (args_size.constant)) , 0, 0);
2666   inc = 1;
2667   argnum = 0;
2668   for (count = 0; count < nargs; count++, argnum += inc)
2669     {
2670       register enum machine_mode mode = argvec[argnum].mode;
2671       register rtx val = argvec[argnum].value;
2672       rtx reg = argvec[argnum].reg;
2673       int partial = argvec[argnum].partial;
2674       if (! (reg != 0 && partial == 0))
2675         emit_push_insn (val, mode, (tree) 0  , (rtx) 0 , 0, partial, reg, 0,
2676                         argblock, gen_rtx (CONST_INT, VOIDmode, (argvec[count].offset.constant)) );
2677       (inhibit_defer_pop += 1) ;
2678     }
2679   argnum = 0;
2680   for (count = 0; count < nargs; count++, argnum += inc)
2681     {
2682       register enum machine_mode mode = argvec[argnum].mode;
2683       register rtx val = argvec[argnum].value;
2684       rtx reg = argvec[argnum].reg;
2685       int partial = argvec[argnum].partial;
2686       if (reg != 0 && partial == 0)
2687         emit_move_insn (reg, val);
2688       (inhibit_defer_pop += 1) ;
2689     }
2690   if (! no_queue)
2691     emit_queue ();
2692   start_sequence ();
2693   for (count = 0; count < nargs; count++)
2694     if (argvec[count].reg != 0)
2695       emit_insn (gen_rtx (USE, VOIDmode, argvec[count].reg));
2696   use_insns = get_insns ();
2697   end_sequence ();
2698   fun = prepare_call_address (fun, (tree) 0  , &use_insns);
2699   (inhibit_defer_pop += 1) ;
2700   emit_call_1 (fun, get_identifier (((orgfun)->fld[ 0].rtstr) ), args_size.constant, 0,
2701                (((target_flags & 32)  && (mode_unit_size[(int)(( ( VOIDmode)))])  > 4   ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far)))  < 6   && (( void_type_node)==0 || ! (((tree)( void_type_node))->common.addressable_flag) )    && (( void_type_node)==0 || ( VOIDmode) != BLKmode      || (((( void_type_node))->type.align)  % 32  == 0))     ? gen_rtx (REG, ( VOIDmode),    ((8)  + ((target_flags & 32)  && (mode_unit_size[(int)(( ( VOIDmode)))])  > 4   ? (((args_so_far)) + ! (((args_so_far)) & 1)) : ((args_so_far))) ))     : 0) ,
2702                outmode != VOIDmode ? hard_libcall_value (outmode) : (rtx) 0 ,
2703                old_inhibit_defer_pop + 1, use_insns, no_queue);
2704   (inhibit_defer_pop -= 1) ;
2705 }
2706 rtx
2707 expand_assignment (to, from, want_value, suggest_reg)
2708      tree to, from;
2709      int want_value;
2710      int suggest_reg;
2711 {
2712   register rtx to_rtx = 0;
2713   rtx result;
2714   if (((enum tree_code) (to)->common.code)  == ERROR_MARK)
2715     return expand_expr (from, (rtx) 0 , VOIDmode, 0);
2716   if (((enum tree_code) (to)->common.code)  == COMPONENT_REF
2717       || ((enum tree_code) (to)->common.code)  == BIT_FIELD_REF
2718       || (((enum tree_code) (to)->common.code)  == ARRAY_REF
2719           && ((enum tree_code) (((to)->exp.operands[ 1]) )->common.code)  == INTEGER_CST
2720           && ((enum tree_code) (((((to)->common.type) )->type.size) )->common.code)  == INTEGER_CST))
2721     {
2722       enum machine_mode mode1;
2723       int bitsize;
2724       int bitpos;
2725       tree offset;
2726       int unsignedp;
2727       int volatilep = 0;
2728       tree tem = get_inner_reference (to, &bitsize, &bitpos, &offset,
2729                                       &mode1, &unsignedp, &volatilep);
2730       if (mode1 == VOIDmode && want_value)
2731         tem = stabilize_reference (tem);
2732       to_rtx = expand_expr (tem, (rtx) 0 , VOIDmode, 0);
2733       if (offset != 0)
2734         {
2735           rtx offset_rtx = expand_expr (offset, (rtx) 0 , VOIDmode, 0);
2736           if (  ((to_rtx)->code)  != MEM)
2737             abort ();
2738           to_rtx = change_address (to_rtx, VOIDmode,
2739                                    gen_rtx (PLUS, SImode , ((to_rtx)->fld[ 0].rtx) ,
2740                                             force_reg (SImode , offset_rtx)));
2741         }
2742       if (volatilep)
2743         {
2744           if (  ((to_rtx)->code)  == MEM)
2745             ((to_rtx)->volatil)  = 1;
2746         }
2747       result = store_field (to_rtx, bitsize, bitpos, mode1, from,
2748                             (want_value
2749                              ? (enum machine_mode) ((((to)->common.type) )->type.mode) 
2750                              : VOIDmode),
2751                             unsignedp,
2752                             ((((tem)->common.type) )->type.align)  / 8 ,
2753                             int_size_in_bytes (((tem)->common.type) ));
2754       preserve_temp_slots (result);
2755       free_temp_slots ();
2756       return result;
2757     }
2758   if (to_rtx == 0)
2759     to_rtx = expand_expr (to, (rtx) 0 , VOIDmode, 0);
2760   if (((enum tree_code) (to)->common.code)  == RESULT_DECL && ((enum tree_code) (from)->common.code)  == INDIRECT_REF
2761       && current_function_returns_struct
2762       && !current_function_returns_pcc_struct)
2763     {
2764       rtx from_rtx = expand_expr (from, (rtx) 0 , VOIDmode, 0);
2765       rtx size = expr_size (from);
2766       emit_library_call (memcpy_libfunc, 0,
2767                          VOIDmode, 3, ((to_rtx)->fld[ 0].rtx) , SImode ,
2768                          ((from_rtx)->fld[ 0].rtx) , SImode ,
2769                          size, SImode );
2770       preserve_temp_slots (to_rtx);
2771       free_temp_slots ();
2772       return to_rtx;
2773     }
2774   result = store_expr (from, to_rtx, want_value);
2775   preserve_temp_slots (result);
2776   free_temp_slots ();
2777   return result;
2778 }
2779 rtx
2780 store_expr (exp, target, suggest_reg)
2781      register tree exp;
2782      register rtx target;
2783      int suggest_reg;
2784 {
2785   register rtx temp;
2786   int dont_return_target = 0;
2787   if (((enum tree_code) (exp)->common.code)  == COMPOUND_EXPR)
2788     {
2789       expand_expr (((exp)->exp.operands[ 0]) , const0_rtx, VOIDmode, 0);
2790       emit_queue ();
2791       return store_expr (((exp)->exp.operands[ 1]) , target, suggest_reg);
2792     }
2793   else if (((enum tree_code) (exp)->common.code)  == COND_EXPR &&       ((target)->mode)  == BLKmode)
2794     {
2795       rtx lab1 = gen_label_rtx (), lab2 = gen_label_rtx ();
2796       emit_queue ();
2797       target = protect_from_queue (target, 1);
2798       (inhibit_defer_pop += 1) ;
2799       jumpifnot (((exp)->exp.operands[ 0]) , lab1);
2800       store_expr (((exp)->exp.operands[ 1]) , target, suggest_reg);
2801       emit_queue ();
2802       emit_jump_insn (gen_jump (lab2));
2803       emit_barrier ();
2804       emit_label (lab1);
2805       store_expr (((exp)->exp.operands[ 2]) , target, suggest_reg);
2806       emit_queue ();
2807       emit_label (lab2);
2808       (inhibit_defer_pop -= 1) ;
2809       return target;
2810     }
2811   else if (suggest_reg &&       ((target)->code)  == MEM
2812            &&   ((target)->mode)  != BLKmode)
2813     {
2814       temp = expand_expr (exp, cse_not_expected ? (rtx) 0  : target,
2815                                 ((target)->mode) , 0);
2816       if (      ((temp)->mode)  != BLKmode &&   ((temp)->mode)  != VOIDmode)
2817         temp = copy_to_reg (temp);
2818       dont_return_target = 1;
2819     }
2820   else if (queued_subexp_p (target))
2821     {
2822       if (      ((target)->mode)  != BLKmode &&         ((target)->mode)  != VOIDmode)
2823         {
2824           temp = gen_reg_rtx (  ((target)->mode) );
2825           temp = expand_expr (exp, temp,        ((target)->mode) , 0);
2826         }
2827       else
2828         temp = expand_expr (exp, (rtx) 0 ,      ((target)->mode) , 0);
2829       dont_return_target = 1;
2830     }
2831   else if (     ((target)->code)  == SUBREG && ((target)->in_struct) )
2832     {
2833       temp = expand_expr (exp, (rtx) 0 , VOIDmode, 0);
2834       convert_move (((target)->fld[0].rtx) , temp,
2835                     ((target)->unchanging) );
2836       return temp;
2837     }
2838   else
2839     {
2840       temp = expand_expr (exp, target,  ((target)->mode) , 0);
2841       if (!(target &&   ((target)->code)  == REG
2842             && ((target)->fld[0].rtint)  < 64 )
2843           && (  ((temp)->code)  == LABEL_REF ||         ((temp)->code)  == SYMBOL_REF   ||      ((temp)->code)  == CONST_INT ||         ((temp)->code)  == CONST_DOUBLE ||      ((temp)->code)  == CONST ||     ((temp)->code)  == HIGH) )
2844         dont_return_target = 1;
2845     }
2846   if (temp != target && ((enum tree_code) (exp)->common.code)  != ERROR_MARK)
2847     {
2848       target = protect_from_queue (target, 1);
2849       if (      ((temp)->mode)  !=      ((target)->mode) 
2850           &&    ((temp)->mode)  != VOIDmode)
2851         {
2852           int unsignedp = ((((exp)->common.type) )->common.unsigned_flag) ;
2853           if (dont_return_target)
2854             {
2855               temp = convert_to_mode (  ((target)->mode) , temp, unsignedp);
2856               emit_move_insn (target, temp);
2857             }
2858           else
2859             convert_move (target, temp, unsignedp);
2860         }
2861       else if ( ((temp)->mode)  == BLKmode && ((enum tree_code) (exp)->common.code)  == STRING_CST)
2862         {
2863           rtx size;
2864           size = expr_size (exp);
2865           if (  ((size)->code)  == CONST_INT
2866               && ((size)->fld[0].rtwint)  < ((exp)->string.length) )
2867             emit_block_move (target, temp, size,
2868                              ((((exp)->common.type) )->type.align)  / 8 );
2869           else
2870             {
2871               tree copy_size
2872                 = fold (build (MIN_EXPR, sizetype,
2873                                size_binop (CEIL_DIV_EXPR,
2874                                            ((((exp)->common.type) )->type.size) ,
2875                                            size_int (8 )),
2876                                convert (sizetype,
2877                                         build_int_2_wide ((int ) (((exp)->string.length) ), (int ) ( 0)) )));
2878               rtx copy_size_rtx = expand_expr (copy_size, (rtx) 0 ,
2879                                                VOIDmode, 0);
2880               rtx label = 0;
2881               emit_block_move (target, temp, copy_size_rtx,
2882                                ((((exp)->common.type) )->type.align)  / 8 );
2883               if (      ((copy_size_rtx)->code)  == CONST_INT)
2884                 {
2885                   temp = plus_constant_wide (((target)->fld[ 0].rtx) , (int ) (
2886                                         ((exp)->string.length) )) ;
2887                   size = plus_constant_wide (size, (int ) (
2888                                         - ((exp)->string.length) )) ;
2889                 }
2890               else
2891                 {
2892                   enum machine_mode size_mode = SImode ;
2893                   temp = force_reg (SImode , ((target)->fld[ 0].rtx) );
2894                   temp = expand_binop (size_mode, add_optab, temp,
2895                                        copy_size_rtx, (rtx) 0 , 0,
2896                                        OPTAB_LIB_WIDEN);
2897                   size = expand_binop (size_mode, sub_optab, size,
2898                                        copy_size_rtx, (rtx) 0 , 0,
2899                                        OPTAB_LIB_WIDEN);
2900                   emit_cmp_insn (size, const0_rtx, LT, (rtx) 0 ,
2901                                         ((size)->mode) , 0, 0);
2902                   label = gen_label_rtx ();
2903                   emit_jump_insn (gen_blt (label));
2904                 }
2905               if (size != const0_rtx)
2906                 {
2907                   emit_library_call (memset_libfunc, 0, VOIDmode, 3,
2908                                      temp, SImode , const0_rtx, SImode , size, SImode );
2909                 }
2910               if (label)
2911                 emit_label (label);
2912             }
2913         }
2914       else if ( ((temp)->mode)  == BLKmode)
2915         emit_block_move (target, temp, expr_size (exp),
2916                          ((((exp)->common.type) )->type.align)  / 8 );
2917       else
2918         emit_move_insn (target, temp);
2919     }
2920   if (dont_return_target)
2921     return temp;
2922   return target;
2923 }
2924 static void
2925 store_constructor (exp, target)
2926      tree exp;
2927      rtx target;
2928 {
2929   tree type = ((exp)->common.type) ;
2930   if (((enum tree_code) (type)->common.code)  == RECORD_TYPE || ((enum tree_code) (type)->common.code)  == UNION_TYPE)
2931     {
2932       register tree elt;
2933       if (((enum tree_code) (type)->common.code)  == UNION_TYPE)
2934         emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
2935       else if ( ((target)->code)  == REG && ((exp)->common.static_flag) )
2936         emit_move_insn (target, const0_rtx);
2937       else if (list_length (((exp)->exp.operands[ 1])  )
2938                != list_length (((type)->type.values) ))
2939         clear_storage (target, int_size_in_bytes (type));
2940       else
2941         emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
2942       for (elt = ((exp)->exp.operands[ 1])  ; elt; elt = ((elt)->common.chain) )
2943         {
2944           register tree field = ((elt)->list.purpose) ;
2945           register enum machine_mode mode;
2946           int bitsize;
2947           int bitpos;
2948           int unsignedp;
2949           if (field == 0)
2950             continue;
2951           bitsize = ((((field)->decl.size) )->int_cst.int_cst_low) ;
2952           unsignedp = ((field)->common.unsigned_flag) ;
2953           mode = ((field)->decl.mode) ;
2954           if (((field)->decl.bit_field_flag) )
2955             mode = VOIDmode;
2956           if (((enum tree_code) (((field)->decl.arguments) )->common.code)  != INTEGER_CST)
2957             abort ();
2958           bitpos = ((((field)->decl.arguments) )->int_cst.int_cst_low) ;
2959           store_field (target, bitsize, bitpos, mode, ((elt)->list.value) ,
2960                        VOIDmode, 0,
2961                        ((type)->type.align)  / 8 ,
2962                        int_size_in_bytes (type));
2963         }
2964     }
2965   else if (((enum tree_code) (type)->common.code)  == ARRAY_TYPE)
2966     {
2967       register tree elt;
2968       register int i;
2969       tree domain = ((type)->type.values) ;
2970       int  minelt = ((((domain)->type.minval) )->int_cst.int_cst_low) ;
2971       int  maxelt = ((((domain)->type.maxval) )->int_cst.int_cst_low) ;
2972       tree elttype = ((type)->common.type) ;
2973       if (list_length (((exp)->exp.operands[ 1])  ) < maxelt - minelt + 1
2974           || (  ((target)->code)  == REG && ((exp)->common.static_flag) ))
2975         clear_storage (target, maxelt - minelt + 1);
2976       else
2977         emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
2978       for (elt = ((exp)->exp.operands[ 1])  , i = 0;
2979            elt;
2980            elt = ((elt)->common.chain) , i++)
2981         {
2982           register enum machine_mode mode;
2983           int bitsize;
2984           int bitpos;
2985           int unsignedp;
2986           mode = ((elttype)->type.mode) ;
2987           bitsize =  (8  * mode_size[(int)(mode)]) ;
2988           unsignedp = ((elttype)->common.unsigned_flag) ;
2989           bitpos = (i * ((((elttype)->type.size) )->int_cst.int_cst_low) );
2990           store_field (target, bitsize, bitpos, mode, ((elt)->list.value) ,
2991                        VOIDmode, 0,
2992                        ((type)->type.align)  / 8 ,
2993                        int_size_in_bytes (type));
2994         }
2995     }
2996   else
2997     abort ();
2998 }
2999 static rtx
3000 store_field (target, bitsize, bitpos, mode, exp, value_mode,
3001              unsignedp, align, total_size)
3002      rtx target;
3003      int bitsize, bitpos;
3004      enum machine_mode mode;
3005      tree exp;
3006      enum machine_mode value_mode;
3007      int unsignedp;
3008      int align;
3009      int total_size;
3010 {
3011   int  width_mask = 0;
3012   if (bitsize < 32  )
3013     width_mask = ((int ) 1 << bitsize) - 1;
3014   if (mode == BLKmode
3015       && (      ((target)->code)  == REG ||     ((target)->code)  == SUBREG))
3016     {
3017       rtx object = assign_stack_temp (  ((target)->mode) ,
3018                                         (mode_size[(int)(       ((target)->mode) )]) , 0);
3019       rtx blk_object = copy_rtx (object);
3020       ((blk_object)->mode = ( BLKmode)) ;
3021       if (bitsize !=  (8  * mode_size[(int)(    ((target)->mode) )]) )
3022         emit_move_insn (object, target);
3023       store_field (blk_object, bitsize, bitpos, mode, exp, VOIDmode, 0,
3024                    align, total_size);
3025       emit_move_insn (target, object);
3026       return target;
3027     }
3028   if (mode == VOIDmode
3029       || (mode != BLKmode && ! direct_store[(int) mode])
3030       ||        ((target)->code)  == REG
3031       ||        ((target)->code)  == SUBREG)
3032     {
3033       rtx temp = expand_expr (exp, (rtx) 0 , VOIDmode, 0);
3034       store_bit_field (target, bitsize, bitpos, mode, temp, align, total_size);
3035       if (value_mode != VOIDmode)
3036         {
3037           if (width_mask != 0
3038               && ! (    ((target)->code)  == MEM && ((target)->volatil) ))
3039             {
3040               tree count;
3041               enum machine_mode tmode;
3042               if (unsignedp)
3043                 return expand_and (temp, gen_rtx (CONST_INT, VOIDmode, (width_mask)) , (rtx) 0 );
3044               tmode =   ((temp)->mode) ;
3045               if (tmode == VOIDmode)
3046                 tmode = value_mode;
3047               count = build_int_2_wide ((int ) ( (8  * mode_size[(int)(tmode)])  - bitsize), (int ) ( 0)) ;
3048               temp = expand_shift (LSHIFT_EXPR, tmode, temp, count, 0, 0);
3049               return expand_shift (RSHIFT_EXPR, tmode, temp, count, 0, 0);
3050             }
3051           return extract_bit_field (target, bitsize, bitpos, unsignedp,
3052                                     (rtx) 0 , value_mode, 0, align,
3053                                     total_size);
3054         }
3055       return const0_rtx;
3056     }
3057   else
3058     {
3059       rtx addr = ((target)->fld[ 0].rtx) ;
3060       rtx to_rtx;
3061       if (value_mode != VOIDmode &&     ((addr)->code)  != REG
3062           && ! ((       ((addr)->code)  == LABEL_REF ||         ((addr)->code)  == SYMBOL_REF   ||      ((addr)->code)  == CONST_INT ||         ((addr)->code)  == CONST_DOUBLE ||      ((addr)->code)  == CONST ||     ((addr)->code)  == HIGH) ) 
3063           && ! (        ((addr)->code)  == PLUS
3064                 &&      ((((addr)->fld[ 1].rtx) )->code)  == CONST_INT
3065                 && (((addr)->fld[ 0].rtx)  == virtual_incoming_args_rtx
3066                     || ((addr)->fld[ 0].rtx)  == virtual_stack_vars_rtx)))
3067         addr = copy_to_reg (addr);
3068       to_rtx = change_address (target, mode,
3069                                plus_constant_wide (addr, (int ) ( (bitpos / 8 ))) );
3070       ((to_rtx)->in_struct)  = 1;
3071       return store_expr (exp, to_rtx, value_mode != VOIDmode);
3072     }
3073 }
3074 tree
3075 get_inner_reference (exp, pbitsize, pbitpos, poffset, pmode, punsignedp, pvolatilep)
3076      tree exp;
3077      int *pbitsize;
3078      int *pbitpos;
3079      tree *poffset;
3080      enum machine_mode *pmode;
3081      int *punsignedp;
3082      int *pvolatilep;
3083 {
3084   tree size_tree = 0;
3085   enum machine_mode mode = VOIDmode;
3086   tree offset = 0;
3087   if (((enum tree_code) (exp)->common.code)  == COMPONENT_REF)
3088     {
3089       size_tree = ((((exp)->exp.operands[ 1]) )->decl.size) ;
3090       if (! ((((exp)->exp.operands[ 1]) )->decl.bit_field_flag) )
3091         mode = ((((exp)->exp.operands[ 1]) )->decl.mode) ;
3092       *punsignedp = ((((exp)->exp.operands[ 1]) )->common.unsigned_flag) ;
3093     }
3094   else if (((enum tree_code) (exp)->common.code)  == BIT_FIELD_REF)
3095     {
3096       size_tree = ((exp)->exp.operands[ 1]) ;
3097       *punsignedp = ((exp)->common.unsigned_flag) ;
3098     }
3099   else
3100     {
3101       mode = ((((exp)->common.type) )->type.mode) ;
3102       *pbitsize =  (8  * mode_size[(int)(mode)]) ;
3103       *punsignedp = ((((exp)->common.type) )->common.unsigned_flag) ;
3104     }
3105   if (size_tree)
3106     {
3107       if (((enum tree_code) (size_tree)->common.code)  != INTEGER_CST)
3108         mode = BLKmode, *pbitsize = -1;
3109       else
3110         *pbitsize = ((size_tree)->int_cst.int_cst_low) ;
3111     }
3112   *pbitpos = 0;
3113   while (1)
3114     {
3115       if (((enum tree_code) (exp)->common.code)  == INDIRECT_REF && flag_volatile)
3116         *pvolatilep = 1;
3117       if (((enum tree_code) (exp)->common.code)  == COMPONENT_REF || ((enum tree_code) (exp)->common.code)  == BIT_FIELD_REF)
3118         {
3119           tree pos = (((enum tree_code) (exp)->common.code)  == COMPONENT_REF
3120                       ? ((((exp)->exp.operands[ 1]) )->decl.arguments) 
3121                       : ((exp)->exp.operands[ 2]) );
3122           if (((enum tree_code) (pos)->common.code)  == PLUS_EXPR)
3123             {
3124               tree constant, var;
3125               if (((enum tree_code) (((pos)->exp.operands[ 0]) )->common.code)  == INTEGER_CST)
3126                 {
3127                   constant = ((pos)->exp.operands[ 0]) ;
3128                   var = ((pos)->exp.operands[ 1]) ;
3129                 }
3130               else if (((enum tree_code) (((pos)->exp.operands[ 1]) )->common.code)  == INTEGER_CST)
3131                 {
3132                   constant = ((pos)->exp.operands[ 1]) ;
3133                   var = ((pos)->exp.operands[ 0]) ;
3134                 }
3135               else
3136                 abort ();
3137               *pbitpos += ((constant)->int_cst.int_cst_low) ;
3138               if (offset)
3139                 offset = size_binop (PLUS_EXPR, offset,
3140                                      size_binop (FLOOR_DIV_EXPR, var,
3141                                                  size_int (8 )));
3142               else
3143                 offset = size_binop (FLOOR_DIV_EXPR, var,
3144                                      size_int (8 ));
3145             }
3146           else if (((enum tree_code) (pos)->common.code)  == INTEGER_CST)
3147             *pbitpos += ((pos)->int_cst.int_cst_low) ;
3148           else
3149             {
3150               if (offset)
3151                 offset = size_binop (PLUS_EXPR, offset,
3152                                      size_binop (FLOOR_DIV_EXPR, pos,
3153                                                  size_int (8 )));
3154               else
3155                 offset = size_binop (FLOOR_DIV_EXPR, pos,
3156                                      size_int (8 ));
3157             }
3158         }
3159       else if (((enum tree_code) (exp)->common.code)  == ARRAY_REF
3160                && ((enum tree_code) (((exp)->exp.operands[ 1]) )->common.code)  == INTEGER_CST
3161                && ((enum tree_code) (((((exp)->common.type) )->type.size) )->common.code)  == INTEGER_CST)
3162         {
3163           *pbitpos += (((((exp)->exp.operands[ 1]) )->int_cst.int_cst_low) 
3164                        * ((((((exp)->common.type) )->type.size) )->int_cst.int_cst_low) );
3165         }
3166       else if (((enum tree_code) (exp)->common.code)  != NON_LVALUE_EXPR
3167                && ! ((((enum tree_code) (exp)->common.code)  == NOP_EXPR
3168                       || ((enum tree_code) (exp)->common.code)  == CONVERT_EXPR)
3169                      && (((((exp)->common.type) )->type.mode) 
3170                          == ((((((exp)->exp.operands[ 0]) )->common.type) )->type.mode) )))
3171         break;
3172       if (((exp)->common.volatile_flag) )
3173         *pvolatilep = 1;
3174       exp = ((exp)->exp.operands[ 0]) ;
3175     }
3176   if (mode == VOIDmode && *pbitpos % *pbitsize == 0)
3177     {
3178       mode = mode_for_size (*pbitsize, MODE_INT, 0);
3179       if (mode == BLKmode)
3180         mode = VOIDmode;
3181     }
3182   *pmode = mode;
3183   *poffset = offset;
3184   return exp;
3185 }
3186 rtx
3187 force_operand (value, target)
3188      rtx value, target;
3189 {
3190   register optab binoptab = 0;
3191   rtx tmp;
3192   register rtx op2;
3193   register rtx subtarget = (target != 0 &&      ((target)->code)  == REG ? target : 0);
3194   if (  ((value)->code)  == PLUS)
3195     binoptab = add_optab;
3196   else if (     ((value)->code)  == MINUS)
3197     binoptab = sub_optab;
3198   else if (     ((value)->code)  == MULT)
3199     {
3200       op2 = ((value)->fld[ 1].rtx) ;
3201       if (!(    ((op2)->code)  == LABEL_REF ||  ((op2)->code)  == SYMBOL_REF    ||      ((op2)->code)  == CONST_INT ||  ((op2)->code)  == CONST_DOUBLE  ||      ((op2)->code)  == CONST ||      ((op2)->code)  == HIGH) 
3202           && !( ((op2)->code)  == REG && op2 != subtarget))
3203         subtarget = 0;
3204       tmp = force_operand (((value)->fld[ 0].rtx) , subtarget);
3205       return expand_mult (      ((value)->mode) , tmp,
3206                           force_operand (op2, (rtx) 0 ),
3207                           target, 0);
3208     }
3209   if (binoptab)
3210     {
3211       op2 = ((value)->fld[ 1].rtx) ;
3212       if (!(    ((op2)->code)  == LABEL_REF ||  ((op2)->code)  == SYMBOL_REF    ||      ((op2)->code)  == CONST_INT ||  ((op2)->code)  == CONST_DOUBLE  ||      ((op2)->code)  == CONST ||      ((op2)->code)  == HIGH) 
3213           && !( ((op2)->code)  == REG && op2 != subtarget))
3214         subtarget = 0;
3215       if (binoptab == sub_optab &&      ((op2)->code)  == CONST_INT)
3216         {
3217           binoptab = add_optab;
3218           op2 = negate_rtx (    ((value)->mode) , op2);
3219         }
3220       if (binoptab == add_optab &&      ((op2)->code)  == CONST_INT
3221           &&    ((((value)->fld[ 0].rtx) )->code)  == PLUS
3222           &&    ((((((value)->fld[ 0].rtx) )->fld[ 0].rtx) )->code)  == REG
3223           && ((((((value)->fld[ 0].rtx) )->fld[ 0].rtx) )->fld[0].rtint)  >= (64 ) 
3224           && ((((((value)->fld[ 0].rtx) )->fld[ 0].rtx) )->fld[0].rtint)  <= (((64 ) ) + 3) )
3225         {
3226           rtx temp = expand_binop (     ((value)->mode) , binoptab,
3227                                    ((((value)->fld[ 0].rtx) )->fld[ 0].rtx) , op2,
3228                                    subtarget, 0, OPTAB_LIB_WIDEN);
3229           return expand_binop ( ((value)->mode) , binoptab, temp,
3230                                force_operand (((((value)->fld[ 0].rtx) )->fld[ 1].rtx) , 0),
3231                                target, 0, OPTAB_LIB_WIDEN);
3232         }
3233       tmp = force_operand (((value)->fld[ 0].rtx) , subtarget);
3234       return expand_binop (     ((value)->mode) , binoptab, tmp,
3235                            force_operand (op2, (rtx) 0 ),
3236                            target, 0, OPTAB_LIB_WIDEN);
3237     }
3238   return value;
3239 }
3240 static tree
3241 save_noncopied_parts (lhs, list)
3242      tree lhs;
3243      tree list;
3244 {
3245   tree tail;
3246   tree parts = 0;
3247   for (tail = list; tail; tail = ((tail)->common.chain) )
3248     if (((enum tree