Start development on 386BSD 0.0

[unix-history] / .ref-BSD-4_3_Net_2 / usr / src / usr.bin / gcc / cc1 / config / out-vax.c

/* Subroutines for insn-output.c for Vax.
  Copyright (C) 1987 Free Software Foundation, Inc.

This file is part of GNU CC.

GNU CC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.

GNU CC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING.  If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include <stdio.h>

/* This function allows any constant operand, even on VMS where some
  constants are not normally legitimate.  */

int
supergeneral_operand (x, mode)
    rtx x;
    enum machine_mode mode;
{
 return (CONSTANT_P (x) || general_operand (x, mode));
}

print_operand_address (file, addr)
    FILE *file;
    register rtx addr;
{
 register rtx reg1, reg2, breg, ireg;
 rtx offset;

retry:
 switch (GET_CODE (addr))
   {
   case MEM:
     fprintf (file, "*");
     addr = XEXP (addr, 0);
     goto retry;

   case REG:
     fprintf (file, "(%s)", reg_names[REGNO (addr)]);
     break;

   case PRE_DEC:
     fprintf (file, "-(%s)", reg_names[REGNO (XEXP (addr, 0))]);
     break;

   case POST_INC:
     fprintf (file, "(%s)+", reg_names[REGNO (XEXP (addr, 0))]);
     break;

   case PLUS:
     reg1 = 0; reg2 = 0;
     ireg = 0; breg = 0;
     offset = 0;
     if (CONSTANT_ADDRESS_P (XEXP (addr, 0))
         || GET_CODE (XEXP (addr, 0)) == MEM)
       {
         offset = XEXP (addr, 0);
         addr = XEXP (addr, 1);
       }
     else if (CONSTANT_ADDRESS_P (XEXP (addr, 1))
              || GET_CODE (XEXP (addr, 1)) == MEM)
       {
         offset = XEXP (addr, 1);
         addr = XEXP (addr, 0);
       }
     if (GET_CODE (addr) != PLUS)
       ;
     else if (GET_CODE (XEXP (addr, 0)) == MULT)
       {
         reg1 = XEXP (addr, 0);
         addr = XEXP (addr, 1);
       }
     else if (GET_CODE (XEXP (addr, 1)) == MULT)
       {
         reg1 = XEXP (addr, 1);
         addr = XEXP (addr, 0);
       }
     else if (GET_CODE (XEXP (addr, 0)) == REG)
       {
         reg1 = XEXP (addr, 0);
         addr = XEXP (addr, 1);
       }
     else if (GET_CODE (XEXP (addr, 1)) == REG)
       {
         reg1 = XEXP (addr, 1);
         addr = XEXP (addr, 0);
       }
     if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT)
       {
         if (reg1 == 0)
           reg1 = addr;
         else
           reg2 = addr;
         addr = 0;
       }
     if (offset != 0)
       {
         if (addr != 0) abort ();
         addr = offset;
       }
     if (reg1 != 0 && GET_CODE (reg1) == MULT)
       {
         breg = reg2;
         ireg = reg1;
       }
     else if (reg2 != 0 && GET_CODE (reg2) == MULT)
       {
         breg = reg1;
         ireg = reg2;
       }
     else if (reg2 != 0 || GET_CODE (addr) == MEM)
       {
         breg = reg2;
         ireg = reg1;
       }
     else
       {
         breg = reg1;
         ireg = reg2;
       }
     if (addr != 0)
       output_address (addr);
     if (breg != 0)
       {
         if (GET_CODE (breg) != REG)
           abort ();
         fprintf (file, "(%s)", reg_names[REGNO (breg)]);
       }
     if (ireg != 0)
       {
         if (GET_CODE (ireg) == MULT)
           ireg = XEXP (ireg, 0);
         if (GET_CODE (ireg) != REG)
           abort ();
         fprintf (file, "[%s]", reg_names[REGNO (ireg)]);
       }
     break;

   default:
     output_addr_const (file, addr);
   }
}