espressif/binutils-gdb
1
0
Fork 0
mirror of https://github.com/espressif/binutils-gdb.git synced 2025-06-06 07:28:44 +08:00
Code Issues Packages Projects Releases Wiki Activity

* valarith.c: Update copyright notice.

Browse Source 
(value_add): Handle range types.
(value_sub): Ditto.
(value_equal): Ditto.
(value_less): Ditto.
(value_neg): Ditto.
(value_complement): Ditto.
(value_binop): Simplify slightly by using is_integral_type and
eliminiating unnecessary COERCE_ENUMs.
This commit is contained in:
Paul N. Hilfinger
2004-04-01 12:08:30 +00:00
parent e489d0aef7
commit 2de41bce0f
2 changed files with 43 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
gdb/ChangeLog
View File

@ -1,3 +1,15 @@
2004-04-01 Paul N. Hilfinger <Hilfinger@gnat.com>
* valarith.c: Update copyright notice.
(value_add): Handle range types.
(value_sub): Ditto.
(value_equal): Ditto.
(value_less): Ditto.
(value_neg): Ditto.
(value_complement): Ditto.
(value_binop): Simplify slightly by using is_integral_type and
eliminiating unnecessary COERCE_ENUMs.
2004-03-31 Andrew Cagney <cagney@redhat.com> 2004-03-31 Andrew Cagney <cagney@redhat.com>
* frame.h (frame_unwind_id): Declare. * frame.h (frame_unwind_id): Declare.

73
gdb/valarith.c
View File

@ -1,7 +1,7 @@
/* Perform arithmetic and other operations on values, for GDB. /* Perform arithmetic and other operations on values, for GDB.
Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
Foundation, Inc. Foundation, Inc.
This file is part of GDB. This file is part of GDB.
@ -91,16 +91,15 @@ value_add (struct value *arg1, struct value *arg2)
LONGEST sz; LONGEST sz;
struct type *type1, *type2, *valptrtype; struct type *type1, *type2, *valptrtype;
COERCE_NUMBER (arg1); COERCE_ARRAY (arg1);
COERCE_NUMBER (arg2); COERCE_ARRAY (arg2);
type1 = check_typedef (VALUE_TYPE (arg1)); type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2)); type2 = check_typedef (VALUE_TYPE (arg2));
if ((TYPE_CODE (type1) == TYPE_CODE_PTR if ((TYPE_CODE (type1) == TYPE_CODE_PTR
|| TYPE_CODE (type2) == TYPE_CODE_PTR) || TYPE_CODE (type2) == TYPE_CODE_PTR)
&& &&
(TYPE_CODE (type1) == TYPE_CODE_INT (is_integral_type (type1) || is_integral_type (type2)))
|| TYPE_CODE (type2) == TYPE_CODE_INT))
/* Exactly one argument is a pointer, and one is an integer. */ /* Exactly one argument is a pointer, and one is an integer. */
{ {
struct value *retval; struct value *retval;
@ -134,14 +133,14 @@ struct value *
value_sub (struct value *arg1, struct value *arg2) value_sub (struct value *arg1, struct value *arg2)
{ {
struct type *type1, *type2; struct type *type1, *type2;
COERCE_NUMBER (arg1); COERCE_ARRAY (arg1);
COERCE_NUMBER (arg2); COERCE_ARRAY (arg2);
type1 = check_typedef (VALUE_TYPE (arg1)); type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2)); type2 = check_typedef (VALUE_TYPE (arg2));
if (TYPE_CODE (type1) == TYPE_CODE_PTR) if (TYPE_CODE (type1) == TYPE_CODE_PTR)
{ {
if (TYPE_CODE (type2) == TYPE_CODE_INT) if (is_integral_type (type2))
{ {
/* pointer - integer. */ /* pointer - integer. */
LONGEST sz = find_size_for_pointer_math (type1); LONGEST sz = find_size_for_pointer_math (type1);
@ -752,22 +751,12 @@ value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op)
COERCE_REF (arg1); COERCE_REF (arg1);
COERCE_REF (arg2); COERCE_REF (arg2);
COERCE_ENUM (arg1);
COERCE_ENUM (arg2);
type1 = check_typedef (VALUE_TYPE (arg1)); type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2)); type2 = check_typedef (VALUE_TYPE (arg2));
if ((TYPE_CODE (type1) != TYPE_CODE_FLT if ((TYPE_CODE (type1) != TYPE_CODE_FLT && !is_integral_type (type1))
&& TYPE_CODE (type1) != TYPE_CODE_CHAR
&& TYPE_CODE (type1) != TYPE_CODE_INT
&& TYPE_CODE (type1) != TYPE_CODE_BOOL
&& TYPE_CODE (type1) != TYPE_CODE_RANGE)
|| ||
(TYPE_CODE (type2) != TYPE_CODE_FLT (TYPE_CODE (type2) != TYPE_CODE_FLT && !is_integral_type (type2)))
&& TYPE_CODE (type2) != TYPE_CODE_CHAR
&& TYPE_CODE (type2) != TYPE_CODE_INT
&& TYPE_CODE (type2) != TYPE_CODE_BOOL
&& TYPE_CODE (type2) != TYPE_CODE_RANGE))
error ("Argument to arithmetic operation not a number or boolean."); error ("Argument to arithmetic operation not a number or boolean.");
if (TYPE_CODE (type1) == TYPE_CODE_FLT if (TYPE_CODE (type1) == TYPE_CODE_FLT
@ -1221,28 +1210,30 @@ value_equal (struct value *arg1, struct value *arg2)
struct type *type1, *type2; struct type *type1, *type2;
enum type_code code1; enum type_code code1;
enum type_code code2; enum type_code code2;
int is_int1, is_int2;
COERCE_NUMBER (arg1); COERCE_ARRAY (arg1);
COERCE_NUMBER (arg2); COERCE_ARRAY (arg2);
type1 = check_typedef (VALUE_TYPE (arg1)); type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2)); type2 = check_typedef (VALUE_TYPE (arg2));
code1 = TYPE_CODE (type1); code1 = TYPE_CODE (type1);
code2 = TYPE_CODE (type2); code2 = TYPE_CODE (type2);
is_int1 = is_integral_type (type1);
is_int2 = is_integral_type (type2);
if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) && if (is_int1 && is_int2)
(code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return longest_to_int (value_as_long (value_binop (arg1, arg2, return longest_to_int (value_as_long (value_binop (arg1, arg2,
BINOP_EQUAL))); BINOP_EQUAL)));
else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) else if ((code1 == TYPE_CODE_FLT || is_int1)
&& (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL)) && (code2 == TYPE_CODE_FLT || is_int2))
return value_as_double (arg1) == value_as_double (arg2); return value_as_double (arg1) == value_as_double (arg2);
/* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
is bigger. */ is bigger. */
else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL)) else if (code1 == TYPE_CODE_PTR && is_int2)
return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2); return value_as_address (arg1) == (CORE_ADDR) value_as_long (arg2);
else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)) else if (code2 == TYPE_CODE_PTR && is_int1)
return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2); return (CORE_ADDR) value_as_long (arg1) == value_as_address (arg2);
else if (code1 == code2 else if (code1 == code2
@ -1278,30 +1269,32 @@ value_less (struct value *arg1, struct value *arg2)
enum type_code code1; enum type_code code1;
enum type_code code2; enum type_code code2;
struct type *type1, *type2; struct type *type1, *type2;
int is_int1, is_int2;
COERCE_NUMBER (arg1); COERCE_ARRAY (arg1);
COERCE_NUMBER (arg2); COERCE_ARRAY (arg2);
type1 = check_typedef (VALUE_TYPE (arg1)); type1 = check_typedef (VALUE_TYPE (arg1));
type2 = check_typedef (VALUE_TYPE (arg2)); type2 = check_typedef (VALUE_TYPE (arg2));
code1 = TYPE_CODE (type1); code1 = TYPE_CODE (type1);
code2 = TYPE_CODE (type2); code2 = TYPE_CODE (type2);
is_int1 = is_integral_type (type1);
is_int2 = is_integral_type (type2);
if ((code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) && if (is_int1 && is_int2)
(code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL))
return longest_to_int (value_as_long (value_binop (arg1, arg2, return longest_to_int (value_as_long (value_binop (arg1, arg2,
BINOP_LESS))); BINOP_LESS)));
else if ((code1 == TYPE_CODE_FLT || code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL) else if ((code1 == TYPE_CODE_FLT || is_int1)
&& (code2 == TYPE_CODE_FLT || code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL)) && (code2 == TYPE_CODE_FLT || is_int2))
return value_as_double (arg1) < value_as_double (arg2); return value_as_double (arg1) < value_as_double (arg2);
else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR) else if (code1 == TYPE_CODE_PTR && code2 == TYPE_CODE_PTR)
return value_as_address (arg1) < value_as_address (arg2); return value_as_address (arg1) < value_as_address (arg2);
/* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever /* FIXME: Need to promote to either CORE_ADDR or LONGEST, whichever
is bigger. */ is bigger. */
else if (code1 == TYPE_CODE_PTR && (code2 == TYPE_CODE_INT || code2 == TYPE_CODE_BOOL)) else if (code1 == TYPE_CODE_PTR && is_int2)
return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2); return value_as_address (arg1) < (CORE_ADDR) value_as_long (arg2);
else if (code2 == TYPE_CODE_PTR && (code1 == TYPE_CODE_INT || code1 == TYPE_CODE_BOOL)) else if (code2 == TYPE_CODE_PTR && is_int1)
return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2); return (CORE_ADDR) value_as_long (arg1) < value_as_address (arg2);
else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING) else if (code1 == TYPE_CODE_STRING && code2 == TYPE_CODE_STRING)
return value_strcmp (arg1, arg2) < 0; return value_strcmp (arg1, arg2) < 0;
@ -1321,13 +1314,12 @@ value_neg (struct value *arg1)
struct type *result_type = VALUE_TYPE (arg1); struct type *result_type = VALUE_TYPE (arg1);
COERCE_REF (arg1); COERCE_REF (arg1);
COERCE_ENUM (arg1);
type = check_typedef (VALUE_TYPE (arg1)); type = check_typedef (VALUE_TYPE (arg1));
if (TYPE_CODE (type) == TYPE_CODE_FLT) if (TYPE_CODE (type) == TYPE_CODE_FLT)
return value_from_double (result_type, -value_as_double (arg1)); return value_from_double (result_type, -value_as_double (arg1));
else if (TYPE_CODE (type) == TYPE_CODE_INT || TYPE_CODE (type) == TYPE_CODE_BOOL) else if (is_integral_type (type))
{ {
/* Perform integral promotion for ANSI C/C++. FIXME: What about /* Perform integral promotion for ANSI C/C++. FIXME: What about
FORTRAN and (the deleted) chill ? */ FORTRAN and (the deleted) chill ? */
@ -1348,15 +1340,12 @@ value_complement (struct value *arg1)
{ {
struct type *type; struct type *type;
struct type *result_type = VALUE_TYPE (arg1); struct type *result_type = VALUE_TYPE (arg1);
int typecode;
COERCE_REF (arg1); COERCE_REF (arg1);
COERCE_ENUM (arg1);
type = check_typedef (VALUE_TYPE (arg1)); type = check_typedef (VALUE_TYPE (arg1));
typecode = TYPE_CODE (type); if (!is_integral_type (type))
if ((typecode != TYPE_CODE_INT) && (typecode != TYPE_CODE_BOOL))
error ("Argument to complement operation not an integer or boolean."); error ("Argument to complement operation not an integer or boolean.");
/* Perform integral promotion for ANSI C/C++. /* Perform integral promotion for ANSI C/C++.