OSDN Git Service

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