* Add native support for long double data type.

	* c-exp.y (%union):  Change dval to typed_val_float.  Use DOUBLEST
	to store actual data.  Change types of INT and FLOAT tokens to
	typed_val_int and typed_val_float respectively.  Create new token
	DOUBLE_KEYWORD to specify the string `double'.  Make production
	for FLOAT use type determined by parse_number.  Add production for
	"long double" data type.
	* (parse_number):  Use sscanf to parse numbers as float, double or
	long double depending upon the type of typed_val_float.dval.  Also
	allow user to specify `f' or `l' suffix to explicitly specify
	float or long double constants.  Change typed_val to
	typed_val_int.
	* (yylex):  Change typed_val to typed_val_int.  Also, scan for
	"double" keyword.
	* coffread.c (decode_base_type):  Add support for T_LNGDBL basic
	type.
	* configure, configure.in:  Add check for long double support in
	the host compiler.
	* defs.h:  Define DOUBLEST appropriatly depending on whether
	HAVE_LONG_DOUBLE (from autoconf) is defined.  Also, fix prototypes
	for functions that handle this type.
	* expression.h (union exp_element):  doubleconst is now type
	DOUBLEST.
	* m2-exp.y f-exp.y (%union):  dval becomes type DOUBLEST.
	* findvar.c (extract_floating):  Make return value be DOUBLEST.
	Also, add support for numbers with size of long double.
	* (store_floating):  Arg `val' is now type DOUBLEST.  Handle all
	floating types.
	* parser-defs.h parse.c (write_exp_elt_dblcst):  Arg expelt is now
	DOUBLEST.
	* valarith.c (value_binop):  Change temp variables v1, v2 and v to
	type DOUBLEST.  Coerce type of result to long double if either op
	was of that type.
	* valops.c (value_arg_coerce):  If argument type is bigger than
	double, coerce to long double.
	* (call_function_by_hand):  If REG_STRUCT_HAS_ADDR is defined, and
	arg type is float and > 8 bytes, then use pointer-to-object
	calling conventions.
	* valprint.c (print_floating):  Arg doub is now type DOUBLEST.
	Use appropriate format and precision to print out floating point
	values.
	* value.h:  Fixup prototypes for value_as_double,
	value_from_double, and unpack_double to use DOUBLEST.
	* values.c (record_latest_value):  Remove check for invalid
	floats.  Allow history to store them so that people may examine
	them in hex if they want.
	* (value_as_double unpack_double):  Change return value to DOUBLEST.
	* (value_from_double):  Arg `num' is now DOUBLEST.
	* (using_struct_return):  Use RETURN_VALUE_ON_STACK macro (target
	specific) to expect certain types to always be returned on the stack.

1 files changed, 33 insertions, 4 deletions

diff --git a/gdb/findvar.c b/gdb/findvar.c
index fd3a532..f0f46d6 100644
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -15,7 +15,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #include "defs.h"
 #include "symtab.h"
@@ -228,7 +228,7 @@ store_address (addr, len, val)
    3.  We probably should have a LONGEST_DOUBLE or DOUBLEST or whatever
    we want to call it which is long double where available.  */
 
-double
+DOUBLEST
 extract_floating (addr, len)
      PTR addr;
      int len;
@@ -247,6 +247,13 @@ extract_floating (addr, len)
       SWAP_FLOATING (&retval, sizeof (retval));
       return retval;
     }
+  else if (len == sizeof (long double))
+    {
+      long double retval;
+      memcpy (&retval, addr, sizeof (retval));
+      SWAP_FLOATING (&retval, sizeof (retval));
+      return retval;
+    }
   else
     {
       error ("Can't deal with a floating point number of %d bytes.", len);
@@ -257,7 +264,7 @@ void
 store_floating (addr, len, val)
      PTR addr;
      int len;
-     double val;
+     DOUBLEST val;
 {
   if (len == sizeof (float))
     {
@@ -267,6 +274,13 @@ store_floating (addr, len, val)
     }
   else if (len == sizeof (double))
     {
+      double doubleval = val;
+
+      SWAP_FLOATING (&doubleval, sizeof (doubleval));
+      memcpy (addr, &doubleval, sizeof (doubleval));
+    }
+  else if (len == sizeof (long double))
+    {
       SWAP_FLOATING (&val, sizeof (val));
       memcpy (addr, &val, sizeof (val));
     }
@@ -971,6 +985,7 @@ symbol_read_needs_frame (sym)
 
     case LOC_BLOCK:
     case LOC_CONST_BYTES:
+    case LOC_UNRESOLVED:
     case LOC_OPTIMIZED_OUT:
       return 0;
     }
@@ -1098,6 +1113,17 @@ read_var_value (var, frame)
       }
       break;
 
+    case LOC_UNRESOLVED:
+      {
+	struct minimal_symbol *msym;
+
+	msym = lookup_minimal_symbol (SYMBOL_NAME (var), NULL, NULL);
+	if (msym == NULL)
+	  return 0;
+	addr = SYMBOL_VALUE_ADDRESS (msym);
+      }
+      break;
+
     case LOC_OPTIMIZED_OUT:
       VALUE_LVAL (v) = not_lval;
       VALUE_OPTIMIZED_OUT (v) = 1;
@@ -1126,11 +1152,14 @@ value_from_register (type, regnum, frame)
   CORE_ADDR addr;
   int optim;
   value_ptr v = allocate_value (type);
-  int len = TYPE_LENGTH (type);
   char *value_bytes = 0;
   int value_bytes_copied = 0;
   int num_storage_locs;
   enum lval_type lval;
+  int len;
+
+  CHECK_TYPEDEF (type);
+  len = TYPE_LENGTH (type);
 
   VALUE_REGNO (v) = regnum;