ppctable.c

来自「开放源码的编译器open watcom 1.6.0版的源代码」· C语言 代码 · 共 410 行 · 第 1/2 页

/****************************************************************************
*
*                            Open Watcom Project
*
*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
*
*  ========================================================================
*
*    This file contains Original Code and/or Modifications of Original
*    Code as defined in and that are subject to the Sybase Open Watcom
*    Public License version 1.0 (the 'License'). You may not use this file
*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
*    provided with the Original Code and Modifications, and is also
*    available at www.sybase.com/developer/opensource.
*
*    The Original Code and all software distributed under the License are
*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
*    NON-INFRINGEMENT. Please see the License for the specific language
*    governing rights and limitations under the License.
*
*  ========================================================================
*
* Description:  Table translating generic cg "assembler" to PowerPC
*               specific instructions.
*
****************************************************************************/


#include "standard.h"
#include "coderep.h"
#include "pattern.h"
#include "regset.h"
#include "model.h"
#include "vergen.h"
#include "tables.h"
#include "funits.h"

opcode_entry    StubUnary[] = {
/*************************/
/*       op1   op2   res           verify          gen           reg      fu */
_Un(    ANY,  ANY,  NONE ),        V_NO,           G_NO,         RG_DWORD, FU_NO,
};


opcode_entry    StubBinary[] = {
/************************/
/*       op1   op2   res   eq      verify          gen           reg      fu */
_Bin(   ANY,  ANY,  ANY,  NONE ),  V_NO,           G_NO,         RG_DWORD, FU_NO,
};

opcode_entry    StubSide[] = {
/******************************/
/*       op1   op2                 verify          gen           reg      fu */
_Side(  ANY,  ANY ),               V_NO,           G_NO,         RG_DWORD, FU_NO,
};

#define LOAD_TABLE( name, reg ) \
static  opcode_entry    name[] = {                                                      \
/********************************/                                                      \
/*       op    res   eq          verify          gen             reg fu*/               \
_UnPP(  M,    R,    NONE ),     V_NO,           G_LOAD_ADDR,    RG_##reg,FU_ALU,                \
_Un(    M,    M,    NONE ),     V_NO,           R_MOVRESTEMP,   RG_##reg,FU_NO,         \
_Un(    M,    ANY,  NONE ),     V_NO,           G_UNKNOWN,      RG_##reg##_NEED,FU_NO,  \
_Un(    ANY,  ANY,  NONE ),     V_NO,           R_FORCEOP1MEM,  RG_##reg,FU_NO,         \
};

LOAD_TABLE( LoadAddr2, WORD );
LOAD_TABLE( LoadAddr8, QWORD );

static  opcode_entry    LoadAddr4[] = {
/*************************************/
/*       op    res   eq          verify          gen             reg fu*/
_Un(    M,    ANY,  NONE ),     V_OFFSETZERO,   R_MOVEINDEX,    RG_DWORD,FU_NO,
_UnPP(  M,    R,    NONE ),     V_NO,           G_LOAD_ADDR,    RG_DWORD,FU_ALU,
_Un(    M,    M,    NONE ),     V_NO,           R_MOVRESTEMP,   RG_DWORD,FU_NO,
_Un(    M,    ANY,  NONE ),     V_NO,           G_UNKNOWN,      RG_DWORD_NEED,FU_NO,
_Un(    ANY,  ANY,  NONE ),     V_NO,           R_FORCEOP1MEM,  RG_DWORD,FU_NO,
};

opcode_entry    Conv[] = {
/************************/
/*       op1   res  eq             verify          gen           reg      fu */
_Un(     ANY,  ANY, NONE ),        V_NO,           R_DOCVT,      RG_,     FU_NO,
};

opcode_entry    NegF[] = {
/************************/
/*       op1   res   eq            verify          gen           reg      fu */
_Un(    R,    R,    NONE ),        V_NO,           G_UNARY,      RG_FLOAT,FU_NO,
_Un(    C|M,  ANY,  NONE ),        V_NO,           R_MOVOP1TEMP, RG_FLOAT,FU_NO,
_Un(    ANY,  M,    NONE ),        V_NO,           R_MOVRESTEMP, RG_FLOAT,FU_NO,
_Un(    ANY,  ANY,  NONE ),        V_NO,           G_UNKNOWN,    RG_FLOAT_NEED, FU_NO,
};

opcode_entry    MoveXX[] = {
/**************************/
/*       op    res   eq            verify          gen           reg      fu*/
_Un(    ANY,  ANY,  NONE  ),       V_REG_SIZE,     R_CHANGETYPE, RG_,     FU_NO,
_Un(    M|U,  M|U,  EQ_R1 ),       NVI(V_NO),      G_NO,         RG_,     FU_NO,
_UnPP(  M,    M,    NONE  ),       NVI(V_SAME_LOCN),G_NO,        RG_,     FU_NO,
_Un(    U,    ANY,  NONE ),        V_NO,           R_FORCEOP1MEM,RG_,     FU_NO,
_Un(    ANY,  U,    NONE ),        V_NO,           R_FORCERESMEM,RG_,     FU_NO,
_Un(    ANY,  ANY,  NONE ),        V_OP1_RES_AL4,  R_MOVEXX_4,   RG_DWORD_NEED,FU_NO,
_Un(    ANY,  ANY,  NONE ),        V_NO,           R_MOVEXX,     RG_,     FU_NO,
};

#define MOVE_TABLE( t_name, reg, load, store ) \
opcode_entry    t_name[] = {                                                            \
/**************************/                                                            \
/*       op1   res   eq            verify          gen           reg      fu */         \
_Un(     ANY,  ANY,  EQ_R1 ),      NVI(V_NO),      G_NO,         RG_,     FU_NO,        \
_UnPP(   M,    M,    NONE  ),      NVI(V_SAME_LOCN),G_NO,         RG_,     FU_NO,       \
_Un(     R,    R,    NONE ),       V_NO,           G_MOVE,       RG_##reg,FU_NO,        \
_Un(     R,    M,    NONE ),       V_NO,           store,        RG_##reg,FU_MEM,       \
_Un(     C,    M,    NONE ),       V_NO,           R_MOVOP1TEMP, RG_##reg,FU_NO,        \
_Un(     M,    R,    NONE ),       V_NO,           load,         RG_##reg,FU_MEM,       \
_Un(     C,    R,    NONE ),       V_OP1HIGHADDR,  G_LEA_HIGH,   RG_##reg,FU_NO,        \
_Un(     C,    R,    NONE ),       V_HALFWORDCONST1,G_LEA,       RG_##reg,FU_NO,        \
_Un(     C,    R,    NONE ),       V_UHALFWORDCONST1,G_MOVE_UI,  RG_##reg,FU_NO,        \
_Un(     C,    R,    NONE ),       V_NO,           R_CONSTLOAD,  RG_##reg,FU_NO,        \
_Un(     M,    M,    NONE ),       V_NO,           R_MOVOP1TEMP, RG_,     FU_NO,        \
_Un(     ANY,  ANY,  NONE ),       V_NO,           G_UNKNOWN,    RG_##reg##_NEED,FU_NO, \
};

MOVE_TABLE( Move1, BYTE,  G_LOAD, G_STORE );
MOVE_TABLE( Move2, WORD,  G_LOAD, G_STORE );
MOVE_TABLE( Move4, DWORD, G_LOAD, G_STORE );

opcode_entry    Move8[] = {
/**************************/
/*       op1   res   eq            verify          gen           reg      fu */
_Un(     ANY,  ANY,  EQ_R1 ),      NVI(V_NO),      G_NO,         RG_,     FU_NO,
_UnPP(   M,    M,    NONE  ),      NVI(V_SAME_LOCN),G_NO,        RG_,     FU_NO,
_Un(     ANY,  ANY,  NONE ),       V_NO,           R_SPLITMOVE,  RG_,     FU_NO,
};

#define BINARY_TABLE( name, reg ) \
opcode_entry    name[] = {                                                              \
/***************************/                                                           \
/*       op1   op2   res   eq      verify          gen           reg      fu */         \
_Bin(    R,    R,    R,    NONE ), V_NO,           G_BINARY,     RG_##reg, FU_ALU,      \
_Bin(    R,    C,    R,    NONE ), V_HALFWORDCONST2,G_BINARY_IMM, RG_##reg, FU_ALU,     \
_Bin(    R,    C,    R,    NONE ), V_NO,           R_MOVOP2TEMP, RG_##reg, FU_NO,       \
_Bin(    C,    C,    R,    NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    C,    ANY,  R,    NONE ), V_SYMMETRIC,    R_SWAPOPS,    RG_##reg, FU_NO,       \
_Bin(    C,    ANY,  R,    NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    M,    ANY,  ANY,  NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  M,    ANY,  NONE ), V_NO,           R_MOVOP2TEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  ANY,  M,    NONE ), V_NO,           R_MOVRESTEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  ANY,  ANY,  NONE ), V_NO,           G_UNKNOWN,    RG_##reg##_NEED, FU_NO,\
};

BINARY_TABLE( Binary1, BYTE  );
BINARY_TABLE( Binary2, WORD  );
BINARY_TABLE( Binary4, DWORD );

#define U_BINARY_TABLE( name, reg ) \
opcode_entry    name[] = {                                                              \
/***************************/                                                           \
/*       op1   op2   res   eq      verify          gen           reg      fu */         \
_Bin(    R,    R,    R,    NONE ), V_NO,           G_BINARYS,    RG_##reg, FU_ALU,      \
_Bin(    R,    C,    R,    NONE ), V_UHALFWORDCONST2,G_BINARYS_IMM,RG_##reg, FU_ALU,    \
_Bin(    R,    C,    R,    NONE ), V_NO,           R_MOVOP2TEMP, RG_##reg, FU_NO,       \
_Bin(    C,    C,    R,    NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    C,    ANY,  R,    NONE ), V_SYMMETRIC,    R_SWAPOPS,    RG_##reg, FU_NO,       \
_Bin(    C,    ANY,  R,    NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    M,    ANY,  ANY,  NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  M,    ANY,  NONE ), V_NO,           R_MOVOP2TEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  ANY,  M,    NONE ), V_NO,           R_MOVRESTEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  ANY,  ANY,  NONE ), V_NO,           G_UNKNOWN,    RG_##reg##_NEED, FU_NO,\
};

U_BINARY_TABLE( UBinary1, BYTE  );
U_BINARY_TABLE( UBinary2, WORD  );
U_BINARY_TABLE( UBinary4, DWORD );

#define N_BINARY_TABLE( name, reg ) \
opcode_entry    name[] = {                                                              \
/***************************/                                                           \
/*       op1   op2   res   eq      verify          gen           reg      fu */         \
_Bin(    R,    R,    R,    NONE ), V_NO,           G_BINARY,     RG_##reg, FU_ALU,      \
_Bin(    R,    C,    R,    NONE ), V_NO,           R_MOVOP2TEMP, RG_##reg, FU_NO,       \
_Bin(    C,    C,    R,    NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    C,    ANY,  R,    NONE ), V_SYMMETRIC,    R_SWAPOPS,    RG_##reg, FU_NO,       \
_Bin(    C,    ANY,  R,    NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    M,    ANY,  ANY,  NONE ), V_NO,           R_MOVOP1TEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  M,    ANY,  NONE ), V_NO,           R_MOVOP2TEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  ANY,  M,    NONE ), V_NO,           R_MOVRESTEMP, RG_##reg, FU_NO,       \
_Bin(    ANY,  ANY,  ANY,  NONE ), V_NO,           G_UNKNOWN,    RG_##reg##_NEED, FU_NO,\
};

N_BINARY_TABLE( NBinary1, BYTE  );
N_BINARY_TABLE( NBinary2, WORD  );
N_BINARY_TABLE( NBinary4, DWORD );

static  opcode_entry    Binary8[] = {
/***********************************/
/*       op1   op2   res  eq      verify      gen           reg         fu*/
_Bin(   ANY,  ANY,  ANY, NONE ),  V_NO,       R_SPLITOP,    RG_QWORD,   FU_NO,
};