X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Feval.c;h=aed89e5f85a1a6806ec4b25df6f76d6d38e4336f;hb=ec8e2b6d3051f0b4b2a8eee9917898e95046c62f;hp=b6fbfcf6c9595e43b27d9877f9a3d1eb66fea2d0;hpb=a6535de1903d9caad8c10c1d81c51a29612456a6;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/eval.c b/gdb/eval.c
index b6fbfcf6c9..aed89e5f85 100644
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -1,6 +1,6 @@
 /* Evaluate expressions for GDB.
 
-   Copyright (C) 1986-2018 Free Software Foundation, Inc.
+   Copyright (C) 1986-2019 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -74,14 +74,14 @@ evaluate_subexp (struct type *expect_type, struct expression *exp,
   gdb::optional<enable_thread_stack_temporaries> stack_temporaries;
   if (*pos == 0 && target_has_execution
       && exp->language_defn->la_language == language_cplus
-      && !thread_stack_temporaries_enabled_p (inferior_ptid))
-    stack_temporaries.emplace (inferior_ptid);
+      && !thread_stack_temporaries_enabled_p (inferior_thread ()))
+    stack_temporaries.emplace (inferior_thread ());
 
   retval = (*exp->language_defn->la_exp_desc->evaluate_exp)
     (expect_type, exp, pos, noside);
 
   if (stack_temporaries.has_value ()
-      && value_in_thread_stack_temporaries (retval, inferior_ptid))
+      && value_in_thread_stack_temporaries (retval, inferior_thread ()))
     retval = value_non_lval (retval);
 
   return retval;
@@ -123,7 +123,7 @@ parse_and_eval (const char *exp)
 struct value *
 parse_to_comma_and_eval (const char **expp)
 {
-  expression_up expr = parse_exp_1 (expp, 0, (struct block *) 0, 1);
+  expression_up expr = parse_exp_1 (expp, 0, nullptr, 1);
 
   return evaluate_expression (expr.get ());
 }
@@ -201,11 +201,11 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
   mark = value_mark ();
   result = NULL;
 
-  TRY
+  try
     {
       result = evaluate_subexp (NULL_TYPE, exp, pc, EVAL_NORMAL);
     }
-  CATCH (ex, RETURN_MASK_ALL)
+  catch (const gdb_exception &ex)
     {
       /* Ignore memory errors if we want watchpoints pointing at
 	 inaccessible memory to still be created; otherwise, throw the
@@ -215,12 +215,12 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
 	case MEMORY_ERROR:
 	  if (!preserve_errors)
 	    break;
+	  /* Fall through.  */
 	default:
-	  throw_exception (ex);
+	  throw;
 	  break;
 	}
     }
-  END_CATCH
 
   new_mark = value_mark ();
   if (mark == new_mark)
@@ -237,15 +237,14 @@ fetch_subexp_value (struct expression *exp, int *pc, struct value **valp,
       else
 	{
 
-	  TRY
+	  try
 	    {
 	      value_fetch_lazy (result);
 	      *valp = result;
 	    }
-	  CATCH (except, RETURN_MASK_ERROR)
+	  catch (const gdb_exception_error &except)
 	    {
 	    }
-	  END_CATCH
 	}
     }
 
@@ -682,9 +681,13 @@ fake_method::fake_method (type_instance_flags flags,
 	}
     }
 
+  /* We don't use TYPE_ZALLOC here to allocate space as TYPE is owned by
+     neither an objfile nor a gdbarch.  As a result we must manually
+     allocate memory for auxiliary fields, and free the memory ourselves
+     when we are done with it.  */
   TYPE_NFIELDS (type) = num_types;
   TYPE_FIELDS (type) = (struct field *)
-    TYPE_ZALLOC (type, sizeof (struct field) * num_types);
+    xzalloc (sizeof (struct field) * num_types);
 
   while (num_types-- > 0)
     TYPE_FIELD_TYPE (type, num_types) = param_types[num_types];
@@ -711,19 +714,18 @@ evaluate_var_value (enum noside noside, const block *blk, symbol *var)
 
   struct value *ret = NULL;
 
-  TRY
+  try
     {
       ret = value_of_variable (var, blk);
     }
 
-  CATCH (except, RETURN_MASK_ERROR)
+  catch (const gdb_exception_error &except)
     {
       if (noside != EVAL_AVOID_SIDE_EFFECTS)
-	throw_exception (except);
+	throw;
 
       ret = value_zero (SYMBOL_TYPE (var), not_lval);
     }
-  END_CATCH
 
   return ret;
 }
@@ -734,17 +736,13 @@ value *
 evaluate_var_msym_value (enum noside noside,
 			 struct objfile *objfile, minimal_symbol *msymbol)
 {
-  if (noside == EVAL_AVOID_SIDE_EFFECTS)
-    {
-      type *the_type = find_minsym_type_and_address (msymbol, objfile, NULL);
-      return value_zero (the_type, not_lval);
-    }
+  CORE_ADDR address;
+  type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
+
+  if (noside == EVAL_AVOID_SIDE_EFFECTS && !TYPE_GNU_IFUNC (the_type))
+    return value_zero (the_type, not_lval);
   else
-    {
-      CORE_ADDR address;
-      type *the_type = find_minsym_type_and_address (msymbol, objfile, &address);
-      return value_at_lazy (the_type, address);
-    }
+    return value_at_lazy (the_type, address);
 }
 
 /* Helper for returning a value when handling EVAL_SKIP.  */
@@ -788,7 +786,9 @@ eval_call (expression *exp, enum noside noside,
       else if (TYPE_CODE (ftype) == TYPE_CODE_XMETHOD)
 	{
 	  type *return_type
-	    = result_type_of_xmethod (argvec[0], nargs, argvec + 1);
+	    = result_type_of_xmethod (argvec[0],
+				      gdb::make_array_view (argvec + 1,
+							    nargs));
 
 	  if (return_type == NULL)
 	    error (_("Xmethod is missing return type."));
@@ -797,6 +797,15 @@ eval_call (expression *exp, enum noside noside,
       else if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
 	       || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
 	{
+	  if (TYPE_GNU_IFUNC (ftype))
+	    {
+	      CORE_ADDR address = value_address (argvec[0]);
+	      type *resolved_type = find_gnu_ifunc_target_type (address);
+
+	      if (resolved_type != NULL)
+		ftype = resolved_type;
+	    }
+
 	  type *return_type = TYPE_TARGET_TYPE (ftype);
 
 	  if (return_type == NULL)
@@ -817,10 +826,10 @@ eval_call (expression *exp, enum noside noside,
       return call_internal_function (exp->gdbarch, exp->language_defn,
 				     argvec[0], nargs, argvec + 1);
     case TYPE_CODE_XMETHOD:
-      return call_xmethod (argvec[0], nargs, argvec + 1);
+      return call_xmethod (argvec[0], gdb::make_array_view (argvec + 1, nargs));
     default:
       return call_function_by_hand (argvec[0], default_return_type,
-				    nargs, argvec + 1);
+				    gdb::make_array_view (argvec + 1, nargs));
     }
 }
 
@@ -945,19 +954,18 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
 	  while (unop_user_defined_p (op, arg2))
 	    {
 	      struct value *value = NULL;
-	      TRY
+	      try
 		{
 		  value = value_x_unop (arg2, op, noside);
 		}
 
-	      CATCH (except, RETURN_MASK_ERROR)
+	      catch (const gdb_exception_error &except)
 		{
 		  if (except.error == NOT_FOUND_ERROR)
 		    break;
 		  else
-		    throw_exception (except);
+		    throw;
 		}
-	      END_CATCH
 
 		arg2 = value;
 	    }
@@ -984,13 +992,13 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
       function_name = NULL;
       if (TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
 	{
-	  function = cp_lookup_symbol_namespace (TYPE_TAG_NAME (type),
+	  function = cp_lookup_symbol_namespace (TYPE_NAME (type),
 						 name,
 						 get_selected_block (0),
 						 VAR_DOMAIN).symbol;
 	  if (function == NULL)
 	    error (_("No symbol \"%s\" in namespace \"%s\"."),
-		   name, TYPE_TAG_NAME (type));
+		   name, TYPE_NAME (type));
 
 	  tem = 1;
 	  /* arg2 is left as NULL on purpose.  */
@@ -1090,7 +1098,8 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
       func_name = (char *) alloca (name_len + 1);
       strcpy (func_name, &exp->elts[string_pc + 1].string);
 
-      find_overload_match (&argvec[1], nargs, func_name,
+      find_overload_match (gdb::make_array_view (&argvec[1], nargs),
+			   func_name,
 			   NON_METHOD, /* not method */
 			   NULL, NULL, /* pass NULL symbol since
 					  symbol is unknown */
@@ -1126,7 +1135,8 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
 	     evaluation.  */
 	  struct value *valp = NULL;
 
-	  (void) find_overload_match (&argvec[1], nargs, tstr,
+	  (void) find_overload_match (gdb::make_array_view (&argvec[1], nargs),
+				      tstr,
 				      METHOD, /* method */
 				      &arg2,  /* the object */
 				      NULL, &valp, NULL,
@@ -1197,7 +1207,7 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
 	  if (op == OP_VAR_VALUE)
 	    function = exp->elts[save_pos1+2].symbol;
 
-	  (void) find_overload_match (&argvec[1], nargs,
+	  (void) find_overload_match (gdb::make_array_view (&argvec[1], nargs),
 				      NULL,        /* no need for name */
 				      NON_METHOD,  /* not method */
 				      NULL, function, /* the function */
@@ -1228,6 +1238,19 @@ evaluate_funcall (type *expect_type, expression *exp, int *pos,
   return eval_call (exp, noside, nargs, argvec, var_func_name, expect_type);
 }
 
+/* Helper for skipping all the arguments in an undetermined argument list.
+   This function was designed for use in the OP_F77_UNDETERMINED_ARGLIST
+   case of evaluate_subexp_standard as multiple, but not all, code paths
+   require a generic skip.  */
+
+static void
+skip_undetermined_arglist (int nargs, struct expression *exp, int *pos,
+			   enum noside noside)
+{
+  for (int i = 0; i < nargs; ++i)
+    evaluate_subexp (NULL_TYPE, exp, pos, noside);
+}
+
 struct value *
 evaluate_subexp_standard (struct type *expect_type,
 			  struct expression *exp, int *pos,
@@ -1276,16 +1299,19 @@ evaluate_subexp_standard (struct type *expect_type,
 
     case OP_ADL_FUNC:
     case OP_VAR_VALUE:
-      (*pos) += 3;
-      if (noside == EVAL_SKIP)
-	return eval_skip_value (exp);
-
       {
+	(*pos) += 3;
 	symbol *var = exp->elts[pc + 2].symbol;
 	if (TYPE_CODE (SYMBOL_TYPE (var)) == TYPE_CODE_ERROR)
 	  error_unknown_type (SYMBOL_PRINT_NAME (var));
-
-	return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
+	if (noside != EVAL_SKIP)
+	    return evaluate_var_value (noside, exp->elts[pc + 1].block, var);
+	else
+	  {
+	    /* Return a dummy value of the correct type when skipping, so
+	       that parent functions know what is to be skipped.  */
+	    return allocate_value (SYMBOL_TYPE (var));
+	  }
       }
 
     case OP_VAR_MSYM_VALUE:
@@ -1369,8 +1395,7 @@ evaluate_subexp_standard (struct type *expect_type,
            So for these registers, we fetch the register value regardless
            of the evaluation mode.  */
 	if (noside == EVAL_AVOID_SIDE_EFFECTS
-	    && regno < gdbarch_num_regs (exp->gdbarch)
-			+ gdbarch_num_pseudo_regs (exp->gdbarch))
+	    && regno < gdbarch_num_cooked_regs (exp->gdbarch))
 	  val = value_zero (register_type (exp->gdbarch, regno), not_lval);
 	else
 	  val = value_of_register (regno, get_selected_frame (NULL));
@@ -1648,7 +1673,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	   only).  */
 	if (gnu_runtime)
 	  {
-	    struct type *type = selector_type;
+	    type = selector_type;
 
 	    type = lookup_function_type (type);
 	    type = lookup_pointer_type (type);
@@ -1703,12 +1728,12 @@ evaluate_subexp_standard (struct type *expect_type,
 	argvec[3] = value_from_longest (long_type, selector);
 	argvec[4] = 0;
 
-	ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
+	ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
 	if (gnu_runtime)
 	  {
 	    /* Function objc_msg_lookup returns a pointer.  */
 	    argvec[0] = ret;
-	    ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
+	    ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
 	  }
 	if (value_as_long (ret) == 0)
 	  error (_("Target does not respond to this message selector."));
@@ -1725,11 +1750,11 @@ evaluate_subexp_standard (struct type *expect_type,
 	argvec[3] = value_from_longest (long_type, selector);
 	argvec[4] = 0;
 
-	ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
+	ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
 	if (gnu_runtime)
 	  {
 	    argvec[0] = ret;
-	    ret = call_function_by_hand (argvec[0], NULL, 3, argvec + 1);
+	    ret = call_function_by_hand (argvec[0], NULL, {argvec + 1, 3});
 	  }
 
 	/* ret should now be the selector.  */
@@ -1742,7 +1767,7 @@ evaluate_subexp_standard (struct type *expect_type,
 	    /* The address might point to a function descriptor;
 	       resolve it to the actual code address instead.  */
 	    addr = gdbarch_convert_from_func_ptr_addr (exp->gdbarch, addr,
-						       &current_target);
+						       current_top_target ());
 
 	    /* Is it a high_level symbol?  */
 	    sym = find_pc_function (addr);
@@ -1835,18 +1860,18 @@ evaluate_subexp_standard (struct type *expect_type,
 	       it's opinion (ie. through "whatis"), it won't offer
 	       it.  */
 
-	    struct type *type = value_type (called_method);
+	    struct type *callee_type = value_type (called_method);
 
-	    if (type && TYPE_CODE (type) == TYPE_CODE_PTR)
-	      type = TYPE_TARGET_TYPE (type);
-	    type = TYPE_TARGET_TYPE (type);
+	    if (callee_type && TYPE_CODE (callee_type) == TYPE_CODE_PTR)
+	      callee_type = TYPE_TARGET_TYPE (callee_type);
+	    callee_type = TYPE_TARGET_TYPE (callee_type);
 
-	    if (type)
+	    if (callee_type)
 	    {
-	      if ((TYPE_CODE (type) == TYPE_CODE_ERROR) && expect_type)
+	      if ((TYPE_CODE (callee_type) == TYPE_CODE_ERROR) && expect_type)
 		return allocate_value (expect_type);
 	      else
-		return allocate_value (type);
+		return allocate_value (callee_type);
 	    }
 	    else
 	      error (_("Expression of type other than "
@@ -1865,17 +1890,17 @@ evaluate_subexp_standard (struct type *expect_type,
 	  argvec[tem + 3] = evaluate_subexp_with_coercion (exp, pos, noside);
 	argvec[tem + 3] = 0;
 
+	auto call_args = gdb::make_array_view (argvec + 1, nargs + 2);
+
 	if (gnu_runtime && (method != NULL))
 	  {
 	    /* Function objc_msg_lookup returns a pointer.  */
 	    deprecated_set_value_type (argvec[0],
 				       lookup_pointer_type (lookup_function_type (value_type (argvec[0]))));
-	    argvec[0]
-	      = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
+	    argvec[0] = call_function_by_hand (argvec[0], NULL, call_args);
 	  }
 
-	ret = call_function_by_hand (argvec[0], NULL, nargs + 2, argvec + 1);
-	return ret;
+	return call_function_by_hand (argvec[0], NULL, call_args);
       }
       break;
 
@@ -1923,19 +1948,34 @@ evaluate_subexp_standard (struct type *expect_type,
 	  if (exp->elts[*pos].opcode == OP_RANGE)
 	    return value_f90_subarray (arg1, exp, pos, noside);
 	  else
-	    goto multi_f77_subscript;
+	    {
+	      if (noside == EVAL_SKIP)
+		{
+		  skip_undetermined_arglist (nargs, exp, pos, noside);
+		  /* Return the dummy value with the correct type.  */
+		  return arg1;
+		}
+	      goto multi_f77_subscript;
+	    }
 
 	case TYPE_CODE_STRING:
 	  if (exp->elts[*pos].opcode == OP_RANGE)
 	    return value_f90_subarray (arg1, exp, pos, noside);
 	  else
 	    {
+	      if (noside == EVAL_SKIP)
+		{
+		  skip_undetermined_arglist (nargs, exp, pos, noside);
+		  /* Return the dummy value with the correct type.  */
+		  return arg1;
+		}
 	      arg2 = evaluate_subexp_with_coercion (exp, pos, noside);
 	      return value_subscript (arg1, value_as_long (arg2));
 	    }
 
 	case TYPE_CODE_PTR:
 	case TYPE_CODE_FUNC:
+	case TYPE_CODE_INTERNAL_FUNCTION:
 	  /* It's a function call.  */
 	  /* Allocate arg vector, including space for the function to be
 	     called in argvec[0] and a terminating NULL.  */
@@ -1944,7 +1984,23 @@ evaluate_subexp_standard (struct type *expect_type,
 	  argvec[0] = arg1;
 	  tem = 1;
 	  for (; tem <= nargs; tem++)
-	    argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+	    {
+	      argvec[tem] = evaluate_subexp_with_coercion (exp, pos, noside);
+	      /* Arguments in Fortran are passed by address.  Coerce the
+		 arguments here rather than in value_arg_coerce as otherwise
+		 the call to malloc to place the non-lvalue parameters in
+		 target memory is hit by this Fortran specific logic.  This
+		 results in malloc being called with a pointer to an integer
+		 followed by an attempt to malloc the arguments to malloc in
+		 target memory.  Infinite recursion ensues.  */
+	      if (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC)
+		{
+		  bool is_artificial
+		    = TYPE_FIELD_ARTIFICIAL (value_type (arg1), tem - 1);
+		  argvec[tem] = fortran_argument_convert (argvec[tem],
+							  is_artificial);
+		}
+	    }
 	  argvec[tem] = 0;	/* signal end of arglist */
 	  if (noside == EVAL_SKIP)
 	    return eval_skip_value (exp);
@@ -1987,19 +2043,18 @@ evaluate_subexp_standard (struct type *expect_type,
       while (unop_user_defined_p (op, arg1))
 	{
 	  struct value *value = NULL;
-	  TRY
+	  try
 	    {
 	      value = value_x_unop (arg1, op, noside);
 	    }
 
-	  CATCH (except, RETURN_MASK_ERROR)
+	  catch (const gdb_exception_error &except)
 	    {
 	      if (except.error == NOT_FOUND_ERROR)
 		break;
 	      else
-		throw_exception (except);
+		throw;
 	    }
-	  END_CATCH
 
 	  arg1 = value;
 	}
@@ -2008,15 +2063,15 @@ evaluate_subexp_standard (struct type *expect_type,
 	 with rtti type in order to continue on with successful
 	 lookup of member / method only available in the rtti type.  */
       {
-        struct type *type = value_type (arg1);
+        struct type *arg_type = value_type (arg1);
         struct type *real_type;
         int full, using_enc;
         LONGEST top;
 	struct value_print_options opts;
 
 	get_user_print_options (&opts);
-        if (opts.objectprint && TYPE_TARGET_TYPE(type)
-            && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
+        if (opts.objectprint && TYPE_TARGET_TYPE (arg_type)
+            && (TYPE_CODE (TYPE_TARGET_TYPE (arg_type)) == TYPE_CODE_STRUCT))
           {
             real_type = value_rtti_indirect_type (arg1, &full, &top,
 						  &using_enc);
@@ -2081,9 +2136,10 @@ evaluate_subexp_standard (struct type *expect_type,
 	for (ix = 0; ix < nargs; ++ix)
 	  arg_types[ix] = exp->elts[pc + 2 + ix + 1].type;
 
-	fake_method expect_type (flags, nargs, arg_types);
+	fake_method fake_expect_type (flags, nargs, arg_types);
 	*(pos) += 4 + nargs;
-	return evaluate_subexp_standard (expect_type.type (), exp, pos, noside);
+	return evaluate_subexp_standard (fake_expect_type.type (), exp, pos,
+					 noside);
       }
 
     case BINOP_CONCAT:
@@ -2662,6 +2718,18 @@ evaluate_subexp_standard (struct type *expect_type,
 	}
       return evaluate_subexp_for_sizeof (exp, pos, noside);
 
+    case UNOP_ALIGNOF:
+      {
+	type = value_type (evaluate_subexp (NULL_TYPE, exp, pos,
+					    EVAL_AVOID_SIDE_EFFECTS));
+	/* FIXME: This should be size_t.  */
+	struct type *size_type = builtin_type (exp->gdbarch)->builtin_int;
+	ULONGEST align = type_align (type);
+	if (align == 0)
+	  error (_("could not determine alignment of type"));
+	return value_from_longest (size_type, align);
+      }
+
     case UNOP_CAST:
       (*pos) += 2;
       type = exp->elts[pc + 1].type;
@@ -2852,7 +2920,7 @@ evaluate_subexp_standard (struct type *expect_type,
 		  || sub_op == STRUCTOP_PTR
 		  || sub_op == OP_SCOPE))
 	    {
-	      struct type *type = value_type (result);
+	      type = value_type (result);
 
 	      if (!TYPE_IS_REFERENCE (type))
 		{
@@ -3126,6 +3194,10 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
 	{
 	  val = evaluate_subexp (NULL_TYPE, exp, pos, EVAL_NORMAL);
 	  type = value_type (val);
+	  if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+              && is_dynamic_type (TYPE_INDEX_TYPE (type))
+              && TYPE_HIGH_BOUND_UNDEFINED (TYPE_INDEX_TYPE (type)))
+	    return allocate_optimized_out_value (size_type);
 	}
       else
 	(*pos) += 4;
@@ -3136,11 +3208,11 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
 	(*pos) += 4;
 
 	minimal_symbol *msymbol = exp->elts[pc + 2].msymbol;
-	value *val = evaluate_var_msym_value (noside,
-					      exp->elts[pc + 1].objfile,
-					      msymbol);
+	value *mval = evaluate_var_msym_value (noside,
+					       exp->elts[pc + 1].objfile,
+					       msymbol);
 
-	type = value_type (val);
+	type = value_type (mval);
 	if (TYPE_CODE (type) == TYPE_CODE_ERROR)
 	  error_unknown_type (MSYMBOL_PRINT_NAME (msymbol));
 
@@ -3155,9 +3227,9 @@ evaluate_subexp_for_sizeof (struct expression *exp, int *pos,
     case BINOP_SUBSCRIPT:
       if (noside == EVAL_NORMAL)
 	{
-	  int pc = (*pos) + 1;
+	  int npc = (*pos) + 1;
 
-	  val = evaluate_subexp (NULL_TYPE, exp, &pc, EVAL_AVOID_SIDE_EFFECTS);
+	  val = evaluate_subexp (NULL_TYPE, exp, &npc, EVAL_AVOID_SIDE_EFFECTS);
 	  type = check_typedef (value_type (val));
 	  if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
 	    {