OSDN Git Service

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