From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 9566 invoked by alias); 27 Mar 2007 16:30:00 -0000 Received: (qmail 9542 invoked by uid 22791); 27 Mar 2007 16:29:57 -0000 X-Spam-Check-By: sourceware.org Received: from igw2.br.ibm.com (HELO igw2.br.ibm.com) (32.104.18.25) by sourceware.org (qpsmtpd/0.31) with ESMTP; Tue, 27 Mar 2007 17:29:50 +0100 Received: from mailhub1.br.ibm.com (mailhub1 [9.18.232.109]) by igw2.br.ibm.com (Postfix) with ESMTP id 822445BE85 for ; Tue, 27 Mar 2007 13:23:55 -0300 (BRT) Received: from d24av02.br.ibm.com (d24av02.br.ibm.com [9.18.232.47]) by mailhub1.br.ibm.com (8.13.8/8.13.8/NCO v8.3) with ESMTP id l2RGTlNG1376382 for ; Tue, 27 Mar 2007 13:29:47 -0300 Received: from d24av02.br.ibm.com (loopback [127.0.0.1]) by d24av02.br.ibm.com (8.12.11.20060308/8.13.3) with ESMTP id l2RGSgre004149 for ; Tue, 27 Mar 2007 13:28:42 -0300 Received: from dyn532128.br.ibm.com ([9.18.238.251]) by d24av02.br.ibm.com (8.12.11.20060308/8.12.11) with ESMTP id l2RGSfak004136 for ; Tue, 27 Mar 2007 13:28:42 -0300 Subject: [patch 3/4] decimal floating point support for expressions From: Thiago Jung Bauermann To: gdb-patches@sourceware.org References: <20070323030737.475073862@br.ibm.com> Content-Type: text/plain Date: Tue, 27 Mar 2007 16:30:00 -0000 Message-Id: <1175012976.21904.11.camel@localhost.localdomain> Mime-Version: 1.0 X-Mailer: Evolution 2.6.3 Content-Transfer-Encoding: 7bit X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2007-03/txt/msg00249.txt.bz2 plain text document attachment (expressions.diff) 2007-03-23 Thiago Jung Bauermann * c-exp.y (YYSTYPE): Add typed_val_decfloat for decimal floating point in YYSTYPE union. Add token DECFLOAT for typed_val_decfloat. Add expression element handling code for DECFLOAT. (parse_number): Parse DFP constants, which end with suffix 'df', 'dd' or 'dl'. Return DECFLOAT. * eval.c (evaluate_subexp_standard): Call value_from_decfloat to handle OP_DECFLOAT. * expression.h (enum exp_opcode): Add an opcode (OP_DECFLOAT) for DFP constants. (union exp_element): Add decfloatconst to represent DFP elements, which is 16 bytes by default. * parse.c (write_exp_elt_decfloatcst): New function to write a decimal float const into the expression. (operator_length_standard): Set operator length for OP_DECFLOAT to 4. * parser-defs.h (write_exp_elt_decfloatcst): Prototype. * valarith.c (value_neg): Add some code to handle the negation operation of DFP values. * value.c (value_from_decfloat): New function to get the value from a decimal floating point. * value.h (value_from_decfloat): Prototype. Index: gdb/c-exp.y =================================================================== --- gdb/c-exp.y.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/c-exp.y 2007-03-20 14:07:37.000000000 -0300 @@ -52,6 +52,7 @@ Boston, MA 02110-1301, USA. */ #include "charset.h" #include "block.h" #include "cp-support.h" +#include "dfp.h" /* Remap normal yacc parser interface names (yyparse, yylex, yyerror, etc), as well as gratuitiously global symbol names, so we can have multiple @@ -130,6 +131,10 @@ void yyerror (char *); DOUBLEST dval; struct type *type; } typed_val_float; + struct { + gdb_byte val[16]; + struct type *type; + } typed_val_decfloat; struct symbol *sym; struct type *tval; struct stoken sval; @@ -162,6 +167,7 @@ static int parse_number (char *, int, in %token INT %token FLOAT +%token DECFLOAT /* Both NAME and TYPENAME tokens represent symbols in the input, and both convey their data as strings. @@ -496,6 +502,13 @@ exp : FLOAT write_exp_elt_opcode (OP_DOUBLE); } ; +exp : DECFLOAT + { write_exp_elt_opcode (OP_DECFLOAT); + write_exp_elt_type ($1.type); + write_exp_elt_decfloatcst ($1.val); + write_exp_elt_opcode (OP_DECFLOAT); } + ; + exp : variable ; @@ -1077,6 +1090,40 @@ parse_number (p, len, parsed_float, puti char saved_char = p[len]; p[len] = 0; /* null-terminate the token */ + + /* If it ends at "df", "dd" or "dl", take it as type of decimal floating + point. Return DECFLOAT. */ + + if (p[len - 2] == 'd' && p[len - 1] == 'f') + { + p[len - 2] = '\0'; + putithere->typed_val_decfloat.type = + builtin_type (current_gdbarch)->builtin_decfloat; + decimal_from_string (putithere->typed_val_decfloat.val, 4, p); + p[len] = saved_char; + return (DECFLOAT); + } + + if (p[len - 2] == 'd' && p[len - 1] == 'd') + { + p[len - 2] = '\0'; + putithere->typed_val_decfloat.type = + builtin_type (current_gdbarch)->builtin_decdouble; + decimal_from_string (putithere->typed_val_decfloat.val, 8, p); + p[len] = saved_char; + return (DECFLOAT); + } + + if (p[len - 2] == 'd' && p[len - 1] == 'l') + { + p[len - 2] = '\0'; + putithere->typed_val_decfloat.type = + builtin_type (current_gdbarch)->builtin_declong; + decimal_from_string (putithere->typed_val_decfloat.val, 16, p); + p[len] = saved_char; + return (DECFLOAT); + } + num = sscanf (p, DOUBLEST_SCAN_FORMAT "%s", &putithere->typed_val_float.dval, s); p[len] = saved_char; /* restore the input stream */ Index: gdb/eval.c =================================================================== --- gdb/eval.c.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/eval.c 2007-03-20 14:07:37.000000000 -0300 @@ -458,6 +458,11 @@ evaluate_subexp_standard (struct type *e return value_from_double (exp->elts[pc + 1].type, exp->elts[pc + 2].doubleconst); + case OP_DECFLOAT: + (*pos) += 3; + return value_from_decfloat (expect_type, exp->elts[pc + 1].type, + exp->elts[pc + 2].decfloatconst); + case OP_VAR_VALUE: (*pos) += 3; if (noside == EVAL_SKIP) Index: gdb/expression.h =================================================================== --- gdb/expression.h.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/expression.h 2007-03-20 14:07:37.000000000 -0300 @@ -334,6 +334,11 @@ enum exp_opcode /* A F90 array range operator (for "exp:exp", "exp:", ":exp" and ":"). */ OP_F90_RANGE, + /* OP_DECFLOAT is followed by a type pointer in the next exp_element + and a dec long constant value in the following exp_element. + Then comes another OP_DECFLOAT. */ + OP_DECFLOAT, + /* First extension operator. Individual language modules define extra operators they need as constants with values OP_LANGUAGE_SPECIFIC0 + k, for k >= 0, using a separate @@ -361,6 +366,7 @@ union exp_element struct symbol *symbol; LONGEST longconst; DOUBLEST doubleconst; + gdb_byte decfloatconst[16]; /* Really sizeof (union exp_element) characters (or less for the last element of a string). */ char string; Index: gdb/parse.c =================================================================== --- gdb/parse.c.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/parse.c 2007-03-20 14:07:38.000000000 -0300 @@ -251,6 +251,18 @@ write_exp_elt_dblcst (DOUBLEST expelt) } void +write_exp_elt_decfloatcst (gdb_byte expelt[16]) +{ + union exp_element tmp; + int index; + + for (index = 0; index < 16; index++) + tmp.decfloatconst[index] = expelt[index]; + + write_exp_elt (tmp); +} + +void write_exp_elt_type (struct type *expelt) { union exp_element tmp; @@ -892,6 +904,7 @@ operator_length_standard (struct express case OP_LONG: case OP_DOUBLE: + case OP_DECFLOAT: case OP_VAR_VALUE: oplen = 4; break; Index: gdb/parser-defs.h =================================================================== --- gdb/parser-defs.h.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/parser-defs.h 2007-03-20 14:07:38.000000000 -0300 @@ -121,6 +121,8 @@ extern void write_exp_elt_longcst (LONGE extern void write_exp_elt_dblcst (DOUBLEST); +extern void write_exp_elt_decfloatcst (gdb_byte *); + extern void write_exp_elt_type (struct type *); extern void write_exp_elt_intern (struct internalvar *); Index: gdb/valarith.c =================================================================== --- gdb/valarith.c.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/valarith.c 2007-03-20 14:13:55.000000000 -0300 @@ -1378,6 +1378,20 @@ value_neg (struct value *arg1) type = check_typedef (value_type (arg1)); + if (TYPE_CODE (type) == TYPE_CODE_DECFLOAT) + { + struct value *val = allocate_value (result_type); + int len = TYPE_LENGTH (type); + gdb_byte *decbytes = (gdb_byte *) value_contents (arg1); + + if (gdbarch_byte_order (current_gdbarch) == BFD_ENDIAN_LITTLE) + decbytes[len-1] = decbytes[len - 1] | 0x80; + else + decbytes[0] = decbytes[0] | 0x80; + memcpy (value_contents_raw (val), decbytes, 16); + return val; + } + if (TYPE_CODE (type) == TYPE_CODE_FLT) return value_from_double (result_type, -value_as_double (arg1)); else if (is_integral_type (type)) Index: gdb/value.c =================================================================== --- gdb/value.c.orig 2007-03-13 14:56:27.000000000 -0300 +++ gdb/value.c 2007-03-20 14:07:38.000000000 -0300 @@ -37,6 +37,7 @@ #include "gdb_assert.h" #include "regcache.h" #include "block.h" +#include "dfp.h" /* Prototypes for exported functions. */ @@ -1607,6 +1608,27 @@ value_from_double (struct type *type, DO } struct value * +value_from_decfloat (struct type *expect_type, struct type *type, + gdb_byte decbytes[16]) +{ + struct value *val = allocate_value (type); + int len = TYPE_LENGTH (type); + + if (expect_type) + { + int expect_len = TYPE_LENGTH (expect_type); + char decstr[128]; + int real_len; + + decimal_to_string (decbytes, len, decstr); + decimal_from_string (decbytes, expect_len, decstr); + } + + memcpy (value_contents_raw (val), decbytes, len); + return val; +} + +struct value * coerce_ref (struct value *arg) { struct type *value_type_arg_tmp = check_typedef (value_type (arg)); Index: gdb/value.h =================================================================== --- gdb/value.h.orig 2007-03-20 14:07:37.000000000 -0300 +++ gdb/value.h 2007-03-20 14:07:38.000000000 -0300 @@ -274,6 +274,9 @@ extern LONGEST unpack_field_as_long (str extern struct value *value_from_longest (struct type *type, LONGEST num); extern struct value *value_from_pointer (struct type *type, CORE_ADDR addr); extern struct value *value_from_double (struct type *type, DOUBLEST num); +extern struct value *value_from_decfloat (struct type *expect_type, + struct type *type, + gdb_byte decbytes[16]); extern struct value *value_from_string (char *string); extern struct value *value_at (struct type *type, CORE_ADDR addr); --