OSDN Git Service

81e6e2801a9ab843e8bd539867d803e838c3efc0
[pf3gnuchains/gcc-fork.git] / gcc / config / vax / vax.c
1 /* Subroutines for insn-output.c for VAX.
2    Copyright (C) 1987, 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002,
3    2004, 2005
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING.  If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA.  */
22
23 #include "config.h"
24 #include "system.h"
25 #include "coretypes.h"
26 #include "tm.h"
27 #include "rtl.h"
28 #include "tree.h"
29 #include "regs.h"
30 #include "hard-reg-set.h"
31 #include "real.h"
32 #include "insn-config.h"
33 #include "conditions.h"
34 #include "function.h"
35 #include "output.h"
36 #include "insn-attr.h"
37 #include "recog.h"
38 #include "expr.h"
39 #include "optabs.h"
40 #include "flags.h"
41 #include "debug.h"
42 #include "toplev.h"
43 #include "tm_p.h"
44 #include "target.h"
45 #include "target-def.h"
46
47 static void vax_output_function_prologue (FILE *, HOST_WIDE_INT);
48 static void vax_file_start (void);
49 static void vax_init_libfuncs (void);
50 static void vax_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
51                                  HOST_WIDE_INT, tree);
52 static int vax_address_cost_1 (rtx);
53 static int vax_address_cost (rtx);
54 static bool vax_rtx_costs (rtx, int, int, int *);
55 static rtx vax_struct_value_rtx (tree, int);
56 \f
57 /* Initialize the GCC target structure.  */
58 #undef TARGET_ASM_ALIGNED_HI_OP
59 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
60
61 #undef TARGET_ASM_FUNCTION_PROLOGUE
62 #define TARGET_ASM_FUNCTION_PROLOGUE vax_output_function_prologue
63
64 #undef TARGET_ASM_FILE_START
65 #define TARGET_ASM_FILE_START vax_file_start
66 #undef TARGET_ASM_FILE_START_APP_OFF
67 #define TARGET_ASM_FILE_START_APP_OFF true
68
69 #undef TARGET_INIT_LIBFUNCS
70 #define TARGET_INIT_LIBFUNCS vax_init_libfuncs
71
72 #undef TARGET_ASM_OUTPUT_MI_THUNK
73 #define TARGET_ASM_OUTPUT_MI_THUNK vax_output_mi_thunk
74 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
75 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
76
77 #undef TARGET_DEFAULT_TARGET_FLAGS
78 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
79
80 #undef TARGET_RTX_COSTS
81 #define TARGET_RTX_COSTS vax_rtx_costs
82 #undef TARGET_ADDRESS_COST
83 #define TARGET_ADDRESS_COST vax_address_cost
84
85 #undef TARGET_PROMOTE_PROTOTYPES
86 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
87
88 #undef TARGET_STRUCT_VALUE_RTX
89 #define TARGET_STRUCT_VALUE_RTX vax_struct_value_rtx
90
91 struct gcc_target targetm = TARGET_INITIALIZER;
92 \f
93 /* Set global variables as needed for the options enabled.  */
94
95 void
96 override_options (void)
97 {
98   /* We're VAX floating point, not IEEE floating point.  */
99   if (TARGET_G_FLOAT)
100     REAL_MODE_FORMAT (DFmode) = &vax_g_format;
101 }
102
103 /* Generate the assembly code for function entry.  FILE is a stdio
104    stream to output the code to.  SIZE is an int: how many units of
105    temporary storage to allocate.
106
107    Refer to the array `regs_ever_live' to determine which registers to
108    save; `regs_ever_live[I]' is nonzero if register number I is ever
109    used in the function.  This function is responsible for knowing
110    which registers should not be saved even if used.  */
111
112 static void
113 vax_output_function_prologue (FILE * file, HOST_WIDE_INT size)
114 {
115   int regno;
116   int mask = 0;
117
118   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
119     if (regs_ever_live[regno] && !call_used_regs[regno])
120       mask |= 1 << regno;
121
122   fprintf (file, "\t.word 0x%x\n", mask);
123
124   if (dwarf2out_do_frame ())
125     {
126       const char *label = dwarf2out_cfi_label ();
127       int offset = 0;
128
129       for (regno = FIRST_PSEUDO_REGISTER-1; regno >= 0; --regno)
130         if (regs_ever_live[regno] && !call_used_regs[regno])
131           dwarf2out_reg_save (label, regno, offset -= 4);
132
133       dwarf2out_reg_save (label, PC_REGNUM, offset -= 4);
134       dwarf2out_reg_save (label, FRAME_POINTER_REGNUM, offset -= 4);
135       dwarf2out_reg_save (label, ARG_POINTER_REGNUM, offset -= 4);
136       dwarf2out_def_cfa (label, FRAME_POINTER_REGNUM, -(offset - 4));
137     }
138
139   size -= STARTING_FRAME_OFFSET;
140   if (size >= 64)
141     asm_fprintf (file, "\tmovab %wd(%Rsp),%Rsp\n", -size);
142   else if (size)
143     asm_fprintf (file, "\tsubl2 $%wd,%Rsp\n", size);
144 }
145
146 /* When debugging with stabs, we want to output an extra dummy label
147    so that gas can distinguish between D_float and G_float prior to
148    processing the .stabs directive identifying type double.  */
149 static void
150 vax_file_start (void)
151 {
152   default_file_start ();
153
154   if (write_symbols == DBX_DEBUG)
155     fprintf (asm_out_file, "___vax_%c_doubles:\n", ASM_DOUBLE_CHAR);
156 }
157
158 /* We can use the BSD C library routines for the libgcc calls that are
159    still generated, since that's what they boil down to anyways.  When
160    ELF, avoid the user's namespace.  */
161
162 static void
163 vax_init_libfuncs (void)
164 {
165   set_optab_libfunc (udiv_optab, SImode, TARGET_ELF ? "*__udiv" : "*udiv");
166   set_optab_libfunc (umod_optab, SImode, TARGET_ELF ? "*__urem" : "*urem");
167 }
168
169 /* This is like nonimmediate_operand with a restriction on the type of MEM.  */
170
171 void
172 split_quadword_operands (rtx * operands, rtx * low, int n ATTRIBUTE_UNUSED)
173 {
174   int i;
175   /* Split operands.  */
176
177   low[0] = low[1] = low[2] = 0;
178   for (i = 0; i < 3; i++)
179     {
180       if (low[i])
181         /* it's already been figured out */;
182       else if (GET_CODE (operands[i]) == MEM
183                && (GET_CODE (XEXP (operands[i], 0)) == POST_INC))
184         {
185           rtx addr = XEXP (operands[i], 0);
186           operands[i] = low[i] = gen_rtx_MEM (SImode, addr);
187           if (which_alternative == 0 && i == 0)
188             {
189               addr = XEXP (operands[i], 0);
190               operands[i+1] = low[i+1] = gen_rtx_MEM (SImode, addr);
191             }
192         }
193       else
194         {
195           low[i] = operand_subword (operands[i], 0, 0, DImode);
196           operands[i] = operand_subword (operands[i], 1, 0, DImode);
197         }
198     }
199 }
200 \f
201 void
202 print_operand_address (FILE * file, rtx addr)
203 {
204   rtx reg1, breg, ireg;
205   rtx offset;
206
207  retry:
208   switch (GET_CODE (addr))
209     {
210     case MEM:
211       fprintf (file, "*");
212       addr = XEXP (addr, 0);
213       goto retry;
214
215     case REG:
216       fprintf (file, "(%s)", reg_names[REGNO (addr)]);
217       break;
218
219     case PRE_DEC:
220       fprintf (file, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);
221       break;
222
223     case POST_INC:
224       fprintf (file, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);
225       break;
226
227     case PLUS:
228       /* There can be either two or three things added here.  One must be a
229          REG.  One can be either a REG or a MULT of a REG and an appropriate
230          constant, and the third can only be a constant or a MEM.
231
232          We get these two or three things and put the constant or MEM in
233          OFFSET, the MULT or REG in IREG, and the REG in BREG.  If we have
234          a register and can't tell yet if it is a base or index register,
235          put it into REG1.  */
236
237       reg1 = 0; ireg = 0; breg = 0; offset = 0;
238
239       if (CONSTANT_ADDRESS_P (XEXP (addr, 0))
240           || GET_CODE (XEXP (addr, 0)) == MEM)
241         {
242           offset = XEXP (addr, 0);
243           addr = XEXP (addr, 1);
244         }
245       else if (CONSTANT_ADDRESS_P (XEXP (addr, 1))
246                || GET_CODE (XEXP (addr, 1)) == MEM)
247         {
248           offset = XEXP (addr, 1);
249           addr = XEXP (addr, 0);
250         }
251       else if (GET_CODE (XEXP (addr, 1)) == MULT)
252         {
253           ireg = XEXP (addr, 1);
254           addr = XEXP (addr, 0);
255         }
256       else if (GET_CODE (XEXP (addr, 0)) == MULT)
257         {
258           ireg = XEXP (addr, 0);
259           addr = XEXP (addr, 1);
260         }
261       else if (GET_CODE (XEXP (addr, 1)) == REG)
262         {
263           reg1 = XEXP (addr, 1);
264           addr = XEXP (addr, 0);
265         }
266       else if (GET_CODE (XEXP (addr, 0)) == REG)
267         {
268           reg1 = XEXP (addr, 0);
269           addr = XEXP (addr, 1);
270         }
271       else
272         abort ();
273
274       if (GET_CODE (addr) == REG)
275         {
276           if (reg1)
277             ireg = addr;
278           else
279             reg1 = addr;
280         }
281       else if (GET_CODE (addr) == MULT)
282         ireg = addr;
283       else if (GET_CODE (addr) == PLUS)
284         {
285           if (CONSTANT_ADDRESS_P (XEXP (addr, 0))
286               || GET_CODE (XEXP (addr, 0)) == MEM)
287             {
288               if (offset)
289                 {
290                   if (GET_CODE (offset) == CONST_INT)
291                     offset = plus_constant (XEXP (addr, 0), INTVAL (offset));
292                   else if (GET_CODE (XEXP (addr, 0)) == CONST_INT)
293                     offset = plus_constant (offset, INTVAL (XEXP (addr, 0)));
294                   else
295                     abort ();
296                 }
297               offset = XEXP (addr, 0);
298             }
299           else if (GET_CODE (XEXP (addr, 0)) == REG)
300             {
301               if (reg1)
302                 ireg = reg1, breg = XEXP (addr, 0), reg1 = 0;
303               else
304                 reg1 = XEXP (addr, 0);
305             }
306           else if (GET_CODE (XEXP (addr, 0)) == MULT)
307             {
308               if (ireg)
309                 abort ();
310               ireg = XEXP (addr, 0);
311             }
312           else
313             abort ();
314
315           if (CONSTANT_ADDRESS_P (XEXP (addr, 1))
316               || GET_CODE (XEXP (addr, 1)) == MEM)
317             {
318               if (offset)
319                 {
320                   if (GET_CODE (offset) == CONST_INT)
321                     offset = plus_constant (XEXP (addr, 1), INTVAL (offset));
322                   else if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
323                     offset = plus_constant (offset, INTVAL (XEXP (addr, 1)));
324                   else
325                     abort ();
326                 }
327               offset = XEXP (addr, 1);
328             }
329           else if (GET_CODE (XEXP (addr, 1)) == REG)
330             {
331               if (reg1)
332                 ireg = reg1, breg = XEXP (addr, 1), reg1 = 0;
333               else
334                 reg1 = XEXP (addr, 1);
335             }
336           else if (GET_CODE (XEXP (addr, 1)) == MULT)
337             {
338               if (ireg)
339                 abort ();
340               ireg = XEXP (addr, 1);
341             }
342           else
343             abort ();
344         }
345       else
346         abort ();
347
348       /* If REG1 is nonzero, figure out if it is a base or index register.  */
349       if (reg1)
350         {
351           if (breg != 0 || (offset && GET_CODE (offset) == MEM))
352             {
353               if (ireg)
354                 abort ();
355               ireg = reg1;
356             }
357           else
358             breg = reg1;
359         }
360
361       if (offset != 0)
362         output_address (offset);
363
364       if (breg != 0)
365         fprintf (file, "(%s)", reg_names[REGNO (breg)]);
366
367       if (ireg != 0)
368         {
369           if (GET_CODE (ireg) == MULT)
370             ireg = XEXP (ireg, 0);
371           if (GET_CODE (ireg) != REG)
372             abort ();
373           fprintf (file, "[%s]", reg_names[REGNO (ireg)]);
374         }
375       break;
376
377     default:
378       output_addr_const (file, addr);
379     }
380 }
381 \f
382 const char *
383 rev_cond_name (rtx op)
384 {
385   switch (GET_CODE (op))
386     {
387     case EQ:
388       return "neq";
389     case NE:
390       return "eql";
391     case LT:
392       return "geq";
393     case LE:
394       return "gtr";
395     case GT:
396       return "leq";
397     case GE:
398       return "lss";
399     case LTU:
400       return "gequ";
401     case LEU:
402       return "gtru";
403     case GTU:
404       return "lequ";
405     case GEU:
406       return "lssu";
407
408     default:
409       abort ();
410     }
411 }
412
413 int
414 vax_float_literal(rtx c)
415 {
416   enum machine_mode mode;
417   REAL_VALUE_TYPE r, s;
418   int i;
419
420   if (GET_CODE (c) != CONST_DOUBLE)
421     return 0;
422
423   mode = GET_MODE (c);
424
425   if (c == const_tiny_rtx[(int) mode][0]
426       || c == const_tiny_rtx[(int) mode][1]
427       || c == const_tiny_rtx[(int) mode][2])
428     return 1;
429
430   REAL_VALUE_FROM_CONST_DOUBLE (r, c);
431
432   for (i = 0; i < 7; i++)
433     {
434       int x = 1 << i;
435       REAL_VALUE_FROM_INT (s, x, 0, mode);
436
437       if (REAL_VALUES_EQUAL (r, s))
438         return 1;
439       if (!exact_real_inverse (mode, &s))
440         abort ();
441       if (REAL_VALUES_EQUAL (r, s))
442         return 1;
443     }
444   return 0;
445 }
446
447
448 /* Return the cost in cycles of a memory address, relative to register
449    indirect.
450
451    Each of the following adds the indicated number of cycles:
452
453    1 - symbolic address
454    1 - pre-decrement
455    1 - indexing and/or offset(register)
456    2 - indirect */
457
458
459 static int
460 vax_address_cost_1 (rtx addr)
461 {
462   int reg = 0, indexed = 0, indir = 0, offset = 0, predec = 0;
463   rtx plus_op0 = 0, plus_op1 = 0;
464  restart:
465   switch (GET_CODE (addr))
466     {
467     case PRE_DEC:
468       predec = 1;
469     case REG:
470     case SUBREG:
471     case POST_INC:
472       reg = 1;
473       break;
474     case MULT:
475       indexed = 1;      /* 2 on VAX 2 */
476       break;
477     case CONST_INT:
478       /* byte offsets cost nothing (on a VAX 2, they cost 1 cycle) */
479       if (offset == 0)
480         offset = (unsigned HOST_WIDE_INT)(INTVAL(addr)+128) > 256;
481       break;
482     case CONST:
483     case SYMBOL_REF:
484       offset = 1;       /* 2 on VAX 2 */
485       break;
486     case LABEL_REF:     /* this is probably a byte offset from the pc */
487       if (offset == 0)
488         offset = 1;
489       break;
490     case PLUS:
491       if (plus_op0)
492         plus_op1 = XEXP (addr, 0);
493       else
494         plus_op0 = XEXP (addr, 0);
495       addr = XEXP (addr, 1);
496       goto restart;
497     case MEM:
498       indir = 2;        /* 3 on VAX 2 */
499       addr = XEXP (addr, 0);
500       goto restart;
501     default:
502       break;
503     }
504
505   /* Up to 3 things can be added in an address.  They are stored in
506      plus_op0, plus_op1, and addr.  */
507
508   if (plus_op0)
509     {
510       addr = plus_op0;
511       plus_op0 = 0;
512       goto restart;
513     }
514   if (plus_op1)
515     {
516       addr = plus_op1;
517       plus_op1 = 0;
518       goto restart;
519     }
520   /* Indexing and register+offset can both be used (except on a VAX 2)
521      without increasing execution time over either one alone.  */
522   if (reg && indexed && offset)
523     return reg + indir + offset + predec;
524   return reg + indexed + indir + offset + predec;
525 }
526
527 static int
528 vax_address_cost (rtx x)
529 {
530   return (1 + (GET_CODE (x) == REG ? 0 : vax_address_cost_1 (x)));
531 }
532
533 /* Cost of an expression on a VAX.  This version has costs tuned for the
534    CVAX chip (found in the VAX 3 series) with comments for variations on
535    other models.
536
537    FIXME: The costs need review, particularly for TRUNCATE, FLOAT_EXTEND
538    and FLOAT_TRUNCATE.  We need a -mcpu option to allow provision of
539    costs on a per cpu basis.  */
540
541 static bool
542 vax_rtx_costs (rtx x, int code, int outer_code, int *total)
543 {
544   enum machine_mode mode = GET_MODE (x);
545   int i = 0;                               /* may be modified in switch */
546   const char *fmt = GET_RTX_FORMAT (code); /* may be modified in switch */
547
548   switch (code)
549     {
550       /* On a VAX, constants from 0..63 are cheap because they can use the
551          1 byte literal constant format.  Compare to -1 should be made cheap
552          so that decrement-and-branch insns can be formed more easily (if
553          the value -1 is copied to a register some decrement-and-branch
554          patterns will not match).  */
555     case CONST_INT:
556       if (INTVAL (x) == 0)
557         return true;
558       if (outer_code == AND)
559         {
560           *total = ((unsigned HOST_WIDE_INT) ~INTVAL (x) <= 077) ? 1 : 2;
561           return true;
562         }
563       if ((unsigned HOST_WIDE_INT) INTVAL (x) <= 077
564           || (outer_code == COMPARE
565               && INTVAL (x) == -1)
566           || ((outer_code == PLUS || outer_code == MINUS)
567               && (unsigned HOST_WIDE_INT) -INTVAL (x) <= 077))
568         {
569           *total = 1;
570           return true;
571         }
572       /* FALLTHRU */
573
574     case CONST:
575     case LABEL_REF:
576     case SYMBOL_REF:
577       *total = 3;
578       return true;
579
580     case CONST_DOUBLE:
581       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
582         *total = vax_float_literal (x) ? 5 : 8;
583       else
584         *total = ((CONST_DOUBLE_HIGH (x) == 0
585                    && (unsigned HOST_WIDE_INT) CONST_DOUBLE_LOW (x) < 64)
586                   || (outer_code == PLUS
587                       && CONST_DOUBLE_HIGH (x) == -1
588                       && (unsigned HOST_WIDE_INT)-CONST_DOUBLE_LOW (x) < 64))
589                  ? 2 : 5;
590       return true;
591
592     case POST_INC:
593       *total = 2;
594       return true;              /* Implies register operand.  */
595
596     case PRE_DEC:
597       *total = 3;
598       return true;              /* Implies register operand.  */
599
600     case MULT:
601       switch (mode)
602         {
603         case DFmode:
604           *total = 16;          /* 4 on VAX 9000 */
605           break;
606         case SFmode:
607           *total = 9;           /* 4 on VAX 9000, 12 on VAX 2 */
608           break;
609         case DImode:
610           *total = 16;          /* 6 on VAX 9000, 28 on VAX 2 */
611           break;
612         case SImode:
613         case HImode:
614         case QImode:
615           *total = 10;          /* 3-4 on VAX 9000, 20-28 on VAX 2 */
616           break;
617         default:
618           *total = MAX_COST;    /* Mode is not supported.  */
619           return true;
620         }
621       break;
622
623     case UDIV:
624       if (mode != SImode)
625         {
626           *total = MAX_COST;    /* Mode is not supported.  */
627           return true;
628         }
629       *total = 17;
630       break;
631
632     case DIV:
633       if (mode == DImode)
634         *total = 30;            /* Highly variable.  */
635       else if (mode == DFmode)
636         /* divide takes 28 cycles if the result is not zero, 13 otherwise */
637         *total = 24;
638       else
639         *total = 11;            /* 25 on VAX 2 */
640       break;
641
642     case MOD:
643       *total = 23;
644       break;
645
646     case UMOD:
647       if (mode != SImode)
648         {
649           *total = MAX_COST;    /* Mode is not supported.  */
650           return true;
651         }
652       *total = 29;
653       break;
654
655     case FLOAT:
656       *total = (6               /* 4 on VAX 9000 */
657                 + (mode == DFmode) + (GET_MODE (XEXP (x, 0)) != SImode));
658       break;
659
660     case FIX:
661       *total = 7;               /* 17 on VAX 2 */
662       break;
663
664     case ASHIFT:
665     case LSHIFTRT:
666     case ASHIFTRT:
667       if (mode == DImode)
668         *total = 12;
669       else
670         *total = 10;            /* 6 on VAX 9000 */
671       break;
672
673     case ROTATE:
674     case ROTATERT:
675       *total = 6;               /* 5 on VAX 2, 4 on VAX 9000 */
676       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
677         fmt = "e";              /* all constant rotate counts are short */
678       break;
679
680     case PLUS:
681     case MINUS:
682       *total = (mode == DFmode) ? 13 : 8; /* 6/8 on VAX 9000, 16/15 on VAX 2 */
683       /* Small integer operands can use subl2 and addl2.  */
684       if ((GET_CODE (XEXP (x, 1)) == CONST_INT)
685           && (unsigned HOST_WIDE_INT)(INTVAL (XEXP (x, 1)) + 63) < 127)
686         fmt = "e";
687       break;
688
689     case IOR:
690     case XOR:
691       *total = 3;
692       break;
693
694     case AND:
695       /* AND is special because the first operand is complemented.  */
696       *total = 3;
697       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
698         {
699           if ((unsigned HOST_WIDE_INT)~INTVAL (XEXP (x, 0)) > 63)
700             *total = 4;
701           fmt = "e";
702           i = 1;
703         }
704       break;
705
706     case NEG:
707       if (mode == DFmode)
708         *total = 9;
709       else if (mode == SFmode)
710         *total = 6;
711       else if (mode == DImode)
712         *total = 4;
713       else
714         *total = 2;
715       break;
716
717     case NOT:
718       *total = 2;
719       break;
720
721     case ZERO_EXTRACT:
722     case SIGN_EXTRACT:
723       *total = 15;
724       break;
725
726     case MEM:
727       if (mode == DImode || mode == DFmode)
728         *total = 5;             /* 7 on VAX 2 */
729       else
730         *total = 3;             /* 4 on VAX 2 */
731       x = XEXP (x, 0);
732       if (GET_CODE (x) != REG && GET_CODE (x) != POST_INC)
733         *total += vax_address_cost_1 (x);
734       return true;
735
736     case FLOAT_EXTEND:
737     case FLOAT_TRUNCATE:
738     case TRUNCATE:
739       *total = 3;               /* FIXME: Costs need to be checked  */
740       break;
741
742     default:
743       return false;
744     }
745
746   /* Now look inside the expression.  Operands which are not registers or
747      short constants add to the cost.
748
749      FMT and I may have been adjusted in the switch above for instructions
750      which require special handling.  */
751
752   while (*fmt++ == 'e')
753     {
754       rtx op = XEXP (x, i);
755
756       i += 1;
757       code = GET_CODE (op);
758
759       /* A NOT is likely to be found as the first operand of an AND
760          (in which case the relevant cost is of the operand inside
761          the not) and not likely to be found anywhere else.  */
762       if (code == NOT)
763         op = XEXP (op, 0), code = GET_CODE (op);
764
765       switch (code)
766         {
767         case CONST_INT:
768           if ((unsigned HOST_WIDE_INT)INTVAL (op) > 63
769               && GET_MODE (x) != QImode)
770             *total += 1;        /* 2 on VAX 2 */
771           break;
772         case CONST:
773         case LABEL_REF:
774         case SYMBOL_REF:
775           *total += 1;          /* 2 on VAX 2 */
776           break;
777         case CONST_DOUBLE:
778           if (GET_MODE_CLASS (GET_MODE (op)) == MODE_FLOAT)
779             {
780               /* Registers are faster than floating point constants -- even
781                  those constants which can be encoded in a single byte.  */
782               if (vax_float_literal (op))
783                 *total += 1;
784               else
785                 *total += (GET_MODE (x) == DFmode) ? 3 : 2;
786             }
787           else
788             {
789               if (CONST_DOUBLE_HIGH (op) != 0
790                   || (unsigned)CONST_DOUBLE_LOW (op) > 63)
791                 *total += 2;
792             }
793           break;
794         case MEM:
795           *total += 1;          /* 2 on VAX 2 */
796           if (GET_CODE (XEXP (op, 0)) != REG)
797             *total += vax_address_cost_1 (XEXP (op, 0));
798           break;
799         case REG:
800         case SUBREG:
801           break;
802         default:
803           *total += 1;
804           break;
805         }
806     }
807   return true;
808 }
809 \f
810 /* Output code to add DELTA to the first argument, and then jump to FUNCTION.
811    Used for C++ multiple inheritance.
812         .mask   ^m<r2,r3,r4,r5,r6,r7,r8,r9,r10,r11>  #conservative entry mask
813         addl2   $DELTA, 4(ap)   #adjust first argument
814         jmp     FUNCTION+2      #jump beyond FUNCTION's entry mask
815 */
816
817 static void
818 vax_output_mi_thunk (FILE * file,
819                      tree thunk ATTRIBUTE_UNUSED,
820                      HOST_WIDE_INT delta,
821                      HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED,
822                      tree function)
823 {
824   fprintf (file, "\t.word 0x0ffc\n\taddl2 $" HOST_WIDE_INT_PRINT_DEC, delta);
825   asm_fprintf (file, ",4(%Rap)\n");
826   fprintf (file, "\tjmp ");
827   assemble_name (file,  XSTR (XEXP (DECL_RTL (function), 0), 0));
828   fprintf (file, "+2\n");
829 }
830 \f
831 static rtx
832 vax_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
833                       int incoming ATTRIBUTE_UNUSED)
834 {
835   return gen_rtx_REG (Pmode, VAX_STRUCT_VALUE_REGNUM);
836 }
837
838 /* Worker function for NOTICE_UPDATE_CC.  */
839
840 void
841 vax_notice_update_cc (rtx exp, rtx insn ATTRIBUTE_UNUSED)
842 {
843   if (GET_CODE (exp) == SET)
844     {
845       if (GET_CODE (SET_SRC (exp)) == CALL)
846         CC_STATUS_INIT;
847       else if (GET_CODE (SET_DEST (exp)) != ZERO_EXTRACT
848                && GET_CODE (SET_DEST (exp)) != PC)
849         {
850           cc_status.flags = 0;
851           /* The integer operations below don't set carry or
852              set it in an incompatible way.  That's ok though
853              as the Z bit is all we need when doing unsigned
854              comparisons on the result of these insns (since
855              they're always with 0).  Set CC_NO_OVERFLOW to
856              generate the correct unsigned branches.  */
857           switch (GET_CODE (SET_SRC (exp)))
858             {
859             case NEG:
860               if (GET_MODE_CLASS (GET_MODE (exp)) == MODE_FLOAT)
861                 break;
862             case AND:
863             case IOR:
864             case XOR:
865             case NOT:
866             case MEM:
867             case REG:
868               cc_status.flags = CC_NO_OVERFLOW;
869               break;
870             default:
871               break;
872             }
873           cc_status.value1 = SET_DEST (exp);
874           cc_status.value2 = SET_SRC (exp);
875         }
876     }
877   else if (GET_CODE (exp) == PARALLEL
878            && GET_CODE (XVECEXP (exp, 0, 0)) == SET)
879     {
880       if (GET_CODE (SET_SRC (XVECEXP (exp, 0, 0))) == CALL)
881         CC_STATUS_INIT;
882       else if (GET_CODE (SET_DEST (XVECEXP (exp, 0, 0))) != PC)
883         {
884           cc_status.flags = 0;
885           cc_status.value1 = SET_DEST (XVECEXP (exp, 0, 0));
886           cc_status.value2 = SET_SRC (XVECEXP (exp, 0, 0));
887         }
888       else
889         /* PARALLELs whose first element sets the PC are aob,
890            sob insns.  They do change the cc's.  */
891         CC_STATUS_INIT;
892     }
893   else
894     CC_STATUS_INIT;
895   if (cc_status.value1 && GET_CODE (cc_status.value1) == REG
896       && cc_status.value2
897       && reg_overlap_mentioned_p (cc_status.value1, cc_status.value2))
898     cc_status.value2 = 0;
899   if (cc_status.value1 && GET_CODE (cc_status.value1) == MEM
900       && cc_status.value2
901       && GET_CODE (cc_status.value2) == MEM)
902     cc_status.value2 = 0;
903   /* Actual condition, one line up, should be that value2's address
904      depends on value1, but that is too much of a pain.  */
905 }
906
907 /* Output integer move instructions.  */
908
909 const char *
910 vax_output_int_move (rtx insn ATTRIBUTE_UNUSED, rtx *operands,
911                      enum machine_mode mode)
912 {
913   switch (mode)
914     {
915     case SImode:
916       if (GET_CODE (operands[1]) == SYMBOL_REF || GET_CODE (operands[1]) == CONST)
917         {
918           if (push_operand (operands[0], SImode))
919             return "pushab %a1";
920           return "movab %a1,%0";
921         }
922       if (operands[1] == const0_rtx)
923         return "clrl %0";
924       if (GET_CODE (operands[1]) == CONST_INT
925           && (unsigned) INTVAL (operands[1]) >= 64)
926         {
927           int i = INTVAL (operands[1]);
928           if ((unsigned)(~i) < 64)
929             return "mcoml %N1,%0";
930           if ((unsigned)i < 0x100)
931             return "movzbl %1,%0";
932           if (i >= -0x80 && i < 0)
933             return "cvtbl %1,%0";
934           if ((unsigned)i < 0x10000)
935             return "movzwl %1,%0";
936           if (i >= -0x8000 && i < 0)
937             return "cvtwl %1,%0";
938         }
939       if (push_operand (operands[0], SImode))
940         return "pushl %1";
941       return "movl %1,%0";
942
943     case HImode:
944       if (GET_CODE (operands[1]) == CONST_INT)
945         {
946           int i = INTVAL (operands[1]);
947           if (i == 0)
948             return "clrw %0";
949           else if ((unsigned int)i < 64)
950             return "movw %1,%0";
951           else if ((unsigned int)~i < 64)
952             return "mcomw %H1,%0";
953           else if ((unsigned int)i < 256)
954             return "movzbw %1,%0";
955         }
956       return "movw %1,%0";
957
958     case QImode:
959       if (GET_CODE (operands[1]) == CONST_INT)
960         {
961           int i = INTVAL (operands[1]);
962           if (i == 0)
963             return "clrb %0";
964           else if ((unsigned int)~i < 64)
965             return "mcomb %B1,%0";
966         }
967       return "movb %1,%0";
968
969     default:
970       gcc_unreachable ();
971     }
972 }
973
974 /* Output integer add instructions.
975
976    The space-time-opcode tradeoffs for addition vary by model of VAX.
977
978    On a VAX 3 "movab (r1)[r2],r3" is faster than "addl3 r1,r2,r3",
979    but it not faster on other models.
980
981    "movab #(r1),r2" is usually shorter than "addl3 #,r1,r2", and is
982    faster on a VAX 3, but some VAXen (e.g. VAX 9000) will stall if
983    a register is used in an address too soon after it is set.
984    Compromise by using movab only when it is shorter than the add
985    or the base register in the address is one of sp, ap, and fp,
986    which are not modified very often.  */
987
988 const char *
989 vax_output_int_add (rtx insn ATTRIBUTE_UNUSED, rtx *operands,
990                     enum machine_mode mode)
991 {
992   switch (mode)
993     {
994     case SImode:
995       if (rtx_equal_p (operands[0], operands[1]))
996         {
997           if (operands[2] == const1_rtx)
998             return "incl %0";
999           if (operands[2] == constm1_rtx)
1000             return "decl %0";
1001           if (GET_CODE (operands[2]) == CONST_INT
1002               && (unsigned) (- INTVAL (operands[2])) < 64)
1003             return "subl2 $%n2,%0";
1004           if (GET_CODE (operands[2]) == CONST_INT
1005               && (unsigned) INTVAL (operands[2]) >= 64
1006               && GET_CODE (operands[1]) == REG
1007               && ((INTVAL (operands[2]) < 32767 && INTVAL (operands[2]) > -32768)
1008                    || REGNO (operands[1]) > 11))
1009             return "movab %c2(%1),%0";
1010           return "addl2 %2,%0";
1011         }
1012
1013       if (rtx_equal_p (operands[0], operands[2]))
1014         return "addl2 %1,%0";
1015
1016       if (GET_CODE (operands[2]) == CONST_INT
1017           && INTVAL (operands[2]) < 32767
1018           && INTVAL (operands[2]) > -32768
1019           && GET_CODE (operands[1]) == REG
1020           && push_operand (operands[0], SImode))
1021         return "pushab %c2(%1)";
1022
1023       if (GET_CODE (operands[2]) == CONST_INT
1024           && (unsigned) (- INTVAL (operands[2])) < 64)
1025         return "subl3 $%n2,%1,%0";
1026
1027       if (GET_CODE (operands[2]) == CONST_INT
1028           && (unsigned) INTVAL (operands[2]) >= 64
1029           && GET_CODE (operands[1]) == REG
1030           && ((INTVAL (operands[2]) < 32767 && INTVAL (operands[2]) > -32768)
1031                || REGNO (operands[1]) > 11))
1032         return "movab %c2(%1),%0";
1033
1034       /* Add this if using gcc on a VAX 3xxx:
1035       if (REG_P (operands[1]) && REG_P (operands[2]))
1036         return "movab (%1)[%2],%0";
1037       */
1038       return "addl3 %1,%2,%0";
1039
1040     case HImode:
1041       if (rtx_equal_p (operands[0], operands[1]))
1042         {
1043           if (operands[2] == const1_rtx)
1044             return "incw %0";
1045           if (operands[2] == constm1_rtx)
1046             return "decw %0";
1047           if (GET_CODE (operands[2]) == CONST_INT
1048               && (unsigned) (- INTVAL (operands[2])) < 64)
1049             return "subw2 $%n2,%0";
1050           return "addw2 %2,%0";
1051         }
1052       if (rtx_equal_p (operands[0], operands[2]))
1053         return "addw2 %1,%0";
1054       if (GET_CODE (operands[2]) == CONST_INT
1055           && (unsigned) (- INTVAL (operands[2])) < 64)
1056         return "subw3 $%n2,%1,%0";
1057       return "addw3 %1,%2,%0";
1058
1059     case QImode:
1060       if (rtx_equal_p (operands[0], operands[1]))
1061         {
1062           if (operands[2] == const1_rtx)
1063             return "incb %0";
1064           if (operands[2] == constm1_rtx)
1065             return "decb %0";
1066           if (GET_CODE (operands[2]) == CONST_INT
1067               && (unsigned) (- INTVAL (operands[2])) < 64)
1068             return "subb2 $%n2,%0";
1069           return "addb2 %2,%0";
1070         }
1071       if (rtx_equal_p (operands[0], operands[2]))
1072         return "addb2 %1,%0";
1073       if (GET_CODE (operands[2]) == CONST_INT
1074           && (unsigned) (- INTVAL (operands[2])) < 64)
1075         return "subb3 $%n2,%1,%0";
1076       return "addb3 %1,%2,%0";
1077
1078     default:
1079       gcc_unreachable ();
1080     }
1081 }
1082
1083 /* Output a conditional branch.  */
1084 const char *
1085 vax_output_conditional_branch (enum rtx_code code)
1086 {
1087   switch (code)
1088     {
1089       case EQ:  return "jeql %l0";
1090       case NE:  return "jneq %l0";
1091       case GT:  return "jgtr %l0";
1092       case LT:  return "jlss %l0";
1093       case GTU: return "jgtru %l0";
1094       case LTU: return "jlssu %l0";
1095       case GE:  return "jgeq %l0";
1096       case LE:  return "jleq %l0";
1097       case GEU: return "jgequ %l0";
1098       case LEU: return "jlequ %l0";
1099       default:
1100         gcc_unreachable ();
1101     }
1102 }
1103
1104 /* 1 if X is an rtx for a constant that is a valid address.  */
1105
1106 int
1107 legitimate_constant_address_p (rtx x)
1108 {
1109   return (GET_CODE (x) == LABEL_REF || GET_CODE (x) == SYMBOL_REF
1110           || GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST
1111           || GET_CODE (x) == HIGH);
1112 }
1113
1114 /* Nonzero if the constant value X is a legitimate general operand.
1115    It is given that X satisfies CONSTANT_P or is a CONST_DOUBLE.  */
1116
1117 int
1118 legitimate_constant_p (rtx x ATTRIBUTE_UNUSED)
1119 {
1120   return 1;
1121 }
1122
1123 /* The other macros defined here are used only in legitimate_address_p ().  */
1124
1125 /* Nonzero if X is a hard reg that can be used as an index
1126    or, if not strict, if it is a pseudo reg.  */
1127 #define INDEX_REGISTER_P(X, STRICT) \
1128 (GET_CODE (X) == REG && (!(STRICT) || REGNO_OK_FOR_INDEX_P (REGNO (X))))
1129
1130 /* Nonzero if X is a hard reg that can be used as a base reg
1131    or, if not strict, if it is a pseudo reg.  */
1132 #define BASE_REGISTER_P(X, STRICT) \
1133 (GET_CODE (X) == REG && (!(STRICT) || REGNO_OK_FOR_BASE_P (REGNO (X))))
1134
1135 #ifdef NO_EXTERNAL_INDIRECT_ADDRESS
1136
1137 /* Re-definition of CONSTANT_ADDRESS_P, which is true only when there
1138    are no SYMBOL_REFs for external symbols present.  */
1139
1140 static int
1141 indirectable_constant_address_p (rtx x)
1142 {
1143   if (!CONSTANT_ADDRESS_P (x))
1144     return 0;
1145   if (GET_CODE (x) == CONST && GET_CODE (XEXP ((x), 0)) == PLUS)
1146     x = XEXP (XEXP (x, 0), 0);
1147   if (GET_CODE (x) == SYMBOL_REF && !SYMBOL_REF_LOCAL_P (x))
1148     return 0;
1149
1150   return 1;
1151 }
1152
1153 #else /* not NO_EXTERNAL_INDIRECT_ADDRESS */
1154
1155 static int
1156 indirectable_constant_address_p (rtx x)
1157 {
1158   return CONSTANT_ADDRESS_P (x);
1159 }
1160
1161 #endif /* not NO_EXTERNAL_INDIRECT_ADDRESS */
1162
1163 /* Nonzero if X is an address which can be indirected.  External symbols
1164    could be in a sharable image library, so we disallow those.  */
1165
1166 static int
1167 indirectable_address_p(rtx x, int strict)
1168 {
1169   if (indirectable_constant_address_p (x))
1170     return 1;
1171   if (BASE_REGISTER_P (x, strict))
1172     return 1;
1173   if (GET_CODE (x) == PLUS
1174       && BASE_REGISTER_P (XEXP (x, 0), strict)
1175       && indirectable_constant_address_p (XEXP (x, 1)))
1176     return 1;
1177   return 0;
1178 }
1179
1180 /* Return 1 if x is a valid address not using indexing.
1181    (This much is the easy part.)  */
1182 static int
1183 nonindexed_address_p (rtx x, int strict)
1184 {
1185   rtx xfoo0;
1186   if (GET_CODE (x) == REG)
1187     {
1188       extern rtx *reg_equiv_mem;
1189       if (! reload_in_progress
1190           || reg_equiv_mem[REGNO (x)] == 0
1191           || indirectable_address_p (reg_equiv_mem[REGNO (x)], strict))
1192         return 1;
1193     }
1194   if (indirectable_constant_address_p (x))
1195     return 1;
1196   if (indirectable_address_p (x, strict))
1197     return 1;
1198   xfoo0 = XEXP (x, 0);
1199   if (GET_CODE (x) == MEM && indirectable_address_p (xfoo0, strict))
1200     return 1;
1201   if ((GET_CODE (x) == PRE_DEC || GET_CODE (x) == POST_INC)
1202       && BASE_REGISTER_P (xfoo0, strict))
1203     return 1;
1204   return 0;
1205 }
1206
1207 /* 1 if PROD is either a reg times size of mode MODE and MODE is less
1208    than or equal 8 bytes, or just a reg if MODE is one byte.  */
1209
1210 static int
1211 index_term_p (rtx prod, enum machine_mode mode, int strict)
1212 {
1213   rtx xfoo0, xfoo1;
1214
1215   if (GET_MODE_SIZE (mode) == 1)
1216     return BASE_REGISTER_P (prod, strict);
1217
1218   if (GET_CODE (prod) != MULT || GET_MODE_SIZE (mode) > 8)
1219     return 0;
1220
1221   xfoo0 = XEXP (prod, 0);
1222   xfoo1 = XEXP (prod, 1);
1223
1224   if (GET_CODE (xfoo0) == CONST_INT
1225       && INTVAL (xfoo0) == (int)GET_MODE_SIZE (mode)
1226       && INDEX_REGISTER_P (xfoo1, strict))
1227     return 1;
1228
1229   if (GET_CODE (xfoo1) == CONST_INT
1230       && INTVAL (xfoo1) == (int)GET_MODE_SIZE (mode)
1231       && INDEX_REGISTER_P (xfoo0, strict))
1232     return 1;
1233
1234   return 0;
1235 }
1236
1237 /* Return 1 if X is the sum of a register
1238    and a valid index term for mode MODE.  */
1239 static int
1240 reg_plus_index_p (rtx x, enum machine_mode mode, int strict)
1241 {
1242   rtx xfoo0, xfoo1;
1243
1244   if (GET_CODE (x) != PLUS)
1245     return 0;
1246
1247   xfoo0 = XEXP (x, 0);
1248   xfoo1 = XEXP (x, 1);
1249
1250   if (BASE_REGISTER_P (xfoo0, strict) && index_term_p (xfoo1, mode, strict))
1251     return 1;
1252
1253   if (BASE_REGISTER_P (xfoo1, strict) && index_term_p (xfoo0, mode, strict))
1254     return 1;
1255
1256   return 0;
1257 }
1258
1259 /* legitimate_address_p returns 1 if it recognizes an RTL expression "x"
1260    that is a valid memory address for an instruction.
1261    The MODE argument is the machine mode for the MEM expression
1262    that wants to use this address.  */
1263 int
1264 legitimate_address_p (enum machine_mode mode, rtx x, int strict)
1265 {
1266   rtx xfoo0, xfoo1;
1267
1268   if (nonindexed_address_p (x, strict))
1269     return 1;
1270
1271   if (GET_CODE (x) != PLUS)
1272     return 0;
1273
1274   /* Handle <address>[index] represented with index-sum outermost */
1275
1276   xfoo0 = XEXP (x, 0);
1277   xfoo1 = XEXP (x, 1);
1278
1279   if (index_term_p (xfoo0, mode, strict)
1280       && nonindexed_address_p (xfoo1, strict))
1281     return 1;
1282
1283   if (index_term_p (xfoo1, mode, strict)
1284       && nonindexed_address_p (xfoo0, strict))
1285     return 1;
1286
1287   /* Handle offset(reg)[index] with offset added outermost */
1288
1289   if (indirectable_constant_address_p (xfoo0)
1290       && (BASE_REGISTER_P (xfoo1, strict)
1291           || reg_plus_index_p (xfoo1, mode, strict)))
1292     return 1;
1293
1294   if (indirectable_constant_address_p (xfoo1)
1295       && (BASE_REGISTER_P (xfoo0, strict)
1296           || reg_plus_index_p (xfoo0, mode, strict)))
1297     return 1;
1298
1299   return 0;
1300 }
1301
1302 /* Return 1 if x (a legitimate address expression) has an effect that
1303    depends on the machine mode it is used for.  On the VAX, the predecrement
1304    and postincrement address depend thus (the amount of decrement or
1305    increment being the length of the operand) and all indexed address depend
1306    thus (because the index scale factor is the length of the operand).  */
1307
1308 int
1309 vax_mode_dependent_address_p (rtx x)
1310 {
1311   rtx xfoo0, xfoo1;
1312
1313   if (GET_CODE (x) == POST_INC || GET_CODE (x) == PRE_DEC)
1314     return 1;
1315   if (GET_CODE (x) != PLUS)
1316     return 0;
1317
1318   xfoo0 = XEXP (x, 0);
1319   xfoo1 = XEXP (x, 1);
1320
1321   if (CONSTANT_ADDRESS_P (xfoo0) && GET_CODE (xfoo1) == REG)
1322     return 0;
1323   if (CONSTANT_ADDRESS_P (xfoo1) && GET_CODE (xfoo0) == REG)
1324     return 0;
1325
1326   return 1;
1327 }