Menu
▾
▴
linux-vax-tools-commit
|
From: Dave A. <ai...@us...> - 2002-10-17 13:17:24
|
Update of /cvsroot/linux-vax/tools/src/gcc/config/vax
In directory usw-pr-cvs1:/tmp/cvs-serv8286/src/gcc/config/vax
Modified Files:
Tag: tools-linuxvax-dynamic-dev
vax.c vax.h
Log Message:
DA: no need for JUMP in vax.h linux.h has it already..
vax.c merge complete..
Index: vax.c
===================================================================
RCS file: /cvsroot/linux-vax/tools/src/gcc/config/vax/vax.c,v
retrieving revision 2.12.2.1
retrieving revision 2.12.2.2
diff -u -r2.12.2.1 -r2.12.2.2
--- vax.c 12 Oct 2002 11:41:55 -0000 2.12.2.1
+++ vax.c 17 Oct 2002 13:17:21 -0000 2.12.2.2
@@ -80,6 +80,22 @@
register rtx reg1, breg, ireg;
rtx offset;
rtx orig_addr = addr;
+
+#if 0
+ if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST)
+ debug_rtx (addr);
+#endif
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ if (flag_pic && GET_CODE (addr) == CONST &&
+ GET_CODE (XEXP (addr, 0)) == PLUS &&
+ GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF &&
+ !SYMBOL_REF_FLAG (XEXP (XEXP (addr, 0), 0)) &&
+ GET_CODE (XEXP (XEXP (addr, 0), 1)) == CONST_INT)
+ {
+ fatal_insn ("Non-PIC operand escaped:\n", addr);
+ }
+#endif
+
retry:
switch (GET_CODE (addr))
{
@@ -238,6 +254,16 @@
}
ireg = XEXP (addr, 1);
}
+ else if (GET_CODE (addr) == SYMBOL_REF)
+ {
+ output_addr_const (file, addr);
+ if (offset != 0)
+ {
+ fputc ('+', file);
+ output_address (offset);
+ offset = 0;
+ }
+ }
else
{
debug_rtx (orig_addr);
@@ -253,7 +279,12 @@
/* If REG1 is non-zero, figure out if it is a base or index register. */
if (reg1)
{
- if (breg != 0 || (offset && GET_CODE (offset) == MEM))
+ if (breg != 0
+ || GET_CODE (addr) == SYMBOL_REF
+ || (offset
+ && (GET_CODE (offset) == MEM
+ || GET_CODE (offset) == SYMBOL_REF
+ || GET_CODE (offset) == CONST)))
{
if (ireg)
{
@@ -709,6 +740,338 @@
}
return 0;
+}
+
+/* Nonzero if X is a hard reg that can be used as an index. */
+#define XREG_OK_FOR_INDEX_P(X, STRICT) (!(STRICT) || REGNO_OK_FOR_INDEX_P (REGNO (X)))
+/* Nonzero if X is a hard reg that can be used as a base reg. */
+#define XREG_OK_FOR_BASE_P(X, STRICT) (!(STRICT) || REGNO_OK_FOR_BASE_P (REGNO (X)))
+
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+
+/* Re-definition of CONSTANT_ADDRESS_P, which is true only when there
+ are no SYMBOL_REFs for external symbols present and allow valid
+ addressing modes. */
+
+#define INDIRECTABLE_CONSTANT_ADDRESS_P(X, INDEXED, INDIRECT) \
+ (GET_CODE (X) == LABEL_REF \
+ || (!INDEXED && GET_CODE (X) == SYMBOL_REF \
+ && (!INDIRECT || SYMBOL_REF_FLAG (X))) \
+ || (!INDEXED && GET_CODE (X) == CONST \
+ && GET_CODE (XEXP ((X), 0)) == PLUS \
+ && GET_CODE (XEXP (XEXP ((X), 0), 0)) == SYMBOL_REF \
+ && ((!INDIRECT && !flag_pic) \
+ || SYMBOL_REF_FLAG (XEXP (XEXP ((X), 0), 0)))) \
+ || GET_CODE (X) == CONST_INT)
+
+/* Non-zero if X is an address which can be indirected. External symbols
+ could be in a sharable image library, so we disallow those. */
+
+#define INDIRECTABLE_ADDRESS_P(X, STRICT, INDEXED, INDIRECT) \
+ (INDIRECTABLE_CONSTANT_ADDRESS_P (X, INDEXED, INDIRECT) \
+ || (GET_CODE (X) == REG && XREG_OK_FOR_BASE_P (X, STRICT)) \
+ || (GET_CODE (X) == PLUS \
+ && GET_CODE (XEXP (X, 0)) == REG \
+ && XREG_OK_FOR_BASE_P (XEXP (X, 0), STRICT) \
+ && GET_CODE (XEXP (X, 1)) != SYMBOL_REF \
+ && !(GET_CODE (XEXP (X, 1)) == CONST \
+ && GET_CODE (XEXP (XEXP (X, 1), 0)) == PLUS \
+ && GET_CODE (XEXP (XEXP (XEXP (X, 1), 0), 0)) == SYMBOL_REF) \
+ && INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (X, 1), INDEXED, INDIRECT)))
+
+#else /* not NO_EXTERNAL_INDIRECT_ADDRESS */
+
+#define INDIRECTABLE_CONSTANT_ADDRESS_P(X, INDEXED, INDIRECT) \
+ CONSTANT_ADDRESS_P (X)
+
+/* Non-zero if X is an address which can be indirected. */
+#define INDIRECTABLE_ADDRESS_P(X, STRICT, INDEXED, INDIRECT) \
+ (INDIRECTABLE_CONSTANT_ADDRESS_P (X, INDEXED, INDIRECT) \
+ || (GET_CODE (X) == REG && XREG_OK_FOR_BASE_P (X, STRICT)) \
+ || (GET_CODE (X) == PLUS \
+ && GET_CODE (XEXP (X, 0)) == REG \
+ && XREG_OK_FOR_BASE_P (XEXP (X, 0), STRICT) \
+ && CONSTANT_ADDRESS_P (XEXP (X, 1))))
+
+#endif /* not NO_EXTERNAL_INDIRECT_ADDRESS */
+
+/* Go to ADDR if X is a valid address not using indexing.
+ (This much is the easy part.) */
+#define GO_IF_NONINDEXED_ADDRESS(X, ADDR, STRICT, INDEXED) \
+{ register rtx xfoob = (X); \
+ if (GET_CODE (X) == REG) \
+ { \
+ extern rtx *reg_equiv_mem; \
+ if (! reload_in_progress) \
+ goto ADDR; \
+ if (!STRICT) \
+ { \
+ if ((xfoob = reg_equiv_mem[REGNO (xfoob)]) == 0) \
+ goto ADDR; \
+ } \
+ if (INDIRECTABLE_ADDRESS_P (xfoob, STRICT, INDEXED, 0)) \
+ goto ADDR; \
+ } \
+ if (INDIRECTABLE_CONSTANT_ADDRESS_P (X, INDEXED, 0)) goto ADDR; \
+ if (INDIRECTABLE_ADDRESS_P (X, STRICT, INDEXED, 0)) goto ADDR; \
+ xfoob = XEXP (X, 0); \
+ if (GET_CODE (X) == MEM \
+ && INDIRECTABLE_ADDRESS_P (xfoob, STRICT, INDEXED, !TARGET_INDIRECT)) \
+ goto ADDR; \
+ if ((GET_CODE (X) == PRE_DEC || GET_CODE (X) == POST_INC) \
+ && GET_CODE (xfoob) == REG \
+ && XREG_OK_FOR_BASE_P (xfoob, STRICT)) \
+ goto ADDR; }
+
+/* 1 if PROD is either a reg times size of mode MODE
+ or just a reg, if MODE is just one byte.
+ This macro's expansion uses the temporary variables xfoo0 and xfoo1
+ that must be declared in the surrounding context. */
+#define INDEX_TERM_P(PROD, MODE, STRICT) \
+(GET_MODE_SIZE (MODE) == 1 \
+ ? (GET_CODE (PROD) == REG && XREG_OK_FOR_BASE_P (PROD, STRICT)) \
+ : (GET_CODE (PROD) == MULT \
+ && \
+ (xfoo0 = XEXP (PROD, 0), xfoo1 = XEXP (PROD, 1), \
+ ((GET_CODE (xfoo0) == CONST_INT \
+ && GET_CODE (xfoo1) == REG \
+ && INTVAL (xfoo0) == (int)GET_MODE_SIZE (MODE) \
+ && XREG_OK_FOR_INDEX_P (xfoo1, STRICT)) \
+ || \
+ (GET_CODE (xfoo1) == CONST_INT \
+ && GET_CODE (xfoo0) == REG \
+ && INTVAL (xfoo1) == (int)GET_MODE_SIZE (MODE) \
+ && XREG_OK_FOR_INDEX_P (xfoo0, STRICT))))))
+
+/* Go to ADDR if X is the sum of a register
+ and a valid index term for mode MODE. */
+#define GO_IF_REG_PLUS_INDEX(X, MODE, ADDR, STRICT) \
+{ register rtx xfooa; \
+ if (GET_CODE (X) == PLUS) \
+ { if (GET_CODE (XEXP (X, 0)) == REG \
+ && XREG_OK_FOR_BASE_P (XEXP (X, 0), STRICT) \
+ && (xfooa = XEXP (X, 1), \
+ INDEX_TERM_P (xfooa, MODE, STRICT))) \
+ goto ADDR; \
+ if (GET_CODE (XEXP (X, 1)) == REG \
+ && XREG_OK_FOR_BASE_P (XEXP (X, 1), STRICT) \
+ && (xfooa = XEXP (X, 0), \
+ INDEX_TERM_P (xfooa, MODE, STRICT))) \
+ goto ADDR; } }
+
+int
+legitimate_pic_operand_p(x, strict)
+ register rtx x;
+ int strict ATTRIBUTE_UNUSED;
+{
+ if (GET_CODE (x) != SYMBOL_REF
+ && !(GET_CODE (x) == CONST
+ && GET_CODE (XEXP (x, 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF))
+ {
+ return 1;
+ }
+ return 0;
+}
+
+int
+legitimate_address_p(mode, xbar, strict)
+ enum machine_mode mode;
+ register rtx xbar;
+ int strict;
+{
+ register rtx xfoo, xfoo0, xfoo1;
+ int from = __LINE__;
+ GO_IF_NONINDEXED_ADDRESS (xbar, win, strict, 0);
+ if (GET_CODE (xbar) == PLUS)
+ {
+ /* Handle <address>[index] represented with index-sum outermost */
+ xfoo = XEXP (xbar, 0);
+ if (INDEX_TERM_P (xfoo, mode, strict))
+ {
+ from = __LINE__;
+ GO_IF_NONINDEXED_ADDRESS (XEXP (xbar, 1), win, strict, 0);
+ }
+ xfoo = XEXP (xbar, 1);
+ if (INDEX_TERM_P (xfoo, mode, strict))
+ {
+ from = __LINE__;
+ GO_IF_NONINDEXED_ADDRESS (XEXP (xbar, 0), win, strict, 0);
+ }
+ /* Handle offset(reg)[index] with offset added outermost */
+ if (INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (xbar, 0), 1, 0))
+ {
+ from = __LINE__;
+ if (GET_CODE (XEXP (xbar, 1)) == REG
+ && XREG_OK_FOR_BASE_P (XEXP (xbar, 1), strict))
+ goto win;
+ from = __LINE__;
+ GO_IF_REG_PLUS_INDEX (XEXP (xbar, 1), mode, win, strict);
+ }
+ if (INDIRECTABLE_CONSTANT_ADDRESS_P (XEXP (xbar, 1), 1, 0))
+ {
+ from = __LINE__;
+ if (GET_CODE (XEXP (xbar, 0)) == REG
+ && XREG_OK_FOR_BASE_P (XEXP (xbar, 0), strict))
+ goto win;
+ from = __LINE__;
+ GO_IF_REG_PLUS_INDEX (XEXP (xbar, 0), mode, win, strict);
+ }
+ }
+ return 0;
+
+ win:
+#if 0
+ if (strict)
+ {
+ fprintf(stderr, "line=%d\n", from);
+ debug_rtx (xbar);
+ }
+#endif
+ if (flag_pic && GET_CODE (xbar) == SYMBOL_REF
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && !SYMBOL_REF_FLAG (xbar)
+#endif
+ && mode == DImode)
+ return 0;
+ return 1;
+}
+
+int
+vax_symbolic_operand (op, mode)
+ register rtx op;
+ enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+ if (!general_operand(op, mode))
+ return 0;
+ if (GET_CODE (op) == SYMBOL_REF
+ || GET_CODE (op) == LABEL_REF
+ || (GET_CODE (op) == CONST
+ && GET_CODE (XEXP (op, 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && (SYMBOL_REF_FLAG (XEXP (XEXP (op, 0), 0)) || !flag_pic)
+#endif
+ && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
+ || (GET_CODE (op) == PLUS
+ && GET_CODE (XEXP (op, 1)) == SYMBOL_REF
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && (SYMBOL_REF_FLAG (XEXP (op, 1)) || !flag_pic)
+#endif
+ && GET_CODE (XEXP (op, 0)) == CONST_INT)
+ || (GET_CODE (op) == PLUS
+ && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && (SYMBOL_REF_FLAG (XEXP (op, 0)) || !flag_pic)
+#endif
+ && GET_CODE (XEXP (op, 1)) == CONST_INT))
+ {
+ return 1;
+ }
+ return 0;
+}
+
+int
+vax_nonsymbolic_operand (op, mode)
+ register rtx op;
+ enum machine_mode mode ATTRIBUTE_UNUSED;
+{
+ if (!general_operand(op, mode))
+ return 0;
+ if (GET_CODE (op) == SYMBOL_REF
+ || GET_CODE (op) == LABEL_REF
+ || (GET_CODE (op) == CONST
+ && GET_CODE (XEXP (op, 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF)
+ || (GET_CODE (op) == MEM
+ && GET_CODE (XEXP (op, 0)) == CONST
+ && GET_CODE (XEXP (XEXP (op, 0), 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (XEXP (op, 0), 0), 0)) == SYMBOL_REF)
+ || (GET_CODE (op) == PLUS
+ && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
+ && GET_CODE (XEXP (op, 1)) == CONST_INT))
+ return 0;
+#if 0
+ if (GET_CODE (op) == PLUS)
+ debug_rtx (op);
+#endif
+ if (vax_symbolic_operand (op, mode))
+ return 0;
+#if 0
+ if (GET_CODE (op) != CONST_INT && GET_CODE (op) != REG &&
+ GET_CODE (op) != MEM)
+ debug_rtx (op);
+#endif
+ return 1;
+}
+
+int
+vax_lvalue_operand(op, mode)
+ register rtx op;
+ enum machine_mode mode;
+{
+ if (!general_operand(op, mode))
+ return 0;
+ return GET_CODE (op) == REG
+ || GET_CODE (op) == SUBREG
+ || GET_CODE (op) == MEM
+ || GET_CODE (op) == CONCAT
+ || GET_CODE (op) == PARALLEL
+ || GET_CODE (op) == STRICT_LOW_PART;
+}
+
+int
+vax_general_operand(op, mode)
+ register rtx op;
+ enum machine_mode mode;
+{
+ if (!general_operand(op, mode))
+ return 0;
+ if (!flag_pic)
+ return 1;
+ if ((GET_CODE (op) == CONST
+ && GET_CODE (XEXP (op, 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && !SYMBOL_REF_FLAG (XEXP (XEXP (op, 0), 0))
+#endif
+ ) || (GET_CODE (op) == MEM
+ && GET_CODE (XEXP (op, 0)) == CONST
+ && GET_CODE (XEXP (XEXP (op, 0), 0)) == PLUS
+ && GET_CODE (XEXP (XEXP (XEXP (op, 0), 0), 0)) == SYMBOL_REF
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && !SYMBOL_REF_FLAG (XEXP (XEXP (op, 0), 0))
+#endif
+ ) || (GET_CODE (op) == PLUS
+ && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
+ && GET_CODE (XEXP (op, 1)) == CONST_INT
+#ifdef NO_EXTERNAL_INDIRECT_ADDRESS
+ && !SYMBOL_REF_FLAG (XEXP (op, 0))
+#endif
+ ))
+ return 0;
+#if 0
+ debug_rtx (op);
+#endif
+ return 1;
+}
+
+int
+vax_reg_used_p(operand, reg)
+ rtx operand;
+ int reg;
+{
+ if (GET_CODE (operand) == REG && REGNO (operand) == reg)
+ return 1;
+ if (GET_CODE (operand) == MEM ||
+ GET_CODE (operand) == PRE_DEC ||
+ GET_CODE (operand) == POST_DEC)
+ return vax_reg_used_p (XEXP(operand, 0), reg);
+ if (GET_CODE (operand) == PLUS ||
+ GET_CODE (operand) == MULT)
+ return vax_reg_used_p (XEXP(operand, 0), reg) ||
+ vax_reg_used_p (XEXP(operand, 1), reg);
+ return 0;
}
#ifdef VMS_TARGET
Index: vax.h
===================================================================
RCS file: /cvsroot/linux-vax/tools/src/gcc/config/vax/vax.h,v
retrieving revision 2.17.2.3
retrieving revision 2.17.2.4
diff -u -r2.17.2.3 -r2.17.2.4
--- vax.h 17 Oct 2002 12:50:00 -0000 2.17.2.3
+++ vax.h 17 Oct 2002 13:17:21 -0000 2.17.2.4
@@ -878,10 +878,6 @@
jumps to the default label instead. */
#define CASE_DROPS_THROUGH
-/* Indicate that jump tables go in the text section. This is
- necessary when compiling PIC code. */
-#define JUMP_TABLES_IN_TEXT_SECTION 1
-
/* Specify the tree operation to be used to convert reals to integers. */
#define IMPLICIT_FIX_EXPR FIX_ROUND_EXPR
|
×
Want the latest updates on software, tech news, and AI?
Get latest updates about software, tech news, and AI from SourceForge directly in your inbox once a month.
Thanks for helping keep SourceForge clean.
X