mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2024-11-27 03:51:15 +08:00
Code Issues Packages Projects Releases Wiki Activity
94ec3e76cb
binutils-gdb/gdb/doc/LRS
Jeff Law db0af6f771 New file describing how stabs for live range splitting work. Should be 
folded into the main stabs documentation.
1997-10-07 19:48:22 +00:00

532 lines
18 KiB
Plaintext
Raw Blame History

Return-Path: owner-egcs@cygnus.com Sun
Received: from cygnus.com (runyon.cygnus.com [205.180.230.5]) by hurl.cygnus.com with ESMTP (8.7.1/8.7.1) id RAA11988 for <law@hurl.cygnus.com>; Sun, 5 Oct 1997 17:27:27 -0600 (MDT)
Received: (from majordom@localhost)
by runyon.cygnus.com (8.8.7-cygnus/8.8.7) id QAA27817;
Sun, 5 Oct 1997 16:16:45 -0700 (PDT)
Received: from YALPH1.physics.yale.edu (hepvms1.physics.yale.edu [198.125.138.1])
by runyon.cygnus.com (8.8.7-cygnus/8.8.7) with ESMTP id QAA27802;
Sun, 5 Oct 1997 16:16:38 -0700 (PDT)
Received: from hepunix2.physics.yale.edu by hepmail.physics.yale.edu
(PMDF V5.1-8 #17719)
with ESMTP id <01IOGJ0WO510CFQE02@hepmail.physics.yale.edu>; Sun,
5 Oct 1997 19:20:08 EDT
Received: from hepunix1.physics.yale.edu by hepunix.physics.yale.edu
(PMDF V5.1-5 #17721) with SMTP id <0EHLPVM0N00788@hepunix.physics.yale.edu>;
Sun, 05 Oct 1997 19:14:13 -0400 (EDT)
Date: Sun, 05 Oct 1997 19:14:09 -0400 (EDT)
From: Weiwen Liu <liu@hepvms.physics.yale.edu>
Subject: Re: complex support on alpha
In-reply-to: <199710020532.WAA16123@dot.cygnus.com>
X-Sender: liu@hepunix1.physics.yale.edu
To: rth@cygnus.com
Cc: egcs@cygnus.com
Message-id: <Pine.OSF.3.96.971005190110.31383A-100000@hepunix1.physics.yale.edu>
MIME-version: 1.0
Content-type: TEXT/PLAIN; charset=US-ASCII
Sender: owner-egcs@cygnus.com
Precedence: bulk
On Wed, 1 Oct 1997, Richard Henderson wrote:
> Well, it is enough to compile those examples properly, but it is
> not completely correct. The problem is that complex numbers should
> be treated as two distinct arguments on Alpha, which affects padding
> of the arguments passed on the stack.
>
Here is a patch for it. It should be applied against egcs-970929.
Beside fixing complex-5.c in the testsuite, egcs with this patch generates
the same result from 'make check-gcc' as without it.
On an alpha-dec-osf4.0, this patch correctly compiles the following test
program with F=char, short, int, long, float, double:
#ifndef F
#define F float
#endif
typedef __complex__ F FC;
FC f1(int odd, FC a, FC b, FC c)
{
return a + b + c;
}
FC f2a(F a, F b, F c, F d, F e, F f, F g, F h)
{
return (a + c + e + g) + 1i * (b + d + f + h);
}
FC f2b(FC a, FC b, FC c, FC d)
{
return a + b + c + d;
}
int main()
{
FC a, b, c, d, e;
a = 1 + 2i;
b = 3+4i;
c = 5+6i;
d = 7+8i;
e = f1(1,a,b,c);
if (e != 9+12i)
abort ();
e=f2b(a,b,c,d);
if (e != 16+20i)
abort ();
e=f2a(1,2,3,4,5,6,7,8);
if (e != 16+20i)
abort ();
return 0;
}
This patch has only been tested on alpha-dec-osf4.0, because I have no
access to other machines. To support compless on other machines, the
machine-dependent tm.h has to be modified similarly to what is done for
alpha.h here.
Weiwen
Sun Oct 5 19:00:00 Weiwen Liu <liu@hepunix.phycis.yale.edu>
* c-tree.h: Define complex_long_integer_type_node
to support __complex__ long.
* c-decl.c (init_decl_processing): Initialize
complex_long_integer_type_node.
* c-lex.c (yylex): Enable __complex__ long.
* expr.h: Define COMPLEX_WORD_MODE and GET_COMPLEX_MODE_SIZE.
* emit-rtl.c (gen_lowpart_common, gen_highpart,
operand_subword): Use them.
* expr.c (move_block_to_reg, emit_push_insn): Use them.
* emit-rtl.c (operand_subword): Deal with a complex mode.
* regs.h: Correctly calculate REG_SIZE for a complex mode.
* config/alpha/alpha.h: Correctly deal with a complex mode in
HARD_REGNO_NREGS, FUNCTION_VALUE, ALPHA_ARG_SIZE.
*** gcc/c-decl.c.orig Sat Sep 27 14:16:06 1997
--- gcc/c-decl.c Wed Oct 1 16:19:39 1997
*************** tree double_type_node;
*** 135,140 ****
--- 135,141 ----
tree long_double_type_node;
tree complex_integer_type_node;
+ tree complex_long_integer_type_node;
tree complex_float_type_node;
tree complex_double_type_node;
tree complex_long_double_type_node;
*************** init_decl_processing ()
*** 2989,2994 ****
--- 2990,3001 ----
complex_integer_type_node));
TREE_TYPE (complex_integer_type_node) = integer_type_node;
layout_type (complex_integer_type_node);
+
+ complex_long_integer_type_node = make_node (COMPLEX_TYPE);
+ pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long int"),
+ complex_long_integer_type_node));
+ TREE_TYPE (complex_long_integer_type_node) = long_integer_type_node;
+ layout_type (complex_long_integer_type_node);
complex_float_type_node = make_node (COMPLEX_TYPE);
pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),
*** gcc/c-lex.c.orig Fri Aug 15 01:32:53 1997
--- gcc/c-lex.c Wed Oct 1 16:19:39 1997
*************** yylex ()
*** 1769,1774 ****
--- 1769,1780 ----
= build_complex (NULL_TREE, integer_zero_node,
convert (integer_type_node,
yylval.ttype));
+ else if (TYPE_PRECISION (type)
+ <= TYPE_PRECISION (long_integer_type_node))
+ yylval.ttype
+ = build_complex (NULL_TREE, integer_zero_node,
+ convert (long_integer_type_node,
+ yylval.ttype));
else
error ("complex integer constant is too wide for `complex int'");
}
*** gcc/c-tree.h.orig Mon Aug 11 11:57:03 1997
--- gcc/c-tree.h Wed Oct 1 16:19:40 1997
*************** extern tree long_long_integer_type_node;
*** 219,224 ****
--- 219,225 ----
extern tree long_long_unsigned_type_node;
extern tree long_unsigned_type_node;
extern tree complex_integer_type_node;
+ extern tree complex_long_integer_type_node;
extern tree complex_float_type_node;
extern tree complex_double_type_node;
extern tree complex_long_double_type_node;
*** gcc/emit-rtl.c.orig Mon Sep 22 13:41:24 1997
--- gcc/emit-rtl.c Sun Oct 5 17:48:05 1997
*************** gen_lowpart_common (mode, x)
*** 635,644 ****
/ UNITS_PER_WORD)))
return 0;
! if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
! word = ((GET_MODE_SIZE (GET_MODE (x))
! - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
! / UNITS_PER_WORD);
if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
&& (GET_MODE_CLASS (mode) == MODE_INT
--- 635,644 ----
/ UNITS_PER_WORD)))
return 0;
! if (WORDS_BIG_ENDIAN && GET_MODE_SIZE (GET_MODE (x)) >0)
! word = GET_COMPLEX_MODE_SIZE (GET_MODE (x))
! - ((GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1))
! / UNITS_PER_WORD);
if ((GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
&& (GET_MODE_CLASS (mode) == MODE_INT
*************** gen_highpart (mode, x)
*** 1013,1022 ****
int word = 0;
if (! WORDS_BIG_ENDIAN
! && GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
! word = ((GET_MODE_SIZE (GET_MODE (x))
! - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD))
! / UNITS_PER_WORD);
/*
* ??? This fails miserably for complex values being passed in registers
--- 1013,1022 ----
int word = 0;
if (! WORDS_BIG_ENDIAN
! && GET_MODE_SIZE (GET_MODE (x)) > 0)
! word = GET_COMPLEX_MODE_SIZE (GET_MODE (x))
! - ((GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1))
! / UNITS_PER_WORD);
/*
* ??? This fails miserably for complex values being passed in registers
*************** operand_subword (op, i, validate_address
*** 1100,1105 ****
--- 1100,1107 ----
/* If OP is narrower than a word or if we want a word outside OP, fail. */
if (mode != BLKmode
+ && (GET_MODE_CLASS (mode) != MODE_COMPLEX_INT
+ && GET_MODE_CLASS (mode) != MODE_COMPLEX_FLOAT)
&& (GET_MODE_SIZE (mode) < UNITS_PER_WORD
|| (i + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode)))
return 0;
*************** operand_subword (op, i, validate_address
*** 1127,1133 ****
|| op == arg_pointer_rtx
#endif
|| op == stack_pointer_rtx)
! return gen_rtx (SUBREG, word_mode, op, i);
else
return gen_rtx (REG, word_mode, REGNO (op) + i);
}
--- 1129,1135 ----
|| op == arg_pointer_rtx
#endif
|| op == stack_pointer_rtx)
! return gen_rtx (SUBREG, COMPLEX_WORD_MODE (mode), op, i);
else
return gen_rtx (REG, word_mode, REGNO (op) + i);
}
*************** operand_subword (op, i, validate_address
*** 1135,1141 ****
return gen_rtx (SUBREG, word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
else if (GET_CODE (op) == CONCAT)
{
! int partwords = GET_MODE_UNIT_SIZE (GET_MODE (op)) / UNITS_PER_WORD;
if (i < partwords)
return operand_subword (XEXP (op, 0), i, validate_address, mode);
return operand_subword (XEXP (op, 1), i - partwords,
--- 1137,1144 ----
return gen_rtx (SUBREG, word_mode, SUBREG_REG (op), i + SUBREG_WORD (op));
else if (GET_CODE (op) == CONCAT)
{
! int partwords = (GET_MODE_UNIT_SIZE (GET_MODE (op))
! + (UNITS_PER_WORD - 1))/ UNITS_PER_WORD;
if (i < partwords)
return operand_subword (XEXP (op, 0), i, validate_address, mode);
return operand_subword (XEXP (op, 1), i - partwords,
*************** operand_subword (op, i, validate_address
*** 1145,1151 ****
/* Form a new MEM at the requested address. */
if (GET_CODE (op) == MEM)
{
! rtx addr = plus_constant (XEXP (op, 0), i * UNITS_PER_WORD);
rtx new;
if (validate_address)
--- 1148,1158 ----
/* Form a new MEM at the requested address. */
if (GET_CODE (op) == MEM)
{
! rtx addr = plus_constant (
! XEXP (op, 0),
! (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
! || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)?
! i*GET_MODE_UNIT_SIZE (mode): i * UNITS_PER_WORD);
rtx new;
if (validate_address)
*************** operand_subword (op, i, validate_address
*** 1159,1165 ****
addr = memory_address (word_mode, addr);
}
! new = gen_rtx (MEM, word_mode, addr);
MEM_VOLATILE_P (new) = MEM_VOLATILE_P (op);
MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (op);
--- 1166,1172 ----
addr = memory_address (word_mode, addr);
}
! new = gen_rtx (MEM, COMPLEX_WORD_MODE (mode), addr);
MEM_VOLATILE_P (new) = MEM_VOLATILE_P (op);
MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (op);
*** gcc/expr.c.orig Sat Oct 4 03:12:35 1997
--- gcc/expr.c Sun Oct 5 18:21:18 1997
*************** move_block_to_reg (regno, x, nregs, mode
*** 1701,1707 ****
#endif
for (i = 0; i < nregs; i++)
! emit_move_insn (gen_rtx (REG, word_mode, regno + i),
operand_subword_force (x, i, mode));
}
--- 1701,1707 ----
#endif
for (i = 0; i < nregs; i++)
! emit_move_insn (gen_rtx (REG, COMPLEX_WORD_MODE (mode), regno + i),
operand_subword_force (x, i, mode));
}
*************** move_block_from_reg (regno, x, nregs, si
*** 1724,1729 ****
--- 1724,1731 ----
/* If SIZE is that of a mode no bigger than a word, just use that
mode's store operation. */
if (size <= UNITS_PER_WORD
+ && GET_MODE_CLASS (GET_MODE (x)) != MODE_COMPLEX_INT
+ && GET_MODE_CLASS (GET_MODE (x)) != MODE_COMPLEX_FLOAT
&& (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode)
{
emit_move_insn (change_address (x, mode, NULL),
*************** move_block_from_reg (regno, x, nregs, si
*** 1769,1780 ****
for (i = 0; i < nregs; i++)
{
! rtx tem = operand_subword (x, i, 1, BLKmode);
if (tem == 0)
abort ();
! emit_move_insn (tem, gen_rtx (REG, word_mode, regno + i));
}
}
--- 1771,1786 ----
for (i = 0; i < nregs; i++)
{
! rtx tem = operand_subword
! (x, i, 1, (GET_MODE_CLASS(GET_MODE (x)) == MODE_COMPLEX_INT
! || GET_MODE_CLASS(GET_MODE (x)) == MODE_COMPLEX_FLOAT)?
! GET_MODE(x):BLKmode);
if (tem == 0)
abort ();
! emit_move_insn (tem, gen_rtx (REG, COMPLEX_WORD_MODE (GET_MODE (x)),
! regno + i));
}
}
*************** emit_push_insn (x, mode, type, size, ali
*** 2687,2693 ****
{
/* Scalar partly in registers. */
! int size = GET_MODE_SIZE (mode) / UNITS_PER_WORD;
int i;
int not_stack;
/* # words of start of argument
--- 2693,2699 ----
{
/* Scalar partly in registers. */
! int size = GET_COMPLEX_MODE_SIZE (mode);
int i;
int not_stack;
/* # words of start of argument
*************** emit_push_insn (x, mode, type, size, ali
*** 2696,2701 ****
--- 2702,2716 ----
int args_offset = INTVAL (args_so_far);
int skip;
+ /* For a complex argument passing partially in a register,
+ save the image part in stack immedially following the space
+ used for save the part passig in register (see function
+ assign_parms in function.c). */
+ if (GET_MODE_CLASS (mode) == MODE_COMPLEX_INT
+ || GET_MODE_CLASS (mode) == MODE_COMPLEX_FLOAT)
+ if (GET_MODE_UNIT_SIZE (mode) < UNITS_PER_WORD)
+ args_offset += GET_MODE_UNIT_SIZE (mode) - UNITS_PER_WORD;
+
/* Push padding now if padding above and stack grows down,
or if padding below and stack grows up.
But if space already allocated, this has already been done. */
*************** emit_push_insn (x, mode, type, size, ali
*** 2742,2748 ****
#endif
if (i >= not_stack + offset)
emit_push_insn (operand_subword_force (x, i, mode),
! word_mode, NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
0, args_addr,
GEN_INT (args_offset + ((i - not_stack + skip)
* UNITS_PER_WORD)));
--- 2757,2764 ----
#endif
if (i >= not_stack + offset)
emit_push_insn (operand_subword_force (x, i, mode),
! COMPLEX_WORD_MODE (mode),
! NULL_TREE, NULL_RTX, align, 0, NULL_RTX,
0, args_addr,
GEN_INT (args_offset + ((i - not_stack + skip)
* UNITS_PER_WORD)));
*** gcc/expr.h.orig Sat Oct 4 23:46:34 1997
--- gcc/expr.h Sun Oct 5 18:21:14 1997
*************** extern void bc_adjust_stack PROTO ((in
*** 952,954 ****
--- 952,970 ----
extern void bc_load_localaddr PROTO ((rtx));
extern void do_jump_by_parts_greater_rtx PROTO ((enum machine_mode, int,
rtx, rtx, rtx, rtx));
+
+ /* Determine the mode for the imagine and real part of a complex MODE.
+ For a non-complex MODE, use WORD_MODE.*/
+ #define COMPLEX_WORD_MODE(MODE) \
+ (((GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT \
+ || GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) \
+ && GET_MODE_UNIT_SIZE (MODE) < UNITS_PER_WORD)? \
+ mode_for_size (GET_MODE_UNIT_SIZE(MODE)*BITS_PER_UNIT, \
+ (GET_MODE_CLASS (MODE) == MODE_COMPLEX_INT)? \
+ MODE_INT:MODE_FLOAT, \
+ 0):word_mode)
+
+ /* Calculate number of bytes needed for a complex MODE */
+ #define GET_COMPLEX_MODE_SIZE(MODE) \
+ (((GET_MODE_UNIT_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD) \
+ * (GET_MODE_SIZE (MODE)) / GET_MODE_UNIT_SIZE (MODE))
*** gcc/regs.h.orig Mon Aug 11 11:57:12 1997
--- gcc/regs.h Wed Oct 1 16:19:31 1997
*************** Boston, MA 02111-1307, USA. */
*** 27,33 ****
valid way to get this value. You cannot get it from the regno. */
#define REG_SIZE(R) \
! ((mode_size[(int) GET_MODE (R)] + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
/* Maximum register number used in this function, plus one. */
--- 27,36 ----
valid way to get this value. You cannot get it from the regno. */
#define REG_SIZE(R) \
! (GET_MODE_SIZE (GET_MODE (R)) == 0? \
! 0:(((GET_MODE_UNIT_SIZE (GET_MODE (R)) + (UNITS_PER_WORD - 1)) \
! / UNITS_PER_WORD) * (GET_MODE_SIZE (GET_MODE (R)) \
! / GET_MODE_UNIT_SIZE (GET_MODE (R)))))
/* Maximum register number used in this function, plus one. */
*** gcc/config/alpha/alpha.h.orig Wed Oct 1 16:16:31 1997
--- gcc/config/alpha/alpha.h Fri Oct 3 11:41:58 1997
*************** extern void override_options ();
*** 515,521 ****
but can be less for certain modes in special long registers. */
#define HARD_REGNO_NREGS(REGNO, MODE) \
! ((GET_MODE_SIZE (MODE) + UNITS_PER_WORD - 1) / UNITS_PER_WORD)
/* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
On Alpha, the integer registers can hold any mode. The floating-point
--- 515,524 ----
but can be less for certain modes in special long registers. */
#define HARD_REGNO_NREGS(REGNO, MODE) \
! (GET_MODE_SIZE (MODE) == 0? \
! 0:(((GET_MODE_UNIT_SIZE (MODE) + (UNITS_PER_WORD - 1)) \
! / UNITS_PER_WORD) * (GET_MODE_SIZE (MODE) \
! / GET_MODE_UNIT_SIZE (MODE))))
/* Value is 1 if hard register REGNO can hold a value of machine-mode MODE.
On Alpha, the integer registers can hold any mode. The floating-point
*************** enum reg_class { NO_REGS, GENERAL_REGS,
*** 891,901 ****
#define FUNCTION_VALUE(VALTYPE, FUNC) \
gen_rtx (REG, \
(INTEGRAL_MODE_P (TYPE_MODE (VALTYPE)) \
&& TYPE_PRECISION (VALTYPE) < BITS_PER_WORD) \
? word_mode : TYPE_MODE (VALTYPE), \
((TARGET_FPREGS \
&& (TREE_CODE (VALTYPE) == REAL_TYPE \
! || TREE_CODE (VALTYPE) == COMPLEX_TYPE)) \
? 32 : 0))
/* Define how to find the value returned by a library function
--- 894,908 ----
#define FUNCTION_VALUE(VALTYPE, FUNC) \
gen_rtx (REG, \
(INTEGRAL_MODE_P (TYPE_MODE (VALTYPE)) \
+ && (GET_MODE_CLASS(TYPE_MODE (VALTYPE)) \
+ != MODE_COMPLEX_INT) \
&& TYPE_PRECISION (VALTYPE) < BITS_PER_WORD) \
? word_mode : TYPE_MODE (VALTYPE), \
((TARGET_FPREGS \
&& (TREE_CODE (VALTYPE) == REAL_TYPE \
! || TREE_CODE (VALTYPE) == COMPLEX_TYPE) \
! && (GET_MODE_CLASS(TYPE_MODE (VALTYPE)) \
! != MODE_COMPLEX_INT)) \
? 32 : 0))
/* Define how to find the value returned by a library function
*************** enum reg_class { NO_REGS, GENERAL_REGS,
*** 953,959 ****
#define ALPHA_ARG_SIZE(MODE, TYPE, NAMED) \
((MODE) != BLKmode \
! ? (GET_MODE_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \
: (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
/* Update the data in CUM to advance over an argument
--- 960,969 ----
#define ALPHA_ARG_SIZE(MODE, TYPE, NAMED) \
((MODE) != BLKmode \
! ? (GET_MODE_SIZE (MODE) > 0? \
! (GET_MODE_UNIT_SIZE (MODE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD \
! * GET_MODE_SIZE (MODE) / GET_MODE_UNIT_SIZE (MODE) \
! : 0) \
: (int_size_in_bytes (TYPE) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
/* Update the data in CUM to advance over an argument
Reference in New Issue View Git Blame Copy Permalink