OSDN Git Service

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