OSDN Git Service

* hooks.h (hook_tree_tree_tree_bool_null): Rename to...
[pf3gnuchains/gcc-fork.git] / gcc / config / alpha / alpha.c
1 /* Subroutines used for code generation on the DEC Alpha.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3    2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
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 -mtune 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   /* The location should not cross aligned word boundary.  */
1479   gcc_assert (offset + GET_MODE_SIZE (GET_MODE (ref))
1480               <= GET_MODE_SIZE (SImode));
1481
1482   /* Access the entire aligned word.  */
1483   *paligned_mem = widen_memory_access (ref, SImode, -offset);
1484
1485   /* Convert the byte offset within the word to a bit offset.  */
1486   if (WORDS_BIG_ENDIAN)
1487     offset = 32 - (GET_MODE_BITSIZE (GET_MODE (ref)) + offset * 8);
1488   else
1489     offset *= 8;
1490   *pbitnum = GEN_INT (offset);
1491 }
1492
1493 /* Similar, but just get the address.  Handle the two reload cases.
1494    Add EXTRA_OFFSET to the address we return.  */
1495
1496 rtx
1497 get_unaligned_address (rtx ref)
1498 {
1499   rtx base;
1500   HOST_WIDE_INT offset = 0;
1501
1502   gcc_assert (MEM_P (ref));
1503
1504   if (reload_in_progress
1505       && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
1506     {
1507       base = find_replacement (&XEXP (ref, 0));
1508
1509       gcc_assert (memory_address_p (GET_MODE (ref), base));
1510     }
1511   else
1512     base = XEXP (ref, 0);
1513
1514   if (GET_CODE (base) == PLUS)
1515     offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
1516
1517   return plus_constant (base, offset);
1518 }
1519
1520 /* Compute a value X, such that X & 7 == (ADDR + OFS) & 7.
1521    X is always returned in a register.  */
1522
1523 rtx
1524 get_unaligned_offset (rtx addr, HOST_WIDE_INT ofs)
1525 {
1526   if (GET_CODE (addr) == PLUS)
1527     {
1528       ofs += INTVAL (XEXP (addr, 1));
1529       addr = XEXP (addr, 0);
1530     }
1531
1532   return expand_simple_binop (Pmode, PLUS, addr, GEN_INT (ofs & 7),
1533                               NULL_RTX, 1, OPTAB_LIB_WIDEN);
1534 }
1535
1536 /* On the Alpha, all (non-symbolic) constants except zero go into
1537    a floating-point register via memory.  Note that we cannot
1538    return anything that is not a subset of RCLASS, and that some
1539    symbolic constants cannot be dropped to memory.  */
1540
1541 enum reg_class
1542 alpha_preferred_reload_class(rtx x, enum reg_class rclass)
1543 {
1544   /* Zero is present in any register class.  */
1545   if (x == CONST0_RTX (GET_MODE (x)))
1546     return rclass;
1547
1548   /* These sorts of constants we can easily drop to memory.  */
1549   if (CONST_INT_P (x)
1550       || GET_CODE (x) == CONST_DOUBLE
1551       || GET_CODE (x) == CONST_VECTOR)
1552     {
1553       if (rclass == FLOAT_REGS)
1554         return NO_REGS;
1555       if (rclass == ALL_REGS)
1556         return GENERAL_REGS;
1557       return rclass;
1558     }
1559
1560   /* All other kinds of constants should not (and in the case of HIGH
1561      cannot) be dropped to memory -- instead we use a GENERAL_REGS
1562      secondary reload.  */
1563   if (CONSTANT_P (x))
1564     return (rclass == ALL_REGS ? GENERAL_REGS : rclass);
1565
1566   return rclass;
1567 }
1568
1569 /* Inform reload about cases where moving X with a mode MODE to a register in
1570    RCLASS requires an extra scratch or immediate register.  Return the class
1571    needed for the immediate register.  */
1572
1573 static enum reg_class
1574 alpha_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
1575                         enum machine_mode mode, secondary_reload_info *sri)
1576 {
1577   /* Loading and storing HImode or QImode values to and from memory
1578      usually requires a scratch register.  */
1579   if (!TARGET_BWX && (mode == QImode || mode == HImode || mode == CQImode))
1580     {
1581       if (any_memory_operand (x, mode))
1582         {
1583           if (in_p)
1584             {
1585               if (!aligned_memory_operand (x, mode))
1586                 sri->icode = reload_in_optab[mode];
1587             }
1588           else
1589             sri->icode = reload_out_optab[mode];
1590           return NO_REGS;
1591         }
1592     }
1593
1594   /* We also cannot do integral arithmetic into FP regs, as might result
1595      from register elimination into a DImode fp register.  */
1596   if (rclass == FLOAT_REGS)
1597     {
1598       if (MEM_P (x) && GET_CODE (XEXP (x, 0)) == AND)
1599         return GENERAL_REGS;
1600       if (in_p && INTEGRAL_MODE_P (mode)
1601           && !MEM_P (x) && !REG_P (x) && !CONST_INT_P (x))
1602         return GENERAL_REGS;
1603     }
1604
1605   return NO_REGS;
1606 }
1607 \f
1608 /* Subfunction of the following function.  Update the flags of any MEM
1609    found in part of X.  */
1610
1611 static int
1612 alpha_set_memflags_1 (rtx *xp, void *data)
1613 {
1614   rtx x = *xp, orig = (rtx) data;
1615
1616   if (!MEM_P (x))
1617     return 0;
1618
1619   MEM_VOLATILE_P (x) = MEM_VOLATILE_P (orig);
1620   MEM_IN_STRUCT_P (x) = MEM_IN_STRUCT_P (orig);
1621   MEM_SCALAR_P (x) = MEM_SCALAR_P (orig);
1622   MEM_NOTRAP_P (x) = MEM_NOTRAP_P (orig);
1623   MEM_READONLY_P (x) = MEM_READONLY_P (orig);
1624
1625   /* Sadly, we cannot use alias sets because the extra aliasing
1626      produced by the AND interferes.  Given that two-byte quantities
1627      are the only thing we would be able to differentiate anyway,
1628      there does not seem to be any point in convoluting the early
1629      out of the alias check.  */
1630
1631   return -1;
1632 }
1633
1634 /* Given SEQ, which is an INSN list, look for any MEMs in either
1635    a SET_DEST or a SET_SRC and copy the in-struct, unchanging, and
1636    volatile flags from REF into each of the MEMs found.  If REF is not
1637    a MEM, don't do anything.  */
1638
1639 void
1640 alpha_set_memflags (rtx seq, rtx ref)
1641 {
1642   rtx insn;
1643
1644   if (!MEM_P (ref))
1645     return;
1646
1647   /* This is only called from alpha.md, after having had something
1648      generated from one of the insn patterns.  So if everything is
1649      zero, the pattern is already up-to-date.  */
1650   if (!MEM_VOLATILE_P (ref)
1651       && !MEM_IN_STRUCT_P (ref)
1652       && !MEM_SCALAR_P (ref)
1653       && !MEM_NOTRAP_P (ref)
1654       && !MEM_READONLY_P (ref))
1655     return;
1656
1657   for (insn = seq; insn; insn = NEXT_INSN (insn))
1658     if (INSN_P (insn))
1659       for_each_rtx (&PATTERN (insn), alpha_set_memflags_1, (void *) ref);
1660     else
1661       gcc_unreachable ();
1662 }
1663 \f
1664 static rtx alpha_emit_set_const (rtx, enum machine_mode, HOST_WIDE_INT,
1665                                  int, bool);
1666
1667 /* Internal routine for alpha_emit_set_const to check for N or below insns.
1668    If NO_OUTPUT is true, then we only check to see if N insns are possible,
1669    and return pc_rtx if successful.  */
1670
1671 static rtx
1672 alpha_emit_set_const_1 (rtx target, enum machine_mode mode,
1673                         HOST_WIDE_INT c, int n, bool no_output)
1674 {
1675   HOST_WIDE_INT new_const;
1676   int i, bits;
1677   /* Use a pseudo if highly optimizing and still generating RTL.  */
1678   rtx subtarget
1679     = (flag_expensive_optimizations && can_create_pseudo_p () ? 0 : target);
1680   rtx temp, insn;
1681
1682   /* If this is a sign-extended 32-bit constant, we can do this in at most
1683      three insns, so do it if we have enough insns left.  We always have
1684      a sign-extended 32-bit constant when compiling on a narrow machine.  */
1685
1686   if (HOST_BITS_PER_WIDE_INT != 64
1687       || c >> 31 == -1 || c >> 31 == 0)
1688     {
1689       HOST_WIDE_INT low = ((c & 0xffff) ^ 0x8000) - 0x8000;
1690       HOST_WIDE_INT tmp1 = c - low;
1691       HOST_WIDE_INT high = (((tmp1 >> 16) & 0xffff) ^ 0x8000) - 0x8000;
1692       HOST_WIDE_INT extra = 0;
1693
1694       /* If HIGH will be interpreted as negative but the constant is
1695          positive, we must adjust it to do two ldha insns.  */
1696
1697       if ((high & 0x8000) != 0 && c >= 0)
1698         {
1699           extra = 0x4000;
1700           tmp1 -= 0x40000000;
1701           high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
1702         }
1703
1704       if (c == low || (low == 0 && extra == 0))
1705         {
1706           /* We used to use copy_to_suggested_reg (GEN_INT (c), target, mode)
1707              but that meant that we can't handle INT_MIN on 32-bit machines
1708              (like NT/Alpha), because we recurse indefinitely through
1709              emit_move_insn to gen_movdi.  So instead, since we know exactly
1710              what we want, create it explicitly.  */
1711
1712           if (no_output)
1713             return pc_rtx;
1714           if (target == NULL)
1715             target = gen_reg_rtx (mode);
1716           emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (c)));
1717           return target;
1718         }
1719       else if (n >= 2 + (extra != 0))
1720         {
1721           if (no_output)
1722             return pc_rtx;
1723           if (!can_create_pseudo_p ())
1724             {
1725               emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (high << 16)));
1726               temp = target;
1727             }
1728           else
1729             temp = copy_to_suggested_reg (GEN_INT (high << 16),
1730                                           subtarget, mode);
1731
1732           /* As of 2002-02-23, addsi3 is only available when not optimizing.
1733              This means that if we go through expand_binop, we'll try to
1734              generate extensions, etc, which will require new pseudos, which
1735              will fail during some split phases.  The SImode add patterns
1736              still exist, but are not named.  So build the insns by hand.  */
1737
1738           if (extra != 0)
1739             {
1740               if (! subtarget)
1741                 subtarget = gen_reg_rtx (mode);
1742               insn = gen_rtx_PLUS (mode, temp, GEN_INT (extra << 16));
1743               insn = gen_rtx_SET (VOIDmode, subtarget, insn);
1744               emit_insn (insn);
1745               temp = subtarget;
1746             }
1747
1748           if (target == NULL)
1749             target = gen_reg_rtx (mode);
1750           insn = gen_rtx_PLUS (mode, temp, GEN_INT (low));
1751           insn = gen_rtx_SET (VOIDmode, target, insn);
1752           emit_insn (insn);
1753           return target;
1754         }
1755     }
1756
1757   /* If we couldn't do it that way, try some other methods.  But if we have
1758      no instructions left, don't bother.  Likewise, if this is SImode and
1759      we can't make pseudos, we can't do anything since the expand_binop
1760      and expand_unop calls will widen and try to make pseudos.  */
1761
1762   if (n == 1 || (mode == SImode && !can_create_pseudo_p ()))
1763     return 0;
1764
1765   /* Next, see if we can load a related constant and then shift and possibly
1766      negate it to get the constant we want.  Try this once each increasing
1767      numbers of insns.  */
1768
1769   for (i = 1; i < n; i++)
1770     {
1771       /* First, see if minus some low bits, we've an easy load of
1772          high bits.  */
1773
1774       new_const = ((c & 0xffff) ^ 0x8000) - 0x8000;
1775       if (new_const != 0)
1776         {
1777           temp = alpha_emit_set_const (subtarget, mode, c - new_const, i, no_output);
1778           if (temp)
1779             {
1780               if (no_output)
1781                 return temp;
1782               return expand_binop (mode, add_optab, temp, GEN_INT (new_const),
1783                                    target, 0, OPTAB_WIDEN);
1784             }
1785         }
1786
1787       /* Next try complementing.  */
1788       temp = alpha_emit_set_const (subtarget, mode, ~c, i, no_output);
1789       if (temp)
1790         {
1791           if (no_output)
1792             return temp;
1793           return expand_unop (mode, one_cmpl_optab, temp, target, 0);
1794         }
1795
1796       /* Next try to form a constant and do a left shift.  We can do this
1797          if some low-order bits are zero; the exact_log2 call below tells
1798          us that information.  The bits we are shifting out could be any
1799          value, but here we'll just try the 0- and sign-extended forms of
1800          the constant.  To try to increase the chance of having the same
1801          constant in more than one insn, start at the highest number of
1802          bits to shift, but try all possibilities in case a ZAPNOT will
1803          be useful.  */
1804
1805       bits = exact_log2 (c & -c);
1806       if (bits > 0)
1807         for (; bits > 0; bits--)
1808           {
1809             new_const = c >> bits;
1810             temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output);
1811             if (!temp && c < 0)
1812               {
1813                 new_const = (unsigned HOST_WIDE_INT)c >> bits;
1814                 temp = alpha_emit_set_const (subtarget, mode, new_const,
1815                                              i, no_output);
1816               }
1817             if (temp)
1818               {
1819                 if (no_output)
1820                   return temp;
1821                 return expand_binop (mode, ashl_optab, temp, GEN_INT (bits),
1822                                      target, 0, OPTAB_WIDEN);
1823               }
1824           }
1825
1826       /* Now try high-order zero bits.  Here we try the shifted-in bits as
1827          all zero and all ones.  Be careful to avoid shifting outside the
1828          mode and to avoid shifting outside the host wide int size.  */
1829       /* On narrow hosts, don't shift a 1 into the high bit, since we'll
1830          confuse the recursive call and set all of the high 32 bits.  */
1831
1832       bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
1833               - floor_log2 (c) - 1 - (HOST_BITS_PER_WIDE_INT < 64));
1834       if (bits > 0)
1835         for (; bits > 0; bits--)
1836           {
1837             new_const = c << bits;
1838             temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output);
1839             if (!temp)
1840               {
1841                 new_const = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1);
1842                 temp = alpha_emit_set_const (subtarget, mode, new_const,
1843                                              i, no_output);
1844               }
1845             if (temp)
1846               {
1847                 if (no_output)
1848                   return temp;
1849                 return expand_binop (mode, lshr_optab, temp, GEN_INT (bits),
1850                                      target, 1, OPTAB_WIDEN);
1851               }
1852           }
1853
1854       /* Now try high-order 1 bits.  We get that with a sign-extension.
1855          But one bit isn't enough here.  Be careful to avoid shifting outside
1856          the mode and to avoid shifting outside the host wide int size.  */
1857
1858       bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
1859               - floor_log2 (~ c) - 2);
1860       if (bits > 0)
1861         for (; bits > 0; bits--)
1862           {
1863             new_const = c << bits;
1864             temp = alpha_emit_set_const (subtarget, mode, new_const, i, no_output);
1865             if (!temp)
1866               {
1867                 new_const = (c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1);
1868                 temp = alpha_emit_set_const (subtarget, mode, new_const,
1869                                              i, no_output);
1870               }
1871             if (temp)
1872               {
1873                 if (no_output)
1874                   return temp;
1875                 return expand_binop (mode, ashr_optab, temp, GEN_INT (bits),
1876                                      target, 0, OPTAB_WIDEN);
1877               }
1878           }
1879     }
1880
1881 #if HOST_BITS_PER_WIDE_INT == 64
1882   /* Finally, see if can load a value into the target that is the same as the
1883      constant except that all bytes that are 0 are changed to be 0xff.  If we
1884      can, then we can do a ZAPNOT to obtain the desired constant.  */
1885
1886   new_const = c;
1887   for (i = 0; i < 64; i += 8)
1888     if ((new_const & ((HOST_WIDE_INT) 0xff << i)) == 0)
1889       new_const |= (HOST_WIDE_INT) 0xff << i;
1890
1891   /* We are only called for SImode and DImode.  If this is SImode, ensure that
1892      we are sign extended to a full word.  */
1893
1894   if (mode == SImode)
1895     new_const = ((new_const & 0xffffffff) ^ 0x80000000) - 0x80000000;
1896
1897   if (new_const != c)
1898     {
1899       temp = alpha_emit_set_const (subtarget, mode, new_const, n - 1, no_output);
1900       if (temp)
1901         {
1902           if (no_output)
1903             return temp;
1904           return expand_binop (mode, and_optab, temp, GEN_INT (c | ~ new_const),
1905                                target, 0, OPTAB_WIDEN);
1906         }
1907     }
1908 #endif
1909
1910   return 0;
1911 }
1912
1913 /* Try to output insns to set TARGET equal to the constant C if it can be
1914    done in less than N insns.  Do all computations in MODE.  Returns the place
1915    where the output has been placed if it can be done and the insns have been
1916    emitted.  If it would take more than N insns, zero is returned and no
1917    insns and emitted.  */
1918
1919 static rtx
1920 alpha_emit_set_const (rtx target, enum machine_mode mode,
1921                       HOST_WIDE_INT c, int n, bool no_output)
1922 {
1923   enum machine_mode orig_mode = mode;
1924   rtx orig_target = target;
1925   rtx result = 0;
1926   int i;
1927
1928   /* If we can't make any pseudos, TARGET is an SImode hard register, we
1929      can't load this constant in one insn, do this in DImode.  */
1930   if (!can_create_pseudo_p () && mode == SImode
1931       && REG_P (target) && REGNO (target) < FIRST_PSEUDO_REGISTER)
1932     {
1933       result = alpha_emit_set_const_1 (target, mode, c, 1, no_output);
1934       if (result)
1935         return result;
1936
1937       target = no_output ? NULL : gen_lowpart (DImode, target);
1938       mode = DImode;
1939     }
1940   else if (mode == V8QImode || mode == V4HImode || mode == V2SImode)
1941     {
1942       target = no_output ? NULL : gen_lowpart (DImode, target);
1943       mode = DImode;
1944     }
1945
1946   /* Try 1 insn, then 2, then up to N.  */
1947   for (i = 1; i <= n; i++)
1948     {
1949       result = alpha_emit_set_const_1 (target, mode, c, i, no_output);
1950       if (result)
1951         {
1952           rtx insn, set;
1953
1954           if (no_output)
1955             return result;
1956
1957           insn = get_last_insn ();
1958           set = single_set (insn);
1959           if (! CONSTANT_P (SET_SRC (set)))
1960             set_unique_reg_note (get_last_insn (), REG_EQUAL, GEN_INT (c));
1961           break;
1962         }
1963     }
1964
1965   /* Allow for the case where we changed the mode of TARGET.  */
1966   if (result)
1967     {
1968       if (result == target)
1969         result = orig_target;
1970       else if (mode != orig_mode)
1971         result = gen_lowpart (orig_mode, result);
1972     }
1973
1974   return result;
1975 }
1976
1977 /* Having failed to find a 3 insn sequence in alpha_emit_set_const,
1978    fall back to a straight forward decomposition.  We do this to avoid
1979    exponential run times encountered when looking for longer sequences
1980    with alpha_emit_set_const.  */
1981
1982 static rtx
1983 alpha_emit_set_long_const (rtx target, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
1984 {
1985   HOST_WIDE_INT d1, d2, d3, d4;
1986
1987   /* Decompose the entire word */
1988 #if HOST_BITS_PER_WIDE_INT >= 64
1989   gcc_assert (c2 == -(c1 < 0));
1990   d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
1991   c1 -= d1;
1992   d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
1993   c1 = (c1 - d2) >> 32;
1994   d3 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
1995   c1 -= d3;
1996   d4 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
1997   gcc_assert (c1 == d4);
1998 #else
1999   d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
2000   c1 -= d1;
2001   d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
2002   gcc_assert (c1 == d2);
2003   c2 += (d2 < 0);
2004   d3 = ((c2 & 0xffff) ^ 0x8000) - 0x8000;
2005   c2 -= d3;
2006   d4 = ((c2 & 0xffffffff) ^ 0x80000000) - 0x80000000;
2007   gcc_assert (c2 == d4);
2008 #endif
2009
2010   /* Construct the high word */
2011   if (d4)
2012     {
2013       emit_move_insn (target, GEN_INT (d4));
2014       if (d3)
2015         emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d3)));
2016     }
2017   else
2018     emit_move_insn (target, GEN_INT (d3));
2019
2020   /* Shift it into place */
2021   emit_move_insn (target, gen_rtx_ASHIFT (DImode, target, GEN_INT (32)));
2022
2023   /* Add in the low bits.  */
2024   if (d2)
2025     emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d2)));
2026   if (d1)
2027     emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d1)));
2028
2029   return target;
2030 }
2031
2032 /* Given an integral CONST_INT, CONST_DOUBLE, or CONST_VECTOR, return 
2033    the low 64 bits.  */
2034
2035 static void
2036 alpha_extract_integer (rtx x, HOST_WIDE_INT *p0, HOST_WIDE_INT *p1)
2037 {
2038   HOST_WIDE_INT i0, i1;
2039
2040   if (GET_CODE (x) == CONST_VECTOR)
2041     x = simplify_subreg (DImode, x, GET_MODE (x), 0);
2042
2043
2044   if (CONST_INT_P (x))
2045     {
2046       i0 = INTVAL (x);
2047       i1 = -(i0 < 0);
2048     }
2049   else if (HOST_BITS_PER_WIDE_INT >= 64)
2050     {
2051       i0 = CONST_DOUBLE_LOW (x);
2052       i1 = -(i0 < 0);
2053     }
2054   else
2055     {
2056       i0 = CONST_DOUBLE_LOW (x);
2057       i1 = CONST_DOUBLE_HIGH (x);
2058     }
2059
2060   *p0 = i0;
2061   *p1 = i1;
2062 }
2063
2064 /* Implement LEGITIMATE_CONSTANT_P.  This is all constants for which we
2065    are willing to load the value into a register via a move pattern.
2066    Normally this is all symbolic constants, integral constants that
2067    take three or fewer instructions, and floating-point zero.  */
2068
2069 bool
2070 alpha_legitimate_constant_p (rtx x)
2071 {
2072   enum machine_mode mode = GET_MODE (x);
2073   HOST_WIDE_INT i0, i1;
2074
2075   switch (GET_CODE (x))
2076     {
2077     case LABEL_REF:
2078     case HIGH:
2079       return true;
2080
2081     case CONST:
2082       if (GET_CODE (XEXP (x, 0)) == PLUS
2083           && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
2084         x = XEXP (XEXP (x, 0), 0);
2085       else
2086         return true;
2087
2088       if (GET_CODE (x) != SYMBOL_REF)
2089         return true;
2090
2091       /* FALLTHRU */
2092
2093     case SYMBOL_REF:
2094       /* TLS symbols are never valid.  */
2095       return SYMBOL_REF_TLS_MODEL (x) == 0;
2096
2097     case CONST_DOUBLE:
2098       if (x == CONST0_RTX (mode))
2099         return true;
2100       if (FLOAT_MODE_P (mode))
2101         return false;
2102       goto do_integer;
2103
2104     case CONST_VECTOR:
2105       if (x == CONST0_RTX (mode))
2106         return true;
2107       if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT)
2108         return false;
2109       if (GET_MODE_SIZE (mode) != 8)
2110         return false;
2111       goto do_integer;
2112
2113     case CONST_INT:
2114     do_integer:
2115       if (TARGET_BUILD_CONSTANTS)
2116         return true;
2117       alpha_extract_integer (x, &i0, &i1);
2118       if (HOST_BITS_PER_WIDE_INT >= 64 || i1 == (-i0 < 0))
2119         return alpha_emit_set_const_1 (x, mode, i0, 3, true) != NULL;
2120       return false;
2121
2122     default:
2123       return false;
2124     }
2125 }
2126
2127 /* Operand 1 is known to be a constant, and should require more than one
2128    instruction to load.  Emit that multi-part load.  */
2129
2130 bool
2131 alpha_split_const_mov (enum machine_mode mode, rtx *operands)
2132 {
2133   HOST_WIDE_INT i0, i1;
2134   rtx temp = NULL_RTX;
2135
2136   alpha_extract_integer (operands[1], &i0, &i1);
2137
2138   if (HOST_BITS_PER_WIDE_INT >= 64 || i1 == -(i0 < 0))
2139     temp = alpha_emit_set_const (operands[0], mode, i0, 3, false);
2140
2141   if (!temp && TARGET_BUILD_CONSTANTS)
2142     temp = alpha_emit_set_long_const (operands[0], i0, i1);
2143
2144   if (temp)
2145     {
2146       if (!rtx_equal_p (operands[0], temp))
2147         emit_move_insn (operands[0], temp);
2148       return true;
2149     }
2150
2151   return false;
2152 }
2153
2154 /* Expand a move instruction; return true if all work is done.
2155    We don't handle non-bwx subword loads here.  */
2156
2157 bool
2158 alpha_expand_mov (enum machine_mode mode, rtx *operands)
2159 {
2160   rtx tmp;
2161
2162   /* If the output is not a register, the input must be.  */
2163   if (MEM_P (operands[0])
2164       && ! reg_or_0_operand (operands[1], mode))
2165     operands[1] = force_reg (mode, operands[1]);
2166
2167   /* Allow legitimize_address to perform some simplifications.  */
2168   if (mode == Pmode && symbolic_operand (operands[1], mode))
2169     {
2170       tmp = alpha_legitimize_address_1 (operands[1], operands[0], mode);
2171       if (tmp)
2172         {
2173           if (tmp == operands[0])
2174             return true;
2175           operands[1] = tmp;
2176           return false;
2177         }
2178     }
2179
2180   /* Early out for non-constants and valid constants.  */
2181   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], mode))
2182     return false;
2183
2184   /* Split large integers.  */
2185   if (CONST_INT_P (operands[1])
2186       || GET_CODE (operands[1]) == CONST_DOUBLE
2187       || GET_CODE (operands[1]) == CONST_VECTOR)
2188     {
2189       if (alpha_split_const_mov (mode, operands))
2190         return true;
2191     }
2192
2193   /* Otherwise we've nothing left but to drop the thing to memory.  */
2194   tmp = force_const_mem (mode, operands[1]);
2195
2196   if (tmp == NULL_RTX)
2197     return false;
2198
2199   if (reload_in_progress)
2200     {
2201       emit_move_insn (operands[0], XEXP (tmp, 0));
2202       operands[1] = replace_equiv_address (tmp, operands[0]);
2203     }
2204   else
2205     operands[1] = validize_mem (tmp);
2206   return false;
2207 }
2208
2209 /* Expand a non-bwx QImode or HImode move instruction;
2210    return true if all work is done.  */
2211
2212 bool
2213 alpha_expand_mov_nobwx (enum machine_mode mode, rtx *operands)
2214 {
2215   rtx seq;
2216
2217   /* If the output is not a register, the input must be.  */
2218   if (MEM_P (operands[0]))
2219     operands[1] = force_reg (mode, operands[1]);
2220
2221   /* Handle four memory cases, unaligned and aligned for either the input
2222      or the output.  The only case where we can be called during reload is
2223      for aligned loads; all other cases require temporaries.  */
2224
2225   if (any_memory_operand (operands[1], mode))
2226     {
2227       if (aligned_memory_operand (operands[1], mode))
2228         {
2229           if (reload_in_progress)
2230             {
2231               if (mode == QImode)
2232                 seq = gen_reload_inqi_aligned (operands[0], operands[1]);
2233               else
2234                 seq = gen_reload_inhi_aligned (operands[0], operands[1]);
2235               emit_insn (seq);
2236             }
2237           else
2238             {
2239               rtx aligned_mem, bitnum;
2240               rtx scratch = gen_reg_rtx (SImode);
2241               rtx subtarget;
2242               bool copyout;
2243
2244               get_aligned_mem (operands[1], &aligned_mem, &bitnum);
2245
2246               subtarget = operands[0];
2247               if (REG_P (subtarget))
2248                 subtarget = gen_lowpart (DImode, subtarget), copyout = false;
2249               else
2250                 subtarget = gen_reg_rtx (DImode), copyout = true;
2251
2252               if (mode == QImode)
2253                 seq = gen_aligned_loadqi (subtarget, aligned_mem,
2254                                           bitnum, scratch);
2255               else
2256                 seq = gen_aligned_loadhi (subtarget, aligned_mem,
2257                                           bitnum, scratch);
2258               emit_insn (seq);
2259
2260               if (copyout)
2261                 emit_move_insn (operands[0], gen_lowpart (mode, subtarget));
2262             }
2263         }
2264       else
2265         {
2266           /* Don't pass these as parameters since that makes the generated
2267              code depend on parameter evaluation order which will cause
2268              bootstrap failures.  */
2269
2270           rtx temp1, temp2, subtarget, ua;
2271           bool copyout;
2272
2273           temp1 = gen_reg_rtx (DImode);
2274           temp2 = gen_reg_rtx (DImode);
2275
2276           subtarget = operands[0];
2277           if (REG_P (subtarget))
2278             subtarget = gen_lowpart (DImode, subtarget), copyout = false;
2279           else
2280             subtarget = gen_reg_rtx (DImode), copyout = true;
2281
2282           ua = get_unaligned_address (operands[1]);
2283           if (mode == QImode)
2284             seq = gen_unaligned_loadqi (subtarget, ua, temp1, temp2);
2285           else
2286             seq = gen_unaligned_loadhi (subtarget, ua, temp1, temp2);
2287
2288           alpha_set_memflags (seq, operands[1]);
2289           emit_insn (seq);
2290
2291           if (copyout)
2292             emit_move_insn (operands[0], gen_lowpart (mode, subtarget));
2293         }
2294       return true;
2295     }
2296
2297   if (any_memory_operand (operands[0], mode))
2298     {
2299       if (aligned_memory_operand (operands[0], mode))
2300         {
2301           rtx aligned_mem, bitnum;
2302           rtx temp1 = gen_reg_rtx (SImode);
2303           rtx temp2 = gen_reg_rtx (SImode);
2304
2305           get_aligned_mem (operands[0], &aligned_mem, &bitnum);
2306
2307           emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
2308                                         temp1, temp2));
2309         }
2310       else
2311         {
2312           rtx temp1 = gen_reg_rtx (DImode);
2313           rtx temp2 = gen_reg_rtx (DImode);
2314           rtx temp3 = gen_reg_rtx (DImode);
2315           rtx ua = get_unaligned_address (operands[0]);
2316
2317           if (mode == QImode)
2318             seq = gen_unaligned_storeqi (ua, operands[1], temp1, temp2, temp3);
2319           else
2320             seq = gen_unaligned_storehi (ua, operands[1], temp1, temp2, temp3);
2321
2322           alpha_set_memflags (seq, operands[0]);
2323           emit_insn (seq);
2324         }
2325       return true;
2326     }
2327
2328   return false;
2329 }
2330
2331 /* Implement the movmisalign patterns.  One of the operands is a memory
2332    that is not naturally aligned.  Emit instructions to load it.  */
2333
2334 void
2335 alpha_expand_movmisalign (enum machine_mode mode, rtx *operands)
2336 {
2337   /* Honor misaligned loads, for those we promised to do so.  */
2338   if (MEM_P (operands[1]))
2339     {
2340       rtx tmp;
2341
2342       if (register_operand (operands[0], mode))
2343         tmp = operands[0];
2344       else
2345         tmp = gen_reg_rtx (mode);
2346
2347       alpha_expand_unaligned_load (tmp, operands[1], 8, 0, 0);
2348       if (tmp != operands[0])
2349         emit_move_insn (operands[0], tmp);
2350     }
2351   else if (MEM_P (operands[0]))
2352     {
2353       if (!reg_or_0_operand (operands[1], mode))
2354         operands[1] = force_reg (mode, operands[1]);
2355       alpha_expand_unaligned_store (operands[0], operands[1], 8, 0);
2356     }
2357   else
2358     gcc_unreachable ();
2359 }
2360
2361 /* Generate an unsigned DImode to FP conversion.  This is the same code
2362    optabs would emit if we didn't have TFmode patterns.
2363
2364    For SFmode, this is the only construction I've found that can pass
2365    gcc.c-torture/execute/ieee/rbug.c.  No scenario that uses DFmode
2366    intermediates will work, because you'll get intermediate rounding
2367    that ruins the end result.  Some of this could be fixed by turning
2368    on round-to-positive-infinity, but that requires diddling the fpsr,
2369    which kills performance.  I tried turning this around and converting
2370    to a negative number, so that I could turn on /m, but either I did
2371    it wrong or there's something else cause I wound up with the exact
2372    same single-bit error.  There is a branch-less form of this same code:
2373
2374         srl     $16,1,$1
2375         and     $16,1,$2
2376         cmplt   $16,0,$3
2377         or      $1,$2,$2
2378         cmovge  $16,$16,$2
2379         itoft   $3,$f10
2380         itoft   $2,$f11
2381         cvtqs   $f11,$f11
2382         adds    $f11,$f11,$f0
2383         fcmoveq $f10,$f11,$f0
2384
2385    I'm not using it because it's the same number of instructions as
2386    this branch-full form, and it has more serialized long latency
2387    instructions on the critical path.
2388
2389    For DFmode, we can avoid rounding errors by breaking up the word
2390    into two pieces, converting them separately, and adding them back:
2391
2392    LC0: .long 0,0x5f800000
2393
2394         itoft   $16,$f11
2395         lda     $2,LC0
2396         cmplt   $16,0,$1
2397         cpyse   $f11,$f31,$f10
2398         cpyse   $f31,$f11,$f11
2399         s4addq  $1,$2,$1
2400         lds     $f12,0($1)
2401         cvtqt   $f10,$f10
2402         cvtqt   $f11,$f11
2403         addt    $f12,$f10,$f0
2404         addt    $f0,$f11,$f0
2405
2406    This doesn't seem to be a clear-cut win over the optabs form.
2407    It probably all depends on the distribution of numbers being
2408    converted -- in the optabs form, all but high-bit-set has a
2409    much lower minimum execution time.  */
2410
2411 void
2412 alpha_emit_floatuns (rtx operands[2])
2413 {
2414   rtx neglab, donelab, i0, i1, f0, in, out;
2415   enum machine_mode mode;
2416
2417   out = operands[0];
2418   in = force_reg (DImode, operands[1]);
2419   mode = GET_MODE (out);
2420   neglab = gen_label_rtx ();
2421   donelab = gen_label_rtx ();
2422   i0 = gen_reg_rtx (DImode);
2423   i1 = gen_reg_rtx (DImode);
2424   f0 = gen_reg_rtx (mode);
2425
2426   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
2427
2428   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
2429   emit_jump_insn (gen_jump (donelab));
2430   emit_barrier ();
2431
2432   emit_label (neglab);
2433
2434   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
2435   emit_insn (gen_anddi3 (i1, in, const1_rtx));
2436   emit_insn (gen_iordi3 (i0, i0, i1));
2437   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
2438   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
2439
2440   emit_label (donelab);
2441 }
2442
2443 /* Generate the comparison for a conditional branch.  */
2444
2445 void
2446 alpha_emit_conditional_branch (rtx operands[], enum machine_mode cmp_mode)
2447 {
2448   enum rtx_code cmp_code, branch_code;
2449   enum machine_mode branch_mode = VOIDmode;
2450   enum rtx_code code = GET_CODE (operands[0]);
2451   rtx op0 = operands[1], op1 = operands[2];
2452   rtx tem;
2453
2454   if (cmp_mode == TFmode)
2455     {
2456       op0 = alpha_emit_xfloating_compare (&code, op0, op1);
2457       op1 = const0_rtx;
2458       cmp_mode = DImode;
2459     }
2460
2461   /* The general case: fold the comparison code to the types of compares
2462      that we have, choosing the branch as necessary.  */
2463   switch (code)
2464     {
2465     case EQ:  case LE:  case LT:  case LEU:  case LTU:
2466     case UNORDERED:
2467       /* We have these compares: */
2468       cmp_code = code, branch_code = NE;
2469       break;
2470
2471     case NE:
2472     case ORDERED:
2473       /* These must be reversed.  */
2474       cmp_code = reverse_condition (code), branch_code = EQ;
2475       break;
2476
2477     case GE:  case GT: case GEU:  case GTU:
2478       /* For FP, we swap them, for INT, we reverse them.  */
2479       if (cmp_mode == DFmode)
2480         {
2481           cmp_code = swap_condition (code);
2482           branch_code = NE;
2483           tem = op0, op0 = op1, op1 = tem;
2484         }
2485       else
2486         {
2487           cmp_code = reverse_condition (code);
2488           branch_code = EQ;
2489         }
2490       break;
2491
2492     default:
2493       gcc_unreachable ();
2494     }
2495
2496   if (cmp_mode == DFmode)
2497     {
2498       if (flag_unsafe_math_optimizations && cmp_code != UNORDERED)
2499         {
2500           /* When we are not as concerned about non-finite values, and we
2501              are comparing against zero, we can branch directly.  */
2502           if (op1 == CONST0_RTX (DFmode))
2503             cmp_code = UNKNOWN, branch_code = code;
2504           else if (op0 == CONST0_RTX (DFmode))
2505             {
2506               /* Undo the swap we probably did just above.  */
2507               tem = op0, op0 = op1, op1 = tem;
2508               branch_code = swap_condition (cmp_code);
2509               cmp_code = UNKNOWN;
2510             }
2511         }
2512       else
2513         {
2514           /* ??? We mark the branch mode to be CCmode to prevent the
2515              compare and branch from being combined, since the compare
2516              insn follows IEEE rules that the branch does not.  */
2517           branch_mode = CCmode;
2518         }
2519     }
2520   else
2521     {
2522       /* The following optimizations are only for signed compares.  */
2523       if (code != LEU && code != LTU && code != GEU && code != GTU)
2524         {
2525           /* Whee.  Compare and branch against 0 directly.  */
2526           if (op1 == const0_rtx)
2527             cmp_code = UNKNOWN, branch_code = code;
2528
2529           /* If the constants doesn't fit into an immediate, but can
2530              be generated by lda/ldah, we adjust the argument and
2531              compare against zero, so we can use beq/bne directly.  */
2532           /* ??? Don't do this when comparing against symbols, otherwise
2533              we'll reduce (&x == 0x1234) to (&x-0x1234 == 0), which will
2534              be declared false out of hand (at least for non-weak).  */
2535           else if (CONST_INT_P (op1)
2536                    && (code == EQ || code == NE)
2537                    && !(symbolic_operand (op0, VOIDmode)
2538                         || (REG_P (op0) && REG_POINTER (op0))))
2539             {
2540               rtx n_op1 = GEN_INT (-INTVAL (op1));
2541
2542               if (! satisfies_constraint_I (op1)
2543                   && (satisfies_constraint_K (n_op1)
2544                       || satisfies_constraint_L (n_op1)))
2545                 cmp_code = PLUS, branch_code = code, op1 = n_op1;
2546             }
2547         }
2548
2549       if (!reg_or_0_operand (op0, DImode))
2550         op0 = force_reg (DImode, op0);
2551       if (cmp_code != PLUS && !reg_or_8bit_operand (op1, DImode))
2552         op1 = force_reg (DImode, op1);
2553     }
2554
2555   /* Emit an initial compare instruction, if necessary.  */
2556   tem = op0;
2557   if (cmp_code != UNKNOWN)
2558     {
2559       tem = gen_reg_rtx (cmp_mode);
2560       emit_move_insn (tem, gen_rtx_fmt_ee (cmp_code, cmp_mode, op0, op1));
2561     }
2562
2563   /* Emit the branch instruction.  */
2564   tem = gen_rtx_SET (VOIDmode, pc_rtx,
2565                      gen_rtx_IF_THEN_ELSE (VOIDmode,
2566                                            gen_rtx_fmt_ee (branch_code,
2567                                                            branch_mode, tem,
2568                                                            CONST0_RTX (cmp_mode)),
2569                                            gen_rtx_LABEL_REF (VOIDmode,
2570                                                               operands[3]),
2571                                            pc_rtx));
2572   emit_jump_insn (tem);
2573 }
2574
2575 /* Certain simplifications can be done to make invalid setcc operations
2576    valid.  Return the final comparison, or NULL if we can't work.  */
2577
2578 bool
2579 alpha_emit_setcc (rtx operands[], enum machine_mode cmp_mode)
2580 {
2581   enum rtx_code cmp_code;
2582   enum rtx_code code = GET_CODE (operands[1]);
2583   rtx op0 = operands[2], op1 = operands[3];
2584   rtx tmp;
2585
2586   if (cmp_mode == TFmode)
2587     {
2588       op0 = alpha_emit_xfloating_compare (&code, op0, op1);
2589       op1 = const0_rtx;
2590       cmp_mode = DImode;
2591     }
2592
2593   if (cmp_mode == DFmode && !TARGET_FIX)
2594     return 0;
2595
2596   /* The general case: fold the comparison code to the types of compares
2597      that we have, choosing the branch as necessary.  */
2598
2599   cmp_code = UNKNOWN;
2600   switch (code)
2601     {
2602     case EQ:  case LE:  case LT:  case LEU:  case LTU:
2603     case UNORDERED:
2604       /* We have these compares.  */
2605       if (cmp_mode == DFmode)
2606         cmp_code = code, code = NE;
2607       break;
2608
2609     case NE:
2610       if (cmp_mode == DImode && op1 == const0_rtx)
2611         break;
2612       /* FALLTHRU */
2613
2614     case ORDERED:
2615       cmp_code = reverse_condition (code);
2616       code = EQ;
2617       break;
2618
2619     case GE:  case GT: case GEU:  case GTU:
2620       /* These normally need swapping, but for integer zero we have
2621          special patterns that recognize swapped operands.  */
2622       if (cmp_mode == DImode && op1 == const0_rtx)
2623         break;
2624       code = swap_condition (code);
2625       if (cmp_mode == DFmode)
2626         cmp_code = code, code = NE;
2627       tmp = op0, op0 = op1, op1 = tmp;
2628       break;
2629
2630     default:
2631       gcc_unreachable ();
2632     }
2633
2634   if (cmp_mode == DImode)
2635     {
2636       if (!register_operand (op0, DImode))
2637         op0 = force_reg (DImode, op0);
2638       if (!reg_or_8bit_operand (op1, DImode))
2639         op1 = force_reg (DImode, op1);
2640     }
2641
2642   /* Emit an initial compare instruction, if necessary.  */
2643   if (cmp_code != UNKNOWN)
2644     {
2645       tmp = gen_reg_rtx (cmp_mode);
2646       emit_insn (gen_rtx_SET (VOIDmode, tmp,
2647                               gen_rtx_fmt_ee (cmp_code, cmp_mode, op0, op1)));
2648
2649       op0 = cmp_mode != DImode ? gen_lowpart (DImode, tmp) : tmp;
2650       op1 = const0_rtx;
2651     }
2652
2653   /* Emit the setcc instruction.  */
2654   emit_insn (gen_rtx_SET (VOIDmode, operands[0],
2655                           gen_rtx_fmt_ee (code, DImode, op0, op1)));
2656   return true;
2657 }
2658
2659
2660 /* Rewrite a comparison against zero CMP of the form
2661    (CODE (cc0) (const_int 0)) so it can be written validly in
2662    a conditional move (if_then_else CMP ...).
2663    If both of the operands that set cc0 are nonzero we must emit
2664    an insn to perform the compare (it can't be done within
2665    the conditional move).  */
2666
2667 rtx
2668 alpha_emit_conditional_move (rtx cmp, enum machine_mode mode)
2669 {
2670   enum rtx_code code = GET_CODE (cmp);
2671   enum rtx_code cmov_code = NE;
2672   rtx op0 = XEXP (cmp, 0);
2673   rtx op1 = XEXP (cmp, 1);
2674   enum machine_mode cmp_mode
2675     = (GET_MODE (op0) == VOIDmode ? DImode : GET_MODE (op0));
2676   enum machine_mode cmov_mode = VOIDmode;
2677   int local_fast_math = flag_unsafe_math_optimizations;
2678   rtx tem;
2679
2680   if (cmp_mode == TFmode)
2681     {
2682       op0 = alpha_emit_xfloating_compare (&code, op0, op1);
2683       op1 = const0_rtx;
2684       cmp_mode = DImode;
2685     }
2686
2687   gcc_assert (cmp_mode == DFmode || cmp_mode == DImode);
2688
2689   if (FLOAT_MODE_P (cmp_mode) != FLOAT_MODE_P (mode))
2690     {
2691       enum rtx_code cmp_code;
2692
2693       if (! TARGET_FIX)
2694         return 0;
2695
2696       /* If we have fp<->int register move instructions, do a cmov by
2697          performing the comparison in fp registers, and move the
2698          zero/nonzero value to integer registers, where we can then
2699          use a normal cmov, or vice-versa.  */
2700
2701       switch (code)
2702         {
2703         case EQ: case LE: case LT: case LEU: case LTU:
2704           /* We have these compares.  */
2705           cmp_code = code, code = NE;
2706           break;
2707
2708         case NE:
2709           /* This must be reversed.  */
2710           cmp_code = EQ, code = EQ;
2711           break;
2712
2713         case GE: case GT: case GEU: case GTU:
2714           /* These normally need swapping, but for integer zero we have
2715              special patterns that recognize swapped operands.  */
2716           if (cmp_mode == DImode && op1 == const0_rtx)
2717             cmp_code = code, code = NE;
2718           else
2719             {
2720               cmp_code = swap_condition (code);
2721               code = NE;
2722               tem = op0, op0 = op1, op1 = tem;
2723             }
2724           break;
2725
2726         default:
2727           gcc_unreachable ();
2728         }
2729
2730       tem = gen_reg_rtx (cmp_mode);
2731       emit_insn (gen_rtx_SET (VOIDmode, tem,
2732                               gen_rtx_fmt_ee (cmp_code, cmp_mode,
2733                                               op0, op1)));
2734
2735       cmp_mode = cmp_mode == DImode ? DFmode : DImode;
2736       op0 = gen_lowpart (cmp_mode, tem);
2737       op1 = CONST0_RTX (cmp_mode);
2738       local_fast_math = 1;
2739     }
2740
2741   /* We may be able to use a conditional move directly.
2742      This avoids emitting spurious compares.  */
2743   if (signed_comparison_operator (cmp, VOIDmode)
2744       && (cmp_mode == DImode || local_fast_math)
2745       && (op0 == CONST0_RTX (cmp_mode) || op1 == CONST0_RTX (cmp_mode)))
2746     return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
2747
2748   /* We can't put the comparison inside the conditional move;
2749      emit a compare instruction and put that inside the
2750      conditional move.  Make sure we emit only comparisons we have;
2751      swap or reverse as necessary.  */
2752
2753   if (!can_create_pseudo_p ())
2754     return NULL_RTX;
2755
2756   switch (code)
2757     {
2758     case EQ:  case LE:  case LT:  case LEU:  case LTU:
2759       /* We have these compares: */
2760       break;
2761
2762     case NE:
2763       /* This must be reversed.  */
2764       code = reverse_condition (code);
2765       cmov_code = EQ;
2766       break;
2767
2768     case GE:  case GT:  case GEU:  case GTU:
2769       /* These must be swapped.  */
2770       if (op1 != CONST0_RTX (cmp_mode))
2771         {
2772           code = swap_condition (code);
2773           tem = op0, op0 = op1, op1 = tem;
2774         }
2775       break;
2776
2777     default:
2778       gcc_unreachable ();
2779     }
2780
2781   if (cmp_mode == DImode)
2782     {
2783       if (!reg_or_0_operand (op0, DImode))
2784         op0 = force_reg (DImode, op0);
2785       if (!reg_or_8bit_operand (op1, DImode))
2786         op1 = force_reg (DImode, op1);
2787     }
2788
2789   /* ??? We mark the branch mode to be CCmode to prevent the compare
2790      and cmov from being combined, since the compare insn follows IEEE
2791      rules that the cmov does not.  */
2792   if (cmp_mode == DFmode && !local_fast_math)
2793     cmov_mode = CCmode;
2794
2795   tem = gen_reg_rtx (cmp_mode);
2796   emit_move_insn (tem, gen_rtx_fmt_ee (code, cmp_mode, op0, op1));
2797   return gen_rtx_fmt_ee (cmov_code, cmov_mode, tem, CONST0_RTX (cmp_mode));
2798 }
2799
2800 /* Simplify a conditional move of two constants into a setcc with
2801    arithmetic.  This is done with a splitter since combine would
2802    just undo the work if done during code generation.  It also catches
2803    cases we wouldn't have before cse.  */
2804
2805 int
2806 alpha_split_conditional_move (enum rtx_code code, rtx dest, rtx cond,
2807                               rtx t_rtx, rtx f_rtx)
2808 {
2809   HOST_WIDE_INT t, f, diff;
2810   enum machine_mode mode;
2811   rtx target, subtarget, tmp;
2812
2813   mode = GET_MODE (dest);
2814   t = INTVAL (t_rtx);
2815   f = INTVAL (f_rtx);
2816   diff = t - f;
2817
2818   if (((code == NE || code == EQ) && diff < 0)
2819       || (code == GE || code == GT))
2820     {
2821       code = reverse_condition (code);
2822       diff = t, t = f, f = diff;
2823       diff = t - f;
2824     }
2825
2826   subtarget = target = dest;
2827   if (mode != DImode)
2828     {
2829       target = gen_lowpart (DImode, dest);
2830       if (can_create_pseudo_p ())
2831         subtarget = gen_reg_rtx (DImode);
2832       else
2833         subtarget = target;
2834     }
2835   /* Below, we must be careful to use copy_rtx on target and subtarget
2836      in intermediate insns, as they may be a subreg rtx, which may not
2837      be shared.  */
2838
2839   if (f == 0 && exact_log2 (diff) > 0
2840       /* On EV6, we've got enough shifters to make non-arithmetic shifts
2841          viable over a longer latency cmove.  On EV5, the E0 slot is a
2842          scarce resource, and on EV4 shift has the same latency as a cmove.  */
2843       && (diff <= 8 || alpha_tune == PROCESSOR_EV6))
2844     {
2845       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
2846       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
2847
2848       tmp = gen_rtx_ASHIFT (DImode, copy_rtx (subtarget),
2849                             GEN_INT (exact_log2 (t)));
2850       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
2851     }
2852   else if (f == 0 && t == -1)
2853     {
2854       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
2855       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
2856
2857       emit_insn (gen_negdi2 (target, copy_rtx (subtarget)));
2858     }
2859   else if (diff == 1 || diff == 4 || diff == 8)
2860     {
2861       rtx add_op;
2862
2863       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
2864       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
2865
2866       if (diff == 1)
2867         emit_insn (gen_adddi3 (target, copy_rtx (subtarget), GEN_INT (f)));
2868       else
2869         {
2870           add_op = GEN_INT (f);
2871           if (sext_add_operand (add_op, mode))
2872             {
2873               tmp = gen_rtx_MULT (DImode, copy_rtx (subtarget),
2874                                   GEN_INT (diff));
2875               tmp = gen_rtx_PLUS (DImode, tmp, add_op);
2876               emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
2877             }
2878           else
2879             return 0;
2880         }
2881     }
2882   else
2883     return 0;
2884
2885   return 1;
2886 }
2887 \f
2888 /* Look up the function X_floating library function name for the
2889    given operation.  */
2890
2891 struct GTY(()) xfloating_op
2892 {
2893   const enum rtx_code code;
2894   const char *const GTY((skip)) osf_func;
2895   const char *const GTY((skip)) vms_func;
2896   rtx libcall;
2897 };
2898
2899 static GTY(()) struct xfloating_op xfloating_ops[] =
2900 {
2901   { PLUS,               "_OtsAddX", "OTS$ADD_X", 0 },
2902   { MINUS,              "_OtsSubX", "OTS$SUB_X", 0 },
2903   { MULT,               "_OtsMulX", "OTS$MUL_X", 0 },
2904   { DIV,                "_OtsDivX", "OTS$DIV_X", 0 },
2905   { EQ,                 "_OtsEqlX", "OTS$EQL_X", 0 },
2906   { NE,                 "_OtsNeqX", "OTS$NEQ_X", 0 },
2907   { LT,                 "_OtsLssX", "OTS$LSS_X", 0 },
2908   { LE,                 "_OtsLeqX", "OTS$LEQ_X", 0 },
2909   { GT,                 "_OtsGtrX", "OTS$GTR_X", 0 },
2910   { GE,                 "_OtsGeqX", "OTS$GEQ_X", 0 },
2911   { FIX,                "_OtsCvtXQ", "OTS$CVTXQ", 0 },
2912   { FLOAT,              "_OtsCvtQX", "OTS$CVTQX", 0 },
2913   { UNSIGNED_FLOAT,     "_OtsCvtQUX", "OTS$CVTQUX", 0 },
2914   { FLOAT_EXTEND,       "_OtsConvertFloatTX", "OTS$CVT_FLOAT_T_X", 0 },
2915   { FLOAT_TRUNCATE,     "_OtsConvertFloatXT", "OTS$CVT_FLOAT_X_T", 0 }
2916 };
2917
2918 static GTY(()) struct xfloating_op vax_cvt_ops[] =
2919 {
2920   { FLOAT_EXTEND,       "_OtsConvertFloatGX", "OTS$CVT_FLOAT_G_X", 0 },
2921   { FLOAT_TRUNCATE,     "_OtsConvertFloatXG", "OTS$CVT_FLOAT_X_G", 0 }
2922 };
2923
2924 static rtx
2925 alpha_lookup_xfloating_lib_func (enum rtx_code code)
2926 {
2927   struct xfloating_op *ops = xfloating_ops;
2928   long n = ARRAY_SIZE (xfloating_ops);
2929   long i;
2930
2931   gcc_assert (TARGET_HAS_XFLOATING_LIBS);
2932
2933   /* How irritating.  Nothing to key off for the main table.  */
2934   if (TARGET_FLOAT_VAX && (code == FLOAT_EXTEND || code == FLOAT_TRUNCATE))
2935     {
2936       ops = vax_cvt_ops;
2937       n = ARRAY_SIZE (vax_cvt_ops);
2938     }
2939
2940   for (i = 0; i < n; ++i, ++ops)
2941     if (ops->code == code)
2942       {
2943         rtx func = ops->libcall;
2944         if (!func)
2945           {
2946             func = init_one_libfunc (TARGET_ABI_OPEN_VMS
2947                                      ? ops->vms_func : ops->osf_func);
2948             ops->libcall = func;
2949           }
2950         return func;
2951       }
2952
2953   gcc_unreachable ();
2954 }
2955
2956 /* Most X_floating operations take the rounding mode as an argument.
2957    Compute that here.  */
2958
2959 static int
2960 alpha_compute_xfloating_mode_arg (enum rtx_code code,
2961                                   enum alpha_fp_rounding_mode round)
2962 {
2963   int mode;
2964
2965   switch (round)
2966     {
2967     case ALPHA_FPRM_NORM:
2968       mode = 2;
2969       break;
2970     case ALPHA_FPRM_MINF:
2971       mode = 1;
2972       break;
2973     case ALPHA_FPRM_CHOP:
2974       mode = 0;
2975       break;
2976     case ALPHA_FPRM_DYN:
2977       mode = 4;
2978       break;
2979     default:
2980       gcc_unreachable ();
2981
2982     /* XXX For reference, round to +inf is mode = 3.  */
2983     }
2984
2985   if (code == FLOAT_TRUNCATE && alpha_fptm == ALPHA_FPTM_N)
2986     mode |= 0x10000;
2987
2988   return mode;
2989 }
2990
2991 /* Emit an X_floating library function call.
2992
2993    Note that these functions do not follow normal calling conventions:
2994    TFmode arguments are passed in two integer registers (as opposed to
2995    indirect); TFmode return values appear in R16+R17.
2996
2997    FUNC is the function to call.
2998    TARGET is where the output belongs.
2999    OPERANDS are the inputs.
3000    NOPERANDS is the count of inputs.
3001    EQUIV is the expression equivalent for the function.
3002 */
3003
3004 static void
3005 alpha_emit_xfloating_libcall (rtx func, rtx target, rtx operands[],
3006                               int noperands, rtx equiv)
3007 {
3008   rtx usage = NULL_RTX, tmp, reg;
3009   int regno = 16, i;
3010
3011   start_sequence ();
3012
3013   for (i = 0; i < noperands; ++i)
3014     {
3015       switch (GET_MODE (operands[i]))
3016         {
3017         case TFmode:
3018           reg = gen_rtx_REG (TFmode, regno);
3019           regno += 2;
3020           break;
3021
3022         case DFmode:
3023           reg = gen_rtx_REG (DFmode, regno + 32);
3024           regno += 1;
3025           break;
3026
3027         case VOIDmode:
3028           gcc_assert (CONST_INT_P (operands[i]));
3029           /* FALLTHRU */
3030         case DImode:
3031           reg = gen_rtx_REG (DImode, regno);
3032           regno += 1;
3033           break;
3034
3035         default:
3036           gcc_unreachable ();
3037         }
3038
3039       emit_move_insn (reg, operands[i]);
3040       usage = alloc_EXPR_LIST (0, gen_rtx_USE (VOIDmode, reg), usage);
3041     }
3042
3043   switch (GET_MODE (target))
3044     {
3045     case TFmode:
3046       reg = gen_rtx_REG (TFmode, 16);
3047       break;
3048     case DFmode:
3049       reg = gen_rtx_REG (DFmode, 32);
3050       break;
3051     case DImode:
3052       reg = gen_rtx_REG (DImode, 0);
3053       break;
3054     default:
3055       gcc_unreachable ();
3056     }
3057
3058   tmp = gen_rtx_MEM (QImode, func);
3059   tmp = emit_call_insn (GEN_CALL_VALUE (reg, tmp, const0_rtx,
3060                                         const0_rtx, const0_rtx));
3061   CALL_INSN_FUNCTION_USAGE (tmp) = usage;
3062   RTL_CONST_CALL_P (tmp) = 1;
3063
3064   tmp = get_insns ();
3065   end_sequence ();
3066
3067   emit_libcall_block (tmp, target, reg, equiv);
3068 }
3069
3070 /* Emit an X_floating library function call for arithmetic (+,-,*,/).  */
3071
3072 void
3073 alpha_emit_xfloating_arith (enum rtx_code code, rtx operands[])
3074 {
3075   rtx func;
3076   int mode;
3077   rtx out_operands[3];
3078
3079   func = alpha_lookup_xfloating_lib_func (code);
3080   mode = alpha_compute_xfloating_mode_arg (code, alpha_fprm);
3081
3082   out_operands[0] = operands[1];
3083   out_operands[1] = operands[2];
3084   out_operands[2] = GEN_INT (mode);
3085   alpha_emit_xfloating_libcall (func, operands[0], out_operands, 3,
3086                                 gen_rtx_fmt_ee (code, TFmode, operands[1],
3087                                                 operands[2]));
3088 }
3089
3090 /* Emit an X_floating library function call for a comparison.  */
3091
3092 static rtx
3093 alpha_emit_xfloating_compare (enum rtx_code *pcode, rtx op0, rtx op1)
3094 {
3095   enum rtx_code cmp_code, res_code;
3096   rtx func, out, operands[2], note;
3097
3098   /* X_floating library comparison functions return
3099            -1  unordered
3100             0  false
3101             1  true
3102      Convert the compare against the raw return value.  */
3103
3104   cmp_code = *pcode;
3105   switch (cmp_code)
3106     {
3107     case UNORDERED:
3108       cmp_code = EQ;
3109       res_code = LT;
3110       break;
3111     case ORDERED:
3112       cmp_code = EQ;
3113       res_code = GE;
3114       break;
3115     case NE:
3116       res_code = NE;
3117       break;
3118     case EQ:
3119     case LT:
3120     case GT:
3121     case LE:
3122     case GE:
3123       res_code = GT;
3124       break;
3125     default:
3126       gcc_unreachable ();
3127     }
3128   *pcode = res_code;
3129
3130   func = alpha_lookup_xfloating_lib_func (cmp_code);
3131
3132   operands[0] = op0;
3133   operands[1] = op1;
3134   out = gen_reg_rtx (DImode);
3135
3136   /* What's actually returned is -1,0,1, not a proper boolean value,
3137      so use an EXPR_LIST as with a generic libcall instead of a 
3138      comparison type expression.  */
3139   note = gen_rtx_EXPR_LIST (VOIDmode, op1, NULL_RTX);
3140   note = gen_rtx_EXPR_LIST (VOIDmode, op0, note);
3141   note = gen_rtx_EXPR_LIST (VOIDmode, func, note);
3142   alpha_emit_xfloating_libcall (func, out, operands, 2, note);
3143
3144   return out;
3145 }
3146
3147 /* Emit an X_floating library function call for a conversion.  */
3148
3149 void
3150 alpha_emit_xfloating_cvt (enum rtx_code orig_code, rtx operands[])
3151 {
3152   int noperands = 1, mode;
3153   rtx out_operands[2];
3154   rtx func;
3155   enum rtx_code code = orig_code;
3156
3157   if (code == UNSIGNED_FIX)
3158     code = FIX;
3159
3160   func = alpha_lookup_xfloating_lib_func (code);
3161
3162   out_operands[0] = operands[1];
3163
3164   switch (code)
3165     {
3166     case FIX:
3167       mode = alpha_compute_xfloating_mode_arg (code, ALPHA_FPRM_CHOP);
3168       out_operands[1] = GEN_INT (mode);
3169       noperands = 2;
3170       break;
3171     case FLOAT_TRUNCATE:
3172       mode = alpha_compute_xfloating_mode_arg (code, alpha_fprm);
3173       out_operands[1] = GEN_INT (mode);
3174       noperands = 2;
3175       break;
3176     default:
3177       break;
3178     }
3179
3180   alpha_emit_xfloating_libcall (func, operands[0], out_operands, noperands,
3181                                 gen_rtx_fmt_e (orig_code,
3182                                                GET_MODE (operands[0]),
3183                                                operands[1]));
3184 }
3185
3186 /* Split a TImode or TFmode move from OP[1] to OP[0] into a pair of
3187    DImode moves from OP[2,3] to OP[0,1].  If FIXUP_OVERLAP is true,
3188    guarantee that the sequence
3189      set (OP[0] OP[2])
3190      set (OP[1] OP[3])
3191    is valid.  Naturally, output operand ordering is little-endian.
3192    This is used by *movtf_internal and *movti_internal.  */
3193   
3194 void
3195 alpha_split_tmode_pair (rtx operands[4], enum machine_mode mode,
3196                         bool fixup_overlap)
3197 {
3198   switch (GET_CODE (operands[1]))
3199     {
3200     case REG:
3201       operands[3] = gen_rtx_REG (DImode, REGNO (operands[1]) + 1);
3202       operands[2] = gen_rtx_REG (DImode, REGNO (operands[1]));
3203       break;
3204
3205     case MEM:
3206       operands[3] = adjust_address (operands[1], DImode, 8);
3207       operands[2] = adjust_address (operands[1], DImode, 0);
3208       break;
3209
3210     case CONST_INT:
3211     case CONST_DOUBLE:
3212       gcc_assert (operands[1] == CONST0_RTX (mode));
3213       operands[2] = operands[3] = const0_rtx;
3214       break;
3215
3216     default:
3217       gcc_unreachable ();
3218     }
3219
3220   switch (GET_CODE (operands[0]))
3221     {
3222     case REG:
3223       operands[1] = gen_rtx_REG (DImode, REGNO (operands[0]) + 1);
3224       operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
3225       break;
3226
3227     case MEM:
3228       operands[1] = adjust_address (operands[0], DImode, 8);
3229       operands[0] = adjust_address (operands[0], DImode, 0);
3230       break;
3231
3232     default:
3233       gcc_unreachable ();
3234     }
3235
3236   if (fixup_overlap && reg_overlap_mentioned_p (operands[0], operands[3]))
3237     {
3238       rtx tmp;
3239       tmp = operands[0], operands[0] = operands[1], operands[1] = tmp;
3240       tmp = operands[2], operands[2] = operands[3], operands[3] = tmp;
3241     }
3242 }
3243
3244 /* Implement negtf2 or abstf2.  Op0 is destination, op1 is source,
3245    op2 is a register containing the sign bit, operation is the
3246    logical operation to be performed.  */
3247
3248 void
3249 alpha_split_tfmode_frobsign (rtx operands[3], rtx (*operation) (rtx, rtx, rtx))
3250 {
3251   rtx high_bit = operands[2];
3252   rtx scratch;
3253   int move;
3254
3255   alpha_split_tmode_pair (operands, TFmode, false);
3256
3257   /* Detect three flavors of operand overlap.  */
3258   move = 1;
3259   if (rtx_equal_p (operands[0], operands[2]))
3260     move = 0;
3261   else if (rtx_equal_p (operands[1], operands[2]))
3262     {
3263       if (rtx_equal_p (operands[0], high_bit))
3264         move = 2;
3265       else
3266         move = -1;
3267     }
3268
3269   if (move < 0)
3270     emit_move_insn (operands[0], operands[2]);
3271
3272   /* ??? If the destination overlaps both source tf and high_bit, then
3273      assume source tf is dead in its entirety and use the other half
3274      for a scratch register.  Otherwise "scratch" is just the proper
3275      destination register.  */
3276   scratch = operands[move < 2 ? 1 : 3];
3277
3278   emit_insn ((*operation) (scratch, high_bit, operands[3]));
3279
3280   if (move > 0)
3281     {
3282       emit_move_insn (operands[0], operands[2]);
3283       if (move > 1)
3284         emit_move_insn (operands[1], scratch);
3285     }
3286 }
3287 \f
3288 /* Use ext[wlq][lh] as the Architecture Handbook describes for extracting
3289    unaligned data:
3290
3291            unsigned:                       signed:
3292    word:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
3293            ldq_u  r2,X+1(r11)              ldq_u  r2,X+1(r11)
3294            lda    r3,X(r11)                lda    r3,X+2(r11)
3295            extwl  r1,r3,r1                 extql  r1,r3,r1
3296            extwh  r2,r3,r2                 extqh  r2,r3,r2
3297            or     r1.r2.r1                 or     r1,r2,r1
3298                                            sra    r1,48,r1
3299
3300    long:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
3301            ldq_u  r2,X+3(r11)              ldq_u  r2,X+3(r11)
3302            lda    r3,X(r11)                lda    r3,X(r11)
3303            extll  r1,r3,r1                 extll  r1,r3,r1
3304            extlh  r2,r3,r2                 extlh  r2,r3,r2
3305            or     r1.r2.r1                 addl   r1,r2,r1
3306
3307    quad:   ldq_u  r1,X(r11)
3308            ldq_u  r2,X+7(r11)
3309            lda    r3,X(r11)
3310            extql  r1,r3,r1
3311            extqh  r2,r3,r2
3312            or     r1.r2.r1
3313 */
3314
3315 void
3316 alpha_expand_unaligned_load (rtx tgt, rtx mem, HOST_WIDE_INT size,
3317                              HOST_WIDE_INT ofs, int sign)
3318 {
3319   rtx meml, memh, addr, extl, exth, tmp, mema;
3320   enum machine_mode mode;
3321
3322   if (TARGET_BWX && size == 2)
3323     {
3324       meml = adjust_address (mem, QImode, ofs);
3325       memh = adjust_address (mem, QImode, ofs+1);
3326       if (BYTES_BIG_ENDIAN)
3327         tmp = meml, meml = memh, memh = tmp;
3328       extl = gen_reg_rtx (DImode);
3329       exth = gen_reg_rtx (DImode);
3330       emit_insn (gen_zero_extendqidi2 (extl, meml));
3331       emit_insn (gen_zero_extendqidi2 (exth, memh));
3332       exth = expand_simple_binop (DImode, ASHIFT, exth, GEN_INT (8),
3333                                   NULL, 1, OPTAB_LIB_WIDEN);
3334       addr = expand_simple_binop (DImode, IOR, extl, exth,
3335                                   NULL, 1, OPTAB_LIB_WIDEN);
3336
3337       if (sign && GET_MODE (tgt) != HImode)
3338         {
3339           addr = gen_lowpart (HImode, addr);
3340           emit_insn (gen_extend_insn (tgt, addr, GET_MODE (tgt), HImode, 0));
3341         }
3342       else
3343         {
3344           if (GET_MODE (tgt) != DImode)
3345             addr = gen_lowpart (GET_MODE (tgt), addr);
3346           emit_move_insn (tgt, addr);
3347         }
3348       return;
3349     }
3350
3351   meml = gen_reg_rtx (DImode);
3352   memh = gen_reg_rtx (DImode);
3353   addr = gen_reg_rtx (DImode);
3354   extl = gen_reg_rtx (DImode);
3355   exth = gen_reg_rtx (DImode);
3356
3357   mema = XEXP (mem, 0);
3358   if (GET_CODE (mema) == LO_SUM)
3359     mema = force_reg (Pmode, mema);
3360
3361   /* AND addresses cannot be in any alias set, since they may implicitly
3362      alias surrounding code.  Ideally we'd have some alias set that
3363      covered all types except those with alignment 8 or higher.  */
3364
3365   tmp = change_address (mem, DImode,
3366                         gen_rtx_AND (DImode,
3367                                      plus_constant (mema, ofs),
3368                                      GEN_INT (-8)));
3369   set_mem_alias_set (tmp, 0);
3370   emit_move_insn (meml, tmp);
3371
3372   tmp = change_address (mem, DImode,
3373                         gen_rtx_AND (DImode,
3374                                      plus_constant (mema, ofs + size - 1),
3375                                      GEN_INT (-8)));
3376   set_mem_alias_set (tmp, 0);
3377   emit_move_insn (memh, tmp);
3378
3379   if (WORDS_BIG_ENDIAN && sign && (size == 2 || size == 4))
3380     {
3381       emit_move_insn (addr, plus_constant (mema, -1));
3382
3383       emit_insn (gen_extqh_be (extl, meml, addr));
3384       emit_insn (gen_extxl_be (exth, memh, GEN_INT (64), addr));
3385
3386       addr = expand_binop (DImode, ior_optab, extl, exth, tgt, 1, OPTAB_WIDEN);
3387       addr = expand_binop (DImode, ashr_optab, addr, GEN_INT (64 - size*8),
3388                            addr, 1, OPTAB_WIDEN);
3389     }
3390   else if (sign && size == 2)
3391     {
3392       emit_move_insn (addr, plus_constant (mema, ofs+2));
3393
3394       emit_insn (gen_extxl_le (extl, meml, GEN_INT (64), addr));
3395       emit_insn (gen_extqh_le (exth, memh, addr));
3396
3397       /* We must use tgt here for the target.  Alpha-vms port fails if we use
3398          addr for the target, because addr is marked as a pointer and combine
3399          knows that pointers are always sign-extended 32-bit values.  */
3400       addr = expand_binop (DImode, ior_optab, extl, exth, tgt, 1, OPTAB_WIDEN);
3401       addr = expand_binop (DImode, ashr_optab, addr, GEN_INT (48),
3402                            addr, 1, OPTAB_WIDEN);
3403     }
3404   else
3405     {
3406       if (WORDS_BIG_ENDIAN)
3407         {
3408           emit_move_insn (addr, plus_constant (mema, ofs+size-1));
3409           switch ((int) size)
3410             {
3411             case 2:
3412               emit_insn (gen_extwh_be (extl, meml, addr));
3413               mode = HImode;
3414               break;
3415
3416             case 4:
3417               emit_insn (gen_extlh_be (extl, meml, addr));
3418               mode = SImode;
3419               break;
3420
3421             case 8:
3422               emit_insn (gen_extqh_be (extl, meml, addr));
3423               mode = DImode;
3424               break;
3425
3426             default:
3427               gcc_unreachable ();
3428             }
3429           emit_insn (gen_extxl_be (exth, memh, GEN_INT (size*8), addr));
3430         }
3431       else
3432         {
3433           emit_move_insn (addr, plus_constant (mema, ofs));
3434           emit_insn (gen_extxl_le (extl, meml, GEN_INT (size*8), addr));
3435           switch ((int) size)
3436             {
3437             case 2:
3438               emit_insn (gen_extwh_le (exth, memh, addr));
3439               mode = HImode;
3440               break;
3441
3442             case 4:
3443               emit_insn (gen_extlh_le (exth, memh, addr));
3444               mode = SImode;
3445               break;
3446
3447             case 8:
3448               emit_insn (gen_extqh_le (exth, memh, addr));
3449               mode = DImode;
3450               break;
3451
3452             default:
3453               gcc_unreachable ();
3454             }
3455         }
3456
3457       addr = expand_binop (mode, ior_optab, gen_lowpart (mode, extl),
3458                            gen_lowpart (mode, exth), gen_lowpart (mode, tgt),
3459                            sign, OPTAB_WIDEN);
3460     }
3461
3462   if (addr != tgt)
3463     emit_move_insn (tgt, gen_lowpart (GET_MODE (tgt), addr));
3464 }
3465
3466 /* Similarly, use ins and msk instructions to perform unaligned stores.  */
3467