OSDN Git Service

* config/alpha/alpha.c: Include libfuncs.h
[pf3gnuchains/gcc-fork.git] / gcc / config / alpha / alpha.c
1 /* Subroutines used for code generation on the DEC Alpha.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4    Free Software Foundation, Inc.
5    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
6
7 This file is part of GCC.
8
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3.  If not see
21 <http://www.gnu.org/licenses/>.  */
22
23
24 #include "config.h"
25 #include "system.h"
26 #include "coretypes.h"
27 #include "tm.h"
28 #include "rtl.h"
29 #include "tree.h"
30 #include "regs.h"
31 #include "hard-reg-set.h"
32 #include "real.h"
33 #include "insn-config.h"
34 #include "conditions.h"
35 #include "output.h"
36 #include "insn-attr.h"
37 #include "flags.h"
38 #include "recog.h"
39 #include "expr.h"
40 #include "optabs.h"
41 #include "reload.h"
42 #include "obstack.h"
43 #include "except.h"
44 #include "function.h"
45 #include "toplev.h"
46 #include "ggc.h"
47 #include "integrate.h"
48 #include "tm_p.h"
49 #include "target.h"
50 #include "target-def.h"
51 #include "debug.h"
52 #include "langhooks.h"
53 #include <splay-tree.h>
54 #include "cfglayout.h"
55 #include "gimple.h"
56 #include "tree-flow.h"
57 #include "tree-stdarg.h"
58 #include "tm-constrs.h"
59 #include "df.h"
60 #include "libfuncs.h"
61
62 /* Specify which cpu to schedule for.  */
63 enum processor_type alpha_tune;
64
65 /* Which cpu we're generating code for.  */
66 enum processor_type alpha_cpu;
67
68 static const char * const alpha_cpu_name[] =
69 {
70   "ev4", "ev5", "ev6"
71 };
72
73 /* Specify how accurate floating-point traps need to be.  */
74
75 enum alpha_trap_precision alpha_tp;
76
77 /* Specify the floating-point rounding mode.  */
78
79 enum alpha_fp_rounding_mode alpha_fprm;
80
81 /* Specify which things cause traps.  */
82
83 enum alpha_fp_trap_mode alpha_fptm;
84
85 /* Nonzero if inside of a function, because the Alpha asm can't
86    handle .files inside of functions.  */
87
88 static int inside_function = FALSE;
89
90 /* The number of cycles of latency we should assume on memory reads.  */
91
92 int alpha_memory_latency = 3;
93
94 /* Whether the function needs the GP.  */
95
96 static int alpha_function_needs_gp;
97
98 /* The alias set for prologue/epilogue register save/restore.  */
99
100 static GTY(()) alias_set_type alpha_sr_alias_set;
101
102 /* The assembler name of the current function.  */
103
104 static const char *alpha_fnname;
105
106 /* The next explicit relocation sequence number.  */
107 extern GTY(()) int alpha_next_sequence_number;
108 int alpha_next_sequence_number = 1;
109
110 /* The literal and gpdisp sequence numbers for this insn, as printed
111    by %# and %* respectively.  */
112 extern GTY(()) int alpha_this_literal_sequence_number;
113 extern GTY(()) int alpha_this_gpdisp_sequence_number;
114 int alpha_this_literal_sequence_number;
115 int alpha_this_gpdisp_sequence_number;
116
117 /* Costs of various operations on the different architectures.  */
118
119 struct alpha_rtx_cost_data
120 {
121   unsigned char fp_add;
122   unsigned char fp_mult;
123   unsigned char fp_div_sf;
124   unsigned char fp_div_df;
125   unsigned char int_mult_si;
126   unsigned char int_mult_di;
127   unsigned char int_shift;
128   unsigned char int_cmov;
129   unsigned short int_div;
130 };
131
132 static struct alpha_rtx_cost_data const alpha_rtx_cost_data[PROCESSOR_MAX] =
133 {
134   { /* EV4 */
135     COSTS_N_INSNS (6),          /* fp_add */
136     COSTS_N_INSNS (6),          /* fp_mult */
137     COSTS_N_INSNS (34),         /* fp_div_sf */
138     COSTS_N_INSNS (63),         /* fp_div_df */
139     COSTS_N_INSNS (23),         /* int_mult_si */
140     COSTS_N_INSNS (23),         /* int_mult_di */
141     COSTS_N_INSNS (2),          /* int_shift */
142     COSTS_N_INSNS (2),          /* int_cmov */
143     COSTS_N_INSNS (97),         /* int_div */
144   },
145   { /* EV5 */
146     COSTS_N_INSNS (4),          /* fp_add */
147     COSTS_N_INSNS (4),          /* fp_mult */
148     COSTS_N_INSNS (15),         /* fp_div_sf */
149     COSTS_N_INSNS (22),         /* fp_div_df */
150     COSTS_N_INSNS (8),          /* int_mult_si */
151     COSTS_N_INSNS (12),         /* int_mult_di */
152     COSTS_N_INSNS (1) + 1,      /* int_shift */
153     COSTS_N_INSNS (1),          /* int_cmov */
154     COSTS_N_INSNS (83),         /* int_div */
155   },
156   { /* EV6 */
157     COSTS_N_INSNS (4),          /* fp_add */
158     COSTS_N_INSNS (4),          /* fp_mult */
159     COSTS_N_INSNS (12),         /* fp_div_sf */
160     COSTS_N_INSNS (15),         /* fp_div_df */
161     COSTS_N_INSNS (7),          /* int_mult_si */
162     COSTS_N_INSNS (7),          /* int_mult_di */
163     COSTS_N_INSNS (1),          /* int_shift */
164     COSTS_N_INSNS (2),          /* int_cmov */
165     COSTS_N_INSNS (86),         /* int_div */
166   },
167 };
168
169 /* Similar but tuned for code size instead of execution latency.  The
170    extra +N is fractional cost tuning based on latency.  It's used to
171    encourage use of cheaper insns like shift, but only if there's just
172    one of them.  */
173
174 static struct alpha_rtx_cost_data const alpha_rtx_cost_size =
175 {
176   COSTS_N_INSNS (1),            /* fp_add */
177   COSTS_N_INSNS (1),            /* fp_mult */
178   COSTS_N_INSNS (1),            /* fp_div_sf */
179   COSTS_N_INSNS (1) + 1,        /* fp_div_df */
180   COSTS_N_INSNS (1) + 1,        /* int_mult_si */
181   COSTS_N_INSNS (1) + 2,        /* int_mult_di */
182   COSTS_N_INSNS (1),            /* int_shift */
183   COSTS_N_INSNS (1),            /* int_cmov */
184   COSTS_N_INSNS (6),            /* int_div */
185 };
186
187 /* Get the number of args of a function in one of two ways.  */
188 #if TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK
189 #define NUM_ARGS crtl->args.info.num_args
190 #else
191 #define NUM_ARGS crtl->args.info
192 #endif
193
194 #define REG_PV 27
195 #define REG_RA 26
196
197 /* Declarations of static functions.  */
198 static struct machine_function *alpha_init_machine_status (void);
199 static rtx alpha_emit_xfloating_compare (enum rtx_code *, rtx, rtx);
200
201 #if TARGET_ABI_OPEN_VMS
202 static void alpha_write_linkage (FILE *, const char *, tree);
203 #endif
204
205 static void unicosmk_output_deferred_case_vectors (FILE *);
206 static void unicosmk_gen_dsib (unsigned long *);
207 static void unicosmk_output_ssib (FILE *, const char *);
208 static int unicosmk_need_dex (rtx);
209 \f
210 /* Implement TARGET_HANDLE_OPTION.  */
211
212 static bool
213 alpha_handle_option (size_t code, const char *arg, int value)
214 {
215   switch (code)
216     {
217     case OPT_mfp_regs:
218       if (value == 0)
219         target_flags |= MASK_SOFT_FP;
220       break;
221
222     case OPT_mieee:
223     case OPT_mieee_with_inexact:
224       target_flags |= MASK_IEEE_CONFORMANT;
225       break;
226
227     case OPT_mtls_size_:
228       if (value != 16 && value != 32 && value != 64)
229         error ("bad value %qs for -mtls-size switch", arg);
230       break;
231     }
232
233   return true;
234 }
235
236 #ifdef TARGET_ALTERNATE_LONG_DOUBLE_MANGLING
237 /* Implement TARGET_MANGLE_TYPE.  */
238
239 static const char *
240 alpha_mangle_type (const_tree type)
241 {
242   if (TYPE_MAIN_VARIANT (type) == long_double_type_node
243       && TARGET_LONG_DOUBLE_128)
244     return "g";
245
246   /* For all other types, use normal C++ mangling.  */
247   return NULL;
248 }
249 #endif
250
251 /* Parse target option strings.  */
252
253 void
254 override_options (void)
255 {
256   static const struct cpu_table {
257     const char *const name;
258     const enum processor_type processor;
259     const int flags;
260   } cpu_table[] = {
261     { "ev4",    PROCESSOR_EV4, 0 },
262     { "ev45",   PROCESSOR_EV4, 0 },
263     { "21064",  PROCESSOR_EV4, 0 },
264     { "ev5",    PROCESSOR_EV5, 0 },
265     { "21164",  PROCESSOR_EV5, 0 },
266     { "ev56",   PROCESSOR_EV5, MASK_BWX },
267     { "21164a", PROCESSOR_EV5, MASK_BWX },
268     { "pca56",  PROCESSOR_EV5, MASK_BWX|MASK_MAX },
269     { "21164PC",PROCESSOR_EV5, MASK_BWX|MASK_MAX },
270     { "21164pc",PROCESSOR_EV5, MASK_BWX|MASK_MAX },
271     { "ev6",    PROCESSOR_EV6, MASK_BWX|MASK_MAX|MASK_FIX },
272     { "21264",  PROCESSOR_EV6, MASK_BWX|MASK_MAX|MASK_FIX },
273     { "ev67",   PROCESSOR_EV6, MASK_BWX|MASK_MAX|MASK_FIX|MASK_CIX },
274     { "21264a", PROCESSOR_EV6, MASK_BWX|MASK_MAX|MASK_FIX|MASK_CIX }
275   };
276
277   int const ct_size = ARRAY_SIZE (cpu_table);
278   int i;
279
280   /* Unicos/Mk doesn't have shared libraries.  */
281   if (TARGET_ABI_UNICOSMK && flag_pic)
282     {
283       warning (0, "-f%s ignored for Unicos/Mk (not supported)",
284                (flag_pic > 1) ? "PIC" : "pic");
285       flag_pic = 0;
286     }
287
288   /* On Unicos/Mk, the native compiler consistently generates /d suffices for
289      floating-point instructions.  Make that the default for this target.  */
290   if (TARGET_ABI_UNICOSMK)
291     alpha_fprm = ALPHA_FPRM_DYN;
292   else
293     alpha_fprm = ALPHA_FPRM_NORM;
294
295   alpha_tp = ALPHA_TP_PROG;
296   alpha_fptm = ALPHA_FPTM_N;
297
298   /* We cannot use su and sui qualifiers for conversion instructions on
299      Unicos/Mk.  I'm not sure if this is due to assembler or hardware
300      limitations.  Right now, we issue a warning if -mieee is specified
301      and then ignore it; eventually, we should either get it right or
302      disable the option altogether.  */
303
304   if (TARGET_IEEE)
305     {
306       if (TARGET_ABI_UNICOSMK)
307         warning (0, "-mieee not supported on Unicos/Mk");
308       else
309         {
310           alpha_tp = ALPHA_TP_INSN;
311           alpha_fptm = ALPHA_FPTM_SU;
312         }
313     }
314
315   if (TARGET_IEEE_WITH_INEXACT)
316     {
317       if (TARGET_ABI_UNICOSMK)
318         warning (0, "-mieee-with-inexact not supported on Unicos/Mk");
319       else
320         {
321           alpha_tp = ALPHA_TP_INSN;
322           alpha_fptm = ALPHA_FPTM_SUI;
323         }
324     }
325
326   if (alpha_tp_string)
327     {
328       if (! strcmp (alpha_tp_string, "p"))
329         alpha_tp = ALPHA_TP_PROG;
330       else if (! strcmp (alpha_tp_string, "f"))
331         alpha_tp = ALPHA_TP_FUNC;
332       else if (! strcmp (alpha_tp_string, "i"))
333         alpha_tp = ALPHA_TP_INSN;
334       else
335         error ("bad value %qs for -mtrap-precision switch", alpha_tp_string);
336     }
337
338   if (alpha_fprm_string)
339     {
340       if (! strcmp (alpha_fprm_string, "n"))
341         alpha_fprm = ALPHA_FPRM_NORM;
342       else if (! strcmp (alpha_fprm_string, "m"))
343         alpha_fprm = ALPHA_FPRM_MINF;
344       else if (! strcmp (alpha_fprm_string, "c"))
345         alpha_fprm = ALPHA_FPRM_CHOP;
346       else if (! strcmp (alpha_fprm_string,"d"))
347         alpha_fprm = ALPHA_FPRM_DYN;
348       else
349         error ("bad value %qs for -mfp-rounding-mode switch",
350                alpha_fprm_string);
351     }
352
353   if (alpha_fptm_string)
354     {
355       if (strcmp (alpha_fptm_string, "n") == 0)
356         alpha_fptm = ALPHA_FPTM_N;
357       else if (strcmp (alpha_fptm_string, "u") == 0)
358         alpha_fptm = ALPHA_FPTM_U;
359       else if (strcmp (alpha_fptm_string, "su") == 0)
360         alpha_fptm = ALPHA_FPTM_SU;
361       else if (strcmp (alpha_fptm_string, "sui") == 0)
362         alpha_fptm = ALPHA_FPTM_SUI;
363       else
364         error ("bad value %qs for -mfp-trap-mode switch", alpha_fptm_string);
365     }
366
367   if (alpha_cpu_string)
368     {
369       for (i = 0; i < ct_size; i++)
370         if (! strcmp (alpha_cpu_string, cpu_table [i].name))
371           {
372             alpha_tune = alpha_cpu = cpu_table [i].processor;
373             target_flags &= ~ (MASK_BWX | MASK_MAX | MASK_FIX | MASK_CIX);
374             target_flags |= cpu_table [i].flags;
375             break;
376           }
377       if (i == ct_size)
378         error ("bad value %qs for -mcpu switch", alpha_cpu_string);
379     }
380
381   if (alpha_tune_string)
382     {
383       for (i = 0; i < ct_size; i++)
384         if (! strcmp (alpha_tune_string, cpu_table [i].name))
385           {
386             alpha_tune = cpu_table [i].processor;
387             break;
388           }
389       if (i == ct_size)
390         error ("bad value %qs for -mcpu switch", alpha_tune_string);
391     }
392
393   /* Do some sanity checks on the above options.  */
394
395   if (TARGET_ABI_UNICOSMK && alpha_fptm != ALPHA_FPTM_N)
396     {
397       warning (0, "trap mode not supported on Unicos/Mk");
398       alpha_fptm = ALPHA_FPTM_N;
399     }
400
401   if ((alpha_fptm == ALPHA_FPTM_SU || alpha_fptm == ALPHA_FPTM_SUI)
402       && alpha_tp != ALPHA_TP_INSN && alpha_cpu != PROCESSOR_EV6)
403     {
404       warning (0, "fp software completion requires -mtrap-precision=i");
405       alpha_tp = ALPHA_TP_INSN;
406     }
407
408   if (alpha_cpu == PROCESSOR_EV6)
409     {
410       /* Except for EV6 pass 1 (not released), we always have precise
411          arithmetic traps.  Which means we can do software completion
412          without minding trap shadows.  */
413       alpha_tp = ALPHA_TP_PROG;
414     }
415
416   if (TARGET_FLOAT_VAX)
417     {
418       if (alpha_fprm == ALPHA_FPRM_MINF || alpha_fprm == ALPHA_FPRM_DYN)
419         {
420           warning (0, "rounding mode not supported for VAX floats");
421           alpha_fprm = ALPHA_FPRM_NORM;
422         }
423       if (alpha_fptm == ALPHA_FPTM_SUI)
424         {
425           warning (0, "trap mode not supported for VAX floats");
426           alpha_fptm = ALPHA_FPTM_SU;
427         }
428       if (target_flags_explicit & MASK_LONG_DOUBLE_128)
429         warning (0, "128-bit long double not supported for VAX floats");
430       target_flags &= ~MASK_LONG_DOUBLE_128;
431     }
432
433   {
434     char *end;
435     int lat;
436
437     if (!alpha_mlat_string)
438       alpha_mlat_string = "L1";
439
440     if (ISDIGIT ((unsigned char)alpha_mlat_string[0])
441         && (lat = strtol (alpha_mlat_string, &end, 10), *end == '\0'))
442       ;
443     else if ((alpha_mlat_string[0] == 'L' || alpha_mlat_string[0] == 'l')
444              && ISDIGIT ((unsigned char)alpha_mlat_string[1])
445              && alpha_mlat_string[2] == '\0')
446       {
447         static int const cache_latency[][4] =
448         {
449           { 3, 30, -1 },        /* ev4 -- Bcache is a guess */
450           { 2, 12, 38 },        /* ev5 -- Bcache from PC164 LMbench numbers */
451           { 3, 12, 30 },        /* ev6 -- Bcache from DS20 LMbench.  */
452         };
453
454         lat = alpha_mlat_string[1] - '0';
455         if (lat <= 0 || lat > 3 || cache_latency[alpha_tune][lat-1] == -1)
456           {
457             warning (0, "L%d cache latency unknown for %s",
458                      lat, alpha_cpu_name[alpha_tune]);
459             lat = 3;
460           }
461         else
462           lat = cache_latency[alpha_tune][lat-1];
463       }
464     else if (! strcmp (alpha_mlat_string, "main"))
465       {
466         /* Most current memories have about 370ns latency.  This is
467            a reasonable guess for a fast cpu.  */
468         lat = 150;
469       }
470     else
471       {
472         warning (0, "bad value %qs for -mmemory-latency", alpha_mlat_string);
473         lat = 3;
474       }
475
476     alpha_memory_latency = lat;
477   }
478
479   /* Default the definition of "small data" to 8 bytes.  */
480   if (!g_switch_set)
481     g_switch_value = 8;
482
483   /* Infer TARGET_SMALL_DATA from -fpic/-fPIC.  */
484   if (flag_pic == 1)
485     target_flags |= MASK_SMALL_DATA;
486   else if (flag_pic == 2)
487     target_flags &= ~MASK_SMALL_DATA;
488
489   /* Align labels and loops for optimal branching.  */
490   /* ??? Kludge these by not doing anything if we don't optimize and also if
491      we are writing ECOFF symbols to work around a bug in DEC's assembler.  */
492   if (optimize > 0 && write_symbols != SDB_DEBUG)
493     {
494       if (align_loops <= 0)
495         align_loops = 16;
496       if (align_jumps <= 0)
497         align_jumps = 16;
498     }
499   if (align_functions <= 0)
500     align_functions = 16;
501
502   /* Acquire a unique set number for our register saves and restores.  */
503   alpha_sr_alias_set = new_alias_set ();
504
505   /* Register variables and functions with the garbage collector.  */
506
507   /* Set up function hooks.  */
508   init_machine_status = alpha_init_machine_status;
509
510   /* Tell the compiler when we're using VAX floating point.  */
511   if (TARGET_FLOAT_VAX)
512     {
513       REAL_MODE_FORMAT (SFmode) = &vax_f_format;
514       REAL_MODE_FORMAT (DFmode) = &vax_g_format;
515       REAL_MODE_FORMAT (TFmode) = NULL;
516     }
517
518 #ifdef TARGET_DEFAULT_LONG_DOUBLE_128
519   if (!(target_flags_explicit & MASK_LONG_DOUBLE_128))
520     target_flags |= MASK_LONG_DOUBLE_128;
521 #endif
522
523   /* If using typedef char *va_list, signal that __builtin_va_start (&ap, 0)
524      can be optimized to ap = __builtin_next_arg (0).  */
525   if (TARGET_ABI_UNICOSMK)
526     targetm.expand_builtin_va_start = NULL;
527 }
528 \f
529 /* Returns 1 if VALUE is a mask that contains full bytes of zero or ones.  */
530
531 int
532 zap_mask (HOST_WIDE_INT value)
533 {
534   int i;
535
536   for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
537        i++, value >>= 8)
538     if ((value & 0xff) != 0 && (value & 0xff) != 0xff)
539       return 0;
540
541   return 1;
542 }
543
544 /* Return true if OP is valid for a particular TLS relocation.
545    We are already guaranteed that OP is a CONST.  */
546
547 int
548 tls_symbolic_operand_1 (rtx op, int size, int unspec)
549 {
550   op = XEXP (op, 0);
551
552   if (GET_CODE (op) != UNSPEC || XINT (op, 1) != unspec)
553     return 0;
554   op = XVECEXP (op, 0, 0);
555
556   if (GET_CODE (op) != SYMBOL_REF)
557     return 0;
558
559   switch (SYMBOL_REF_TLS_MODEL (op))
560     {
561     case TLS_MODEL_LOCAL_DYNAMIC:
562       return unspec == UNSPEC_DTPREL && size == alpha_tls_size;
563     case TLS_MODEL_INITIAL_EXEC:
564       return unspec == UNSPEC_TPREL && size == 64;
565     case TLS_MODEL_LOCAL_EXEC:
566       return unspec == UNSPEC_TPREL && size == alpha_tls_size;
567     default:
568       gcc_unreachable ();
569     }
570 }
571
572 /* Used by aligned_memory_operand and unaligned_memory_operand to
573    resolve what reload is going to do with OP if it's a register.  */
574
575 rtx
576 resolve_reload_operand (rtx op)
577 {
578   if (reload_in_progress)
579     {
580       rtx tmp = op;
581       if (GET_CODE (tmp) == SUBREG)
582         tmp = SUBREG_REG (tmp);
583       if (REG_P (tmp)
584           && REGNO (tmp) >= FIRST_PSEUDO_REGISTER)
585         {
586           op = reg_equiv_memory_loc[REGNO (tmp)];
587           if (op == 0)
588             return 0;
589         }
590     }
591   return op;
592 }
593
594 /* The scalar modes supported differs from the default check-what-c-supports
595    version in that sometimes TFmode is available even when long double
596    indicates only DFmode.  On unicosmk, we have the situation that HImode
597    doesn't map to any C type, but of course we still support that.  */
598
599 static bool
600 alpha_scalar_mode_supported_p (enum machine_mode mode)
601 {
602   switch (mode)
603     {
604     case QImode:
605     case HImode:
606     case SImode:
607     case DImode:
608     case TImode: /* via optabs.c */
609       return true;
610
611     case SFmode:
612     case DFmode:
613       return true;
614
615     case TFmode:
616       return TARGET_HAS_XFLOATING_LIBS;
617
618     default:
619       return false;
620     }
621 }
622
623 /* Alpha implements a couple of integer vector mode operations when
624    TARGET_MAX is enabled.  We do not check TARGET_MAX here, however,
625    which allows the vectorizer to operate on e.g. move instructions,
626    or when expand_vector_operations can do something useful.  */
627
628 static bool
629 alpha_vector_mode_supported_p (enum machine_mode mode)
630 {
631   return mode == V8QImode || mode == V4HImode || mode == V2SImode;
632 }
633
634 /* Return 1 if this function can directly return via $26.  */
635
636 int
637 direct_return (void)
638 {
639   return (! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK
640           && reload_completed
641           && alpha_sa_size () == 0
642           && get_frame_size () == 0
643           && crtl->outgoing_args_size == 0
644           && crtl->args.pretend_args_size == 0);
645 }
646
647 /* Return the ADDR_VEC associated with a tablejump insn.  */
648
649 rtx
650 alpha_tablejump_addr_vec (rtx insn)
651 {
652   rtx tmp;
653
654   tmp = JUMP_LABEL (insn);
655   if (!tmp)
656     return NULL_RTX;
657   tmp = NEXT_INSN (tmp);
658   if (!tmp)
659     return NULL_RTX;
660   if (JUMP_P (tmp)
661       && GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC)
662     return PATTERN (tmp);
663   return NULL_RTX;
664 }
665
666 /* Return the label of the predicted edge, or CONST0_RTX if we don't know.  */
667
668 rtx
669 alpha_tablejump_best_label (rtx insn)
670 {
671   rtx jump_table = alpha_tablejump_addr_vec (insn);
672   rtx best_label = NULL_RTX;
673
674   /* ??? Once the CFG doesn't keep getting completely rebuilt, look
675      there for edge frequency counts from profile data.  */
676
677   if (jump_table)
678     {
679       int n_labels = XVECLEN (jump_table, 1);
680       int best_count = -1;
681       int i, j;
682
683       for (i = 0; i < n_labels; i++)
684         {
685           int count = 1;
686
687           for (j = i + 1; j < n_labels; j++)
688             if (XEXP (XVECEXP (jump_table, 1, i), 0)
689                 == XEXP (XVECEXP (jump_table, 1, j), 0))
690               count++;
691
692           if (count > best_count)
693             best_count = count, best_label = XVECEXP (jump_table, 1, i);
694         }
695     }
696
697   return best_label ? best_label : const0_rtx;
698 }
699
700 /* Return the TLS model to use for SYMBOL.  */
701
702 static enum tls_model
703 tls_symbolic_operand_type (rtx symbol)
704 {
705   enum tls_model model;
706
707   if (GET_CODE (symbol) != SYMBOL_REF)
708     return TLS_MODEL_NONE;
709   model = SYMBOL_REF_TLS_MODEL (symbol);
710
711   /* Local-exec with a 64-bit size is the same code as initial-exec.  */
712   if (model == TLS_MODEL_LOCAL_EXEC && alpha_tls_size == 64)
713     model = TLS_MODEL_INITIAL_EXEC;
714
715   return model;
716 }
717 \f
718 /* Return true if the function DECL will share the same GP as any
719    function in the current unit of translation.  */
720
721 static bool
722 decl_has_samegp (const_tree decl)
723 {
724   /* Functions that are not local can be overridden, and thus may
725      not share the same gp.  */
726   if (!(*targetm.binds_local_p) (decl))
727     return false;
728
729   /* If -msmall-data is in effect, assume that there is only one GP
730      for the module, and so any local symbol has this property.  We
731      need explicit relocations to be able to enforce this for symbols
732      not defined in this unit of translation, however.  */
733   if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA)
734     return true;
735
736   /* Functions that are not external are defined in this UoT.  */
737   /* ??? Irritatingly, static functions not yet emitted are still
738      marked "external".  Apply this to non-static functions only.  */
739   return !TREE_PUBLIC (decl) || !DECL_EXTERNAL (decl);
740 }
741
742 /* Return true if EXP should be placed in the small data section.  */
743
744 static bool
745 alpha_in_small_data_p (const_tree exp)
746 {
747   /* We want to merge strings, so we never consider them small data.  */
748   if (TREE_CODE (exp) == STRING_CST)
749     return false;
750
751   /* Functions are never in the small data area.  Duh.  */
752   if (TREE_CODE (exp) == FUNCTION_DECL)
753     return false;
754
755   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
756     {
757       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
758       if (strcmp (section, ".sdata") == 0
759           || strcmp (section, ".sbss") == 0)
760         return true;
761     }
762   else
763     {
764       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
765
766       /* If this is an incomplete type with size 0, then we can't put it
767          in sdata because it might be too big when completed.  */
768       if (size > 0 && (unsigned HOST_WIDE_INT) size <= g_switch_value)
769         return true;
770     }
771
772   return false;
773 }
774
775 #if TARGET_ABI_OPEN_VMS
776 static bool
777 alpha_linkage_symbol_p (const char *symname)
778 {
779   int symlen = strlen (symname);
780
781   if (symlen > 4)
782     return strcmp (&symname [symlen - 4], "..lk") == 0;
783
784   return false;
785 }
786
787 #define LINKAGE_SYMBOL_REF_P(X) \
788   ((GET_CODE (X) == SYMBOL_REF   \
789     && alpha_linkage_symbol_p (XSTR (X, 0))) \
790    || (GET_CODE (X) == CONST                 \
791        && GET_CODE (XEXP (X, 0)) == PLUS     \
792        && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF \
793        && alpha_linkage_symbol_p (XSTR (XEXP (XEXP (X, 0), 0), 0))))
794 #endif
795
796 /* legitimate_address_p recognizes an RTL expression that is a valid
797    memory address for an instruction.  The MODE argument is the
798    machine mode for the MEM expression that wants to use this address.
799
800    For Alpha, we have either a constant address or the sum of a
801    register and a constant address, or just a register.  For DImode,
802    any of those forms can be surrounded with an AND that clear the
803    low-order three bits; this is an "unaligned" access.  */
804
805 static bool
806 alpha_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
807 {
808   /* If this is an ldq_u type address, discard the outer AND.  */
809   if (mode == DImode
810       && GET_CODE (x) == AND
811       && CONST_INT_P (XEXP (x, 1))
812       && INTVAL (XEXP (x, 1)) == -8)
813     x = XEXP (x, 0);
814
815   /* Discard non-paradoxical subregs.  */
816   if (GET_CODE (x) == SUBREG
817       && (GET_MODE_SIZE (GET_MODE (x))
818           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
819     x = SUBREG_REG (x);
820
821   /* Unadorned general registers are valid.  */
822   if (REG_P (x)
823       && (strict
824           ? STRICT_REG_OK_FOR_BASE_P (x)
825           : NONSTRICT_REG_OK_FOR_BASE_P (x)))
826     return true;
827
828   /* Constant addresses (i.e. +/- 32k) are valid.  */
829   if (CONSTANT_ADDRESS_P (x))
830     return true;
831
832 #if TARGET_ABI_OPEN_VMS
833   if (LINKAGE_SYMBOL_REF_P (x))
834     return true;
835 #endif
836
837   /* Register plus a small constant offset is valid.  */
838   if (GET_CODE (x) == PLUS)
839     {
840       rtx ofs = XEXP (x, 1);
841       x = XEXP (x, 0);
842
843       /* Discard non-paradoxical subregs.  */
844       if (GET_CODE (x) == SUBREG
845           && (GET_MODE_SIZE (GET_MODE (x))
846               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
847         x = SUBREG_REG (x);
848
849       if (REG_P (x))
850         {
851           if (! strict
852               && NONSTRICT_REG_OK_FP_BASE_P (x)
853               && CONST_INT_P (ofs))
854             return true;
855           if ((strict
856                ? STRICT_REG_OK_FOR_BASE_P (x)
857                : NONSTRICT_REG_OK_FOR_BASE_P (x))
858               && CONSTANT_ADDRESS_P (ofs))
859             return true;
860         }
861     }
862
863   /* If we're managing explicit relocations, LO_SUM is valid, as are small
864      data symbols.  Avoid explicit relocations of modes larger than word
865      mode since i.e. $LC0+8($1) can fold around +/- 32k offset.  */
866   else if (TARGET_EXPLICIT_RELOCS
867            && GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
868     {
869       if (small_symbolic_operand (x, Pmode))
870         return true;
871
872       if (GET_CODE (x) == LO_SUM)
873         {
874           rtx ofs = XEXP (x, 1);
875           x = XEXP (x, 0);
876
877           /* Discard non-paradoxical subregs.  */
878           if (GET_CODE (x) == SUBREG
879               && (GET_MODE_SIZE (GET_MODE (x))
880                   < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
881             x = SUBREG_REG (x);
882
883           /* Must have a valid base register.  */
884           if (! (REG_P (x)
885                  && (strict
886                      ? STRICT_REG_OK_FOR_BASE_P (x)
887                      : NONSTRICT_REG_OK_FOR_BASE_P (x))))
888             return false;
889
890           /* The symbol must be local.  */
891           if (local_symbolic_operand (ofs, Pmode)
892               || dtp32_symbolic_operand (ofs, Pmode)
893               || tp32_symbolic_operand (ofs, Pmode))
894             return true;
895         }
896     }
897
898   return false;
899 }
900
901 /* Build the SYMBOL_REF for __tls_get_addr.  */
902
903 static GTY(()) rtx tls_get_addr_libfunc;
904
905 static rtx
906 get_tls_get_addr (void)
907 {
908   if (!tls_get_addr_libfunc)
909     tls_get_addr_libfunc = init_one_libfunc ("__tls_get_addr");
910   return tls_get_addr_libfunc;
911 }
912
913 /* Try machine-dependent ways of modifying an illegitimate address
914    to be legitimate.  If we find one, return the new, valid address.  */
915
916 static rtx
917 alpha_legitimize_address_1 (rtx x, rtx scratch, enum machine_mode mode)
918 {
919   HOST_WIDE_INT addend;
920
921   /* If the address is (plus reg const_int) and the CONST_INT is not a
922      valid offset, compute the high part of the constant and add it to
923      the register.  Then our address is (plus temp low-part-const).  */
924   if (GET_CODE (x) == PLUS
925       && REG_P (XEXP (x, 0))
926       && CONST_INT_P (XEXP (x, 1))
927       && ! CONSTANT_ADDRESS_P (XEXP (x, 1)))
928     {
929       addend = INTVAL (XEXP (x, 1));
930       x = XEXP (x, 0);
931       goto split_addend;
932     }
933
934   /* If the address is (const (plus FOO const_int)), find the low-order
935      part of the CONST_INT.  Then load FOO plus any high-order part of the
936      CONST_INT into a register.  Our address is (plus reg low-part-const).
937      This is done to reduce the number of GOT entries.  */
938   if (can_create_pseudo_p ()
939       && GET_CODE (x) == CONST
940       && GET_CODE (XEXP (x, 0)) == PLUS
941       && CONST_INT_P (XEXP (XEXP (x, 0), 1)))
942     {
943       addend = INTVAL (XEXP (XEXP (x, 0), 1));
944       x = force_reg (Pmode, XEXP (XEXP (x, 0), 0));
945       goto split_addend;
946     }
947
948   /* If we have a (plus reg const), emit the load as in (2), then add
949      the two registers, and finally generate (plus reg low-part-const) as
950      our address.  */
951   if (can_create_pseudo_p ()
952       && GET_CODE (x) == PLUS
953       && REG_P (XEXP (x, 0))
954       && GET_CODE (XEXP (x, 1)) == CONST
955       && GET_CODE (XEXP (XEXP (x, 1), 0)) == PLUS
956       && CONST_INT_P (XEXP (XEXP (XEXP (x, 1), 0), 1)))
957     {
958       addend = INTVAL (XEXP (XEXP (XEXP (x, 1), 0), 1));
959       x = expand_simple_binop (Pmode, PLUS, XEXP (x, 0),
960                                XEXP (XEXP (XEXP (x, 1), 0), 0),
961                                NULL_RTX, 1, OPTAB_LIB_WIDEN);
962       goto split_addend;
963     }
964
965   /* If this is a local symbol, split the address into HIGH/LO_SUM parts.
966      Avoid modes larger than word mode since i.e. $LC0+8($1) can fold
967      around +/- 32k offset.  */
968   if (TARGET_EXPLICIT_RELOCS
969       && GET_MODE_SIZE (mode) <= UNITS_PER_WORD
970       && symbolic_operand (x, Pmode))
971     {
972       rtx r0, r16, eqv, tga, tp, insn, dest, seq;
973
974       switch (tls_symbolic_operand_type (x))
975         {
976         case TLS_MODEL_NONE:
977           break;
978
979         case TLS_MODEL_GLOBAL_DYNAMIC:
980           start_sequence ();
981
982           r0 = gen_rtx_REG (Pmode, 0);
983           r16 = gen_rtx_REG (Pmode, 16);
984           tga = get_tls_get_addr ();
985           dest = gen_reg_rtx (Pmode);
986           seq = GEN_INT (alpha_next_sequence_number++);
987
988           emit_insn (gen_movdi_er_tlsgd (r16, pic_offset_table_rtx, x, seq));
989           insn = gen_call_value_osf_tlsgd (r0, tga, seq);
990           insn = emit_call_insn (insn);
991           RTL_CONST_CALL_P (insn) = 1;
992           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r16);
993
994           insn = get_insns ();
995           end_sequence ();
996
997           emit_libcall_block (insn, dest, r0, x);
998           return dest;
999
1000         case TLS_MODEL_LOCAL_DYNAMIC:
1001           start_sequence ();
1002
1003           r0 = gen_rtx_REG (Pmode, 0);
1004           r16 = gen_rtx_REG (Pmode, 16);
1005           tga = get_tls_get_addr ();
1006           scratch = gen_reg_rtx (Pmode);
1007           seq = GEN_INT (alpha_next_sequence_number++);
1008
1009           emit_insn (gen_movdi_er_tlsldm (r16, pic_offset_table_rtx, seq));
1010           insn = gen_call_value_osf_tlsldm (r0, tga, seq);
1011           insn = emit_call_insn (insn);
1012           RTL_CONST_CALL_P (insn) = 1;
1013           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r16);
1014
1015           insn = get_insns ();
1016           end_sequence ();
1017
1018           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
1019                                 UNSPEC_TLSLDM_CALL);
1020           emit_libcall_block (insn, scratch, r0, eqv);
1021
1022           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_DTPREL);
1023           eqv = gen_rtx_CONST (Pmode, eqv);
1024
1025           if (alpha_tls_size == 64)
1026             {
1027               dest = gen_reg_rtx (Pmode);
1028               emit_insn (gen_rtx_SET (VOIDmode, dest, eqv));
1029               emit_insn (gen_adddi3 (dest, dest, scratch));
1030               return dest;
1031             }
1032           if (alpha_tls_size == 32)
1033             {
1034               insn = gen_rtx_HIGH (Pmode, eqv);
1035               insn = gen_rtx_PLUS (Pmode, scratch, insn);
1036               scratch = gen_reg_rtx (Pmode);
1037               emit_insn (gen_rtx_SET (VOIDmode, scratch, insn));
1038             }
1039           return gen_rtx_LO_SUM (Pmode, scratch, eqv);
1040
1041         case TLS_MODEL_INITIAL_EXEC:
1042           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_TPREL);
1043           eqv = gen_rtx_CONST (Pmode, eqv);
1044           tp = gen_reg_rtx (Pmode);
1045           scratch = gen_reg_rtx (Pmode);
1046           dest = gen_reg_rtx (Pmode);
1047
1048           emit_insn (gen_load_tp (tp));
1049           emit_insn (gen_rtx_SET (VOIDmode, scratch, eqv));
1050           emit_insn (gen_adddi3 (dest, tp, scratch));
1051           return dest;
1052
1053         case TLS_MODEL_LOCAL_EXEC:
1054           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_TPREL);
1055           eqv = gen_rtx_CONST (Pmode, eqv);
1056           tp = gen_reg_rtx (Pmode);
1057
1058           emit_insn (gen_load_tp (tp));
1059           if (alpha_tls_size == 32)
1060             {
1061               insn = gen_rtx_HIGH (Pmode, eqv);
1062               insn = gen_rtx_PLUS (Pmode, tp, insn);
1063               tp = gen_reg_rtx (Pmode);
1064               emit_insn (gen_rtx_SET (VOIDmode, tp, insn));
1065             }
1066           return gen_rtx_LO_SUM (Pmode, tp, eqv);
1067
1068         default:
1069           gcc_unreachable ();
1070         }
1071
1072       if (local_symbolic_operand (x, Pmode))
1073         {
1074           if (small_symbolic_operand (x, Pmode))
1075             return x;
1076           else
1077             {
1078               if (can_create_pseudo_p ())
1079                 scratch = gen_reg_rtx (Pmode);
1080               emit_insn (gen_rtx_SET (VOIDmode, scratch,
1081                                       gen_rtx_HIGH (Pmode, x)));
1082               return gen_rtx_LO_SUM (Pmode, scratch, x);
1083             }
1084         }
1085     }
1086
1087   return NULL;
1088
1089  split_addend:
1090   {
1091     HOST_WIDE_INT low, high;
1092
1093     low = ((addend & 0xffff) ^ 0x8000) - 0x8000;
1094     addend -= low;
1095     high = ((addend & 0xffffffff) ^ 0x80000000) - 0x80000000;
1096     addend -= high;
1097
1098     if (addend)
1099       x = expand_simple_binop (Pmode, PLUS, x, GEN_INT (addend),
1100                                (!can_create_pseudo_p () ? scratch : NULL_RTX),
1101                                1, OPTAB_LIB_WIDEN);
1102     if (high)
1103       x = expand_simple_binop (Pmode, PLUS, x, GEN_INT (high),
1104                                (!can_create_pseudo_p () ? scratch : NULL_RTX),
1105                                1, OPTAB_LIB_WIDEN);
1106
1107     return plus_constant (x, low);
1108   }
1109 }
1110
1111
1112 /* Try machine-dependent ways of modifying an illegitimate address
1113    to be legitimate.  Return X or the new, valid address.  */
1114
1115 static rtx
1116 alpha_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
1117                           enum machine_mode mode)
1118 {
1119   rtx new_x = alpha_legitimize_address_1 (x, NULL_RTX, mode);
1120   return new_x ? new_x : x;
1121 }
1122
1123 /* Primarily this is required for TLS symbols, but given that our move
1124    patterns *ought* to be able to handle any symbol at any time, we
1125    should never be spilling symbolic operands to the constant pool, ever.  */
1126
1127 static bool
1128 alpha_cannot_force_const_mem (rtx x)
1129 {
1130   enum rtx_code code = GET_CODE (x);
1131   return code == SYMBOL_REF || code == LABEL_REF || code == CONST;
1132 }
1133
1134 /* We do not allow indirect calls to be optimized into sibling calls, nor
1135    can we allow a call to a function with a different GP to be optimized
1136    into a sibcall.  */
1137
1138 static bool
1139 alpha_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
1140 {
1141   /* Can't do indirect tail calls, since we don't know if the target
1142      uses the same GP.  */
1143   if (!decl)
1144     return false;
1145
1146   /* Otherwise, we can make a tail call if the target function shares
1147      the same GP.  */
1148   return decl_has_samegp (decl);
1149 }
1150
1151 int
1152 some_small_symbolic_operand_int (rtx *px, void *data ATTRIBUTE_UNUSED)
1153 {
1154   rtx x = *px;
1155
1156   /* Don't re-split.  */
1157   if (GET_CODE (x) == LO_SUM)
1158     return -1;
1159
1160   return small_symbolic_operand (x, Pmode) != 0;
1161 }
1162
1163 static int
1164 split_small_symbolic_operand_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
1165 {
1166   rtx x = *px;
1167
1168   /* Don't re-split.  */
1169   if (GET_CODE (x) == LO_SUM)
1170     return -1;
1171
1172   if (small_symbolic_operand (x, Pmode))
1173     {
1174       x = gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, x);
1175       *px = x;
1176       return -1;
1177     }
1178
1179   return 0;
1180 }
1181
1182 rtx
1183 split_small_symbolic_operand (rtx x)
1184 {
1185   x = copy_insn (x);
1186   for_each_rtx (&x, split_small_symbolic_operand_1, NULL);
1187   return x;
1188 }
1189
1190 /* Indicate that INSN cannot be duplicated.  This is true for any insn
1191    that we've marked with gpdisp relocs, since those have to stay in
1192    1-1 correspondence with one another.
1193
1194    Technically we could copy them if we could set up a mapping from one
1195    sequence number to another, across the set of insns to be duplicated.
1196    This seems overly complicated and error-prone since interblock motion
1197    from sched-ebb could move one of the pair of insns to a different block.
1198
1199    Also cannot allow jsr insns to be duplicated.  If they throw exceptions,
1200    then they'll be in a different block from their ldgp.  Which could lead
1201    the bb reorder code to think that it would be ok to copy just the block
1202    containing the call and branch to the block containing the ldgp.  */
1203
1204 static bool
1205 alpha_cannot_copy_insn_p (rtx insn)
1206 {
1207   if (!reload_completed || !TARGET_EXPLICIT_RELOCS)
1208     return false;
1209   if (recog_memoized (insn) >= 0)
1210     return get_attr_cannot_copy (insn);
1211   else
1212     return false;
1213 }
1214
1215
1216 /* Try a machine-dependent way of reloading an illegitimate address
1217    operand.  If we find one, push the reload and return the new rtx.  */
1218
1219 rtx
1220 alpha_legitimize_reload_address (rtx x,
1221                                  enum machine_mode mode ATTRIBUTE_UNUSED,
1222                                  int opnum, int type,
1223                                  int ind_levels ATTRIBUTE_UNUSED)
1224 {
1225   /* We must recognize output that we have already generated ourselves.  */
1226   if (GET_CODE (x) == PLUS
1227       && GET_CODE (XEXP (x, 0)) == PLUS
1228       && REG_P (XEXP (XEXP (x, 0), 0))
1229       && CONST_INT_P (XEXP (XEXP (x, 0), 1))
1230       && CONST_INT_P (XEXP (x, 1)))
1231     {
1232       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
1233                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
1234                    opnum, (enum reload_type) type);
1235       return x;
1236     }
1237
1238   /* We wish to handle large displacements off a base register by
1239      splitting the addend across an ldah and the mem insn.  This
1240      cuts number of extra insns needed from 3 to 1.  */
1241   if (GET_CODE (x) == PLUS
1242       && REG_P (XEXP (x, 0))
1243       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
1244       && REGNO_OK_FOR_BASE_P (REGNO (XEXP (x, 0)))
1245       && GET_CODE (XEXP (x, 1)) == CONST_INT)
1246     {
1247       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
1248       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
1249       HOST_WIDE_INT high
1250         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
1251
1252       /* Check for 32-bit overflow.  */
1253       if (high + low != val)
1254         return NULL_RTX;
1255
1256       /* Reload the high part into a base reg; leave the low part
1257          in the mem directly.  */
1258       x = gen_rtx_PLUS (GET_MODE (x),
1259                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
1260                                       GEN_INT (high)),
1261                         GEN_INT (low));
1262
1263       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
1264                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
1265                    opnum, (enum reload_type) type);
1266       return x;
1267     }
1268
1269   return NULL_RTX;
1270 }
1271 \f
1272 /* Compute a (partial) cost for rtx X.  Return true if the complete
1273    cost has been computed, and false if subexpressions should be
1274    scanned.  In either case, *TOTAL contains the cost result.  */
1275
1276 static bool
1277 alpha_rtx_costs (rtx x, int code, int outer_code, int *total,
1278                  bool speed)
1279 {
1280   enum machine_mode mode = GET_MODE (x);
1281   bool float_mode_p = FLOAT_MODE_P (mode);
1282   const struct alpha_rtx_cost_data *cost_data;
1283
1284   if (!speed)
1285     cost_data = &alpha_rtx_cost_size;
1286   else
1287     cost_data = &alpha_rtx_cost_data[alpha_tune];
1288
1289   switch (code)
1290     {
1291     case CONST_INT:
1292       /* If this is an 8-bit constant, return zero since it can be used
1293          nearly anywhere with no cost.  If it is a valid operand for an
1294          ADD or AND, likewise return 0 if we know it will be used in that
1295          context.  Otherwise, return 2 since it might be used there later.
1296          All other constants take at least two insns.  */
1297       if (INTVAL (x) >= 0 && INTVAL (x) < 256)
1298         {
1299           *total = 0;
1300           return true;
1301         }
1302       /* FALLTHRU */
1303
1304     case CONST_DOUBLE:
1305       if (x == CONST0_RTX (mode))
1306         *total = 0;
1307       else if ((outer_code == PLUS && add_operand (x, VOIDmode))
1308                || (outer_code == AND && and_operand (x, VOIDmode)))
1309         *total = 0;
1310       else if (add_operand (x, VOIDmode) || and_operand (x, VOIDmode))
1311         *total = 2;
1312       else
1313         *total = COSTS_N_INSNS (2);
1314       return true;
1315
1316     case CONST:
1317     case SYMBOL_REF:
1318     case LABEL_REF:
1319       if (TARGET_EXPLICIT_RELOCS && small_symbolic_operand (x, VOIDmode))
1320         *total = COSTS_N_INSNS (outer_code != MEM);
1321       else if (TARGET_EXPLICIT_RELOCS && local_symbolic_operand (x, VOIDmode))
1322         *total = COSTS_N_INSNS (1 + (outer_code != MEM));
1323       else if (tls_symbolic_operand_type (x))
1324         /* Estimate of cost for call_pal rduniq.  */
1325         /* ??? How many insns do we emit here?  More than one...  */
1326         *total = COSTS_N_INSNS (15);
1327       else
1328         /* Otherwise we do a load from the GOT.  */
1329         *total = COSTS_N_INSNS (!speed ? 1 : alpha_memory_latency);
1330       return true;
1331
1332     case HIGH:
1333       /* This is effectively an add_operand.  */
1334       *total = 2;
1335       return true;
1336
1337     case PLUS:
1338     case MINUS:
1339       if (float_mode_p)
1340         *total = cost_data->fp_add;
1341       else if (GET_CODE (XEXP (x, 0)) == MULT
1342                && const48_operand (XEXP (XEXP (x, 0), 1), VOIDmode))
1343         {
1344           *total = (rtx_cost (XEXP (XEXP (x, 0), 0),
1345                               (enum rtx_code) outer_code, speed)
1346                     + rtx_cost (XEXP (x, 1),
1347                                 (enum rtx_code) outer_code, speed)
1348                     + COSTS_N_INSNS (1));
1349           return true;
1350         }
1351       return false;
1352
1353     case MULT:
1354       if (float_mode_p)
1355         *total = cost_data->fp_mult;
1356       else if (mode == DImode)
1357         *total = cost_data->int_mult_di;
1358       else
1359         *total = cost_data->int_mult_si;
1360       return false;
1361
1362     case ASHIFT:
1363       if (CONST_INT_P (XEXP (x, 1))
1364           && INTVAL (XEXP (x, 1)) <= 3)
1365         {
1366           *total = COSTS_N_INSNS (1);
1367           return false;
1368         }
1369       /* FALLTHRU */
1370
1371     case ASHIFTRT:
1372     case LSHIFTRT:
1373       *total = cost_data->int_shift;
1374       return false;
1375
1376     case IF_THEN_ELSE:
1377       if (float_mode_p)
1378         *total = cost_data->fp_add;
1379       else
1380         *total = cost_data->int_cmov;
1381       return false;
1382
1383     case DIV:
1384     case UDIV:
1385     case MOD:
1386     case UMOD:
1387       if (!float_mode_p)
1388         *total = cost_data->int_div;
1389       else if (mode == SFmode)
1390         *total = cost_data->fp_div_sf;
1391       else
1392         *total = cost_data->fp_div_df;
1393       return false;
1394
1395     case MEM:
1396       *total = COSTS_N_INSNS (!speed ? 1 : alpha_memory_latency);
1397       return true;
1398
1399     case NEG:
1400       if (! float_mode_p)
1401         {
1402           *total = COSTS_N_INSNS (1);
1403           return false;
1404         }
1405       /* FALLTHRU */
1406
1407     case ABS:
1408       if (! float_mode_p)
1409         {
1410           *total = COSTS_N_INSNS (1) + cost_data->int_cmov;
1411           return false;
1412         }
1413       /* FALLTHRU */
1414
1415     case FLOAT:
1416     case UNSIGNED_FLOAT:
1417     case FIX:
1418     case UNSIGNED_FIX:
1419     case FLOAT_TRUNCATE:
1420       *total = cost_data->fp_add;
1421       return false;
1422
1423     case FLOAT_EXTEND:
1424       if (MEM_P (XEXP (x, 0)))
1425         *total = 0;
1426       else
1427         *total = cost_data->fp_add;
1428       return false;
1429
1430     default:
1431       return false;
1432     }
1433 }
1434 \f
1435 /* REF is an alignable memory location.  Place an aligned SImode
1436    reference into *PALIGNED_MEM and the number of bits to shift into
1437    *PBITNUM.  SCRATCH is a free register for use in reloading out
1438    of range stack slots.  */
1439
1440 void
1441 get_aligned_mem (rtx ref, rtx *paligned_mem, rtx *pbitnum)
1442 {
1443   rtx base;
1444   HOST_WIDE_INT disp, offset;
1445
1446   gcc_assert (MEM_P (ref));
1447
1448   if (reload_in_progress
1449       && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
1450     {
1451       base = find_replacement (&XEXP (ref, 0));
1452       gcc_assert (memory_address_p (GET_MODE (ref), base));
1453     }
1454   else
1455     base = XEXP (ref, 0);
1456
1457   if (GET_CODE (base) == PLUS)
1458     disp = INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
1459   else
1460     disp = 0;
1461
1462   /* Find the byte offset within an aligned word.  If the memory itself is
1463      claimed to be aligned, believe it.  Otherwise, aligned_memory_operand
1464      will have examined the base register and determined it is aligned, and
1465      thus displacements from it are naturally alignable.  */
1466   if (MEM_ALIGN (ref) >= 32)
1467     offset = 0;
1468   else
1469     offset = disp & 3;
1470
1471   /* Access the entire aligned word.  */
1472   *paligned_mem = widen_memory_access (ref, SImode, -offset);
1473
1474   /* Convert the byte offset within the word to a bit offset.  */
1475   if (WORDS_BIG_ENDIAN)
1476     offset = 32 - (GET_MODE_BITSIZE (GET_MODE (ref)) + offset * 8);
1477   else
1478     offset *= 8;
1479   *pbitnum = GEN_INT (offset);
1480 }
1481
1482 /* Similar, but just get the address.  Handle the two reload cases.
1483    Add EXTRA_OFFSET to the address we return.  */
1484
1485 rtx
1486 get_unaligned_address (rtx ref)
1487 {
1488   rtx base;
1489   HOST_WIDE_INT offset = 0;
1490
1491   gcc_assert (MEM_P (ref));
1492
1493   if (reload_in_progress
1494       && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
1495     {
1496       base = find_replacement (&XEXP (ref, 0));
1497
1498       gcc_assert (memory_address_p (GET_MODE (ref), base));
1499     }
1500   else
1501     base = XEXP (ref, 0);
1502
1503   if (GET_CODE (base) == PLUS)
1504     offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
1505
1506   return plus_constant (base, offset);
1507 }
1508
1509 /* Compute a value X, such that X & 7 == (ADDR + OFS) & 7.
1510    X is always returned in a register.  */
1511
1512 rtx
1513 get_unaligned_offset (rtx addr, HOST_WIDE_INT ofs)
1514 {
1515   if (GET_CODE (addr) == PLUS)
1516     {
1517       ofs += INTVAL (XEXP (addr, 1));
1518       addr = XEXP (addr, 0);
1519     }
1520
1521   return expand_simple_binop (Pmode, PLUS, addr, GEN_INT (ofs & 7),
1522                               NULL_RTX, 1, OPTAB_LIB_WIDEN);
1523 }
1524
1525 /* On the Alpha, all (non-symbolic) constants except zero go into
1526    a floating-point register via memory.  Note that we cannot
1527    return anything that is not a subset of RCLASS, and that some
1528    symbolic constants cannot be dropped to memory.  */
1529
1530 enum reg_class
1531 alpha_preferred_reload_class(rtx x, enum reg_class rclass)
1532 {
1533   /* Zero is present in any register class.  */
1534   if (x == CONST0_RTX (GET_MODE (x)))
1535     return rclass;
1536
1537   /* These sorts of constants we can easily drop to memory.  */
1538   if (CONST_INT_P (x)
1539       || GET_CODE (x) == CONST_DOUBLE
1540       || GET_CODE (x) == CONST_VECTOR)
1541     {
1542       if (rclass == FLOAT_REGS)
1543         return NO_REGS;
1544       if (rclass == ALL_REGS)
1545         return GENERAL_REGS;
1546       return rclass;
1547     }
1548
1549   /* All other kinds of constants should not (and in the case of HIGH
1550      cannot) be dropped to memory -- instead we use a GENERAL_REGS
1551      secondary reload.  */
1552   if (CONSTANT_P (x))
1553     return (rclass == ALL_REGS ? GENERAL_REGS : rclass);
1554
1555   return rclass;
1556 }
1557
1558 /* Inform reload about cases where moving X with a mode MODE to a register in
1559    RCLASS requires an extra scratch or immediate register.  Return the class
1560    needed for the immediate register.  */
1561
1562 static enum reg_class
1563 alpha_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
1564                         enum machine_mode mode, secondary_reload_info *sri)
1565 {
1566   /* Loading and storing HImode or QImode values to and from memory
1567      usually requires a scratch register.  */
1568   if (!TARGET_BWX && (mode == QImode || mode == HImode || mode == CQImode))
1569     {
1570       if (any_memory_operand (x, mode))
1571         {
1572           if (in_p)
1573             {
1574               if (!aligned_memory_operand (x, mode))
1575                 sri->icode = reload_in_optab[mode];
1576             }
1577           else
1578             sri->icode = reload_out_optab[mode];
1579           return NO_REGS;
1580         }
1581     }
1582
1583   /* We also cannot do integral arithmetic into FP regs, as might result
1584      from register elimination into a DImode fp register.  */
1585   if (rclass == FLOAT_REGS)
1586     {
1587       if (MEM_P (x) && GET_CODE (XEXP (x, 0)) == AND)
1588         return GENERAL_REGS;
1589       if (in_p && INTEGRAL_MODE_P (mode)
1590           && !MEM_P (x) && !REG_P (x) && !CONST_INT_P (x))
1591         return GENERAL_REGS;
1592     }
1593
1594   return NO_REGS;
1595 }
1596 \f
1597 /* Subfunction of the following function.  Update the flags of any MEM
1598    found in part of X.  */
1599
1600 static int
1601 alpha_set_memflags_1 (rtx *xp, void *data)
1602 {
1603   rtx x = *xp, orig = (rtx) data;
1604
1605   if (!MEM_P (x))
1606     return 0;
1607
1608   MEM_VOLATILE_P (x) = MEM_VOLATILE_P (orig);
1609   MEM_IN_STRUCT_P (x) = MEM_IN_STRUCT_P (orig);
1610   MEM_SCALAR_P (x) = MEM_SCALAR_P (orig);
1611   MEM_NOTRAP_P (x) = MEM_NOTRAP_P (orig);
1612   MEM_READONLY_P (x) = MEM_READONLY_P (orig);
1613
1614   /* Sadly, we cannot use alias sets because the extra aliasing
1615      produced by the AND interferes.  Given that two-byte quantities
1616      are the only thing we would be able to differentiate anyway,
1617      there does not seem to be any point in convoluting the early
1618      out of the alias check.  */
1619
1620   return -1;
1621 }
1622
1623 /* Given SEQ, which is an INSN list, look for any MEMs in either
1624    a SET_DEST or a SET_SRC and copy the in-struct, unchanging, and
1625    volatile flags from REF into each of the MEMs found.  If REF is not
1626    a MEM, don't do anything.  */
1627
1628 void
1629 alpha_set_memflags (rtx seq, rtx ref)
1630 {
1631   rtx insn;
1632
1633   if (!MEM_P (ref))
1634     return;
1635
1636   /* This is only called from alpha.md, after having had something
1637      generated from one of the insn patterns.  So if everything is
1638      zero, the pattern is already up-to-date.  */
1639   if (!MEM_VOLATILE_P (ref)
1640       && !MEM_IN_STRUCT_P (ref)
1641       && !MEM_SCALAR_P (ref)
1642       && !MEM_NOTRAP_P (ref)
1643       && !MEM_READONLY_P (ref))
1644     return;
1645
1646   for (insn = seq; insn; insn = NEXT_INSN (insn))
1647     if (INSN_P (insn))
1648       for_each_rtx (&PATTERN (insn), alpha_set_memflags_1, (void *) ref);
1649     else
1650       gcc_unreachable ();
1651 }
1652 \f
1653 static rtx alpha_emit_set_const (rtx, enum machine_mode, HOST_WIDE_INT,
1654                                  int, bool);
1655
1656 /* Internal routine for alpha_emit_set_const to check for N or below insns.
1657    If NO_OUTPUT is true, then we only check to see if N insns are possible,
1658    and return pc_rtx if successful.  */
1659
1660 static rtx
1661 alpha_emit_set_const_1 (rtx target, enum machine_mode mode,
1662                         HOST_WIDE_INT c, int n, bool no_output)
1663 {
1664   HOST_WIDE_INT new_const;
1665   int i, bits;
1666   /* Use a pseudo if highly optimizing and still generating RTL.  */
1667   rtx subtarget
1668     = (flag_expensive_optimizations && can_create_pseudo_p () ? 0 : target);
1669   rtx temp, insn;
1670
1671   /* If this is a sign-extended 32-bit constant, we can do this in at most
1672      three insns, so do it if we have enough insns left.  We always have
1673      a sign-extended 32-bit constant when compiling on a narrow machine.  */
1674
1675   if (HOST_BITS_PER_WIDE_INT != 64
1676       || c >> 31 == -1 || c >> 31 == 0)
1677     {
1678       HOST_WIDE_INT low = ((c & 0xffff) ^ 0x8000) - 0x8000;
1679       HOST_WIDE_INT tmp1 = c - low;
1680       HOST_WIDE_INT high = (((tmp1 >> 16) & 0xffff) ^ 0x8000) - 0x8000;
1681       HOST_WIDE_INT extra = 0;
1682
1683       /* If HIGH will be interpreted as negative but the constant is
1684          positive, we must adjust it to do two ldha insns.  */
1685
1686       if ((high & 0x8000) != 0 && c >= 0)
1687         {
1688           extra = 0x4000;
1689           tmp1 -= 0x40000000;
1690           high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
1691         }
1692
1693       if (c == low || (low == 0 && extra == 0))
1694         {
1695           /* We used to use copy_to_suggested_reg (GEN_INT (c), target, mode)
1696              but that meant that we can't handle INT_MIN on 32-bit machines
1697              (like NT/Alpha), because we recurse indefinitely through
1698              emit_move_insn to gen_movdi.  So instead, since we know exactly
1699              what we want, create it explicitly.  */
1700
1701           if (no_output)
1702             return pc_rtx;
1703           if (target == NULL)
1704             target = gen_reg_rtx (mode);
1705           emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (c)));
1706           return target;
1707         }
1708       else if (n >= 2 + (extra != 0))
1709         {
1710           if (no_output)
1711             return pc_rtx;
1712           if (!can_create_pseudo_p ())
1713             {
1714               emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (high << 16)));
1715               temp = target;
1716             }
1717           else
1718             temp = copy_to_suggested_reg (GEN_INT (high << 16),
1719                                           subtarget, mode);
1720
1721           /* As of 2002-02-23, addsi3 is only available when not optimizing.
1722              This means that if we go through expand_binop, we'll try to
1723              generate extensions, etc, which will require new pseudos, which
1724              will fail during some split phases.  The SImode add patterns
1725              still exist, but are not named.  So build the insns by hand.  */
1726
1727           if (extra != 0)
1728             {
1729               if (! subtarget)
1730                 subtarget = gen_reg_rtx (mode);
1731               insn = gen_rtx_PLUS (mode, temp, GEN_INT (extra << 16));
1732               insn = gen_rtx_SET (VOIDmode, subtarget, insn);
1733               emit_insn (insn);
1734               temp = subtarget;
1735             }
1736
1737           if (target == NULL)
1738             target = gen_reg_rtx (mode);
1739           insn = gen_rtx_PLUS (mode, temp, GEN_INT (low));
1740           insn = gen_rtx_SET (VOIDmode, target, insn);
1741           emit_insn (insn);
1742           return target;
1743         }
1744     }
1745
1746   /* If we couldn't do it that way, try some other methods.  But if we have
1747      no instructions left, don't bother.  Likewise, if this is SImode and
1748      we can't make pseudos, we can't do anything since the expand_binop
1749      and expand_unop calls will widen and try to make pseudos.  */
1750
1751   if (n == 1 || (mode == SImode && !can_create_pseudo_p ()))
1752     return 0;
1753
1754   /* Next, see if we can load a related constant and then shift and possibly
1755      negate it to get the constant we want.  Try this once each increasing
1756      numbers of insns.  */
1757
1758   for (i = 1; i < n; i++)
1759     {
1760       /* First, see if minus some low bits, we've an easy load of
1761          high bits.  */
1762
1763       new_const = ((c & 0xffff) ^ 0x8000) - 0x8000;
1764       if (new_const != 0)
1765         {
1766           temp = alpha_emit_set_const (subtarget, mode, c - new_const, i, no_output);
1767           if (temp)
1768             {
1769               if (no_output)
1770                 return temp;
1771               return expand_binop (mode, add_optab, temp, GEN_INT (new_const),
1772                                    target, 0, OPTAB_WIDEN);
1773             }
1774         }
1775
1776       /* Next try complementing.  */
1777       temp = alpha_emit_set_const (subtarget, mode, ~c, i, no_output);
1778       if (temp)
1779         {
1780           if (no_output)
1781             return temp;
1782           return expand_unop (mode, one_cmpl_optab, temp, target, 0);
1783         }
1784
1785       /* Next try to form a constant and do a left shift.  We can do this
1786          if some low-order bits are zero; the exact_log2 call below tells
1787          us that information.  The bits we are shifting out could be any
1788          value, but here we'll just try the 0- and sign-extended forms of
1789          the constant.  To try to increase the chance of having the same
1790          constant in more than one insn, start at the highest number of
1791          bits to shift, but try all possibilities in case a ZAPNOT will
1792          be useful.  */
1793
1794       bits = exact_log2 (c & -c);
1795       if (bits > 0)
1796         for (; bits > 0; bits--)
1797           {
1798             new_const = c >> bits;
1799             temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output);
1800             if (!temp && c < 0)
1801               {
1802                 new_const = (unsigned HOST_WIDE_INT)c >> bits;
1803                 temp = alpha_emit_set_const (subtarget, mode, new_const,
1804                                              i, no_output);
1805               }
1806             if (temp)
1807               {
1808                 if (no_output)
1809                   return temp;
1810                 return expand_binop (mode, ashl_optab, temp, GEN_INT (bits),
1811                                      target, 0, OPTAB_WIDEN);
1812               }
1813           }
1814
1815       /* Now try high-order zero bits.  Here we try the shifted-in bits as
1816          all zero and all ones.  Be careful to avoid shifting outside the
1817          mode and to avoid shifting outside the host wide int size.  */
1818       /* On narrow hosts, don't shift a 1 into the high bit, since we'll
1819          confuse the recursive call and set all of the high 32 bits.  */
1820
1821       bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
1822               - floor_log2 (c) - 1 - (HOST_BITS_PER_WIDE_INT < 64));
1823       if (bits > 0)
1824         for (; bits > 0; bits--)
1825           {
1826             new_const = c << bits;
1827             temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output);
1828             if (!temp)
1829               {
1830                 new_const = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1);
1831                 temp = alpha_emit_set_const (subtarget, mode, new_const,
1832                                              i, no_output);
1833               }
1834             if (temp)
1835               {
1836                 if (no_output)
1837                   return temp;
1838                 return expand_binop (mode, lshr_optab, temp, GEN_INT (bits),
1839                                      target, 1, OPTAB_WIDEN);
1840               }
1841           }
1842
1843       /* Now try high-order 1 bits.  We get that with a sign-extension.
1844          But one bit isn't enough here.  Be careful to avoid shifting outside
1845          the mode and to avoid shifting outside the host wide int size.  */
1846
1847       bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
1848               - floor_log2 (~ c) - 2);
1849       if (bits > 0)
1850         for (; bits > 0; bits--)
1851           {
1852             new_const = c << bits;
1853             temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output);
1854             if (!temp)
1855               {
1856                 new_const = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1);
1857                 temp = alpha_emit_set_const (subtarget, mode, new_const,
1858                                              i, no_output);
1859               }
1860             if (temp)
1861               {
1862                 if (no_output)
1863                   return temp;
1864                 return expand_binop (mode, ashr_optab, temp, GEN_INT (bits),
1865                                      target, 0, OPTAB_WIDEN);
1866               }
1867           }
1868     }
1869
1870 #if HOST_BITS_PER_WIDE_INT == 64
1871   /* Finally, see if can load a value into the target that is the same as the
1872      constant except that all bytes that are 0 are changed to be 0xff.  If we
1873      can, then we can do a ZAPNOT to obtain the desired constant.  */
1874
1875   new_const = c;
1876   for (i = 0; i < 64; i += 8)
1877     if ((new_const & ((HOST_WIDE_INT) 0xff << i)) == 0)
1878       new_const |= (HOST_WIDE_INT) 0xff << i;
1879
1880   /* We are only called for SImode and DImode.  If this is SImode, ensure that
1881      we are sign extended to a full word.  */
1882
1883   if (mode == SImode)
1884     new_const = ((new_const & 0xffffffff) ^ 0x80000000) - 0x80000000;
1885
1886   if (new_const != c)
1887     {
1888       temp = alpha_emit_set_const (subtarget, mode, new_const, n - 1, no_output);
1889       if (temp)
1890         {
1891           if (no_output)
1892             return temp;
1893           return expand_binop (mode, and_optab, temp, GEN_INT (c | ~ new_const),
1894                                target, 0, OPTAB_WIDEN);
1895         }
1896     }
1897 #endif
1898
1899   return 0;
1900 }
1901
1902 /* Try to output insns to set TARGET equal to the constant C if it can be
1903    done in less than N insns.  Do all computations in MODE.  Returns the place
1904    where the output has been placed if it can be done and the insns have been
1905    emitted.  If it would take more than N insns, zero is returned and no
1906    insns and emitted.  */
1907
1908 static rtx
1909 alpha_emit_set_const (rtx target, enum machine_mode mode,
1910                       HOST_WIDE_INT c, int n, bool no_output)
1911 {
1912   enum machine_mode orig_mode = mode;
1913   rtx orig_target = target;
1914   rtx result = 0;
1915   int i;
1916
1917   /* If we can't make any pseudos, TARGET is an SImode hard register, we
1918      can't load this constant in one insn, do this in DImode.  */
1919   if (!can_create_pseudo_p () && mode == SImode
1920       && REG_P (target) && REGNO (target) < FIRST_PSEUDO_REGISTER)
1921     {
1922       result = alpha_emit_set_const_1 (target, mode, c, 1, no_output);
1923       if (result)
1924         return result;
1925
1926       target = no_output ? NULL : gen_lowpart (DImode, target);
1927       mode = DImode;
1928     }
1929   else if (mode == V8QImode || mode == V4HImode || mode == V2SImode)
1930     {
1931       target = no_output ? NULL : gen_lowpart (DImode, target);
1932       mode = DImode;
1933     }
1934
1935   /* Try 1 insn, then 2, then up to N.  */
1936   for (i = 1; i <= n; i++)
1937     {
1938       result = alpha_emit_set_const_1 (target, mode, c, i, no_output);
1939       if (result)
1940         {
1941           rtx insn, set;
1942
1943           if (no_output)
1944             return result;
1945
1946           insn = get_last_insn ();
1947           set = single_set (insn);
1948           if (! CONSTANT_P (SET_SRC (set)))
1949             set_unique_reg_note (get_last_insn (), REG_EQUAL, GEN_INT (c));
1950           break;
1951         }
1952     }
1953
1954   /* Allow for the case where we changed the mode of TARGET.  */
1955   if (result)
1956     {
1957       if (result == target)
1958         result = orig_target;
1959       else if (mode != orig_mode)
1960         result = gen_lowpart (orig_mode, result);
1961     }
1962
1963   return result;
1964 }
1965
1966 /* Having failed to find a 3 insn sequence in alpha_emit_set_const,
1967    fall back to a straight forward decomposition.  We do this to avoid
1968    exponential run times encountered when looking for longer sequences
1969    with alpha_emit_set_const.  */
1970
1971 static rtx
1972 alpha_emit_set_long_const (rtx target, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
1973 {
1974   HOST_WIDE_INT d1, d2, d3, d4;
1975
1976   /* Decompose the entire word */
1977 #if HOST_BITS_PER_WIDE_INT >= 64
1978   gcc_assert (c2 == -(c1 < 0));
1979   d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
1980   c1 -= d1;
1981   d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
1982   c1 = (c1 - d2) >> 32;
1983   d3 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
1984   c1 -= d3;
1985   d4 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
1986   gcc_assert (c1 == d4);
1987 #else
1988   d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
1989   c1 -= d1;
1990   d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
1991   gcc_assert (c1 == d2);
1992   c2 += (d2 < 0);
1993   d3 = ((c2 & 0xffff) ^ 0x8000) - 0x8000;
1994   c2 -= d3;
1995   d4 = ((c2 & 0xffffffff) ^ 0x80000000) - 0x80000000;
1996   gcc_assert (c2 == d4);
1997 #endif
1998
1999   /* Construct the high word */
2000   if (d4)
2001     {
2002       emit_move_insn (target, GEN_INT (d4));
2003       if (d3)
2004         emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d3)));
2005     }
2006   else
2007     emit_move_insn (target, GEN_INT (d3));
2008
2009   /* Shift it into place */
2010   emit_move_insn (target, gen_rtx_ASHIFT (DImode, target, GEN_INT (32)));
2011
2012   /* Add in the low bits.  */
2013   if (d2)
2014     emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d2)));
2015   if (d1)
2016     emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d1)));
2017
2018   return target;
2019 }
2020
2021 /* Given an integral CONST_INT, CONST_DOUBLE, or CONST_VECTOR, return 
2022    the low 64 bits.  */
2023
2024 static void
2025 alpha_extract_integer (rtx x, HOST_WIDE_INT *p0, HOST_WIDE_INT *p1)
2026 {
2027   HOST_WIDE_INT i0, i1;
2028
2029   if (GET_CODE (x) == CONST_VECTOR)
2030     x = simplify_subreg (DImode, x, GET_MODE (x), 0);
2031
2032
2033   if (CONST_INT_P (x))
2034     {
2035       i0 = INTVAL (x);
2036       i1 = -(i0 < 0);
2037     }
2038   else if (HOST_BITS_PER_WIDE_INT >= 64)
2039     {
2040       i0 = CONST_DOUBLE_LOW (x);
2041       i1 = -(i0 < 0);
2042     }
2043   else
2044     {
2045       i0 = CONST_DOUBLE_LOW (x);
2046       i1 = CONST_DOUBLE_HIGH (x);
2047     }
2048
2049   *p0 = i0;
2050   *p1 = i1;
2051 }
2052
2053 /* Implement LEGITIMATE_CONSTANT_P.  This is all constants for which we
2054    are willing to load the value into a register via a move pattern.
2055    Normally this is all symbolic constants, integral constants that
2056    take three or fewer instructions, and floating-point zero.  */
2057
2058 bool
2059 alpha_legitimate_constant_p (rtx x)
2060 {
2061   enum machine_mode mode = GET_MODE (x);
2062   HOST_WIDE_INT i0, i1;
2063
2064   switch (GET_CODE (x))
2065     {
2066     case LABEL_REF:
2067     case HIGH:
2068       return true;
2069
2070     case CONST:
2071       if (GET_CODE (XEXP (x, 0)) == PLUS
2072           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2073         x = XEXP (XEXP (x, 0), 0);
2074       else
2075         return true;
2076
2077       if (GET_CODE (x) != SYMBOL_REF)
2078         return true;
2079
2080       /* FALLTHRU */
2081
2082     case SYMBOL_REF:
2083       /* TLS symbols are never valid.  */
2084       return SYMBOL_REF_TLS_MODEL (x) == 0;
2085
2086     case CONST_DOUBLE:
2087       if (x == CONST0_RTX (mode))
2088         return true;
2089       if (FLOAT_MODE_P (mode))
2090         return false;
2091       goto do_integer;
2092
2093     case CONST_VECTOR:
2094       if (x == CONST0_RTX (mode))
2095         return true;
2096       if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT)
2097         return false;
2098       if (GET_MODE_SIZE (mode) != 8)
2099         return false;
2100       goto do_integer;
2101
2102     case CONST_INT:
2103     do_integer:
2104       if (TARGET_BUILD_CONSTANTS)
2105         return true;
2106       alpha_extract_integer (x, &i0, &i1);
2107       if (HOST_BITS_PER_WIDE_INT >= 64 || i1 == (-i0 < 0))
2108         return alpha_emit_set_const_1 (x, mode, i0, 3, true) != NULL;
2109       return false;
2110
2111     default:
2112       return false;
2113     }
2114 }
2115
2116 /* Operand 1 is known to be a constant, and should require more than one
2117    instruction to load.  Emit that multi-part load.  */
2118
2119 bool
2120 alpha_split_const_mov (enum machine_mode mode, rtx *operands)
2121 {
2122   HOST_WIDE_INT i0, i1;
2123   rtx temp = NULL_RTX;
2124
2125   alpha_extract_integer (operands[1], &i0, &i1);
2126
2127   if (HOST_BITS_PER_WIDE_INT >= 64 || i1 == -(i0 < 0))
2128     temp = alpha_emit_set_const (operands[0], mode, i0, 3, false);
2129
2130   if (!temp && TARGET_BUILD_CONSTANTS)
2131     temp = alpha_emit_set_long_const (operands[0], i0, i1);
2132
2133   if (temp)
2134     {
2135       if (!rtx_equal_p (operands[0], temp))
2136         emit_move_insn (operands[0], temp);
2137       return true;
2138     }
2139
2140   return false;
2141 }
2142
2143 /* Expand a move instruction; return true if all work is done.
2144    We don't handle non-bwx subword loads here.  */
2145
2146 bool
2147 alpha_expand_mov (enum machine_mode mode, rtx *operands)
2148 {
2149   rtx tmp;
2150
2151   /* If the output is not a register, the input must be.  */
2152   if (MEM_P (operands[0])
2153       && ! reg_or_0_operand (operands[1], mode))
2154     operands[1] = force_reg (mode, operands[1]);
2155
2156   /* Allow legitimize_address to perform some simplifications.  */
2157   if (mode == Pmode && symbolic_operand (operands[1], mode))
2158     {
2159       tmp = alpha_legitimize_address_1 (operands[1], operands[0], mode);
2160       if (tmp)
2161         {
2162           if (tmp == operands[0])
2163             return true;
2164           operands[1] = tmp;
2165           return false;
2166         }
2167     }
2168
2169   /* Early out for non-constants and valid constants.  */
2170   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], mode))
2171     return false;
2172
2173   /* Split large integers.  */
2174   if (CONST_INT_P (operands[1])
2175       || GET_CODE (operands[1]) == CONST_DOUBLE
2176       || GET_CODE (operands[1]) == CONST_VECTOR)
2177     {
2178       if (alpha_split_const_mov (mode, operands))
2179         return true;
2180     }
2181
2182   /* Otherwise we've nothing left but to drop the thing to memory.  */
2183   tmp = force_const_mem (mode, operands[1]);
2184
2185   if (tmp == NULL_RTX)
2186     return false;
2187
2188   if (reload_in_progress)
2189     {
2190       emit_move_insn (operands[0], XEXP (tmp, 0));
2191       operands[1] = replace_equiv_address (tmp, operands[0]);
2192     }
2193   else
2194     operands[1] = validize_mem (tmp);
2195   return false;
2196 }
2197
2198 /* Expand a non-bwx QImode or HImode move instruction;
2199    return true if all work is done.  */
2200
2201 bool
2202 alpha_expand_mov_nobwx (enum machine_mode mode, rtx *operands)
2203 {
2204   rtx seq;
2205
2206   /* If the output is not a register, the input must be.  */
2207   if (MEM_P (operands[0]))
2208     operands[1] = force_reg (mode, operands[1]);
2209
2210   /* Handle four memory cases, unaligned and aligned for either the input
2211      or the output.  The only case where we can be called during reload is
2212      for aligned loads; all other cases require temporaries.  */
2213
2214   if (any_memory_operand (operands[1], mode))
2215     {
2216       if (aligned_memory_operand (operands[1], mode))
2217         {
2218           if (reload_in_progress)
2219             {
2220               if (mode == QImode)
2221                 seq = gen_reload_inqi_aligned (operands[0], operands[1]);
2222               else
2223                 seq = gen_reload_inhi_aligned (operands[0], operands[1]);
2224               emit_insn (seq);
2225             }
2226           else
2227             {
2228               rtx aligned_mem, bitnum;
2229               rtx scratch = gen_reg_rtx (SImode);
2230               rtx subtarget;
2231               bool copyout;
2232
2233               get_aligned_mem (operands[1], &aligned_mem, &bitnum);
2234
2235               subtarget = operands[0];
2236               if (REG_P (subtarget))
2237                 subtarget = gen_lowpart (DImode, subtarget), copyout = false;
2238               else
2239                 subtarget = gen_reg_rtx (DImode), copyout = true;
2240
2241               if (mode == QImode)
2242                 seq = gen_aligned_loadqi (subtarget, aligned_mem,
2243                                           bitnum, scratch);
2244               else
2245                 seq = gen_aligned_loadhi (subtarget, aligned_mem,
2246                                           bitnum, scratch);
2247               emit_insn (seq);
2248
2249               if (copyout)
2250                 emit_move_insn (operands[0], gen_lowpart (mode, subtarget));
2251             }
2252         }
2253       else
2254         {
2255           /* Don't pass these as parameters since that makes the generated
2256              code depend on parameter evaluation order which will cause
2257              bootstrap failures.  */
2258
2259           rtx temp1, temp2, subtarget, ua;
2260           bool copyout;
2261
2262           temp1 = gen_reg_rtx (DImode);
2263           temp2 = gen_reg_rtx (DImode);
2264
2265           subtarget = operands[0];
2266           if (REG_P (subtarget))
2267             subtarget = gen_lowpart (DImode, subtarget), copyout = false;
2268           else
2269             subtarget = gen_reg_rtx (DImode), copyout = true;
2270
2271           ua = get_unaligned_address (operands[1]);
2272           if (mode == QImode)
2273             seq = gen_unaligned_loadqi (subtarget, ua, temp1, temp2);
2274           else
2275             seq = gen_unaligned_loadhi (subtarget, ua, temp1, temp2);
2276
2277           alpha_set_memflags (seq, operands[1]);
2278           emit_insn (seq);
2279
2280           if (copyout)
2281             emit_move_insn (operands[0], gen_lowpart (mode, subtarget));
2282         }
2283       return true;
2284     }
2285
2286   if (any_memory_operand (operands[0], mode))
2287     {
2288       if (aligned_memory_operand (operands[0], mode))
2289         {
2290           rtx aligned_mem, bitnum;
2291           rtx temp1 = gen_reg_rtx (SImode);
2292           rtx temp2 = gen_reg_rtx (SImode);
2293
2294           get_aligned_mem (operands[0], &aligned_mem, &bitnum);
2295
2296           emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
2297                                         temp1, temp2));
2298         }
2299       else
2300         {
2301           rtx temp1 = gen_reg_rtx (DImode);
2302           rtx temp2 = gen_reg_rtx (DImode);
2303           rtx temp3 = gen_reg_rtx (DImode);
2304           rtx ua = get_unaligned_address (operands[0]);
2305
2306           if (mode == QImode)
2307             seq = gen_unaligned_storeqi (ua, operands[1], temp1, temp2, temp3);
2308           else
2309             seq = gen_unaligned_storehi (ua, operands[1], temp1, temp2, temp3);
2310
2311           alpha_set_memflags (seq, operands[0]);
2312           emit_insn (seq);
2313         }
2314       return true;
2315     }
2316
2317   return false;
2318 }
2319
2320 /* Implement the movmisalign patterns.  One of the operands is a memory
2321    that is not naturally aligned.  Emit instructions to load it.  */
2322
2323 void
2324 alpha_expand_movmisalign (enum machine_mode mode, rtx *operands)
2325 {
2326   /* Honor misaligned loads, for those we promised to do so.  */
2327   if (MEM_P (operands[1]))
2328     {
2329       rtx tmp;
2330
2331       if (register_operand (operands[0], mode))
2332         tmp = operands[0];
2333       else
2334         tmp = gen_reg_rtx (mode);
2335
2336       alpha_expand_unaligned_load (tmp, operands[1], 8, 0, 0);
2337       if (tmp != operands[0])
2338         emit_move_insn (operands[0], tmp);
2339     }
2340   else if (MEM_P (operands[0]))
2341     {
2342       if (!reg_or_0_operand (operands[1], mode))
2343         operands[1] = force_reg (mode, operands[1]);
2344       alpha_expand_unaligned_store (operands[0], operands[1], 8, 0);
2345     }
2346   else
2347     gcc_unreachable ();
2348 }
2349
2350 /* Generate an unsigned DImode to FP conversion.  This is the same code
2351    optabs would emit if we didn't have TFmode patterns.
2352
2353    For SFmode, this is the only construction I've found that can pass
2354    gcc.c-torture/execute/ieee/rbug.c.  No scenario that uses DFmode
2355    intermediates will work, because you'll get intermediate rounding
2356    that ruins the end result.  Some of this could be fixed by turning
2357    on round-to-positive-infinity, but that requires diddling the fpsr,
2358    which kills performance.  I tried turning this around and converting
2359    to a negative number, so that I could turn on /m, but either I did
2360    it wrong or there's something else cause I wound up with the exact
2361    same single-bit error.  There is a branch-less form of this same code:
2362
2363         srl     $16,1,$1
2364         and     $16,1,$2
2365         cmplt   $16,0,$3
2366         or      $1,$2,$2
2367         cmovge  $16,$16,$2
2368         itoft   $3,$f10
2369         itoft   $2,$f11
2370         cvtqs   $f11,$f11
2371         adds    $f11,$f11,$f0
2372         fcmoveq $f10,$f11,$f0
2373
2374    I'm not using it because it's the same number of instructions as
2375    this branch-full form, and it has more serialized long latency
2376    instructions on the critical path.
2377
2378    For DFmode, we can avoid rounding errors by breaking up the word
2379    into two pieces, converting them separately, and adding them back:
2380
2381    LC0: .long 0,0x5f800000
2382
2383         itoft   $16,$f11
2384         lda     $2,LC0
2385         cmplt   $16,0,$1
2386         cpyse   $f11,$f31,$f10
2387         cpyse   $f31,$f11,$f11
2388         s4addq  $1,$2,$1
2389         lds     $f12,0($1)
2390         cvtqt   $f10,$f10
2391         cvtqt   $f11,$f11
2392         addt    $f12,$f10,$f0
2393         addt    $f0,$f11,$f0
2394
2395    This doesn't seem to be a clear-cut win over the optabs form.
2396    It probably all depends on the distribution of numbers being
2397    converted -- in the optabs form, all but high-bit-set has a
2398    much lower minimum execution time.  */
2399
2400 void
2401 alpha_emit_floatuns (rtx operands[2])
2402 {
2403   rtx neglab, donelab, i0, i1, f0, in, out;
2404   enum machine_mode mode;
2405
2406   out = operands[0];
2407   in = force_reg (DImode, operands[1]);
2408   mode = GET_MODE (out);
2409   neglab = gen_label_rtx ();
2410   donelab = gen_label_rtx ();
2411   i0 = gen_reg_rtx (DImode);
2412   i1 = gen_reg_rtx (DImode);
2413   f0 = gen_reg_rtx (mode);
2414
2415   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
2416
2417   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
2418   emit_jump_insn (gen_jump (donelab));
2419   emit_barrier ();
2420
2421   emit_label (neglab);
2422
2423   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
2424   emit_insn (gen_anddi3 (i1, in, const1_rtx));
2425   emit_insn (gen_iordi3 (i0, i0, i1));
2426   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
2427   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
2428
2429   emit_label (donelab);
2430 }
2431
2432 /* Generate the comparison for a conditional branch.  */
2433
2434 void
2435 alpha_emit_conditional_branch (rtx operands[], enum machine_mode cmp_mode)
2436 {
2437   enum rtx_code cmp_code, branch_code;
2438   enum machine_mode branch_mode = VOIDmode;
2439   enum rtx_code code = GET_CODE (operands[0]);
2440   rtx op0 = operands[1], op1 = operands[2];
2441   rtx tem;
2442
2443   if (cmp_mode == TFmode)
2444     {
2445       op0 = alpha_emit_xfloating_compare (&code, op0, op1);
2446       op1 = const0_rtx;
2447       cmp_mode = DImode;
2448     }
2449
2450   /* The general case: fold the comparison code to the types of compares
2451      that we have, choosing the branch as necessary.  */
2452   switch (code)
2453     {
2454     case EQ:  case LE:  case LT:  case LEU:  case LTU:
2455     case UNORDERED:
2456       /* We have these compares: */
2457       cmp_code = code, branch_code = NE;
2458       break;
2459
2460     case NE:
2461     case ORDERED:
2462       /* These must be reversed.  */
2463       cmp_code = reverse_condition (code), branch_code = EQ;
2464       break;
2465
2466     case GE:  case GT: case GEU:  case GTU:
2467       /* For FP, we swap them, for INT, we reverse them.  */
2468       if (cmp_mode == DFmode)
2469         {
2470           cmp_code = swap_condition (code);
2471           branch_code = NE;
2472           tem = op0, op0 = op1, op1 = tem;
2473         }
2474       else
2475         {
2476           cmp_code = reverse_condition (code);
2477           branch_code = EQ;
2478         }
2479       break;
2480
2481     default:
2482       gcc_unreachable ();
2483     }
2484
2485   if (cmp_mode == DFmode)
2486     {
2487       if (flag_unsafe_math_optimizations && cmp_code != UNORDERED)
2488         {
2489           /* When we are not as concerned about non-finite values, and we
2490              are comparing against zero, we can branch directly.  */
2491           if (op1 == CONST0_RTX (DFmode))
2492             cmp_code = UNKNOWN, branch_code = code;
2493           else if (op0 == CONST0_RTX (DFmode))
2494             {
2495               /* Undo the swap we probably did just above.  */
2496               tem = op0, op0 = op1, op1 = tem;
2497               branch_code = swap_condition (cmp_code);
2498               cmp_code = UNKNOWN;
2499             }
2500         }
2501       else
2502         {
2503           /* ??? We mark the branch mode to be CCmode to prevent the
2504              compare and branch from being combined, since the compare
2505              insn follows IEEE rules that the branch does not.  */
2506           branch_mode = CCmode;
2507         }
2508     }
2509   else
2510     {
2511       /* The following optimizations are only for signed compares.  */
2512       if (code != LEU && code != LTU && code != GEU && code != GTU)
2513         {
2514           /* Whee.  Compare and branch against 0 directly.  */
2515           if (op1 == const0_rtx)
2516             cmp_code = UNKNOWN, branch_code = code;
2517
2518           /* If the constants doesn't fit into an immediate, but can
2519              be generated by lda/ldah, we adjust the argument and
2520              compare against zero, so we can use beq/bne directly.  */
2521           /* ??? Don't do this when comparing against symbols, otherwise
2522              we'll reduce (&x == 0x1234) to (&x-0x1234 == 0), which will
2523              be declared false out of hand (at least for non-weak).  */
2524           else if (CONST_INT_P (op1)
2525                    && (code == EQ || code == NE)
2526                    && !(symbolic_operand (op0, VOIDmode)
2527                         || (REG_P (op0) && REG_POINTER (op0))))
2528             {
2529               rtx n_op1 = GEN_INT (-INTVAL (op1));
2530
2531               if (! satisfies_constraint_I (op1)
2532                   && (satisfies_constraint_K (n_op1)
2533                       || satisfies_constraint_L (n_op1)))
2534                 cmp_code = PLUS, branch_code = code, op1 = n_op1;
2535             }
2536         }
2537
2538       if (!reg_or_0_operand (op0, DImode))
2539         op0 = force_reg (DImode, op0);
2540       if (cmp_code != PLUS && !reg_or_8bit_operand (op1, DImode))
2541         op1 = force_reg (DImode, op1);
2542     }
2543
2544   /* Emit an initial compare instruction, if necessary.  */
2545   tem = op0;
2546   if (cmp_code != UNKNOWN)
2547     {
2548       tem = gen_reg_rtx (cmp_mode);
2549       emit_move_insn (tem, gen_rtx_fmt_ee (cmp_code, cmp_mode, op0, op1));
2550     }
2551
2552   /* Emit the branch instruction.  */
2553   tem = gen_rtx_SET (VOIDmode, pc_rtx,
2554                      gen_rtx_IF_THEN_ELSE (VOIDmode,
2555                                            gen_rtx_fmt_ee (branch_code,
2556                                                            branch_mode, tem,
2557                                                            CONST0_RTX (cmp_mode)),
2558                                            gen_rtx_LABEL_REF (VOIDmode,
2559                                                               operands[3]),
2560                                            pc_rtx));
2561   emit_jump_insn (tem);
2562 }
2563
2564 /* Certain simplifications can be done to make invalid setcc operations
2565    valid.  Return the final comparison, or NULL if we can't work.  */
2566
2567 bool
2568 alpha_emit_setcc (rtx operands[], enum machine_mode cmp_mode)
2569 {
2570   enum rtx_code cmp_code;
2571   enum rtx_code code = GET_CODE (operands[1]);
2572   rtx op0 = operands[2], op1 = operands[3];
2573   rtx tmp;
2574
2575   if (cmp_mode == TFmode)
2576     {
2577       op0 = alpha_emit_xfloating_compare (&code, op0, op1);
2578       op1 = const0_rtx;
2579       cmp_mode = DImode;
2580     }
2581
2582   if (cmp_mode == DFmode && !TARGET_FIX)
2583     return 0;
2584
2585   /* The general case: fold the comparison code to the types of compares
2586      that we have, choosing the branch as necessary.  */
2587
2588   cmp_code = UNKNOWN;
2589   switch (code)
2590     {
2591     case EQ:  case LE:  case LT:  case LEU:  case LTU:
2592     case UNORDERED:
2593       /* We have these compares.  */
2594       if (cmp_mode == DFmode)
2595         cmp_code = code, code = NE;
2596       break;
2597
2598     case NE:
2599       if (cmp_mode == DImode && op1 == const0_rtx)
2600         break;
2601       /* FALLTHRU */
2602
2603     case ORDERED:
2604       cmp_code = reverse_condition (code);
2605       code = EQ;
2606       break;
2607
2608     case GE:  case GT: case GEU:  case GTU:
2609       /* These normally need swapping, but for integer zero we have
2610          special patterns that recognize swapped operands.  */
2611       if (cmp_mode == DImode && op1 == const0_rtx)
2612         break;
2613       code = swap_condition (code);
2614       if (cmp_mode == DFmode)
2615         cmp_code = code, code = NE;
2616       tmp = op0, op0 = op1, op1 = tmp;
2617       break;
2618
2619     default:
2620       gcc_unreachable ();
2621     }
2622
2623   if (cmp_mode == DImode)
2624     {
2625       if (!register_operand (op0, DImode))
2626         op0 = force_reg (DImode, op0);
2627       if (!reg_or_8bit_operand (op1, DImode))
2628         op1 = force_reg (DImode, op1);
2629     }
2630
2631   /* Emit an initial compare instruction, if necessary.  */
2632   if (cmp_code != UNKNOWN)
2633     {
2634       tmp = gen_reg_rtx (cmp_mode);
2635       emit_insn (gen_rtx_SET (VOIDmode, tmp,
2636                               gen_rtx_fmt_ee (cmp_code, cmp_mode, op0, op1)));
2637
2638       op0 = cmp_mode != DImode ? gen_lowpart (DImode, tmp) : tmp;
2639       op1 = const0_rtx;
2640     }
2641
2642   /* Emit the setcc instruction.  */
2643   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2644                           gen_rtx_fmt_ee (code, DImode, op0, op1)));
2645   return true;
2646 }
2647
2648
2649 /* Rewrite a comparison against zero CMP of the form
2650    (CODE (cc0) (const_int 0)) so it can be written validly in
2651    a conditional move (if_then_else CMP ...).
2652    If both of the operands that set cc0 are nonzero we must emit
2653    an insn to perform the compare (it can't be done within
2654    the conditional move).  */
2655
2656 rtx
2657 alpha_emit_conditional_move (rtx cmp, enum machine_mode mode)
2658 {
2659   enum rtx_code code = GET_CODE (cmp);
2660   enum rtx_code cmov_code = NE;
2661   rtx op0 = XEXP (cmp, 0);
2662   rtx op1 = XEXP (cmp, 1);
2663   enum machine_mode cmp_mode
2664     = (GET_MODE (op0) == VOIDmode ? DImode : GET_MODE (op0));
2665   enum machine_mode cmov_mode = VOIDmode;
2666   int local_fast_math = flag_unsafe_math_optimizations;
2667   rtx tem;
2668
2669   gcc_assert (cmp_mode == DFmode || cmp_mode == DImode);
2670
2671   if (FLOAT_MODE_P (cmp_mode) != FLOAT_MODE_P (mode))
2672     {
2673       enum rtx_code cmp_code;
2674
2675       if (! TARGET_FIX)
2676         return 0;
2677
2678       /* If we have fp<->int register move instructions, do a cmov by
2679          performing the comparison in fp registers, and move the
2680          zero/nonzero value to integer registers, where we can then
2681          use a normal cmov, or vice-versa.  */
2682
2683       switch (code)
2684         {
2685         case EQ: case LE: case LT: case LEU: case LTU:
2686           /* We have these compares.  */
2687           cmp_code = code, code = NE;
2688           break;
2689
2690         case NE:
2691           /* This must be reversed.  */
2692           cmp_code = EQ, code = EQ;
2693           break;
2694
2695         case GE: case GT: case GEU: case GTU:
2696           /* These normally need swapping, but for integer zero we have
2697              special patterns that recognize swapped operands.  */
2698           if (cmp_mode == DImode && op1 == const0_rtx)
2699             cmp_code = code, code = NE;
2700           else
2701             {
2702               cmp_code = swap_condition (code);
2703               code = NE;
2704               tem = op0, op0 = op1, op1 = tem;
2705             }
2706           break;
2707
2708         default:
2709           gcc_unreachable ();
2710         }
2711
2712       tem = gen_reg_rtx (cmp_mode);
2713       emit_insn (gen_rtx_SET (VOIDmode, tem,
2714                               gen_rtx_fmt_ee (cmp_code, cmp_mode,
2715                                               op0, op1)));
2716
2717       cmp_mode = cmp_mode == DImode ? DFmode : DImode;
2718       op0 = gen_lowpart (cmp_mode, tem);
2719       op1 = CONST0_RTX (cmp_mode);
2720       local_fast_math = 1;
2721     }
2722
2723   /* We may be able to use a conditional move directly.
2724      This avoids emitting spurious compares.  */
2725   if (signed_comparison_operator (cmp, VOIDmode)
2726       && (cmp_mode == DImode || local_fast_math)
2727       && (op0 == CONST0_RTX (cmp_mode) || op1 == CONST0_RTX (cmp_mode)))
2728     return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
2729
2730   /* We can't put the comparison inside the conditional move;
2731      emit a compare instruction and put that inside the
2732      conditional move.  Make sure we emit only comparisons we have;
2733      swap or reverse as necessary.  */
2734
2735   if (!can_create_pseudo_p ())
2736     return NULL_RTX;
2737
2738   switch (code)
2739     {
2740     case EQ:  case LE:  case LT:  case LEU:  case LTU:
2741       /* We have these compares: */
2742       break;
2743
2744     case NE:
2745       /* This must be reversed.  */
2746       code = reverse_condition (code);
2747       cmov_code = EQ;
2748       break;
2749
2750     case GE:  case GT:  case GEU:  case GTU:
2751       /* These must be swapped.  */
2752       if (op1 != CONST0_RTX (cmp_mode))
2753         {
2754           code = swap_condition (code);
2755           tem = op0, op0 = op1, op1 = tem;
2756         }
2757       break;
2758
2759     default:
2760       gcc_unreachable ();
2761     }
2762
2763   if (cmp_mode == DImode)
2764     {
2765       if (!reg_or_0_operand (op0, DImode))
2766         op0 = force_reg (DImode, op0);
2767       if (!reg_or_8bit_operand (op1, DImode))
2768         op1 = force_reg (DImode, op1);
2769     }
2770
2771   /* ??? We mark the branch mode to be CCmode to prevent the compare
2772      and cmov from being combined, since the compare insn follows IEEE
2773      rules that the cmov does not.  */
2774   if (cmp_mode == DFmode && !local_fast_math)
2775     cmov_mode = CCmode;
2776
2777   tem = gen_reg_rtx (cmp_mode);
2778   emit_move_insn (tem, gen_rtx_fmt_ee (code, cmp_mode, op0, op1));
2779   return gen_rtx_fmt_ee (cmov_code, cmov_mode, tem, CONST0_RTX (cmp_mode));
2780 }
2781
2782 /* Simplify a conditional move of two constants into a setcc with
2783    arithmetic.  This is done with a splitter since combine would
2784    just undo the work if done during code generation.  It also catches
2785    cases we wouldn't have before cse.  */
2786
2787 int
2788 alpha_split_conditional_move (enum rtx_code code, rtx dest, rtx cond,
2789                               rtx t_rtx, rtx f_rtx)
2790 {
2791   HOST_WIDE_INT t, f, diff;
2792   enum machine_mode mode;
2793   rtx target, subtarget, tmp;
2794
2795   mode = GET_MODE (dest);
2796   t = INTVAL (t_rtx);
2797   f = INTVAL (f_rtx);
2798   diff = t - f;
2799
2800   if (((code == NE || code == EQ) && diff < 0)
2801       || (code == GE || code == GT))
2802     {
2803       code = reverse_condition (code);
2804       diff = t, t = f, f = diff;
2805       diff = t - f;
2806     }
2807
2808   subtarget = target = dest;
2809   if (mode != DImode)
2810     {
2811       target = gen_lowpart (DImode, dest);
2812       if (can_create_pseudo_p ())
2813         subtarget = gen_reg_rtx (DImode);
2814       else
2815         subtarget = target;
2816     }
2817   /* Below, we must be careful to use copy_rtx on target and subtarget
2818      in intermediate insns, as they may be a subreg rtx, which may not
2819      be shared.  */
2820
2821   if (f == 0 && exact_log2 (diff) > 0
2822       /* On EV6, we've got enough shifters to make non-arithmetic shifts
2823          viable over a longer latency cmove.  On EV5, the E0 slot is a
2824          scarce resource, and on EV4 shift has the same latency as a cmove.  */
2825       && (diff <= 8 || alpha_tune == PROCESSOR_EV6))
2826     {
2827       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
2828       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
2829
2830       tmp = gen_rtx_ASHIFT (DImode, copy_rtx (subtarget),
2831                             GEN_INT (exact_log2 (t)));
2832       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
2833     }
2834   else if (f == 0 && t == -1)
2835     {
2836       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
2837       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
2838
2839       emit_insn (gen_negdi2 (target, copy_rtx (subtarget)));
2840     }
2841   else if (diff == 1 || diff == 4 || diff == 8)
2842     {
2843       rtx add_op;
2844
2845       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
2846       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
2847
2848       if (diff == 1)
2849         emit_insn (gen_adddi3 (target, copy_rtx (subtarget), GEN_INT (f)));
2850       else
2851         {
2852           add_op = GEN_INT (f);
2853           if (sext_add_operand (add_op, mode))
2854             {
2855               tmp = gen_rtx_MULT (DImode, copy_rtx (subtarget),
2856                                   GEN_INT (diff));
2857               tmp = gen_rtx_PLUS (DImode, tmp, add_op);
2858               emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
2859             }
2860           else
2861             return 0;
2862         }
2863     }
2864   else
2865     return 0;
2866
2867   return 1;
2868 }
2869 \f
2870 /* Look up the function X_floating library function name for the
2871    given operation.  */
2872
2873 struct GTY(()) xfloating_op
2874 {
2875   const enum rtx_code code;
2876   const char *const GTY((skip)) osf_func;
2877   const char *const GTY((skip)) vms_func;
2878   rtx libcall;
2879 };
2880
2881 static GTY(()) struct xfloating_op xfloating_ops[] =
2882 {
2883   { PLUS,               "_OtsAddX", "OTS$ADD_X", 0 },
2884   { MINUS,              "_OtsSubX", "OTS$SUB_X", 0 },
2885   { MULT,               "_OtsMulX", "OTS$MUL_X", 0 },
2886   { DIV,                "_OtsDivX", "OTS$DIV_X", 0 },
2887   { EQ,                 "_OtsEqlX", "OTS$EQL_X", 0 },
2888   { NE,                 "_OtsNeqX", "OTS$NEQ_X", 0 },
2889   { LT,                 "_OtsLssX", "OTS$LSS_X", 0 },
2890   { LE,                 "_OtsLeqX", "OTS$LEQ_X", 0 },
2891   { GT,                 "_OtsGtrX", "OTS$GTR_X", 0 },
2892   { GE,                 "_OtsGeqX", "OTS$GEQ_X", 0 },
2893   { FIX,                "_OtsCvtXQ", "OTS$CVTXQ", 0 },
2894   { FLOAT,              "_OtsCvtQX", "OTS$CVTQX", 0 },
2895   { UNSIGNED_FLOAT,     "_OtsCvtQUX", "OTS$CVTQUX", 0 },
2896   { FLOAT_EXTEND,       "_OtsConvertFloatTX", "OTS$CVT_FLOAT_T_X", 0 },
2897   { FLOAT_TRUNCATE,     "_OtsConvertFloatXT", "OTS$CVT_FLOAT_X_T", 0 }
2898 };
2899
2900 static GTY(()) struct xfloating_op vax_cvt_ops[] =
2901 {
2902   { FLOAT_EXTEND,       "_OtsConvertFloatGX", "OTS$CVT_FLOAT_G_X", 0 },
2903   { FLOAT_TRUNCATE,     "_OtsConvertFloatXG", "OTS$CVT_FLOAT_X_G", 0 }
2904 };
2905
2906 static rtx
2907 alpha_lookup_xfloating_lib_func (enum rtx_code code)
2908 {
2909   struct xfloating_op *ops = xfloating_ops;
2910   long n = ARRAY_SIZE (xfloating_ops);
2911   long i;
2912
2913   gcc_assert (TARGET_HAS_XFLOATING_LIBS);
2914
2915   /* How irritating.  Nothing to key off for the main table.  */
2916   if (TARGET_FLOAT_VAX && (code == FLOAT_EXTEND || code == FLOAT_TRUNCATE))
2917     {
2918       ops = vax_cvt_ops;
2919       n = ARRAY_SIZE (vax_cvt_ops);
2920     }
2921
2922   for (i = 0; i < n; ++i, ++ops)
2923     if (ops->code == code)
2924       {
2925         rtx func = ops->libcall;
2926         if (!func)
2927           {
2928             func = init_one_libfunc (TARGET_ABI_OPEN_VMS
2929                                      ? ops->vms_func : ops->osf_func);
2930             ops->libcall = func;
2931           }
2932         return func;
2933       }
2934
2935   gcc_unreachable ();
2936 }
2937
2938 /* Most X_floating operations take the rounding mode as an argument.
2939    Compute that here.  */
2940
2941 static int
2942 alpha_compute_xfloating_mode_arg (enum rtx_code code,
2943                                   enum alpha_fp_rounding_mode round)
2944 {
2945   int mode;
2946
2947   switch (round)
2948     {
2949     case ALPHA_FPRM_NORM:
2950       mode = 2;
2951       break;
2952     case ALPHA_FPRM_MINF:
2953       mode = 1;
2954       break;
2955     case ALPHA_FPRM_CHOP:
2956       mode = 0;
2957       break;
2958     case ALPHA_FPRM_DYN:
2959       mode = 4;
2960       break;
2961     default:
2962       gcc_unreachable ();
2963
2964     /* XXX For reference, round to +inf is mode = 3.  */
2965     }
2966
2967   if (code == FLOAT_TRUNCATE && alpha_fptm == ALPHA_FPTM_N)
2968     mode |= 0x10000;
2969
2970   return mode;
2971 }
2972
2973 /* Emit an X_floating library function call.
2974
2975    Note that these functions do not follow normal calling conventions:
2976    TFmode arguments are passed in two integer registers (as opposed to
2977    indirect); TFmode return values appear in R16+R17.
2978
2979    FUNC is the function to call.
2980    TARGET is where the output belongs.
2981    OPERANDS are the inputs.
2982    NOPERANDS is the count of inputs.
2983    EQUIV is the expression equivalent for the function.
2984 */
2985
2986 static void
2987 alpha_emit_xfloating_libcall (rtx func, rtx target, rtx operands[],
2988                               int noperands, rtx equiv)
2989 {
2990   rtx usage = NULL_RTX, tmp, reg;
2991   int regno = 16, i;
2992
2993   start_sequence ();
2994
2995   for (i = 0; i < noperands; ++i)
2996     {
2997       switch (GET_MODE (operands[i]))
2998         {
2999         case TFmode:
3000           reg = gen_rtx_REG (TFmode, regno);
3001           regno += 2;
3002           break;
3003
3004         case DFmode:
3005           reg = gen_rtx_REG (DFmode, regno + 32);
3006           regno += 1;
3007           break;
3008
3009         case VOIDmode:
3010           gcc_assert (CONST_INT_P (operands[i]));
3011           /* FALLTHRU */
3012         case DImode:
3013           reg = gen_rtx_REG (DImode, regno);
3014           regno += 1;
3015           break;
3016
3017         default:
3018           gcc_unreachable ();
3019         }
3020
3021       emit_move_insn (reg, operands[i]);
3022       usage = alloc_EXPR_LIST (0, gen_rtx_USE (VOIDmode, reg), usage);
3023     }
3024
3025   switch (GET_MODE (target))
3026     {
3027     case TFmode:
3028       reg = gen_rtx_REG (TFmode, 16);
3029       break;
3030     case DFmode:
3031       reg = gen_rtx_REG (DFmode, 32);
3032       break;
3033     case DImode:
3034       reg = gen_rtx_REG (DImode, 0);
3035       break;
3036     default:
3037       gcc_unreachable ();
3038     }
3039
3040   tmp = gen_rtx_MEM (QImode, func);
3041   tmp = emit_call_insn (GEN_CALL_VALUE (reg, tmp, const0_rtx,
3042                                         const0_rtx, const0_rtx));
3043   CALL_INSN_FUNCTION_USAGE (tmp) = usage;
3044   RTL_CONST_CALL_P (tmp) = 1;
3045
3046   tmp = get_insns ();
3047   end_sequence ();
3048
3049   emit_libcall_block (tmp, target, reg, equiv);
3050 }
3051
3052 /* Emit an X_floating library function call for arithmetic (+,-,*,/).  */
3053
3054 void
3055 alpha_emit_xfloating_arith (enum rtx_code code, rtx operands[])
3056 {
3057   rtx func;
3058   int mode;
3059   rtx out_operands[3];
3060
3061   func = alpha_lookup_xfloating_lib_func (code);
3062   mode = alpha_compute_xfloating_mode_arg (code, alpha_fprm);
3063
3064   out_operands[0] = operands[1];
3065   out_operands[1] = operands[2];
3066   out_operands[2] = GEN_INT (mode);
3067   alpha_emit_xfloating_libcall (func, operands[0], out_operands, 3,
3068                                 gen_rtx_fmt_ee (code, TFmode, operands[1],
3069                                                 operands[2]));
3070 }
3071
3072 /* Emit an X_floating library function call for a comparison.  */
3073
3074 static rtx
3075 alpha_emit_xfloating_compare (enum rtx_code *pcode, rtx op0, rtx op1)
3076 {
3077   enum rtx_code cmp_code, res_code;
3078   rtx func, out, operands[2], note;
3079
3080   /* X_floating library comparison functions return
3081            -1  unordered
3082             0  false
3083             1  true
3084      Convert the compare against the raw return value.  */
3085
3086   cmp_code = *pcode;
3087   switch (cmp_code)
3088     {
3089     case UNORDERED:
3090       cmp_code = EQ;
3091       res_code = LT;
3092       break;
3093     case ORDERED:
3094       cmp_code = EQ;
3095       res_code = GE;
3096       break;
3097     case NE:
3098       res_code = NE;
3099       break;
3100     case EQ:
3101     case LT:
3102     case GT:
3103     case LE:
3104     case GE:
3105       res_code = GT;
3106       break;
3107     default:
3108       gcc_unreachable ();
3109     }
3110   *pcode = res_code;
3111
3112   func = alpha_lookup_xfloating_lib_func (cmp_code);
3113
3114   operands[0] = op0;
3115   operands[1] = op1;
3116   out = gen_reg_rtx (DImode);
3117
3118   /* What's actually returned is -1,0,1, not a proper boolean value,
3119      so use an EXPR_LIST as with a generic libcall instead of a 
3120      comparison type expression.  */
3121   note = gen_rtx_EXPR_LIST (VOIDmode, op1, NULL_RTX);
3122   note = gen_rtx_EXPR_LIST (VOIDmode, op0, note);
3123   note = gen_rtx_EXPR_LIST (VOIDmode, func, note);
3124   alpha_emit_xfloating_libcall (func, out, operands, 2, note);
3125
3126   return out;
3127 }
3128
3129 /* Emit an X_floating library function call for a conversion.  */
3130
3131 void
3132 alpha_emit_xfloating_cvt (enum rtx_code orig_code, rtx operands[])
3133 {
3134   int noperands = 1, mode;
3135   rtx out_operands[2];
3136   rtx func;
3137   enum rtx_code code = orig_code;
3138
3139   if (code == UNSIGNED_FIX)
3140     code = FIX;
3141
3142   func = alpha_lookup_xfloating_lib_func (code);
3143
3144   out_operands[0] = operands[1];
3145
3146   switch (code)
3147     {
3148     case FIX:
3149       mode = alpha_compute_xfloating_mode_arg (code, ALPHA_FPRM_CHOP);
3150       out_operands[1] = GEN_INT (mode);
3151       noperands = 2;
3152       break;
3153     case FLOAT_TRUNCATE:
3154       mode = alpha_compute_xfloating_mode_arg (code, alpha_fprm);
3155       out_operands[1] = GEN_INT (mode);
3156       noperands = 2;
3157       break;
3158     default:
3159       break;
3160     }
3161
3162   alpha_emit_xfloating_libcall (func, operands[0], out_operands, noperands,
3163                                 gen_rtx_fmt_e (orig_code,
3164                                                GET_MODE (operands[0]),
3165                                                operands[1]));
3166 }
3167
3168 /* Split a TImode or TFmode move from OP[1] to OP[0] into a pair of
3169    DImode moves from OP[2,3] to OP[0,1].  If FIXUP_OVERLAP is true,
3170    guarantee that the sequence
3171      set (OP[0] OP[2])
3172      set (OP[1] OP[3])
3173    is valid.  Naturally, output operand ordering is little-endian.
3174    This is used by *movtf_internal and *movti_internal.  */
3175   
3176 void
3177 alpha_split_tmode_pair (rtx operands[4], enum machine_mode mode,
3178                         bool fixup_overlap)
3179 {
3180   switch (GET_CODE (operands[1]))
3181     {
3182     case REG:
3183       operands[3] = gen_rtx_REG (DImode, REGNO (operands[1]) + 1);
3184       operands[2] = gen_rtx_REG (DImode, REGNO (operands[1]));
3185       break;
3186
3187     case MEM:
3188       operands[3] = adjust_address (operands[1], DImode, 8);
3189       operands[2] = adjust_address (operands[1], DImode, 0);
3190       break;
3191
3192     case CONST_INT:
3193     case CONST_DOUBLE:
3194       gcc_assert (operands[1] == CONST0_RTX (mode));
3195       operands[2] = operands[3] = const0_rtx;
3196       break;
3197
3198     default:
3199       gcc_unreachable ();
3200     }
3201
3202   switch (GET_CODE (operands[0]))
3203     {
3204     case REG:
3205       operands[1] = gen_rtx_REG (DImode, REGNO (operands[0]) + 1);
3206       operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
3207       break;
3208
3209     case MEM:
3210       operands[1] = adjust_address (operands[0], DImode, 8);
3211       operands[0] = adjust_address (operands[0], DImode, 0);
3212       break;
3213
3214     default:
3215       gcc_unreachable ();
3216     }
3217
3218   if (fixup_overlap && reg_overlap_mentioned_p (operands[0], operands[3]))
3219     {
3220       rtx tmp;
3221       tmp = operands[0], operands[0] = operands[1], operands[1] = tmp;
3222       tmp = operands[2], operands[2] = operands[3], operands[3] = tmp;
3223     }
3224 }
3225
3226 /* Implement negtf2 or abstf2.  Op0 is destination, op1 is source,
3227    op2 is a register containing the sign bit, operation is the
3228    logical operation to be performed.  */
3229
3230 void
3231 alpha_split_tfmode_frobsign (rtx operands[3], rtx (*operation) (rtx, rtx, rtx))
3232 {
3233   rtx high_bit = operands[2];
3234   rtx scratch;
3235   int move;
3236
3237   alpha_split_tmode_pair (operands, TFmode, false);
3238
3239   /* Detect three flavors of operand overlap.  */
3240   move = 1;
3241   if (rtx_equal_p (operands[0], operands[2]))
3242     move = 0;
3243   else if (rtx_equal_p (operands[1], operands[2]))
3244     {
3245       if (rtx_equal_p (operands[0], high_bit))
3246         move = 2;
3247       else
3248         move = -1;
3249     }
3250
3251   if (move < 0)
3252     emit_move_insn (operands[0], operands[2]);
3253
3254   /* ??? If the destination overlaps both source tf and high_bit, then
3255      assume source tf is dead in its entirety and use the other half
3256      for a scratch register.  Otherwise "scratch" is just the proper
3257      destination register.  */
3258   scratch = operands[move < 2 ? 1 : 3];
3259
3260   emit_insn ((*operation) (scratch, high_bit, operands[3]));
3261
3262   if (move > 0)
3263     {
3264       emit_move_insn (operands[0], operands[2]);
3265       if (move > 1)
3266         emit_move_insn (operands[1], scratch);
3267     }
3268 }
3269 \f
3270 /* Use ext[wlq][lh] as the Architecture Handbook describes for extracting
3271    unaligned data:
3272
3273            unsigned:                       signed:
3274    word:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
3275            ldq_u  r2,X+1(r11)              ldq_u  r2,X+1(r11)
3276            lda    r3,X(r11)                lda    r3,X+2(r11)
3277            extwl  r1,r3,r1                 extql  r1,r3,r1
3278            extwh  r2,r3,r2                 extqh  r2,r3,r2
3279            or     r1.r2.r1                 or     r1,r2,r1
3280                                            sra    r1,48,r1
3281
3282    long:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
3283            ldq_u  r2,X+3(r11)              ldq_u  r2,X+3(r11)
3284            lda    r3,X(r11)                lda    r3,X(r11)
3285            extll  r1,r3,r1                 extll  r1,r3,r1
3286            extlh  r2,r3,r2                 extlh  r2,r3,r2
3287            or     r1.r2.r1                 addl   r1,r2,r1
3288
3289    quad:   ldq_u  r1,X(r11)
3290            ldq_u  r2,X+7(r11)
3291            lda    r3,X(r11)
3292            extql  r1,r3,r1
3293            extqh  r2,r3,r2
3294            or     r1.r2.r1
3295 */
3296
3297 void
3298 alpha_expand_unaligned_load (rtx tgt, rtx mem, HOST_WIDE_INT size,
3299                              HOST_WIDE_INT ofs, int sign)
3300 {
3301   rtx meml, memh, addr, extl, exth, tmp, mema;
3302   enum machine_mode mode;
3303
3304   if (TARGET_BWX && size == 2)
3305     {
3306       meml = adjust_address (mem, QImode, ofs);
3307       memh = adjust_address (mem, QImode, ofs+1);
3308       if (BYTES_BIG_ENDIAN)
3309         tmp = meml, meml = memh, memh = tmp;
3310       extl = gen_reg_rtx (DImode);
3311       exth = gen_reg_rtx (DImode);
3312       emit_insn (gen_zero_extendqidi2 (extl, meml));
3313       emit_insn (gen_zero_extendqidi2 (exth, memh));
3314       exth = expand_simple_binop (DImode, ASHIFT, exth, GEN_INT (8),
3315                                   NULL, 1, OPTAB_LIB_WIDEN);
3316       addr = expand_simple_binop (DImode, IOR, extl, exth,
3317                                   NULL, 1, OPTAB_LIB_WIDEN);
3318
3319       if (sign && GET_MODE (tgt) != HImode)
3320         {
3321           addr = gen_lowpart (HImode, addr);
3322           emit_insn (gen_extend_insn (tgt, addr, GET_MODE (tgt), HImode, 0));
3323         }
3324       else
3325         {
3326           if (GET_MODE (tgt) != DImode)
3327             addr = gen_lowpart (GET_MODE (tgt), addr);
3328           emit_move_insn (tgt, addr);
3329         }
3330       return;
3331     }
3332
3333   meml = gen_reg_rtx (DImode);
3334   memh = gen_reg_rtx (DImode);
3335   addr = gen_reg_rtx (DImode);
3336   extl = gen_reg_rtx (DImode);
3337   exth = gen_reg_rtx (DImode);
3338
3339   mema = XEXP (mem, 0);
3340   if (GET_CODE (mema) == LO_SUM)
3341     mema = force_reg (Pmode, mema);
3342
3343   /* AND addresses cannot be in any alias set, since they may implicitly
3344      alias surrounding code.  Ideally we'd have some alias set that
3345      covered all types except those with alignment 8 or higher.  */
3346
3347   tmp = change_address (mem, DImode,
3348                         gen_rtx_AND (DImode,
3349                                      plus_constant (mema, ofs),
3350                                      GEN_INT (-8)));
3351   set_mem_alias_set (tmp, 0);
3352   emit_move_insn (meml, tmp);
3353
3354   tmp = change_address (mem, DImode,
3355                         gen_rtx_AND (DImode,
3356                                      plus_constant (mema, ofs + size - 1),
3357                                      GEN_INT (-8)));
3358   set_mem_alias_set (tmp, 0);
3359   emit_move_insn (memh, tmp);
3360
3361   if (WORDS_BIG_ENDIAN && sign && (size == 2 || size == 4))
3362     {
3363       emit_move_insn (addr, plus_constant (mema, -1));
3364
3365       emit_insn (gen_extqh_be (extl, meml, addr));
3366       emit_insn (gen_extxl_be (exth, memh, GEN_INT (64), addr));
3367
3368       addr = expand_binop (DImode, ior_optab, extl, exth, tgt, 1, OPTAB_WIDEN);
3369       addr = expand_binop (DImode, ashr_optab, addr, GEN_INT (64 - size*8),
3370                            addr, 1, OPTAB_WIDEN);
3371     }
3372   else if (sign && size == 2)
3373     {
3374       emit_move_insn (addr, plus_constant (mema, ofs+2));
3375
3376       emit_insn (gen_extxl_le (extl, meml, GEN_INT (64), addr));
3377       emit_insn (gen_extqh_le (exth, memh, addr));
3378
3379       /* We must use tgt here for the target.  Alpha-vms port fails if we use
3380          addr for the target, because addr is marked as a pointer and combine
3381          knows that pointers are always sign-extended 32-bit values.  */
3382       addr = expand_binop (DImode, ior_optab, extl, exth, tgt, 1, OPTAB_WIDEN);
3383       addr = expand_binop (DImode, ashr_optab, addr, GEN_INT (48),
3384                            addr, 1, OPTAB_WIDEN);
3385     }
3386   else
3387     {
3388       if (WORDS_BIG_ENDIAN)
3389         {
3390           emit_move_insn (addr, plus_constant (mema, ofs+size-1));
3391           switch ((int) size)
3392             {
3393             case 2:
3394               emit_insn (gen_extwh_be (extl, meml, addr));
3395               mode = HImode;
3396               break;
3397
3398             case 4:
3399               emit_insn (gen_extlh_be (extl, meml, addr));
3400               mode = SImode;
3401               break;
3402
3403             case 8:
3404               emit_insn (gen_extqh_be (extl, meml, addr));
3405               mode = DImode;
3406               break;
3407
3408             default:
3409               gcc_unreachable ();
3410             }
3411           emit_insn (gen_extxl_be (exth, memh, GEN_INT (size*8), addr));
3412         }
3413       else
3414         {
3415           emit_move_insn (addr, plus_constant (mema, ofs));
3416           emit_insn (gen_extxl_le (extl, meml, GEN_INT (size*8), addr));
3417           switch ((int) size)
3418             {
3419             case 2:
3420               emit_insn (gen_extwh_le (exth, memh, addr));
3421               mode = HImode;
3422               break;
3423
3424             case 4:
3425               emit_insn (gen_extlh_le (exth, memh, addr));
3426               mode = SImode;
3427               break;
3428
3429             case 8:
3430               emit_insn (gen_extqh_le (exth, memh, addr));
3431               mode = DImode;
3432               break;
3433
3434             default:
3435               gcc_unreachable ();
3436             }
3437         }
3438
3439       addr = expand_binop (mode, ior_optab, gen_lowpart (mode, extl),
3440                            gen_lowpart (mode, exth), gen_lowpart (mode, tgt),
3441                            sign, OPTAB_WIDEN);
3442     }
3443
3444   if (addr != tgt)
3445     emit_move_insn (tgt, gen_lowpart (GET_MODE (tgt), addr));
3446 }
3447
3448 /* Similarly, use ins and msk instructions to perform unaligned stores.  */
3449
3450 void
3451 alpha_expand_unaligned_store (rtx dst, rtx src,
3452                               HOST_WIDE_INT size, HOST_WIDE_INT ofs)
3453 {
3454   rtx dstl, dsth, addr, insl, insh, meml, memh, dsta;
3455
3456   if (TARGET_BWX && size == 2)
3457     {
3458       if (src != const0_rtx)
3459         {
3460           dstl = gen_lowpart (QImode, src);
3461           dsth = expand_simple_binop (DImode, LSHIFTRT, src, GEN_INT (8),
3462                                       NULL, 1, OPTAB_LIB_WIDEN);
3463           dsth = gen_lowpart (QImode, dsth);
3464         }
3465       else
3466  &nbs