From FEDORA_PATCHES Mon Sep 17 00:00:00 2001

From: Fedora GDB patches <invalid@email.com>

Date: Fri, 27 Oct 2017 21:07:50 +0200

Subject: gdb-vla-intel-fortran-strides.patch

;; VLA (Fortran dynamic arrays) from Intel + archer-jankratochvil-vla tests.

;;=push

git diff --stat -p gdb/master...gdb/users/bheckel/fortran-strides

dbfd7140bf4c0500d1f5d192be781f83f78f7922

 gdb/dwarf2loc.c                             |  46 ++-

 gdb/dwarf2loc.h                             |   6 +

 gdb/dwarf2read.c                            |  13 +-

 gdb/eval.c                                  | 391 +++++++++++++++++++++-----

 gdb/expprint.c                              |  20 +-

 gdb/expression.h                            |  18 +-

 gdb/f-exp.y                                 |  42 ++-

 gdb/f-valprint.c                            |   8 +-

 gdb/gdbtypes.c                              |  34 ++-

 gdb/gdbtypes.h                              |  18 +-

 gdb/parse.c                                 |  24 +-

 gdb/rust-exp.y                              |  12 +-

 gdb/rust-lang.c                             |  17 +-

 gdb/testsuite/gdb.fortran/static-arrays.exp | 421 ++++++++++++++++++++++++++++

 gdb/testsuite/gdb.fortran/static-arrays.f90 |  55 ++++

 gdb/testsuite/gdb.fortran/vla-ptype.exp     |   4 +

 gdb/testsuite/gdb.fortran/vla-sizeof.exp    |   4 +

 gdb/testsuite/gdb.fortran/vla-stride.exp    |  44 +++

 gdb/testsuite/gdb.fortran/vla-stride.f90    |  29 ++

 gdb/testsuite/gdb.fortran/vla.f90           |  10 +

 gdb/valarith.c                              |  10 +-

 gdb/valops.c                                | 197 +++++++++++--

 gdb/value.h                                 |   2 +

 23 files changed, 1242 insertions(+), 183 deletions(-)

diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c

--- a/gdb/dwarf2loc.c

+++ b/gdb/dwarf2loc.c

@@ -2429,11 +2429,14 @@ dwarf2_locexpr_baton_eval (const struct dwarf2_locexpr_baton *dlbaton,

 /* See dwarf2loc.h.  */

 int

-dwarf2_evaluate_property (const struct dynamic_prop *prop,

+dwarf2_evaluate_property_signed (const struct dynamic_prop *prop,

 			  struct frame_info *frame,

 			  struct property_addr_info *addr_stack,

-			  CORE_ADDR *value)

+			  CORE_ADDR *value,

+			  int is_signed)

 {

+  int rc = 0;

+

   if (prop == NULL)

     return 0;

@@ -2457,7 +2460,7 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,

 		*value = value_as_address (val);

 	      }

-	    return 1;

+	    rc = 1;

 	  }

       }

       break;

@@ -2479,7 +2482,7 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,

 	    if (!value_optimized_out (val))

 	      {

 		*value = value_as_address (val);

-		return 1;

+		rc = 1;

 	      }

 	  }

       }

@@ -2487,8 +2490,8 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,

     case PROP_CONST:

       *value = prop->data.const_val;

-      return 1;

-

+      rc = 1;

+      break;

     case PROP_ADDR_OFFSET:

       {

 	struct dwarf2_property_baton *baton

@@ -2509,11 +2512,38 @@ dwarf2_evaluate_property (const struct dynamic_prop *prop,

 	  val = value_at (baton->offset_info.type,

 			  pinfo->addr + baton->offset_info.offset);

 	*value = value_as_address (val);

-	return 1;

+	rc = 1;

       }

+      break;

     }

-  return 0;

+  if (rc == 1 && is_signed == 1)

+    {

+      /* If we have a valid return candidate and it's value is signed,

+         we have to sign-extend the value because CORE_ADDR on 64bit machine has

+         8 bytes but address size of an 32bit application is 4 bytes.  */

+      struct gdbarch * gdbarch = target_gdbarch ();

+      const int addr_bit = gdbarch_addr_bit (gdbarch);

+      const CORE_ADDR neg_mask = ((~0) <<  (addr_bit - 1));

+

+      /* Check if signed bit is set and sign-extend values.  */

+      if (*value & (neg_mask))

+	*value |= (neg_mask );

+    }

+  return rc;

+}

+

+int

+dwarf2_evaluate_property (const struct dynamic_prop *prop,

+			  struct frame_info *frame,

+			  struct property_addr_info *addr_stack,

+			  CORE_ADDR *value)

+{

+  return dwarf2_evaluate_property_signed (prop,

+				   frame,

+				   addr_stack,

+				   value,

+				   0);

 }

 /* See dwarf2loc.h.  */

diff --git a/gdb/dwarf2loc.h b/gdb/dwarf2loc.h

--- a/gdb/dwarf2loc.h

+++ b/gdb/dwarf2loc.h

@@ -143,6 +143,12 @@ int dwarf2_evaluate_property (const struct dynamic_prop *prop,

 			      struct property_addr_info *addr_stack,

 			      CORE_ADDR *value);

+int dwarf2_evaluate_property_signed (const struct dynamic_prop *prop,

+			      struct frame_info *frame,

+			      struct property_addr_info *addr_stack,

+			      CORE_ADDR *value,

+			      int is_signed);

+

 /* A helper for the compiler interface that compiles a single dynamic

    property to C code.

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c

--- a/gdb/dwarf2read.c

+++ b/gdb/dwarf2read.c

@@ -17773,7 +17773,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)

   struct type *base_type, *orig_base_type;

   struct type *range_type;

   struct attribute *attr;

-  struct dynamic_prop low, high;

+  struct dynamic_prop low, high, stride;

   int low_default_is_valid;

   int high_bound_is_count = 0;

   const char *name;

@@ -17793,7 +17793,9 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)

   low.kind = PROP_CONST;

   high.kind = PROP_CONST;

+  stride.kind = PROP_CONST;

   high.data.const_val = 0;

+  stride.data.const_val = 0;

   /* Set LOW_DEFAULT_IS_VALID if current language and DWARF version allow

      omitting DW_AT_lower_bound.  */

@@ -17826,6 +17828,14 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)

       break;

     }

+  attr = dwarf2_attr (die, DW_AT_byte_stride, cu);

+  if (attr)

+    if (!attr_to_dynamic_prop (attr, die, cu, &stride))

+        complaint (_("Missing DW_AT_byte_stride "

+		     "- DIE at 0x%s [in module %s]"),

+		   sect_offset_str (die->sect_off),

+		   objfile_name (cu->per_cu->dwarf2_per_objfile->objfile));

+

   attr = dwarf2_attr (die, DW_AT_lower_bound, cu);

   if (attr)

     attr_to_dynamic_prop (attr, die, cu, &low);

@@ -17918,7 +17928,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)

       && !TYPE_UNSIGNED (base_type) && (high.data.const_val & negative_mask))

     high.data.const_val |= negative_mask;

-  range_type = create_range_type (NULL, orig_base_type, &low, &high);

+  range_type = create_range_type (NULL, orig_base_type, &low, &high, &stride);

   if (high_bound_is_count)

     TYPE_RANGE_DATA (range_type)->flag_upper_bound_is_count = 1;

diff --git a/gdb/eval.c b/gdb/eval.c

--- a/gdb/eval.c

+++ b/gdb/eval.c

@@ -377,29 +377,324 @@ init_array_element (struct value *array, struct value *element,

   return index;

 }

+/* Evaluates any operation on Fortran arrays or strings with at least

+   one user provided parameter.  Expects the input ARRAY to be either

+   an array, or a string.  Evaluates EXP by incrementing POS, and

+   writes the content from the elt stack into a local struct.  NARGS

+   specifies number of literal or range arguments the user provided.

+   NARGS must be the same number as ARRAY has dimensions.  */

+

 static struct value *

-value_f90_subarray (struct value *array,

-		    struct expression *exp, int *pos, enum noside noside)

+value_f90_subarray (struct value *array, struct expression *exp,

+		    int *pos, int nargs, enum noside noside)

 {

-  int pc = (*pos) + 1;

-  LONGEST low_bound, high_bound;

-  struct type *range = check_typedef (TYPE_INDEX_TYPE (value_type (array)));

-  enum range_type range_type

-    = (enum range_type) longest_to_int (exp->elts[pc].longconst);

- 

-  *pos += 3;

-

-  if (range_type == LOW_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)

-    low_bound = TYPE_LOW_BOUND (range);

-  else

-    low_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

+  int i, dim_count = 0;

+  struct value *new_array = array;

+  struct type *array_type = check_typedef (value_type (new_array));

+  struct type *elt_type;

+

+  typedef struct

+  {

+    enum range_type f90_range_type;

+    LONGEST low, high, stride;

+  } subscript_range;

+

+  typedef enum subscript_kind

+  {

+    SUBSCRIPT_RANGE,    /* e.g. "(lowbound:highbound)"  */

+    SUBSCRIPT_INDEX    /* e.g. "(literal)"  */

+  } kind;

+

+  /* Local struct to hold user data for Fortran subarray dimensions.  */

+  struct subscript_store

+  {

+    /* For every dimension, we are either working on a range or an index

+       expression, so we store this info separately for later.  */

+    enum subscript_kind kind;

+

+    /* We also store either the lower and upper bound info, or the index

+       number.  Before evaluation of the input values, we do not know if we are

+       actually working on a range of ranges, or an index in a range.  So as a

+       first step we store all input in a union.  The array calculation itself

+       deals with this later on.  */

+    union element_range

+    {

+      subscript_range range;

+      LONGEST number;

+    } U;

+  } *subscript_array;

+

+  /* Check if the number of arguments provided by the user matches

+     the number of dimension of the array.  A string has only one

+     dimension.  */

+  if (nargs != calc_f77_array_dims (value_type (new_array)))

+    error (_("Wrong number of subscripts"));

+

+  subscript_array = (struct subscript_store*) alloca (sizeof (*subscript_array) * nargs);

+

+  /* Parse the user input into the SUBSCRIPT_ARRAY to store it.  We need

+     to evaluate it first, as the input is from left-to-right.  The

+     array is stored from right-to-left.  So we have to use the user

+     input in reverse order.  Later on, we need the input information to

+     re-calculate the output array.  For multi-dimensional arrays, we

+     can be dealing with any possible combination of ranges and indices

+     for every dimension.  */

+  for (i = 0; i < nargs; i++)

+    {

+      struct subscript_store *index = &subscript_array[i];

+

+      /* The user input is a range, with or without lower and upper bound.

+	 E.g.: "p arry(2:5)", "p arry( :5)", "p arry( : )", etc.  */

+      if (exp->elts[*pos].opcode == OP_RANGE)

+	{

+	  int pc = (*pos) + 1;

+	  subscript_range *range;

+

+	  index->kind = SUBSCRIPT_RANGE;

+	  range = &index->U.range;

+

+	  *pos += 3;

+	  range->f90_range_type = (enum range_type) exp->elts[pc].longconst;

+

+	  /* If a lower bound was provided by the user, the bit has been

+	     set and we can assign the value from the elt stack.  Same for

+	     upper bound.  */

+	  if ((range->f90_range_type & SUBARRAY_LOW_BOUND)

+	      == SUBARRAY_LOW_BOUND)

+	    range->low = value_as_long (evaluate_subexp (NULL_TYPE, exp,

+							 pos, noside));

+	  if ((range->f90_range_type & SUBARRAY_HIGH_BOUND)

+	      == SUBARRAY_HIGH_BOUND)

+	    range->high = value_as_long (evaluate_subexp (NULL_TYPE, exp,

+							  pos, noside));

+

+	  /* Assign the user's stride value if provided.  */

+	  if ((range->f90_range_type & SUBARRAY_STRIDE) == SUBARRAY_STRIDE)

+	    range->stride = value_as_long (evaluate_subexp (NULL_TYPE, exp,

+							     pos, noside));

+

+	  /* Assign the default stride value '1'.  */

+	  else

+	    range->stride = 1;

-  if (range_type == HIGH_BOUND_DEFAULT || range_type == BOTH_BOUND_DEFAULT)

-    high_bound = TYPE_HIGH_BOUND (range);

-  else

-    high_bound = value_as_long (evaluate_subexp (NULL_TYPE, exp, pos, noside));

+	  /* Check the provided stride value is illegal, aka '0'.  */

+	  if (range->stride == 0)

+	    error (_("Stride must not be 0"));

+	}

+      /* User input is an index.  E.g.: "p arry(5)".  */

+      else

+	{

+	  struct value *val;

+

+	  index->kind = SUBSCRIPT_INDEX;

+

+	  /* Evaluate each subscript; it must be a legal integer in F77.  This

+	     ensures the validity of the provided index.  */

+	  val = evaluate_subexp_with_coercion (exp, pos, noside);

+	  index->U.number = value_as_long (val);

+	}

+

+    }

+

+  /* Traverse the array from right to left and set the high and low bounds

+     for later use.  */

+  for (i = nargs - 1; i >= 0; i--)

+    {

+      struct subscript_store *index = &subscript_array[i];

+      struct type *index_type = TYPE_INDEX_TYPE (array_type);

+

+      switch (index->kind)

+	{

+	case SUBSCRIPT_RANGE:

+	  {

+

+	    /* When we hit the first range specified by the user, we must

+	       treat any subsequent user entry as a range.  We simply

+	       increment DIM_COUNT which tells us how many times we are

+	       calling VALUE_SLICE_1.  */

+	    subscript_range *range = &index->U.range;

+

+	    /* If no lower bound was provided by the user, we take the

+	       default boundary.  Same for the high bound.  */

+	    if ((range->f90_range_type & SUBARRAY_LOW_BOUND) == 0)

+	      range->low = TYPE_LOW_BOUND (index_type);

+

+	    if ((range->f90_range_type & SUBARRAY_HIGH_BOUND) == 0)

+	      range->high = TYPE_HIGH_BOUND (index_type);

+

+	    /* Both user provided low and high bound have to be inside the

+	       array bounds.  Throw an error if not.  */

+	    if (range->low < TYPE_LOW_BOUND (index_type)

+		|| range->low > TYPE_HIGH_BOUND (index_type)

+		|| range->high < TYPE_LOW_BOUND (index_type)

+		|| range->high > TYPE_HIGH_BOUND (index_type))

+	      error (_("provided bound(s) outside array bound(s)"));

+

+	    /* For a negative stride the lower boundary must be larger than the

+	       upper boundary.

+	       For a positive stride the lower boundary must be smaller than the

+	       upper boundary.  */

+	    if ((range->stride < 0 && range->low < range->high)

+		|| (range->stride > 0 && range->low > range->high))

+	      error (_("Wrong value provided for stride and boundaries"));

+

+	  }

+	  break;

+

+	case SUBSCRIPT_INDEX:

+	  break;

+

+	}

+

+       array_type = TYPE_TARGET_TYPE (array_type);

+    }

+

+  /* Reset ARRAY_TYPE before slicing.*/

+  array_type = check_typedef (value_type (new_array));

+

+  /* Traverse the array from right to left and evaluate each corresponding

+     user input.  VALUE_SUBSCRIPT is called for every index, until a range

+     expression is evaluated.  After a range expression has been evaluated,

+     every subsequent expression is also treated as a range.  */

+  for (i = nargs - 1; i >= 0; i--)

+    {

+      struct subscript_store *index = &subscript_array[i];

+      struct type *index_type = TYPE_INDEX_TYPE (array_type);

+

+      switch (index->kind)

+	{

+	case SUBSCRIPT_RANGE:

+	  {

+

+	    /* When we hit the first range specified by the user, we must

+	       treat any subsequent user entry as a range.  We simply

+	       increment DIM_COUNT which tells us how many times we are

+	       calling VALUE_SLICE_1.  */

+	    subscript_range *range = &index->U.range;

+

+	    /* DIM_COUNT counts every user argument that is treated as a range.

+	       This is necessary for expressions like 'print array(7, 8:9).

+	       Here the first argument is a literal, but must be treated as a

+	       range argument to allow the correct output representation.  */

+	    dim_count++;

+

+	    new_array

+	      = value_slice_1 (new_array, range->low,

+			       range->high - range->low + 1,

+			       range->stride, dim_count);

+	  }

+	  break;

+

+	case SUBSCRIPT_INDEX:

+	  {

+	    /* DIM_COUNT only stays '0' when no range argument was processed

+	       before, starting from the last dimension.  This way we can

+	       reduce the number of dimensions from the result array.

+	       However, if a range has been processed before an index, we

+	       treat the index like a range with equal low- and high bounds

+	       to get the value offset right.  */

+	    if (dim_count == 0)

+	      new_array

+	        = value_subscripted_rvalue (new_array, index->U.number,

+					    f77_get_lowerbound (value_type

+								  (new_array)));

+	    else

+	      {

+		dim_count++;

+

+		/* We might end up here, because we have to treat the provided

+		   index like a range. But now VALUE_SUBSCRIPTED_RVALUE

+		   cannot do the range checks for us. So we have to make sure

+		   ourselves that the user provided index is inside the

+		   array bounds.  Throw an error if not.  */

+		if (index->U.number < TYPE_LOW_BOUND (index_type)

+		    && index->U.number > TYPE_HIGH_BOUND (index_type))

+		  error (_("provided bound(s) outside array bound(s)"));

+

+		if (index->U.number > TYPE_LOW_BOUND (index_type)

+		    && index->U.number > TYPE_HIGH_BOUND (index_type))

+		  error (_("provided bound(s) outside array bound(s)"));

+

+		new_array = value_slice_1 (new_array,

+					   index->U.number,

+					   1, /* COUNT is '1' element  */

+					   1, /* STRIDE set to '1'  */

+					   dim_count);

+	      }

+

+	  }

+	  break;

+	}

+      array_type = TYPE_TARGET_TYPE (array_type);

+    }

+

+  /* With DIM_COUNT > 1 we currently have a one dimensional array, but expect

+     an array of arrays, depending on how many ranges have been provided by

+     the user.  So we need to rebuild the array dimensions for printing it

+     correctly.

+     Starting from right to left in the user input, after we hit the first

+     range argument every subsequent argument is also treated as a range.

+     E.g.:

+     "p ary(3, 7, 2:15)" in Fortran has only 1 dimension, but we calculated 3

+     ranges.

+     "p ary(3, 7:12, 4)" in Fortran has only 1 dimension, but we calculated 2

+     ranges.

+     "p ary(2:4, 5, 7)" in Fortran has only 1 dimension, and we calculated 1

+     range.  */

+  if (dim_count > 1)

+    {

+      struct value *v = NULL;

+

+      elt_type = TYPE_TARGET_TYPE (value_type (new_array));

-  return value_slice (array, low_bound, high_bound - low_bound + 1);

+      /* Every SUBSCRIPT_RANGE in the user input signifies an actual range in

+	 the output array.  So we traverse the SUBSCRIPT_ARRAY again, looking

+	 for a range entry.  When we find one, we use the range info to create

+	 an additional range_type to set the correct bounds and dimensions for

+	 the output array.  In addition, we may have a stride value that is not

+	 '1', forcing us to adjust the number of elements in a range, according

+	 to the stride value.  */

+      for (i = 0; i < nargs; i++)

+	{

+	  struct subscript_store *index = &subscript_array[i];

+

+	  if (index->kind == SUBSCRIPT_RANGE)

+	    {

+	      struct type *range_type, *interim_array_type;

+

+	      int new_length;

+

+	      /* The length of a sub-dimension with all elements between the

+		 bounds plus the start element itself.  It may be modified by

+		 a user provided stride value.  */

+	      new_length = index->U.range.high - index->U.range.low;

+

+	      new_length /= index->U.range.stride;

+

+	      range_type

+		= create_static_range_type (NULL,

+					    elt_type,

+					    index->U.range.low,

+					    index->U.range.low + new_length);

+

+	      interim_array_type = create_array_type (NULL,

+						      elt_type,

+						      range_type);

+

+	      TYPE_CODE (interim_array_type)

+		= TYPE_CODE (value_type (new_array));

+

+	      v = allocate_value (interim_array_type);

+

+	      elt_type = value_type (v);

+	    }

+

+	}

+      value_contents_copy (v, 0, new_array, 0, TYPE_LENGTH (elt_type));

+      return v;

+    }

+

+  return new_array;

 }

@@ -1242,19 +1537,6 @@ 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,

@@ -1949,33 +2231,8 @@ evaluate_subexp_standard (struct type *expect_type,

       switch (code)

 	{

 	case TYPE_CODE_ARRAY:

-	  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;

-		}

-	      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));

-	    }

+	  return value_f90_subarray (arg1, exp, pos, nargs, noside);

 	case TYPE_CODE_PTR:

 	case TYPE_CODE_FUNC:

@@ -2372,49 +2629,6 @@ evaluate_subexp_standard (struct type *expect_type,

 	}

       return (arg1);

-    multi_f77_subscript:

-      {

-	LONGEST subscript_array[MAX_FORTRAN_DIMS];

-	int ndimensions = 1, i;

-	struct value *array = arg1;

-

-	if (nargs > MAX_FORTRAN_DIMS)

-	  error (_("Too many subscripts for F77 (%d Max)"), MAX_FORTRAN_DIMS);

-

-	ndimensions = calc_f77_array_dims (type);

-

-	if (nargs != ndimensions)

-	  error (_("Wrong number of subscripts"));

-

-	gdb_assert (nargs > 0);

-

-	/* Now that we know we have a legal array subscript expression 

-	   let us actually find out where this element exists in the array.  */

-

-	/* Take array indices left to right.  */

-	for (i = 0; i < nargs; i++)

-	  {

-	    /* Evaluate each subscript; it must be a legal integer in F77.  */

-	    arg2 = evaluate_subexp_with_coercion (exp, pos, noside);

-

-	    /* Fill in the subscript array.  */

-

-	    subscript_array[i] = value_as_long (arg2);

-	  }

-

-	/* Internal type of array is arranged right to left.  */

-	for (i = nargs; i > 0; i--)

-	  {

-	    struct type *array_type = check_typedef (value_type (array));

-	    LONGEST index = subscript_array[i - 1];

-

-	    array = value_subscripted_rvalue (array, index,

-					      f77_get_lowerbound (array_type));

-	  }

-

-	return array;

-      }

-

     case BINOP_LOGICAL_AND:

       arg1 = evaluate_subexp (NULL_TYPE, exp, pos, noside);

       if (noside == EVAL_SKIP)

@@ -3334,6 +3548,9 @@ calc_f77_array_dims (struct type *array_type)

   int ndimen = 1;

   struct type *tmp_type;

+  if (TYPE_CODE (array_type) == TYPE_CODE_STRING)

+    return 1;

+

   if ((TYPE_CODE (array_type) != TYPE_CODE_ARRAY))

     error (_("Can't get dimensions for a non-array type"));

diff --git a/gdb/expprint.c b/gdb/expprint.c

--- a/gdb/expprint.c

+++ b/gdb/expprint.c

@@ -578,17 +578,14 @@ print_subexp_standard (struct expression *exp, int *pos,

 	  longest_to_int (exp->elts[pc + 1].longconst);

 	*pos += 2;

-	if (range_type == NONE_BOUND_DEFAULT_EXCLUSIVE

-	    || range_type == LOW_BOUND_DEFAULT_EXCLUSIVE)

+	if ((range_type & SUBARRAY_HIGH_BOUND_EXCLUSIVE)

+	    == SUBARRAY_HIGH_BOUND_EXCLUSIVE)

 	  fputs_filtered ("EXCLUSIVE_", stream);

 	fputs_filtered ("RANGE(", stream);

-	if (range_type == HIGH_BOUND_DEFAULT

-	    || range_type == NONE_BOUND_DEFAULT

-	    || range_type == NONE_BOUND_DEFAULT_EXCLUSIVE)

+	if ((range_type & SUBARRAY_LOW_BOUND) == SUBARRAY_LOW_BOUND)

 	  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);

 	fputs_filtered ("..", stream);

-	if (range_type == LOW_BOUND_DEFAULT

-	    || range_type == NONE_BOUND_DEFAULT)

+	if ((range_type & SUBARRAY_HIGH_BOUND) == SUBARRAY_HIGH_BOUND)

 	  print_subexp (exp, pos, stream, PREC_ABOVE_COMMA);

 	fputs_filtered (")", stream);

 	return;

@@ -1105,22 +1102,24 @@ dump_subexp_body_standard (struct expression *exp,

 	switch (range_type)

 	  {

-	  case BOTH_BOUND_DEFAULT:

+	  case SUBARRAY_NONE_BOUND:

 	    fputs_filtered ("Range '..'", stream);

 	    break;

-	  case LOW_BOUND_DEFAULT:

+	  case SUBARRAY_HIGH_BOUND:

 	    fputs_filtered ("Range '..EXP'", stream);

 	    break;

-	  case LOW_BOUND_DEFAULT_EXCLUSIVE:

-	    fputs_filtered ("ExclusiveRange '..EXP'", stream);

-	    break;

-	  case HIGH_BOUND_DEFAULT:

+	  case SUBARRAY_LOW_BOUND:

 	    fputs_filtered ("Range 'EXP..'", stream);

 	    break;

-	  case NONE_BOUND_DEFAULT:

+	  case (SUBARRAY_LOW_BOUND

+		| SUBARRAY_HIGH_BOUND

+		| SUBARRAY_HIGH_BOUND_EXCLUSIVE):

+	    fputs_filtered ("ExclusiveRange '..EXP'", stream);

+	    break;

+	  case (SUBARRAY_LOW_BOUND | SUBARRAY_HIGH_BOUND):

 	    fputs_filtered ("Range 'EXP..EXP'", stream);

 	    break;

-	  case NONE_BOUND_DEFAULT_EXCLUSIVE:

+	  case (SUBARRAY_HIGH_BOUND | SUBARRAY_HIGH_BOUND_EXCLUSIVE):

 	    fputs_filtered ("ExclusiveRange 'EXP..EXP'", stream);

 	    break;

 	  default:

@@ -1128,11 +1127,9 @@ dump_subexp_body_standard (struct expression *exp,

 	    break;

 	  }

-	if (range_type == HIGH_BOUND_DEFAULT

-	    || range_type == NONE_BOUND_DEFAULT)

+	if ((range_type & SUBARRAY_LOW_BOUND) == SUBARRAY_LOW_BOUND)

 	  elt = dump_subexp (exp, stream, elt);

-	if (range_type == LOW_BOUND_DEFAULT

-	    || range_type == NONE_BOUND_DEFAULT)

+	if ((range_type & SUBARRAY_HIGH_BOUND) == SUBARRAY_HIGH_BOUND)

 	  elt = dump_subexp (exp, stream, elt);