OSDN Git Service

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