OSDN Git Service

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